/* GStreamer

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

 *                    2000 Wim Taymans <wtay@chello.be>

 *                    2004 Wim Taymans <wim@fluendo.com>

 *

 * gstclock.c: Clock subsystem for maintaining time sync

 *

 * 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., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:gstclock

 * @title: GstClock

 * @short_description: Abstract class for global clocks

 * @see_also: #GstSystemClock, #GstPipeline

 *

 * GStreamer uses a global clock to synchronize the plugins in a pipeline.

 * Different clock implementations are possible by implementing this abstract

 * base class or, more conveniently, by subclassing #GstSystemClock.

 *

 * The #GstClock returns a monotonically increasing time with the method

 * gst_clock_get_time(). Its accuracy and base time depend on the specific

 * clock implementation but time is always expressed in nanoseconds. Since the

 * baseline of the clock is undefined, the clock time returned is not

 * meaningful in itself, what matters are the deltas between two clock times.

 * The time returned by a clock is called the absolute time.

 *

 * The pipeline uses the clock to calculate the running time. Usually all

 * renderers synchronize to the global clock using the buffer timestamps, the

 * newsegment events and the element's base time, see #GstPipeline.

 *

 * A clock implementation can support periodic and single shot clock

 * notifications both synchronous and asynchronous.

 *

 * One first needs to create a #GstClockID for the periodic or single shot

 * notification using gst_clock_new_single_shot_id() or

 * gst_clock_new_periodic_id().

 *

 * To perform a blocking wait for the specific time of the #GstClockID use the

 * gst_clock_id_wait(). To receive a callback when the specific time is reached

 * in the clock use gst_clock_id_wait_async(). Both these calls can be

 * interrupted with the gst_clock_id_unschedule() call. If the blocking wait is

 * unscheduled a return value of #GST_CLOCK_UNSCHEDULED is returned.

 *

 * Periodic callbacks scheduled async will be repeatedly called automatically

 * until it is unscheduled. To schedule a sync periodic callback,

 * gst_clock_id_wait() should be called repeatedly.

 *

 * The async callbacks can happen from any thread, either provided by the core

 * or from a streaming thread. The application should be prepared for this.

 *

 * A #GstClockID that has been unscheduled cannot be used again for any wait

 * operation, a new #GstClockID should be created and the old unscheduled one

 * should be destroyed with gst_clock_id_unref().

 *

 * It is possible to perform a blocking wait on the same #GstClockID from

 * multiple threads. However, registering the same #GstClockID for multiple

 * async notifications is not possible, the callback will only be called for

 * the thread registering the entry last.

 *

 * None of the wait operations unref the #GstClockID, the owner is responsible

 * for unreffing the ids itself. This holds for both periodic and single shot

 * notifications. The reason being that the owner of the #GstClockID has to

 * keep a handle to the #GstClockID to unblock the wait on FLUSHING events or

 * state changes and if the entry would be unreffed automatically, the handle

 * might become invalid without any notification.

 *

 * These clock operations do not operate on the running time, so the callbacks

 * will also occur when not in PLAYING state as if the clock just keeps on

 * running. Some clocks however do not progress when the element that provided

 * the clock is not PLAYING.

 *

 * When a clock has the #GST_CLOCK_FLAG_CAN_SET_MASTER flag set, it can be

 * slaved to another #GstClock with the gst_clock_set_master(). The clock will

 * then automatically be synchronized to this master clock by repeatedly

 * sampling the master clock and the slave clock and recalibrating the slave

 * clock with gst_clock_set_calibration(). This feature is mostly useful for

 * plugins that have an internal clock but must operate with another clock

 * selected by the #GstPipeline.  They can track the offset and rate difference

 * of their internal clock relative to the master clock by using the

 * gst_clock_get_calibration() function.

 *

 * The master/slave synchronisation can be tuned with the #GstClock:timeout,

 * #GstClock:window-size and #GstClock:window-threshold properties.

 * The #GstClock:timeout property defines the interval to sample the master

 * clock and run the calibration functions. #GstClock:window-size defines the

 * number of samples to use when calibrating and #GstClock:window-threshold

 * defines the minimum number of samples before the calibration is performed.

 */

