/* GStreamer

 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

 *                    2005 Wim Taymans <wim@fluendo.com>

 *

 * gstbaseaudiosink.c: 

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:gstbaseaudiosink

 * @short_description: Base class for audio sinks

 * @see_also: #GstAudioSink, #GstRingBuffer.

 *

 * This is the base class for audio sinks. Subclasses need to implement the

 * ::create_ringbuffer vmethod. This base class will then take care of

 * writing samples to the ringbuffer, synchronisation, clipping and flushing.

 *

 * Last reviewed on 2006-09-27 (0.10.12)

 */

#include <string.h>

#include "gstbaseaudiosink.h"

GST_DEBUG_CATEGORY_STATIC (gst_base_audio_sink_debug);

#define GST_CAT_DEFAULT gst_base_audio_sink_debug

#define GST_BASE_AUDIO_SINK_GET_PRIVATE(obj)  \

   (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_BASE_AUDIO_SINK, GstBaseAudioSinkPrivate))

struct _GstBaseAudioSinkPrivate

{

  /* upstream latency */

  GstClockTime us_latency;

  /* the clock slaving algorithm in use */

  GstBaseAudioSinkSlaveMethod slave_method;

  /* running average of clock skew */

  GstClockTimeDiff avg_skew;

  /* the number of samples we aligned last time */

  gint64 last_align;

};

/* BaseAudioSink signals and args */

enum

{

  /* FILL ME */

  LAST_SIGNAL

};

/* we tollerate half a second diff before we start resyncing. This

 * should be enough to compensate for various rounding errors in the timestamp

 * and sample offset position. 

 * This is an emergency resync fallback since buffers marked as DISCONT will

 * always lock to the correct timestamp immediatly and buffers not marked as

 * DISCONT are contiguous by definition.

 */

#define DIFF_TOLERANCE  2

/* FIXME: 0.11, store the buffer_time and latency_time in nanoseconds */

#define DEFAULT_BUFFER_TIME     ((200 * GST_MSECOND) / GST_USECOND)

#define DEFAULT_LATENCY_TIME    ((10 * GST_MSECOND) / GST_USECOND)

#define DEFAULT_PROVIDE_CLOCK   TRUE

#define DEFAULT_SLAVE_METHOD    GST_BASE_AUDIO_SINK_SLAVE_SKEW

enum

{

  PROP_0,

  PROP_BUFFER_TIME,

  PROP_LATENCY_TIME,

  PROP_PROVIDE_CLOCK,

};

{

  static GType slave_method_type = 0;

  static const GEnumValue slave_method[] = {

    {GST_BASE_AUDIO_SINK_SLAVE_RESAMPLE, "Resampling slaving", "resample"},

    {GST_BASE_AUDIO_SINK_SLAVE_SKEW, "Skew slaving", "skew"},

    {GST_BASE_AUDIO_SINK_SLAVE_NONE, "No slaving", "none"},

    {0, NULL, NULL},

  };

  if (!slave_method_type) {

    slave_method_type =

        g_enum_register_static ("GstBaseAudioSinkSlaveMethod", slave_method);

  }

  return slave_method_type;

}

#define _do_init(bla) \

    GST_DEBUG_CATEGORY_INIT (gst_base_audio_sink_debug, "baseaudiosink", 0, "baseaudiosink element");

GST_BOILERPLATE_FULL (GstBaseAudioSink, gst_base_audio_sink, GstBaseSink,

    GST_TYPE_BASE_SINK, _do_init);

static void gst_base_audio_sink_dispose (GObject * object);

static void gst_base_audio_sink_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_base_audio_sink_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static GstStateChangeReturn gst_base_audio_sink_async_play (GstBaseSink *

    basesink);

static GstStateChangeReturn gst_base_audio_sink_change_state (GstElement *

    element, GstStateChange transition);

static gboolean gst_base_audio_sink_activate_pull (GstBaseSink * basesink,

    gboolean active);

static gboolean gst_base_audio_sink_query (GstElement * element, GstQuery *

    query);

static GstClock *gst_base_audio_sink_provide_clock (GstElement * elem);

static GstClockTime gst_base_audio_sink_get_time (GstClock * clock,

    GstBaseAudioSink * sink);

static void gst_base_audio_sink_callback (GstRingBuffer * rbuf, guint8 * data,

    guint len, gpointer user_data);

static GstFlowReturn gst_base_audio_sink_preroll (GstBaseSink * bsink,

    GstBuffer * buffer);

static GstFlowReturn gst_base_audio_sink_render (GstBaseSink * bsink,

    GstBuffer * buffer);

static gboolean gst_base_audio_sink_event (GstBaseSink * bsink,

    GstEvent * event);

static void gst_base_audio_sink_get_times (GstBaseSink * bsink,

    GstBuffer * buffer, GstClockTime * start, GstClockTime * end);

static gboolean gst_base_audio_sink_setcaps (GstBaseSink * bsink,

    GstCaps * caps);

