--- a/gstreamer_core/gst/gstsystemclock.c Tue Aug 31 15:30:33 2010 +0300
+++ b/gstreamer_core/gst/gstsystemclock.c Wed Sep 01 12:16:41 2010 +0100
@@ -40,11 +40,8 @@
#include "gst_private.h"
#include "gstinfo.h"
+
#include "gstsystemclock.h"
-#include "gstenumtypes.h"
-#include "gstpoll.h"
-
-#include <errno.h>
#ifdef __SYMBIAN32__
#include <glib_global.h>
@@ -53,45 +50,12 @@
/* Define this to get some extra debug about jitter from each clock_wait */
#undef WAIT_DEBUGGING
-struct _GstSystemClockPrivate
-{
- GstClockType clock_type;
- GstPoll *timer;
- gint wakeup_count; /* the number of entries with a pending wakeup */
- gboolean async_wakeup; /* if the wakeup was because of a async list change */
-};
-
-#define GST_SYSTEM_CLOCK_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_SYSTEM_CLOCK, \
- GstSystemClockPrivate))
-
-#ifdef HAVE_POSIX_TIMERS
-# ifdef HAVE_MONOTONIC_CLOCK
-# define DEFAULT_CLOCK_TYPE GST_CLOCK_TYPE_MONOTONIC
-# else
-# define DEFAULT_CLOCK_TYPE GST_CLOCK_TYPE_REALTIME
-# endif
-#else
-#define DEFAULT_CLOCK_TYPE GST_CLOCK_TYPE_REALTIME
-#endif
-
-enum
-{
- PROP_0,
- PROP_CLOCK_TYPE,
- /* FILL ME */
-};
-
/* the one instance of the systemclock */
static GstClock *_the_system_clock = NULL;
static void gst_system_clock_class_init (GstSystemClockClass * klass);
static void gst_system_clock_init (GstSystemClock * clock);
static void gst_system_clock_dispose (GObject * object);
-static void gst_system_clock_set_property (GObject * object, guint prop_id,
- const GValue * value, GParamSpec * pspec);
-static void gst_system_clock_get_property (GObject * object, guint prop_id,
- GValue * value, GParamSpec * pspec);
static GstClockTime gst_system_clock_get_internal_time (GstClock * clock);
static guint64 gst_system_clock_get_resolution (GstClock * clock);
@@ -106,37 +70,56 @@
GstClockEntry * entry);
static void gst_system_clock_async_thread (GstClock * clock);
static gboolean gst_system_clock_start_async (GstSystemClock * clock);
-static void gst_system_clock_add_wakeup (GstSystemClock * sysclock);
static GStaticMutex _gst_sysclock_mutex = G_STATIC_MUTEX_INIT;
static GstClockClass *parent_class = NULL;
/* static guint gst_system_clock_signals[LAST_SIGNAL] = { 0 }; */
+#ifdef __SYMBIAN32__
+EXPORT_C
+#endif
-G_DEFINE_TYPE (GstSystemClock, gst_system_clock, GST_TYPE_CLOCK);
+
+GType
+gst_system_clock_get_type (void)
+{
+ static GType clock_type = 0;
+
+ if (G_UNLIKELY (clock_type == 0)) {
+ static const GTypeInfo clock_info = {
+ sizeof (GstSystemClockClass),
+ NULL,
+ NULL,
+ (GClassInitFunc) gst_system_clock_class_init,
+ NULL,
+ NULL,
+ sizeof (GstSystemClock),
+ 0,
+ (GInstanceInitFunc) gst_system_clock_init,
+ NULL
+ };
+
+ clock_type = g_type_register_static (GST_TYPE_CLOCK, "GstSystemClock",
+ &clock_info, 0);
+ }
+ return clock_type;
+}
static void
gst_system_clock_class_init (GstSystemClockClass * klass)
{
GObjectClass *gobject_class;
+ GstObjectClass *gstobject_class;
GstClockClass *gstclock_class;
gobject_class = (GObjectClass *) klass;
+ gstobject_class = (GstObjectClass *) klass;
gstclock_class = (GstClockClass *) klass;
parent_class = g_type_class_peek_parent (klass);
- g_type_class_add_private (klass, sizeof (GstSystemClockPrivate));
-
gobject_class->dispose = gst_system_clock_dispose;
- gobject_class->set_property = gst_system_clock_set_property;
- gobject_class->get_property = gst_system_clock_get_property;
-
- g_object_class_install_property (gobject_class, PROP_CLOCK_TYPE,
- g_param_spec_enum ("clock-type", "Clock type",
- "The type of underlying clock implementation used",
- GST_TYPE_CLOCK_TYPE, DEFAULT_CLOCK_TYPE, G_PARAM_READWRITE));
gstclock_class->get_internal_time = gst_system_clock_get_internal_time;
gstclock_class->get_resolution = gst_system_clock_get_resolution;
@@ -154,16 +137,11 @@
GST_CLOCK_FLAG_CAN_DO_PERIODIC_SYNC |
GST_CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC);
- clock->priv = GST_SYSTEM_CLOCK_GET_PRIVATE (clock);
-
- clock->priv->clock_type = DEFAULT_CLOCK_TYPE;
- clock->priv->timer = gst_poll_new_timer ();
-
#if 0
/* Uncomment this to start the async clock thread straight away */
- GST_OBJECT_LOCK (clock);
+ GST_CLOCK_LOCK (clock);
gst_system_clock_start_async (clock);
- GST_OBJECT_UNLOCK (clock);
+ GST_CLOCK_UNLOCK (clock);
#endif
}
@@ -171,7 +149,8 @@
gst_system_clock_dispose (GObject * object)
{
GstClock *clock = (GstClock *) object;
- GstSystemClock *sysclock = GST_SYSTEM_CLOCK_CAST (clock);
+
+ GstSystemClock *sysclock = GST_SYSTEM_CLOCK (clock);
GList *entries;
/* else we have to stop the thread */
@@ -187,7 +166,6 @@
g_list_free (clock->entries);
clock->entries = NULL;
GST_CLOCK_BROADCAST (clock);
- gst_system_clock_add_wakeup (sysclock);
GST_OBJECT_UNLOCK (clock);
if (sysclock->thread)
@@ -195,8 +173,6 @@
sysclock->thread = NULL;
GST_CAT_DEBUG (GST_CAT_CLOCK, "joined thread");
- gst_poll_free (sysclock->priv->timer);
-
G_OBJECT_CLASS (parent_class)->dispose (object);
if (_the_system_clock == clock) {
@@ -205,40 +181,6 @@
}
}
-static void
-gst_system_clock_set_property (GObject * object, guint prop_id,
- const GValue * value, GParamSpec * pspec)
-{
- GstSystemClock *sysclock = GST_SYSTEM_CLOCK (object);
-
- switch (prop_id) {
- case PROP_CLOCK_TYPE:
- sysclock->priv->clock_type = g_value_get_enum (value);
- GST_CAT_DEBUG (GST_CAT_CLOCK, "clock-type set to %d",
- sysclock->priv->clock_type);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
- }
-}
-
-static void
-gst_system_clock_get_property (GObject * object, guint prop_id, GValue * value,
- GParamSpec * pspec)
-{
- GstSystemClock *sysclock = GST_SYSTEM_CLOCK (object);
-
- switch (prop_id) {
- case PROP_CLOCK_TYPE:
- g_value_set_enum (value, sysclock->priv->clock_type);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
- }
-}
-
/**
* gst_system_clock_obtain:
*
@@ -269,7 +211,8 @@
/* we created the global clock; take ownership so
* we can hand out instances later */
- gst_object_ref_sink (clock);
+ gst_object_ref (clock);
+ gst_object_sink (GST_OBJECT (clock));
_the_system_clock = clock;
g_static_mutex_unlock (&_gst_sysclock_mutex);
@@ -283,49 +226,6 @@
return clock;
}
-static void
-gst_system_clock_remove_wakeup (GstSystemClock * sysclock)
-{
- g_return_if_fail (sysclock->priv->wakeup_count > 0);
-
- sysclock->priv->wakeup_count--;
- if (sysclock->priv->wakeup_count == 0) {
- /* read the control socket byte when we removed the last wakeup count */
- GST_CAT_DEBUG (GST_CAT_CLOCK, "reading control");
- while (!gst_poll_read_control (sysclock->priv->timer)) {
- g_warning ("gstsystemclock: read control failed, trying again\n");
- }
- GST_CLOCK_BROADCAST (sysclock);
- }
- GST_CAT_DEBUG (GST_CAT_CLOCK, "wakeup count %d",
- sysclock->priv->wakeup_count);
-}
-
-static void
-gst_system_clock_add_wakeup (GstSystemClock * sysclock)
-{
- /* only write the control socket for the first wakeup */
- if (sysclock->priv->wakeup_count == 0) {
- GST_CAT_DEBUG (GST_CAT_CLOCK, "writing control");
- while (!gst_poll_write_control (sysclock->priv->timer)) {
- g_warning
- ("gstsystemclock: write control failed in wakeup_async, trying again : %d:%s\n",
- errno, g_strerror (errno));
- }
- }
- sysclock->priv->wakeup_count++;
- GST_CAT_DEBUG (GST_CAT_CLOCK, "wakeup count %d",
- sysclock->priv->wakeup_count);
-}
-
-static void
-gst_system_clock_wait_wakeup (GstSystemClock * sysclock)
-{
- while (sysclock->priv->wakeup_count > 0) {
- GST_CLOCK_WAIT (sysclock);
- }
-}
-
/* this thread reads the sorted clock entries from the queue.
*
* It waits on each of them and fires the callback when the timeout occurs.
@@ -341,7 +241,7 @@
static void
gst_system_clock_async_thread (GstClock * clock)
{
- GstSystemClock *sysclock = GST_SYSTEM_CLOCK_CAST (clock);
+ GstSystemClock *sysclock = GST_SYSTEM_CLOCK (clock);
GST_CAT_DEBUG (GST_CAT_CLOCK, "enter system clock thread");
GST_OBJECT_LOCK (clock);
@@ -364,14 +264,6 @@
goto exit;
}
- /* see if we have a pending wakeup because the order of the list
- * changed. */
- if (sysclock->priv->async_wakeup) {
- GST_CAT_DEBUG (GST_CAT_CLOCK, "clear async wakeup");
- gst_system_clock_remove_wakeup (sysclock);
- sysclock->priv->async_wakeup = FALSE;
- }
-
/* pick the next entry */
entry = clock->entries->data;
/* if it was unscheduled, just move on to the next entry */
@@ -397,7 +289,7 @@
{
/* entry timed out normally, fire the callback and move to the next
* entry */
- GST_CAT_DEBUG (GST_CAT_CLOCK, "async entry %p timed out", entry);
+ GST_CAT_DEBUG (GST_CAT_CLOCK, "async entry %p unlocked", entry);
if (entry->func) {
/* unlock before firing the callback */
GST_OBJECT_UNLOCK (clock);
@@ -406,7 +298,6 @@
GST_OBJECT_LOCK (clock);
}
if (entry->type == GST_CLOCK_ENTRY_PERIODIC) {
- GST_CAT_DEBUG (GST_CAT_CLOCK, "updating periodic entry %p", entry);
/* adjust time now */
entry->time = requested + entry->interval;
/* and resort the list now */
@@ -415,7 +306,6 @@
/* and restart */
continue;
} else {
- GST_CAT_DEBUG (GST_CAT_CLOCK, "moving to next entry");
goto next_entry;
}
}
@@ -425,11 +315,6 @@
* was canceled. Whatever it is, pick the head entry of the list and
* continue waiting. */
GST_CAT_DEBUG (GST_CAT_CLOCK, "async entry %p needs restart", entry);
-
- /* we set the entry back to the OK state. This is needed so that the
- * _unschedule() code can see if an entry is currently being waited
- * on (when its state is BUSY). */
- entry->status = GST_CLOCK_OK;
continue;
default:
GST_CAT_DEBUG (GST_CAT_CLOCK,
@@ -450,60 +335,21 @@
GST_CAT_DEBUG (GST_CAT_CLOCK, "exit system clock thread");
}
-#ifdef HAVE_POSIX_TIMERS
-static inline clockid_t
-clock_type_to_posix_id (GstClockType clock_type)
-{
-#ifdef HAVE_MONOTONIC_CLOCK
- if (clock_type == GST_CLOCK_TYPE_MONOTONIC)
- return CLOCK_MONOTONIC;
- else
-#endif
- return CLOCK_REALTIME;
-}
-#endif
-
/* MT safe */
static GstClockTime
gst_system_clock_get_internal_time (GstClock * clock)
{
-#ifdef HAVE_POSIX_TIMERS
- GstSystemClock *sysclock = GST_SYSTEM_CLOCK_CAST (clock);
- clockid_t ptype;
- struct timespec ts;
-
- ptype = clock_type_to_posix_id (sysclock->priv->clock_type);
-
- if (G_UNLIKELY (clock_gettime (ptype, &ts)))
- return GST_CLOCK_TIME_NONE;
-
- return GST_TIMESPEC_TO_TIME (ts);
-#else
GTimeVal timeval;
g_get_current_time (&timeval);
return GST_TIMEVAL_TO_TIME (timeval);
-#endif
}
static guint64
gst_system_clock_get_resolution (GstClock * clock)
{
-#ifdef HAVE_POSIX_TIMERS
- GstSystemClock *sysclock = GST_SYSTEM_CLOCK_CAST (clock);
- clockid_t ptype;
- struct timespec ts;
-
- ptype = clock_type_to_posix_id (sysclock->priv->clock_type);
-
- if (G_UNLIKELY (clock_getres (ptype, &ts)))
- return GST_CLOCK_TIME_NONE;
-
- return GST_TIMESPEC_TO_TIME (ts);
-#else
return 1 * GST_USECOND;
-#endif
}
/* synchronously wait on the given GstClockEntry.
@@ -526,115 +372,81 @@
gst_system_clock_id_wait_jitter_unlocked (GstClock * clock,
GstClockEntry * entry, GstClockTimeDiff * jitter, gboolean restart)
{
- GstSystemClock *sysclock = GST_SYSTEM_CLOCK_CAST (clock);
- GstClockTime entryt, real, now;
+ GstClockTime entryt, real, now, target;
GstClockTimeDiff diff;
/* need to call the overridden method because we want to sync against the time
* of the clock, whatever the subclass uses as a clock. */
real = GST_CLOCK_GET_CLASS (clock)->get_internal_time (clock);
- now = gst_clock_adjust_unlocked (clock, real);
-
- /* get the time of the entry */
entryt = GST_CLOCK_ENTRY_TIME (entry);
+ now = gst_clock_adjust_unlocked (clock, real);
if (jitter) {
*jitter = GST_CLOCK_DIFF (entryt, now);
}
/* the diff of the entry with the clock is the amount of time we have to
* wait */
diff = entryt - now;
+ /* Our GCond implementation expects an absolute time against the system clock
+ * as a timeout value. We use our internal time to get the system time and add
+ * the expected timeout to it, this gives us the absolute time of the
+ * timeout. */
+ target = gst_system_clock_get_internal_time (clock) + diff;
GST_CAT_DEBUG (GST_CAT_CLOCK, "entry %p"
- " time %" GST_TIME_FORMAT
+ " target %" GST_TIME_FORMAT
+ " entry %" GST_TIME_FORMAT
" now %" GST_TIME_FORMAT
" real %" GST_TIME_FORMAT
- " diff (time-now) %" G_GINT64_FORMAT,
+ " diff (entry-now) %" G_GINT64_FORMAT,
entry,
+ GST_TIME_ARGS (target),
GST_TIME_ARGS (entryt), GST_TIME_ARGS (now), GST_TIME_ARGS (real), diff);
if (diff > 0) {
+ GTimeVal tv;
+
#ifdef WAIT_DEBUGGING
- GstClockTime final;
+ GstClockTime result, final;
#endif
- while (entry->status != GST_CLOCK_UNSCHEDULED) {
- gint pollret;
-
- /* mark the entry as busy */
- entry->status = GST_CLOCK_BUSY;
- GST_OBJECT_UNLOCK (clock);
-
- /* now wait on the entry, it either times out or the fd is written. */
- pollret = gst_poll_wait (sysclock->priv->timer, diff);
-
- /* another thread can read the fd before we get the lock */
- GST_OBJECT_LOCK (clock);
- if (entry->status == GST_CLOCK_UNSCHEDULED) {
- GST_CAT_DEBUG (GST_CAT_CLOCK, "entry %p unlocked", entry);
- gst_system_clock_remove_wakeup (sysclock);
- } else {
- if (pollret != 0) {
- /* some other id got unlocked */
- if (!restart) {
- /* this can happen if the entry got unlocked because of an async
- * entry was added to the head of the async queue. */
- GST_CAT_DEBUG (GST_CAT_CLOCK, "wakeup waiting for entry %p", entry);
- break;
- }
-
- /* mark ourselves as EARLY, we release the lock and we could be
- * unscheduled ourselves but we don't want the unscheduling thread
- * to write on the control socket (it does that when an entry has a
- * BUSY status). */
- entry->status = GST_CLOCK_EARLY;
+ GST_TIME_TO_TIMEVAL (target, tv);
- /* wait till all the entries got woken up */
- gst_system_clock_wait_wakeup (sysclock);
-
- /* we released the lock in the wait, recheck our status, we don't need
- * to remove the wakeup count because we marked the entry as EARLY
- * before releasing the object lock. */
- if (entry->status == GST_CLOCK_UNSCHEDULED) {
- GST_CAT_DEBUG (GST_CAT_CLOCK, "entry %p got unscheduled", entry);
- break;
- }
-
- GST_CAT_DEBUG (GST_CAT_CLOCK, "entry %p needs to be restarted",
- entry);
- } else {
- GST_CAT_DEBUG (GST_CAT_CLOCK, "entry %p unlocked after timeout",
- entry);
- }
-
- /* reschedule if gst_poll_wait returned early or we have to reschedule after
- * an unlock*/
- real = GST_CLOCK_GET_CLASS (clock)->get_internal_time (clock);
- now = gst_clock_adjust_unlocked (clock, real);
- diff = entryt - now;
-
- if (diff <= 0) {
- /* timeout, this is fine, we can report success now */
- entry->status = GST_CLOCK_OK;
-
- GST_CAT_DEBUG (GST_CAT_CLOCK,
- "entry %p finished, diff %" G_GINT64_FORMAT, entry, diff);
+ while (TRUE) {
+ /* now wait on the entry, it either times out or the cond is signaled. */
+ if (!GST_CLOCK_TIMED_WAIT (clock, &tv)) {
+ /* timeout, this is fine, we can report success now */
+ GST_CAT_DEBUG (GST_CAT_CLOCK, "entry %p unlocked after timeout", entry);
+ entry->status = GST_CLOCK_OK;
#ifdef WAIT_DEBUGGING
- final = gst_system_clock_get_internal_time (clock);
- GST_CAT_DEBUG (GST_CAT_CLOCK, "Waited for %" G_GINT64_FORMAT
- " got %" G_GINT64_FORMAT " diff %" G_GINT64_FORMAT
- " %g target-offset %" G_GINT64_FORMAT " %g", entryt, now,
- now - entryt,
- (double) (GstClockTimeDiff) (now - entryt) / GST_SECOND,
- (final - target),
- ((double) (GstClockTimeDiff) (final - target)) / GST_SECOND);
+ real = GST_CLOCK_GET_CLASS (clock)->get_internal_time (clock);
+ result = gst_clock_adjust_unlocked (clock, real);
+ final = gst_system_clock_get_internal_time (clock);
+ GST_CAT_DEBUG (GST_CAT_CLOCK, "Waited for %" G_GINT64_FORMAT
+ " got %" G_GINT64_FORMAT " diff %" G_GINT64_FORMAT
+ " %g target-offset %" G_GINT64_FORMAT " %g", entryt, result,
+ result - entryt,
+ (double) (GstClockTimeDiff) (result - entryt) / GST_SECOND,
+ (final - target),
+ ((double) (GstClockTimeDiff) (final - target)) / GST_SECOND);
#endif
+ break;
+ } else {
+ /* the waiting is interrupted because the GCond was signaled. This can
+ * be because this or some other entry was unscheduled. */
+ GST_CAT_DEBUG (GST_CAT_CLOCK, "entry %p unlocked with signal", entry);
+ /* if the entry is unscheduled, we can stop waiting for it, else we
+ * continue our while loop. */
+ if (entry->status == GST_CLOCK_UNSCHEDULED)
break;
- } else {
- GST_CAT_DEBUG (GST_CAT_CLOCK,
- "entry %p restart, diff %" G_GINT64_FORMAT, entry, diff);
- }
+ /* else restart if we must */
+ if (!restart)
+ break;
+
+ /* this can happen if the entry got unlocked because of an async entry
+ * was added to the head of the async queue. */
+ GST_CAT_DEBUG (GST_CAT_CLOCK, "continue waiting for entry %p", entry);
}
}
} else if (diff == 0) {
@@ -652,20 +464,10 @@
GstClockReturn ret;
GST_OBJECT_LOCK (clock);
- if (G_UNLIKELY (entry->status == GST_CLOCK_UNSCHEDULED))
- goto was_unscheduled;
-
ret = gst_system_clock_id_wait_jitter_unlocked (clock, entry, jitter, TRUE);
GST_OBJECT_UNLOCK (clock);
return ret;
-
- /* ERRORS */
-was_unscheduled:
- {
- GST_OBJECT_UNLOCK (clock);
- return GST_CLOCK_UNSCHEDULED;
- }
}
/* Start the async clock thread. Must be called with the object lock
@@ -675,12 +477,12 @@
{
GError *error = NULL;
- if (G_LIKELY (clock->thread != NULL))
+ if (clock->thread != NULL)
return TRUE; /* Thread already running. Nothing to do */
clock->thread = g_thread_create ((GThreadFunc) gst_system_clock_async_thread,
clock, TRUE, &error);
- if (G_UNLIKELY (error))
+ if (error)
goto no_thread;
/* wait for it to spin up */
@@ -692,7 +494,6 @@
no_thread:
{
g_warning ("could not create async clock thread: %s", error->message);
- g_error_free (error);
}
return FALSE;
}
@@ -707,26 +508,14 @@
static GstClockReturn
gst_system_clock_id_wait_async (GstClock * clock, GstClockEntry * entry)
{
- GstSystemClock *sysclock;
- GstClockEntry *head;
-
- sysclock = GST_SYSTEM_CLOCK_CAST (clock);
-
GST_CAT_DEBUG (GST_CAT_CLOCK, "adding async entry %p", entry);
GST_OBJECT_LOCK (clock);
+
/* Start the clock async thread if needed */
- if (G_UNLIKELY (!gst_system_clock_start_async (sysclock)))
+ if (!gst_system_clock_start_async (GST_SYSTEM_CLOCK (clock)))
goto thread_error;
- if (G_UNLIKELY (entry->status == GST_CLOCK_UNSCHEDULED))
- goto was_unscheduled;
-
- if (clock->entries)
- head = clock->entries->data;
- else
- head = NULL;
-
/* need to take a ref */
gst_clock_id_ref ((GstClockID) entry);
/* insert the entry in sorted order */
@@ -737,40 +526,21 @@
* front, else the thread is just waiting for another entry and
* will get to this entry automatically. */
if (clock->entries->data == entry) {
- GST_CAT_DEBUG (GST_CAT_CLOCK, "async entry added to head");
- if (head == NULL) {
- /* the list was empty before, signal the cond so that the async thread can
- * start taking a look at the queue */
- GST_CAT_DEBUG (GST_CAT_CLOCK, "first entry, sending signal");
- GST_CLOCK_BROADCAST (clock);
- } else {
- if (head->status == GST_CLOCK_BUSY) {
- /* the async thread was waiting for an entry, unlock the wait so that it
- * looks at the new head entry instead, we only need to do this once */
- if (!sysclock->priv->async_wakeup) {
- GST_CAT_DEBUG (GST_CAT_CLOCK, "wakeup async thread");
- sysclock->priv->async_wakeup = TRUE;
- gst_system_clock_add_wakeup (sysclock);
- }
- }
- }
+ GST_CAT_DEBUG (GST_CAT_CLOCK, "async entry added to head, sending signal");
+ /* this will wake up _all_ entries waiting for the clock because we have
+ * only one cond for all entries (makes allocation faster). Entries that
+ * have not timed out will have their status set to BUSY and should continue
+ * to wait. In the case of the async ones, the new head entry should be
+ * taken and waited for. */
+ GST_CLOCK_BROADCAST (clock);
}
GST_OBJECT_UNLOCK (clock);
return GST_CLOCK_OK;
- /* ERRORS */
thread_error:
- {
- /* Could not start the async clock thread */
- GST_OBJECT_UNLOCK (clock);
- return GST_CLOCK_ERROR;
- }
-was_unscheduled:
- {
- GST_OBJECT_UNLOCK (clock);
- return GST_CLOCK_UNSCHEDULED;
- }
+ /* Could not start the async clock thread */
+ return GST_CLOCK_ERROR;
}
/* unschedule an entry. This will set the state of the entry to GST_CLOCK_UNSCHEDULED
@@ -783,22 +553,14 @@
static void
gst_system_clock_id_unschedule (GstClock * clock, GstClockEntry * entry)
{
- GstSystemClock *sysclock;
-
- sysclock = GST_SYSTEM_CLOCK_CAST (clock);
-
GST_CAT_DEBUG (GST_CAT_CLOCK, "unscheduling entry %p", entry);
GST_OBJECT_LOCK (clock);
- if (entry->status == GST_CLOCK_BUSY) {
- /* the entry was being busy, wake up all entries so that they recheck their
- * status. We cannot wake up just one entry because allocating such a
- * datastructure for each entry would be too heavy and unlocking an entry
- * is usually done when shutting down or some other exceptional case. */
- GST_CAT_DEBUG (GST_CAT_CLOCK, "entry was BUSY, doing wakeup");
- gst_system_clock_add_wakeup (sysclock);
- }
- /* when it leaves the poll, it'll detect the unscheduled */
+ /* mark entry as unscheduled, then wake up all entries. The entries that did
+ * not timeout will be woken up but immediatly go to sleep again because their
+ * status would still be busy. */
entry->status = GST_CLOCK_UNSCHEDULED;
+ GST_CAT_DEBUG (GST_CAT_CLOCK, "sending signal");
+ GST_CLOCK_BROADCAST (clock);
GST_OBJECT_UNLOCK (clock);
}