#include "gst_private.h"

#include <time.h>

#include "gstclock.h"

#include "gstinfo.h"

#include "gstutils.h"

#include "glib-compat-private.h"

/* #define DEBUGGING_ENABLED */

#define DEFAULT_WINDOW_SIZE             32

#define DEFAULT_WINDOW_THRESHOLD        4

#define DEFAULT_TIMEOUT                 GST_SECOND / 10

enum

{

  PROP_0,

  PROP_WINDOW_SIZE,

  PROP_WINDOW_THRESHOLD,

  PROP_TIMEOUT

};

enum

{

  SIGNAL_SYNCED,

  SIGNAL_LAST

};

#define GST_CLOCK_SLAVE_LOCK(clock)     g_mutex_lock (&GST_CLOCK_CAST (clock)->priv->slave_lock)

#define GST_CLOCK_SLAVE_UNLOCK(clock)   g_mutex_unlock (&GST_CLOCK_CAST (clock)->priv->slave_lock)

struct _GstClockPrivate

{

  GMutex slave_lock;            /* order: SLAVE_LOCK, OBJECT_LOCK */

  GCond sync_cond;

  /* with LOCK */

  GstClockTime internal_calibration;

  GstClockTime external_calibration;

  GstClockTime rate_numerator;

  GstClockTime rate_denominator;

  GstClockTime last_time;

  /* with LOCK */

  GstClockTime resolution;

  /* for master/slave clocks */

  GstClock *master;

  /* with SLAVE_LOCK */

  gboolean filling;

  gint window_size;

  gint window_threshold;

  gint time_index;

  GstClockTime timeout;

  GstClockTime *times;

  GstClockTime *times_temp;

  GstClockID clockid;

  gint pre_count;

  gint post_count;

  gboolean synced;

};

/* seqlocks */

#define read_seqbegin(clock)                                   \

  g_atomic_int_get (&clock->priv->post_count);

static inline gboolean

read_seqretry (GstClock * clock, gint seq)

{

  /* no retry if the seqnum did not change */

  if (G_LIKELY (seq == g_atomic_int_get (&clock->priv->pre_count)))

    return FALSE;

  /* wait for the writer to finish and retry */

  GST_OBJECT_LOCK (clock);

  GST_OBJECT_UNLOCK (clock);

  return TRUE;

}

#define write_seqlock(clock)                      \

G_STMT_START {                                    \

  GST_OBJECT_LOCK (clock);                        \

  g_atomic_int_inc (&clock->priv->pre_count);     \

} G_STMT_END;

#define write_sequnlock(clock)                    \

G_STMT_START {                                    \

  g_atomic_int_inc (&clock->priv->post_count);    \

  GST_OBJECT_UNLOCK (clock);                      \

} G_STMT_END;

#ifndef GST_DISABLE_GST_DEBUG

static const gchar *

gst_clock_return_get_name (GstClockReturn ret)

{

  switch (ret) {

    case GST_CLOCK_OK:

      return "ok";

    case GST_CLOCK_EARLY:

      return "early";

    case GST_CLOCK_UNSCHEDULED:

      return "unscheduled";

    case GST_CLOCK_BUSY:

      return "busy";

    case GST_CLOCK_BADTIME:

      return "bad-time";

    case GST_CLOCK_ERROR:

      return "error";

    case GST_CLOCK_UNSUPPORTED:

      return "unsupported";

    case GST_CLOCK_DONE:

      return "done";

    default:

      break;

  }

  return "unknown";

}

#endif /* GST_DISABLE_GST_DEBUG */

static void gst_clock_dispose (GObject * object);

static void gst_clock_finalize (GObject * object);

static void gst_clock_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_clock_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static guint gst_clock_signals[SIGNAL_LAST] = { 0 };

static GstClockID

gst_clock_entry_new (GstClock * clock, GstClockTime time,

    GstClockTime interval, GstClockEntryType type)