static void gst_base_audio_sink_fixate (GstBaseSink * bsink, GstCaps * caps);

/* static guint gst_base_audio_sink_signals[LAST_SIGNAL] = { 0 }; */

static void

gst_base_audio_sink_base_init (gpointer g_class)

{

}

static void

gst_base_audio_sink_class_init (GstBaseAudioSinkClass * klass)

{

  GObjectClass *gobject_class;

  GstElementClass *gstelement_class;

  GstBaseSinkClass *gstbasesink_class;

  gobject_class = (GObjectClass *) klass;

  gstelement_class = (GstElementClass *) klass;

  gstbasesink_class = (GstBaseSinkClass *) klass;

  g_type_class_add_private (klass, sizeof (GstBaseAudioSinkPrivate));

  gobject_class->set_property =

      GST_DEBUG_FUNCPTR (gst_base_audio_sink_set_property);

  gobject_class->get_property =

      GST_DEBUG_FUNCPTR (gst_base_audio_sink_get_property);

  gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_base_audio_sink_dispose);

  g_object_class_install_property (gobject_class, PROP_BUFFER_TIME,

      g_param_spec_int64 ("buffer-time", "Buffer Time",

          "Size of audio buffer in microseconds", 1,

  g_object_class_install_property (gobject_class, PROP_LATENCY_TIME,

      g_param_spec_int64 ("latency-time", "Latency Time",

          "Audio latency in microseconds", 1,

  g_object_class_install_property (gobject_class, PROP_PROVIDE_CLOCK,

      g_param_spec_boolean ("provide-clock", "Provide Clock",

          "Provide a clock to be used as the global pipeline clock",

  g_object_class_install_property (gobject_class, PROP_SLAVE_METHOD,

      g_param_spec_enum ("slave-method", "Slave Method",

          "Algorithm to use to match the rate of the masterclock",

  gstelement_class->change_state =

      GST_DEBUG_FUNCPTR (gst_base_audio_sink_change_state);

  gstelement_class->provide_clock =

      GST_DEBUG_FUNCPTR (gst_base_audio_sink_provide_clock);

  gstelement_class->query = GST_DEBUG_FUNCPTR (gst_base_audio_sink_query);

  gstbasesink_class->event = GST_DEBUG_FUNCPTR (gst_base_audio_sink_event);

  gstbasesink_class->preroll = GST_DEBUG_FUNCPTR (gst_base_audio_sink_preroll);

  gstbasesink_class->render = GST_DEBUG_FUNCPTR (gst_base_audio_sink_render);

  gstbasesink_class->get_times =

      GST_DEBUG_FUNCPTR (gst_base_audio_sink_get_times);

  gstbasesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_base_audio_sink_setcaps);

  gstbasesink_class->fixate = GST_DEBUG_FUNCPTR (gst_base_audio_sink_fixate);

  gstbasesink_class->async_play =

      GST_DEBUG_FUNCPTR (gst_base_audio_sink_async_play);

  gstbasesink_class->activate_pull =

      GST_DEBUG_FUNCPTR (gst_base_audio_sink_activate_pull);

  /* ref class from a thread-safe context to work around missing bit of

   * thread-safety in GObject */

  g_type_class_ref (GST_TYPE_AUDIO_CLOCK);

}

static void

gst_base_audio_sink_init (GstBaseAudioSink * baseaudiosink,

    GstBaseAudioSinkClass * g_class)

{

  baseaudiosink->priv = GST_BASE_AUDIO_SINK_GET_PRIVATE (baseaudiosink);

  baseaudiosink->buffer_time = DEFAULT_BUFFER_TIME;

  baseaudiosink->latency_time = DEFAULT_LATENCY_TIME;

  baseaudiosink->provide_clock = DEFAULT_PROVIDE_CLOCK;

  baseaudiosink->priv->slave_method = DEFAULT_SLAVE_METHOD;

  baseaudiosink->provided_clock = gst_audio_clock_new ("GstAudioSinkClock",

      (GstAudioClockGetTimeFunc) gst_base_audio_sink_get_time, baseaudiosink);

  GST_BASE_SINK (baseaudiosink)->can_activate_push = TRUE;

}

static void

gst_base_audio_sink_dispose (GObject * object)

{

  GstBaseAudioSink *sink;

  sink = GST_BASE_AUDIO_SINK (object);

  if (sink->provided_clock)

    gst_object_unref (sink->provided_clock);

  sink->provided_clock = NULL;

  if (sink->ringbuffer) {

    gst_object_unparent (GST_OBJECT_CAST (sink->ringbuffer));

    sink->ringbuffer = NULL;

  }

  G_OBJECT_CLASS (parent_class)->dispose (object);

}

static GstClock *

gst_base_audio_sink_provide_clock (GstElement * elem)

{

  GstBaseAudioSink *sink;

  GstClock *clock;

  sink = GST_BASE_AUDIO_SINK (elem);

  /* we have no ringbuffer (must be NULL state) */

  if (sink->ringbuffer == NULL)

    goto wrong_state;

  if (!gst_ring_buffer_is_acquired (sink->ringbuffer))

    goto wrong_state;

  GST_OBJECT_LOCK (sink);

  if (!sink->provide_clock)

    goto clock_disabled;

  clock = GST_CLOCK_CAST (gst_object_ref (sink->provided_clock));

  GST_OBJECT_UNLOCK (sink);

  return clock;

  /* ERRORS */

wrong_state:

  {

    GST_DEBUG_OBJECT (sink, "ringbuffer not acquired");

    return NULL;

  }

clock_disabled:

  {

    GST_DEBUG_OBJECT (sink, "clock provide disabled");

    GST_OBJECT_UNLOCK (sink);

    return NULL;

  }

}

static gboolean

gst_base_audio_sink_query (GstElement * element, GstQuery * query)

{

  gboolean res = FALSE;

  switch (GST_QUERY_TYPE (query)) {

    case GST_QUERY_LATENCY:

    {

      gboolean live, us_live;

      GstClockTime min_l, max_l;

      GST_DEBUG_OBJECT (basesink, "latency query");

      if (!basesink->ringbuffer || !basesink->ringbuffer->spec.rate) {

        GST_DEBUG_OBJECT (basesink,

            "we are not yet negotiated, can't report latency yet");

        res = FALSE;

        goto done;

      }

      /* ask parent first, it will do an upstream query for us. */

      if ((res =

              gst_base_sink_query_latency (GST_BASE_SINK_CAST (basesink), &live,

                  &us_live, &min_l, &max_l))) {

        GstClockTime min_latency, max_latency;

        /* we and upstream are both live, adjust the min_latency */

        if (live && us_live) {

          GstRingBufferSpec *spec;

          spec = &basesink->ringbuffer->spec;

          basesink->priv->us_latency = min_l;

          min_latency =

              GST_SECOND, spec->rate * spec->bytes_per_sample);

          /* we cannot go lower than the buffer size and the min peer latency */

          min_latency = min_latency + min_l;

          /* the max latency is the max of the peer, we can delay an infinite

           * amount of time. */

          max_latency = min_latency + (max_l == -1 ? 0 : max_l);

          GST_DEBUG_OBJECT (basesink,

              "peer min %" GST_TIME_FORMAT ", our min latency: %"

              GST_TIME_FORMAT, GST_TIME_ARGS (min_l),

              GST_TIME_ARGS (min_latency));

        } else {

          GST_DEBUG_OBJECT (basesink,

              "peer or we are not live, don't care about latency");

        }

        gst_query_set_latency (query, live, min_latency, max_latency);

      }

      break;

    }

    default:

      res = GST_ELEMENT_CLASS (parent_class)->query (element, query);

      break;

  }

done:

  return res;

}

static GstClockTime

gst_base_audio_sink_get_time (GstClock * clock, GstBaseAudioSink * sink)

{

  guint64 raw, samples;

  guint delay;

  if (sink->ringbuffer == NULL || sink->ringbuffer->spec.rate == 0)

    return GST_CLOCK_TIME_NONE;

  /* our processed samples are always increasing */

  raw = samples = gst_ring_buffer_samples_done (sink->ringbuffer);

  /* the number of samples not yet processed, this is still queued in the

   * device (not played for playback). */

  delay = gst_ring_buffer_delay (sink->ringbuffer);

  if (G_LIKELY (samples >= delay))

    samples -= delay;

  else

    samples = 0;

  result = gst_util_uint64_scale_int (samples, GST_SECOND,

      sink->ringbuffer->spec.rate);

  GST_DEBUG_OBJECT (sink,

  return result;

}

/**

 * gst_base_audio_sink_set_provide_clock:

 * @sink: a #GstBaseAudioSink

 * @provide: new state

 *

 * Controls whether @sink will provide a clock or not. If @provide is %TRUE, 

 * gst_element_provide_clock() will return a clock that reflects the datarate

 * of @sink. If @provide is %FALSE, gst_element_provide_clock() will return NULL.

 *

 * Since: 0.10.16

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_base_audio_sink_set_provide_clock (GstBaseAudioSink * sink,

    gboolean provide)

{

  g_return_if_fail (GST_IS_BASE_AUDIO_SINK (sink));

  GST_OBJECT_LOCK (sink);

  sink->provide_clock = provide;

  GST_OBJECT_UNLOCK (sink);

}

/**

 * gst_base_audio_sink_get_provide_clock:

 * @sink: a #GstBaseAudioSink

 *

 * Queries whether @sink will provide a clock or not. See also

 * gst_base_audio_sink_set_provide_clock.

 *

 * Returns: %TRUE if @sink will provide a clock.

 *

 * Since: 0.10.16

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_base_audio_sink_get_provide_clock (GstBaseAudioSink * sink)

{