{

  GstClockEntry *entry;

  entry = g_slice_new (GstClockEntry);

  /* FIXME: add tracer hook for struct allocations such as clock entries */

  GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock,

      "created entry %p, time %" GST_TIME_FORMAT, entry, GST_TIME_ARGS (time));

  entry->refcount = 1;

  entry->clock = clock;

  entry->type = type;

  entry->time = time;

  entry->interval = interval;

  entry->status = GST_CLOCK_OK;

  entry->func = NULL;

  entry->user_data = NULL;

  entry->destroy_data = NULL;

  entry->unscheduled = FALSE;

  entry->woken_up = FALSE;

  return (GstClockID) entry;

}

/* WARNING : Does not modify the refcount

 * WARNING : Do not use if a pending clock operation is happening on that entry */

static gboolean

gst_clock_entry_reinit (GstClock * clock, GstClockEntry * entry,

    GstClockTime time, GstClockTime interval, GstClockEntryType type)

{

  g_return_val_if_fail (entry->status != GST_CLOCK_BUSY, FALSE);

  g_return_val_if_fail (entry->clock == clock, FALSE);

  entry->type = type;

  entry->time = time;

  entry->interval = interval;

  entry->status = GST_CLOCK_OK;

  entry->unscheduled = FALSE;

  entry->woken_up = FALSE;

  return TRUE;

}

/**

 * gst_clock_single_shot_id_reinit:

 * @clock: a #GstClock

 * @id: a #GstClockID

 * @time: The requested time.

 *

 * Reinitializes the provided single shot @id to the provided time. Does not

 * modify the reference count.

 *

 * Returns: %TRUE if the GstClockID could be reinitialized to the provided

 * @time, else %FALSE.

 */

gboolean

gst_clock_single_shot_id_reinit (GstClock * clock, GstClockID id,

    GstClockTime time)

{

  return gst_clock_entry_reinit (clock, (GstClockEntry *) id, time,

      GST_CLOCK_TIME_NONE, GST_CLOCK_ENTRY_SINGLE);

}

/**

 * gst_clock_periodic_id_reinit:

 * @clock: a #GstClock

 * @id: a #GstClockID

 * @start_time: the requested start time

 * @interval: the requested interval

 *

 * Reinitializes the provided periodic @id to the provided start time and

 * interval. Does not modify the reference count.

 *

 * Returns: %TRUE if the GstClockID could be reinitialized to the provided

 * @time, else %FALSE.

 */

gboolean

gst_clock_periodic_id_reinit (GstClock * clock, GstClockID id,

    GstClockTime start_time, GstClockTime interval)

{

  return gst_clock_entry_reinit (clock, (GstClockEntry *) id, start_time,

      interval, GST_CLOCK_ENTRY_PERIODIC);

}

/**

 * gst_clock_id_ref:

 * @id: The #GstClockID to ref

 *

 * Increase the refcount of given @id.

 *

 * Returns: (transfer full): The same #GstClockID with increased refcount.

 *

 * MT safe.

 */

GstClockID

gst_clock_id_ref (GstClockID id)

{

  g_return_val_if_fail (id != NULL, NULL);

  g_atomic_int_inc (&((GstClockEntry *) id)->refcount);

  return id;

}

static void

_gst_clock_id_free (GstClockID id)

{

  GstClockEntry *entry;

  g_return_if_fail (id != NULL);

  GST_CAT_DEBUG (GST_CAT_CLOCK, "freed entry %p", id);

  entry = (GstClockEntry *) id;

  if (entry->destroy_data)

    entry->destroy_data (entry->user_data);

  /* FIXME: add tracer hook for struct allocations such as clock entries */

  g_slice_free (GstClockEntry, id);

}

/**

 * gst_clock_id_unref:

 * @id: (transfer full): The #GstClockID to unref

 *

 * Unref given @id. When the refcount reaches 0 the

 * #GstClockID will be freed.

 *

 * MT safe.

 */

void

gst_clock_id_unref (GstClockID id)

{

  gint zero;

  g_return_if_fail (id != NULL);

  zero = g_atomic_int_dec_and_test (&((GstClockEntry *) id)->refcount);

  /* if we ended up with the refcount at zero, free the id */

  if (zero) {

    _gst_clock_id_free (id);

  }

}

/**

 * gst_clock_new_single_shot_id:

 * @clock: The #GstClockID to get a single shot notification from

 * @time: the requested time

 *

 * Get a #GstClockID from @clock to trigger a single shot

 * notification at the requested time. The single shot id should be

 * unreffed after usage.

 *

 * Free-function: gst_clock_id_unref

 *

 * Returns: (transfer full): a #GstClockID that can be used to request the

 *     time notification.

 *

 * MT safe.

 */

GstClockID

gst_clock_new_single_shot_id (GstClock * clock, GstClockTime time)

{

  g_return_val_if_fail (GST_IS_CLOCK (clock), NULL);

  return gst_clock_entry_new (clock,

      time, GST_CLOCK_TIME_NONE, GST_CLOCK_ENTRY_SINGLE);

}

/**

 * gst_clock_new_periodic_id:

 * @clock: The #GstClockID to get a periodic notification id from

 * @start_time: the requested start time

 * @interval: the requested interval

 *

 * Get an ID from @clock to trigger a periodic notification.

 * The periodic notifications will start at time @start_time and

 * will then be fired with the given @interval. @id should be unreffed

 * after usage.

 *

 * Free-function: gst_clock_id_unref

 *

 * Returns: (transfer full): a #GstClockID that can be used to request the

 *     time notification.

 *

 * MT safe.

 */

GstClockID

gst_clock_new_periodic_id (GstClock * clock, GstClockTime start_time,

    GstClockTime interval)

{

  g_return_val_if_fail (GST_IS_CLOCK (clock), NULL);

  g_return_val_if_fail (GST_CLOCK_TIME_IS_VALID (start_time), NULL);

  g_return_val_if_fail (interval != 0, NULL);

  g_return_val_if_fail (GST_CLOCK_TIME_IS_VALID (interval), NULL);

  return gst_clock_entry_new (clock,

      start_time, interval, GST_CLOCK_ENTRY_PERIODIC);

}

/**

 * gst_clock_id_compare_func:

 * @id1: A #GstClockID

 * @id2: A #GstClockID to compare with

 *

 * Compares the two #GstClockID instances. This function can be used

 * as a GCompareFunc when sorting ids.

 *

 * Returns: negative value if a < b; zero if a = b; positive value if a > b

 *

 * MT safe.

 */

gint

gst_clock_id_compare_func (gconstpointer id1, gconstpointer id2)

{

  GstClockEntry *entry1, *entry2;

  entry1 = (GstClockEntry *) id1;

  entry2 = (GstClockEntry *) id2;

  if (GST_CLOCK_ENTRY_TIME (entry1) > GST_CLOCK_ENTRY_TIME (entry2)) {

    return 1;

  }

  if (GST_CLOCK_ENTRY_TIME (entry1) < GST_CLOCK_ENTRY_TIME (entry2)) {

    return -1;

  }

  return 0;

}

/**

 * gst_clock_id_get_time:

 * @id: The #GstClockID to query

 *

 * Get the time of the clock ID

 *

 * Returns: the time of the given clock id.

 *

 * MT safe.

 */

GstClockTime

gst_clock_id_get_time (GstClockID id)

{

  g_return_val_if_fail (id != NULL, GST_CLOCK_TIME_NONE);

  return GST_CLOCK_ENTRY_TIME ((GstClockEntry *) id);

}

/**

 * gst_clock_id_wait:

 * @id: The #GstClockID to wait on

 * @jitter: (out) (allow-none): a pointer that will contain the jitter,

 *     can be %NULL.

 *

 * Perform a blocking wait on @id.

 * @id should have been created with gst_clock_new_single_shot_id()

 * or gst_clock_new_periodic_id() and should not have been unscheduled

 * with a call to gst_clock_id_unschedule().

 *

 * If the @jitter argument is not %NULL and this function returns #GST_CLOCK_OK

 * or #GST_CLOCK_EARLY, it will contain the difference

 * against the clock and the time of @id when this method was

 * called.

 * Positive values indicate how late @id was relative to the clock

 * (in which case this function will return #GST_CLOCK_EARLY).

 * Negative values indicate how much time was spent waiting on the clock

 * before this function returned.

 *

 * Returns: the result of the blocking wait. #GST_CLOCK_EARLY will be returned

 * if the current clock time is past the time of @id, #GST_CLOCK_OK if

 * @id was scheduled in time. #GST_CLOCK_UNSCHEDULED if @id was

 * unscheduled with gst_clock_id_unschedule().

 *

 * MT safe.

 */

GstClockReturn

gst_clock_id_wait (GstClockID id, GstClockTimeDiff * jitter)

{

  GstClockEntry *entry;

  GstClock *clock;

  GstClockReturn res;

  GstClockTime requested;

  GstClockClass *cclass;

  g_return_val_if_fail (id != NULL, GST_CLOCK_ERROR);

  entry = (GstClockEntry *) id;

  requested = GST_CLOCK_ENTRY_TIME (entry);

  clock = GST_CLOCK_ENTRY_CLOCK (entry);

  /* can't sync on invalid times */

  if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (requested)))

    goto invalid_time;

  cclass = GST_CLOCK_GET_CLASS (clock);

  GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock, "waiting on clock entry %p", id);

  /* if we have a wait_jitter function, use that */

  if (G_UNLIKELY (cclass->wait == NULL))

    goto not_supported;

  res = cclass->wait (clock, entry, jitter);

  GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock,

      "done waiting entry %p, res: %d (%s)", id, res,

      gst_clock_return_get_name (res));

  if (entry->type == GST_CLOCK_ENTRY_PERIODIC)

    entry->time = requested + entry->interval;

  return res;

  /* ERRORS */

invalid_time:

  {

    GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock,

        "invalid time requested, returning _BADTIME");

    return GST_CLOCK_BADTIME;

  }

not_supported:

  {

    GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock, "clock wait is not supported");

    return GST_CLOCK_UNSUPPORTED;

  }

}

/**

 * gst_clock_id_wait_async:

 * @id: a #GstClockID to wait on

 * @func: The callback function

 * @user_data: User data passed in the callback

 * @destroy_data: #GDestroyNotify for user_data

 *

 * Register a callback on the given #GstClockID @id with the given

 * function and user_data. When passing a #GstClockID with an invalid

 * time to this function, the callback will be called immediately

 * with  a time set to GST_CLOCK_TIME_NONE. The callback will

 * be called when the time of @id has been reached.

 *

 * The callback @func can be invoked from any thread, either provided by the

 * core or from a streaming thread. The application should be prepared for this.

 *

 * Returns: the result of the non blocking wait.

 *

 * MT safe.

 */

GstClockReturn

gst_clock_id_wait_async (GstClockID id,

    GstClockCallback func, gpointer user_data, GDestroyNotify destroy_data)

{

  GstClockEntry *entry;

  GstClock *clock;

  GstClockReturn res;

  GstClockClass *cclass;

  GstClockTime requested;

  g_return_val_if_fail (id != NULL, GST_CLOCK_ERROR);

  g_return_val_if_fail (func != NULL, GST_CLOCK_ERROR);

  entry = (GstClockEntry *) id;

  requested = GST_CLOCK_ENTRY_TIME (entry);

  clock = GST_CLOCK_ENTRY_CLOCK (entry);

  /* can't sync on invalid times */

  if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (requested)))

    goto invalid_time;

  cclass = GST_CLOCK_GET_CLASS (clock);

  if (G_UNLIKELY (cclass->wait_async == NULL))

    goto not_supported;

  entry->func = func;

  entry->user_data = user_data;

  entry->destroy_data = destroy_data;

  res = cclass->wait_async (clock, entry);

  return res;

  /* ERRORS */

invalid_time:

  {

    (func) (clock, GST_CLOCK_TIME_NONE, id, user_data);

    GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock,

        "invalid time requested, returning _BADTIME");

    return GST_CLOCK_BADTIME;

  }

not_supported:

  {

    GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock, "clock wait is not supported");

    return GST_CLOCK_UNSUPPORTED;

  }

}

/**

 * gst_clock_id_unschedule:

 * @id: The id to unschedule

 *

 * Cancel an outstanding request with @id. This can either

 * be an outstanding async notification or a pending sync notification.

 * After this call, @id cannot be used anymore to receive sync or

 * async notifications, you need to create a new #GstClockID.

 *

 * MT safe.

 */

void

gst_clock_id_unschedule (GstClockID id)

{

  GstClockEntry *entry;

  GstClock *clock;

  GstClockClass *cclass;

  g_return_if_fail (id != NULL);

  entry = (GstClockEntry *) id;

  clock = entry->clock;

  cclass = GST_CLOCK_GET_CLASS (clock);

  if (G_LIKELY (cclass->unschedule))

    cclass->unschedule (clock, entry);

}

/*

 * GstClock abstract base class implementation

 */

#define gst_clock_parent_class parent_class

G_DEFINE_ABSTRACT_TYPE (GstClock, gst_clock, GST_TYPE_OBJECT);

static void

gst_clock_class_init (GstClockClass * klass)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->dispose = gst_clock_dispose;

  gobject_class->finalize = gst_clock_finalize;

  gobject_class->set_property = gst_clock_set_property;

  gobject_class->get_property = gst_clock_get_property;

  g_object_class_install_property (gobject_class, PROP_WINDOW_SIZE,

      g_param_spec_int ("window-size", "Window size",

          "The size of the window used to calculate rate and offset", 2, 1024,

          DEFAULT_WINDOW_SIZE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_WINDOW_THRESHOLD,

      g_param_spec_int ("window-threshold", "Window threshold",

          "The threshold to start calculating rate and offset", 2, 1024,

          DEFAULT_WINDOW_THRESHOLD,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_TIMEOUT,

      g_param_spec_uint64 ("timeout", "Timeout",

          "The amount of time, in nanoseconds, to sample master and slave clocks",

          0, G_MAXUINT64, DEFAULT_TIMEOUT,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**

   * GstClock::synced:

   * @clock: the clock

   * @synced: if the clock is synced now

   *

   * Signaled on clocks with GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC set once

   * the clock is synchronized, or when it completely lost synchronization.

   * This signal will not be emitted on clocks without the flag.

   *

   * This signal will be emitted from an arbitrary thread, most likely not

   * the application's main thread.

   *

   * Since: 1.6

   */

  gst_clock_signals[SIGNAL_SYNCED] =

      g_signal_new ("synced", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,

      0, NULL, NULL,

      g_cclosure_marshal_generic, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);

  g_type_class_add_private (klass, sizeof (GstClockPrivate));

}

static void

gst_clock_init (GstClock * clock)

{

  GstClockPrivate *priv;

  clock->priv = priv =

      G_TYPE_INSTANCE_GET_PRIVATE (clock, GST_TYPE_CLOCK, GstClockPrivate);

  priv->last_time = 0;

  priv->internal_calibration = 0;

  priv->external_calibration = 0;

  priv->rate_numerator = 1;

  priv->rate_denominator = 1;

  g_mutex_init (&priv->slave_lock);

  g_cond_init (&priv->sync_cond);

  priv->window_size = DEFAULT_WINDOW_SIZE;

  priv->window_threshold = DEFAULT_WINDOW_THRESHOLD;

  priv->filling = TRUE;

  priv->time_index = 0;

  priv->timeout = DEFAULT_TIMEOUT;

  priv->times = g_new0 (GstClockTime, 4 * priv->window_size);

  priv->times_temp = priv->times + 2 * priv->window_size;

}

static void

gst_clock_dispose (GObject * object)

{

  GstClock *clock = GST_CLOCK (object);

  GstClock **master_p;

  GST_OBJECT_LOCK (clock);

  master_p = &clock->priv->master;

  gst_object_replace ((GstObject **) master_p, NULL);

  GST_OBJECT_UNLOCK (clock);

  G_OBJECT_CLASS (parent_class)->dispose (object);

}

static void

gst_clock_finalize (GObject * object)

{

  GstClock *clock = GST_CLOCK (object);

  GST_CLOCK_SLAVE_LOCK (clock);

  if (clock->priv->clockid) {

    gst_clock_id_unschedule (clock->priv->clockid);

    gst_clock_id_unref (clock->priv->clockid);

    clock->priv->clockid = NULL;

  }

  g_free (clock->priv->times);

  clock->priv->times = NULL;

  clock->priv->times_temp = NULL;

  GST_CLOCK_SLAVE_UNLOCK (clock);

  g_mutex_clear (&clock->priv->slave_lock);

  g_cond_clear (&clock->priv->sync_cond);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

/**

 * gst_clock_set_resolution:

 * @clock: a #GstClock

 * @resolution: The resolution to set

 *

 * Set the accuracy of the clock. Some clocks have the possibility to operate

 * with different accuracy at the expense of more resource usage. There is

 * normally no need to change the default resolution of a clock. The resolution

 * of a clock can only be changed if the clock has the

 * #GST_CLOCK_FLAG_CAN_SET_RESOLUTION flag set.

 *

 * Returns: the new resolution of the clock.

 */

GstClockTime

gst_clock_set_resolution (GstClock * clock, GstClockTime resolution)

{

  GstClockPrivate *priv;

  GstClockClass *cclass;

  g_return_val_if_fail (GST_IS_CLOCK (clock), 0);

  g_return_val_if_fail (resolution != 0, 0);

  cclass = GST_CLOCK_GET_CLASS (clock);

  priv = clock->priv;

  if (cclass->change_resolution)

    priv->resolution =

        cclass->change_resolution (clock, priv->resolution, resolution);

  return priv->resolution;

}

/**

 * gst_clock_get_resolution:

 * @clock: a #GstClock

 *

 * Get the accuracy of the clock. The accuracy of the clock is the granularity

 * of the values returned by gst_clock_get_time().

 *

 * Returns: the resolution of the clock in units of #GstClockTime.

 *

 * MT safe.

 */

GstClockTime

gst_clock_get_resolution (GstClock * clock)

{

  GstClockClass *cclass;

  g_return_val_if_fail (GST_IS_CLOCK (clock), 0);

  cclass = GST_CLOCK_GET_CLASS (clock);

  if (cclass->get_resolution)

    return cclass->get_resolution (clock);

  return 1;

}

/* FIXME 2.0: Remove clock parameter below */

/**

 * gst_clock_adjust_with_calibration:

 * @clock: (allow-none): a #GstClock to use

 * @internal_target: a clock time

 * @cinternal: a reference internal time

 * @cexternal: a reference external time

 * @cnum: the numerator of the rate of the clock relative to its

 *        internal time

 * @cdenom: the denominator of the rate of the clock

 *

 * Converts the given @internal_target clock time to the external time,

 * using the passed calibration parameters. This function performs the

 * same calculation as gst_clock_adjust_unlocked() when called using the

 * current calibration parameters, but doesn't ensure a monotonically

 * increasing result as gst_clock_adjust_unlocked() does.

 *

 * Note: The @clock parameter is unused and can be NULL

 *

 * Returns: the converted time of the clock.

 *

 * Since: 1.6

 */

GstClockTime

gst_clock_adjust_with_calibration (GstClock * clock,

    GstClockTime internal_target, GstClockTime cinternal,

    GstClockTime cexternal, GstClockTime cnum, GstClockTime cdenom)

{

  GstClockTime ret;

  /* avoid divide by 0 */

  if (G_UNLIKELY (cdenom == 0))

    cnum = cdenom = 1;

  /* The formula is (internal - cinternal) * cnum / cdenom + cexternal

   *

   * Since we do math on unsigned 64-bit ints we have to special case for

   * internal < cinternal to get the sign right. this case is not very common,

   * though.

   */

  if (G_LIKELY (internal_target >= cinternal)) {