* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2005 Wim Taymans <wim@fluendo.com>
* 2005 Andy Wingo <wingo@pobox.com>
+ * Copyright (C) 2012 Collabora Ltd. <tim.muller@collabora.co.uk>
+ * Copyright (C) 2015 Sebastian Dröge <sebastian@centricular.com>
*
* gstnetclientclock.h: clock that synchronizes itself to a time provider over
* the network
*
* 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.
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
*/
/**
* SECTION:gstnetclientclock
* provider.
* @see_also: #GstClock, #GstNetTimeProvider, #GstPipeline
*
- * This object implements a custom #GstClock that synchronizes its time
- * to a remote time provider such as #GstNetTimeProvider.
+ * #GstNetClientClock implements a custom #GstClock that synchronizes its time
+ * to a remote time provider such as #GstNetTimeProvider. #GstNtpClock
+ * implements a #GstClock that synchronizes its time to a remote NTPv4 server.
*
- * A new clock is created with gst_net_client_clock_new() which takes the
- * address and port of the remote time provider along with a name and
- * an initial time.
+ * A new clock is created with gst_net_client_clock_new() or
+ * gst_ntp_clock_new(), which takes the address and port of the remote time
+ * provider along with a name and an initial time.
*
* This clock will poll the time provider and will update its calibration
* parameters based on the local and remote observations.
*
+ * The "round-trip" property limits the maximum round trip packets can take.
+ *
* Various parameters of the clock can be configured with the parent #GstClock
* "timeout", "window-size" and "window-threshold" object properties.
*
- * A #GstNetClientClock is typically set on a #GstPipeline with
+ * A #GstNetClientClock and #GstNtpClock is typically set on a #GstPipeline with
* gst_pipeline_use_clock().
*
- * Last reviewed on 2005-11-23 (0.9.5)
+ * If you set a #GstBus on the clock via the "bus" object property, it will
+ * send @GST_MESSAGE_ELEMENT messages with an attached #GstStructure containing
+ * statistics about clock accuracy and network traffic.
*/
#ifdef HAVE_CONFIG_H
#endif
#include "gstnettimepacket.h"
+#include "gstntppacket.h"
#include "gstnetclientclock.h"
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
+#include <gio/gio.h>
-#if defined (_MSC_VER) && _MSC_VER >= 1400
-#include <io.h>
-#endif
+#include <string.h>
GST_DEBUG_CATEGORY_STATIC (ncc_debug);
#define GST_CAT_DEFAULT (ncc_debug)
+typedef struct
+{
+ GstClock *clock; /* GstNetClientInternalClock */
+
+ GList *clocks; /* GstNetClientClocks */
+
+ GstClockID remove_id;
+} ClockCache;
+
+G_LOCK_DEFINE_STATIC (clocks_lock);
+static GList *clocks = NULL;
+
+#define GST_TYPE_NET_CLIENT_INTERNAL_CLOCK \
+ (gst_net_client_internal_clock_get_type())
+#define GST_NET_CLIENT_INTERNAL_CLOCK(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_NET_CLIENT_INTERNAL_CLOCK,GstNetClientInternalClock))
+#define GST_NET_CLIENT_INTERNAL_CLOCK_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_NET_CLIENT_INTERNAL_CLOCK,GstNetClientInternalClockClass))
+#define GST_IS_NET_CLIENT_INTERNAL_CLOCK(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_NET_CLIENT_INTERNAL_CLOCK))
+#define GST_IS_NET_CLIENT_INTERNAL_CLOCK_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_NET_CLIENT_INTERNAL_CLOCK))
+
+typedef struct _GstNetClientInternalClock GstNetClientInternalClock;
+typedef struct _GstNetClientInternalClockClass GstNetClientInternalClockClass;
+
+G_GNUC_INTERNAL GType gst_net_client_internal_clock_get_type (void);
+
#define DEFAULT_ADDRESS "127.0.0.1"
#define DEFAULT_PORT 5637
#define DEFAULT_TIMEOUT GST_SECOND
+#define DEFAULT_ROUNDTRIP_LIMIT GST_SECOND
+/* Minimum timeout will be immediately (ie, as fast as one RTT), but no
+ * more often than 1/20th second (arbitrarily, to spread observations a little) */
+#define DEFAULT_MINIMUM_UPDATE_INTERVAL (GST_SECOND / 20)
+#define DEFAULT_BASE_TIME 0
-#ifdef G_OS_WIN32
-#define getsockname(sock,addr,len) getsockname(sock,addr,(int *)len)
-#endif
+/* Maximum number of clock updates we can skip before updating */
+#define MAX_SKIPPED_UPDATES 5
+
+#define MEDIAN_PRE_FILTERING_WINDOW 9
enum
{
PROP_0,
PROP_ADDRESS,
PROP_PORT,
+ PROP_ROUNDTRIP_LIMIT,
+ PROP_MINIMUM_UPDATE_INTERVAL,
+ PROP_BUS,
+ PROP_BASE_TIME,
+ PROP_INTERNAL_CLOCK,
+ PROP_IS_NTP
};
-#define GST_NET_CLIENT_CLOCK_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_NET_CLIENT_CLOCK, GstNetClientClockPrivate))
+struct _GstNetClientInternalClock
+{
+ GstSystemClock clock;
+
+ GThread *thread;
+
+ GSocket *socket;
+ GSocketAddress *servaddr;
+ GCancellable *cancel;
+ gboolean made_cancel_fd;
+
+ GstClockTime timeout_expiration;
+ GstClockTime roundtrip_limit;
+ GstClockTime rtt_avg;
+ GstClockTime minimum_update_interval;
+ GstClockTime last_remote_poll_interval;
+ guint skipped_updates;
+ GstClockTime last_rtts[MEDIAN_PRE_FILTERING_WINDOW];
+ gint last_rtts_missing;
+
+ gchar *address;
+ gint port;
+ gboolean is_ntp;
+
+ /* Protected by OBJECT_LOCK */
+ GList *busses;
+};
-struct _GstNetClientClockPrivate
+struct _GstNetClientInternalClockClass
{
- GstPollFD sock;
- GstPoll *fdset;
+ GstSystemClockClass parent_class;
};
#define _do_init \
GST_DEBUG_CATEGORY_INIT (ncc_debug, "netclock", 0, "Network client clock");
-#define gst_net_client_clock_parent_class parent_class
-G_DEFINE_TYPE_WITH_CODE (GstNetClientClock, gst_net_client_clock,
- GST_TYPE_SYSTEM_CLOCK, _do_init);
+G_DEFINE_TYPE_WITH_CODE (GstNetClientInternalClock,
+ gst_net_client_internal_clock, GST_TYPE_SYSTEM_CLOCK, _do_init);
-static void gst_net_client_clock_finalize (GObject * object);
-static void gst_net_client_clock_set_property (GObject * object, guint prop_id,
- const GValue * value, GParamSpec * pspec);
-static void gst_net_client_clock_get_property (GObject * object, guint prop_id,
- GValue * value, GParamSpec * pspec);
+static void gst_net_client_internal_clock_finalize (GObject * object);
+static void gst_net_client_internal_clock_set_property (GObject * object,
+ guint prop_id, const GValue * value, GParamSpec * pspec);
+static void gst_net_client_internal_clock_get_property (GObject * object,
+ guint prop_id, GValue * value, GParamSpec * pspec);
+static void gst_net_client_internal_clock_constructed (GObject * object);
-static void gst_net_client_clock_stop (GstNetClientClock * self);
-
-#ifdef G_OS_WIN32
-static int
-inet_aton (const char *c, struct in_addr *paddr)
-{
- /* note that inet_addr is deprecated on unix because
- * inet_addr returns -1 (INADDR_NONE) for the valid 255.255.255.255
- * address. */
- paddr->s_addr = inet_addr (c);
- if (paddr->s_addr == INADDR_NONE)
- return 0;
-
- return 1;
-}
-#endif
+static gboolean gst_net_client_internal_clock_start (GstNetClientInternalClock *
+ self);
+static void gst_net_client_internal_clock_stop (GstNetClientInternalClock *
+ self);
static void
-gst_net_client_clock_class_init (GstNetClientClockClass * klass)
+gst_net_client_internal_clock_class_init (GstNetClientInternalClockClass *
+ klass)
{
GObjectClass *gobject_class;
gobject_class = G_OBJECT_CLASS (klass);
- g_type_class_add_private (klass, sizeof (GstNetClientClockPrivate));
-
- gobject_class->finalize = gst_net_client_clock_finalize;
- gobject_class->get_property = gst_net_client_clock_get_property;
- gobject_class->set_property = gst_net_client_clock_set_property;
+ gobject_class->finalize = gst_net_client_internal_clock_finalize;
+ gobject_class->get_property = gst_net_client_internal_clock_get_property;
+ gobject_class->set_property = gst_net_client_internal_clock_set_property;
+ gobject_class->constructed = gst_net_client_internal_clock_constructed;
g_object_class_install_property (gobject_class, PROP_ADDRESS,
g_param_spec_string ("address", "address",
- "The address of the machine providing a time server, "
- "as a dotted quad (x.x.x.x)", DEFAULT_ADDRESS,
- G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+ "The IP address of the machine providing a time server",
+ DEFAULT_ADDRESS,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_PORT,
g_param_spec_int ("port", "port",
"The port on which the remote server is listening", 0, G_MAXUINT16,
- DEFAULT_PORT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+ DEFAULT_PORT,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+ g_object_class_install_property (gobject_class, PROP_IS_NTP,
+ g_param_spec_boolean ("is-ntp", "Is NTP",
+ "The clock is using the NTPv4 protocol", FALSE,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
}
static void
-gst_net_client_clock_init (GstNetClientClock * self)
+gst_net_client_internal_clock_init (GstNetClientInternalClock * self)
{
- GstClock *clock = GST_CLOCK_CAST (self);
-
-#ifdef G_OS_WIN32
- WSADATA w;
- int error = WSAStartup (0x0202, &w);
-
- if (error) {
- GST_DEBUG_OBJECT (self, "Error on WSAStartup");
- }
- if (w.wVersion != 0x0202) {
- WSACleanup ();
- }
-#endif
- self->priv = GST_NET_CLIENT_CLOCK_GET_PRIVATE (self);
+ GST_OBJECT_FLAG_SET (self, GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC);
self->port = DEFAULT_PORT;
self->address = g_strdup (DEFAULT_ADDRESS);
+ self->is_ntp = FALSE;
- clock->timeout = DEFAULT_TIMEOUT;
+ gst_clock_set_timeout (GST_CLOCK (self), DEFAULT_TIMEOUT);
- self->priv->sock.fd = -1;
self->thread = NULL;
self->servaddr = NULL;
+ self->rtt_avg = GST_CLOCK_TIME_NONE;
+ self->roundtrip_limit = DEFAULT_ROUNDTRIP_LIMIT;
+ self->minimum_update_interval = DEFAULT_MINIMUM_UPDATE_INTERVAL;
+ self->last_remote_poll_interval = GST_CLOCK_TIME_NONE;
+ self->skipped_updates = 0;
+ self->last_rtts_missing = MEDIAN_PRE_FILTERING_WINDOW;
}
static void
-gst_net_client_clock_finalize (GObject * object)
+gst_net_client_internal_clock_finalize (GObject * object)
{
- GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object);
+ GstNetClientInternalClock *self = GST_NET_CLIENT_INTERNAL_CLOCK (object);
if (self->thread) {
- gst_net_client_clock_stop (self);
- g_assert (self->thread == NULL);
- }
-
- if (self->priv->fdset) {
- gst_poll_free (self->priv->fdset);
- self->priv->fdset = NULL;
+ gst_net_client_internal_clock_stop (self);
}
g_free (self->address);
self->address = NULL;
- g_free (self->servaddr);
- self->servaddr = NULL;
+ if (self->servaddr != NULL) {
+ g_object_unref (self->servaddr);
+ self->servaddr = NULL;
+ }
-#ifdef G_OS_WIN32
- WSACleanup ();
-#endif
+ if (self->socket != NULL) {
+ if (!g_socket_close (self->socket, NULL))
+ GST_ERROR_OBJECT (self, "Failed to close socket");
+ g_object_unref (self->socket);
+ self->socket = NULL;
+ }
+
+ g_warn_if_fail (self->busses == NULL);
- G_OBJECT_CLASS (parent_class)->finalize (object);
+ G_OBJECT_CLASS (gst_net_client_internal_clock_parent_class)->finalize
+ (object);
}
static void
-gst_net_client_clock_set_property (GObject * object, guint prop_id,
+gst_net_client_internal_clock_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
- GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object);
+ GstNetClientInternalClock *self = GST_NET_CLIENT_INTERNAL_CLOCK (object);
switch (prop_id) {
case PROP_ADDRESS:
+ GST_OBJECT_LOCK (self);
g_free (self->address);
- if (g_value_get_string (value) == NULL)
+ self->address = g_value_dup_string (value);
+ if (self->address == NULL)
self->address = g_strdup (DEFAULT_ADDRESS);
- else
- self->address = g_strdup (g_value_get_string (value));
+ GST_OBJECT_UNLOCK (self);
break;
case PROP_PORT:
+ GST_OBJECT_LOCK (self);
self->port = g_value_get_int (value);
+ GST_OBJECT_UNLOCK (self);
+ break;
+ case PROP_IS_NTP:
+ GST_OBJECT_LOCK (self);
+ self->is_ntp = g_value_get_boolean (value);
+ GST_OBJECT_UNLOCK (self);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
static void
-gst_net_client_clock_get_property (GObject * object, guint prop_id,
+gst_net_client_internal_clock_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
- GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object);
+ GstNetClientInternalClock *self = GST_NET_CLIENT_INTERNAL_CLOCK (object);
switch (prop_id) {
case PROP_ADDRESS:
+ GST_OBJECT_LOCK (self);
g_value_set_string (value, self->address);
+ GST_OBJECT_UNLOCK (self);
break;
case PROP_PORT:
g_value_set_int (value, self->port);
break;
+ case PROP_IS_NTP:
+ g_value_set_boolean (value, self->is_ntp);
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
static void
-gst_net_client_clock_observe_times (GstNetClientClock * self,
- GstClockTime local_1, GstClockTime remote, GstClockTime local_2)
+gst_net_client_internal_clock_constructed (GObject * object)
+{
+ GstNetClientInternalClock *self = GST_NET_CLIENT_INTERNAL_CLOCK (object);
+
+ G_OBJECT_CLASS (gst_net_client_internal_clock_parent_class)->constructed
+ (object);
+
+ if (!gst_net_client_internal_clock_start (self)) {
+ g_warning ("failed to start clock '%s'", GST_OBJECT_NAME (self));
+ }
+
+ /* all systems go, cap'n */
+}
+
+static gint
+compare_clock_time (const GstClockTime * a, const GstClockTime * b)
+{
+ if (*a < *b)
+ return -1;
+ else if (*a > *b)
+ return 1;
+ return 0;
+}
+
+static void
+gst_net_client_internal_clock_observe_times (GstNetClientInternalClock * self,
+ GstClockTime local_1, GstClockTime remote_1, GstClockTime remote_2,
+ GstClockTime local_2)
{
- GstClockTime local_avg;
+ GstClockTime current_timeout = 0;
+ GstClockTime local_avg, remote_avg;
gdouble r_squared;
GstClock *clock;
+ GstClockTime rtt, rtt_limit, min_update_interval;
+ /* Use for discont tracking */
+ GstClockTime time_before = 0;
+ GstClockTime min_guess = 0;
+ GstClockTimeDiff time_discont = 0;
+ gboolean synched, now_synched;
+ GstClockTime internal_time, external_time, rate_num, rate_den;
+ GstClockTime orig_internal_time, orig_external_time, orig_rate_num,
+ orig_rate_den;
+ GstClockTime max_discont;
+ GstClockTime last_rtts[MEDIAN_PRE_FILTERING_WINDOW];
+ GstClockTime median;
+ gint i;
+
+ GST_OBJECT_LOCK (self);
+ rtt_limit = self->roundtrip_limit;
+
+ GST_LOG_OBJECT (self,
+ "local1 %" G_GUINT64_FORMAT " remote1 %" G_GUINT64_FORMAT " remote2 %"
+ G_GUINT64_FORMAT " local2 %" G_GUINT64_FORMAT, local_1, remote_1,
+ remote_2, local_2);
+
+ /* If the server told us a poll interval and it's bigger than the
+ * one configured via the property, use the server's */
+ if (self->last_remote_poll_interval != GST_CLOCK_TIME_NONE &&
+ self->last_remote_poll_interval > self->minimum_update_interval)
+ min_update_interval = self->last_remote_poll_interval;
+ else
+ min_update_interval = self->minimum_update_interval;
+ GST_OBJECT_UNLOCK (self);
+
+ if (local_2 < local_1) {
+ GST_LOG_OBJECT (self, "Dropping observation: receive time %" GST_TIME_FORMAT
+ " < send time %" GST_TIME_FORMAT, GST_TIME_ARGS (local_1),
+ GST_TIME_ARGS (local_2));
+ goto bogus_observation;
+ }
- if (local_2 < local_1)
+ if (remote_2 < remote_1) {
+ GST_LOG_OBJECT (self,
+ "Dropping observation: remote receive time %" GST_TIME_FORMAT
+ " < send time %" GST_TIME_FORMAT, GST_TIME_ARGS (remote_1),
+ GST_TIME_ARGS (remote_2));
goto bogus_observation;
+ }
- local_avg = (local_2 + local_1) / 2;
+ /* The round trip time is (assuming symmetric path delays)
+ * delta = (local_2 - local_1) - (remote_2 - remote_1)
+ */
- clock = GST_CLOCK_CAST (self);
+ rtt = GST_CLOCK_DIFF (local_1, local_2) - GST_CLOCK_DIFF (remote_1, remote_2);
+
+ if ((rtt_limit > 0) && (rtt > rtt_limit)) {
+ GST_LOG_OBJECT (self,
+ "Dropping observation: RTT %" GST_TIME_FORMAT " > limit %"
+ GST_TIME_FORMAT, GST_TIME_ARGS (rtt), GST_TIME_ARGS (rtt_limit));
+ goto bogus_observation;
+ }
- gst_clock_add_observation (GST_CLOCK (self), local_avg, remote, &r_squared);
+ for (i = 1; i < MEDIAN_PRE_FILTERING_WINDOW; i++)
+ self->last_rtts[i - 1] = self->last_rtts[i];
+ self->last_rtts[i - 1] = rtt;
- GST_CLOCK_SLAVE_LOCK (self);
- if (clock->filling) {
- self->current_timeout = 0;
+ if (self->last_rtts_missing) {
+ self->last_rtts_missing--;
} else {
- /* geto formula */
- self->current_timeout =
- (1e-3 / (1 - MIN (r_squared, 0.99999))) * GST_SECOND;
- self->current_timeout = MIN (self->current_timeout, clock->timeout);
+ memcpy (&last_rtts, &self->last_rtts, sizeof (last_rtts));
+ g_qsort_with_data (&last_rtts,
+ MEDIAN_PRE_FILTERING_WINDOW, sizeof (GstClockTime),
+ (GCompareDataFunc) compare_clock_time, NULL);
+
+ median = last_rtts[MEDIAN_PRE_FILTERING_WINDOW / 2];
+
+ /* FIXME: We might want to use something else here, like only allowing
+ * things in the interquartile range, or also filtering away delays that
+ * are too small compared to the median. This here worked well enough
+ * in tests so far.
+ */
+ if (rtt > 2 * median) {
+ GST_LOG_OBJECT (self,
+ "Dropping observation, long RTT %" GST_TIME_FORMAT " > 2 * median %"
+ GST_TIME_FORMAT, GST_TIME_ARGS (rtt), GST_TIME_ARGS (median));
+ goto bogus_observation;
+ }
}
- GST_CLOCK_SLAVE_UNLOCK (clock);
-
- return;
-bogus_observation:
- {
- GST_WARNING_OBJECT (self, "time packet receive time < send time (%"
- GST_TIME_FORMAT " < %" GST_TIME_FORMAT ")", GST_TIME_ARGS (local_1),
- GST_TIME_ARGS (local_2));
- return;
+ /* Track an average round trip time, for a bit of smoothing */
+ /* Always update before discarding a sample, so genuine changes in
+ * the network get picked up, eventually */
+ if (self->rtt_avg == GST_CLOCK_TIME_NONE)
+ self->rtt_avg = rtt;
+ else if (rtt < self->rtt_avg) /* Shorter RTTs carry more weight than longer */
+ self->rtt_avg = (3 * self->rtt_avg + rtt) / 4;
+ else
+ self->rtt_avg = (15 * self->rtt_avg + rtt) / 16;
+
+ if (rtt > 2 * self->rtt_avg) {
+ GST_LOG_OBJECT (self,
+ "Dropping observation, long RTT %" GST_TIME_FORMAT " > 2 * avg %"
+ GST_TIME_FORMAT, GST_TIME_ARGS (rtt), GST_TIME_ARGS (self->rtt_avg));
+ goto bogus_observation;
}
-}
-static gint
-gst_net_client_clock_do_select (GstNetClientClock * self)
-{
- while (TRUE) {
- GstClockTime diff;
- gint ret;
+ /* The difference between the local and remote clock (again assuming
+ * symmetric path delays):
+ *
+ * local_1 + delta / 2 - remote_1 = theta
+ * or
+ * local_2 - delta / 2 - remote_2 = theta
+ *
+ * which gives after some simple algebraic transformations:
+ *
+ * (remote_1 - local_1) + (remote_2 - local_2)
+ * theta = -------------------------------------------
+ * 2
+ *
+ *
+ * Thus remote time at local_avg is equal to:
+ *
+ * local_avg + theta =
+ *
+ * local_1 + local_2 (remote_1 - local_1) + (remote_2 - local_2)
+ * ----------------- + -------------------------------------------
+ * 2 2
+ *
+ * =
+ *
+ * remote_1 + remote_2
+ * ------------------- = remote_avg
+ * 2
+ *
+ * We use this for our clock estimation, i.e. local_avg at remote clock
+ * being the same as remote_avg.
+ */
- GST_LOG_OBJECT (self, "doing select");
+ local_avg = (local_2 + local_1) / 2;
+ remote_avg = (remote_2 + remote_1) / 2;
- diff = gst_clock_get_internal_time (GST_CLOCK (self));
- ret = gst_poll_wait (self->priv->fdset, self->current_timeout);
- diff = gst_clock_get_internal_time (GST_CLOCK (self)) - diff;
+ GST_LOG_OBJECT (self,
+ "remoteavg %" G_GUINT64_FORMAT " localavg %" G_GUINT64_FORMAT,
+ remote_avg, local_avg);
- if (diff > self->current_timeout)
- self->current_timeout = 0;
- else
- self->current_timeout -= diff;
+ clock = GST_CLOCK_CAST (self);
- GST_LOG_OBJECT (self, "select returned %d", ret);
+ /* Store what the clock produced as 'now' before this update */
+ gst_clock_get_calibration (GST_CLOCK_CAST (self), &orig_internal_time,
+ &orig_external_time, &orig_rate_num, &orig_rate_den);
+ internal_time = orig_internal_time;
+ external_time = orig_external_time;
+ rate_num = orig_rate_num;
+ rate_den = orig_rate_den;
+
+ min_guess =
+ gst_clock_adjust_with_calibration (GST_CLOCK_CAST (self), local_1,
+ internal_time, external_time, rate_num, rate_den);
+ time_before =
+ gst_clock_adjust_with_calibration (GST_CLOCK_CAST (self), local_2,
+ internal_time, external_time, rate_num, rate_den);
+
+ /* Maximum discontinuity, when we're synched with the master. Could make this a property,
+ * but this value seems to work fine */
+ max_discont = self->rtt_avg / 4;
+
+ /* If the remote observation was within a max_discont window around our min/max estimates, we're synched */
+ synched =
+ (GST_CLOCK_DIFF (remote_avg, min_guess) < (GstClockTimeDiff) (max_discont)
+ && GST_CLOCK_DIFF (time_before,
+ remote_avg) < (GstClockTimeDiff) (max_discont));
+
+ if (gst_clock_add_observation_unapplied (GST_CLOCK_CAST (self),
+ local_avg, remote_avg, &r_squared, &internal_time, &external_time,
+ &rate_num, &rate_den)) {
+
+ /* Now compare the difference (discont) in the clock
+ * after this observation */
+ time_discont = GST_CLOCK_DIFF (time_before,
+ gst_clock_adjust_with_calibration (GST_CLOCK_CAST (self), local_2,
+ internal_time, external_time, rate_num, rate_den));
+
+ /* If we were in sync with the remote clock, clamp the allowed
+ * discontinuity to within quarter of one RTT. In sync means our send/receive estimates
+ * of remote time correctly windowed the actual remote time observation */
+ if (synched && ABS (time_discont) > max_discont) {
+ GstClockTimeDiff offset;
+ GST_DEBUG_OBJECT (clock,
+ "Too large a discont, clamping to 1/4 average RTT = %"
+ GST_TIME_FORMAT, GST_TIME_ARGS (max_discont));
+ if (time_discont > 0) { /* Too large a forward step - add a -ve offset */
+ offset = max_discont - time_discont;
+ if (-offset > external_time)
+ external_time = 0;
+ else
+ external_time += offset;
+ } else { /* Too large a backward step - add a +ve offset */
+ offset = -(max_discont + time_discont);
+ external_time += offset;
+ }
+
+ time_discont += offset;
+ }
- if (ret < 0 && errno != EBUSY) {
- if (errno != EAGAIN && errno != EINTR)
- goto select_error;
- else
- continue;
+ /* Check if the new clock params would have made our observation within range */
+ now_synched =
+ (GST_CLOCK_DIFF (remote_avg,
+ gst_clock_adjust_with_calibration (GST_CLOCK_CAST (self),
+ local_1, internal_time, external_time, rate_num,
+ rate_den)) < (GstClockTimeDiff) (max_discont))
+ &&
+ (GST_CLOCK_DIFF (gst_clock_adjust_with_calibration
+ (GST_CLOCK_CAST (self), local_2, internal_time, external_time,
+ rate_num, rate_den),
+ remote_avg) < (GstClockTimeDiff) (max_discont));
+
+ /* Only update the clock if we had synch or just gained it */
+ if (synched || now_synched || self->skipped_updates > MAX_SKIPPED_UPDATES) {
+ gst_clock_set_calibration (GST_CLOCK_CAST (self), internal_time,
+ external_time, rate_num, rate_den);
+ /* ghetto formula - shorter timeout for bad correlations */
+ current_timeout = (1e-3 / (1 - MIN (r_squared, 0.99999))) * GST_SECOND;
+ current_timeout =
+ MIN (current_timeout, gst_clock_get_timeout (GST_CLOCK_CAST (self)));
+ self->skipped_updates = 0;
+
+ /* FIXME: When do we consider the clock absolutely not synced anymore? */
+ gst_clock_set_synced (GST_CLOCK (self), TRUE);
} else {
- return ret;
+ /* Restore original calibration vars for the report, we're not changing the clock */
+ internal_time = orig_internal_time;
+ external_time = orig_external_time;
+ rate_num = orig_rate_num;
+ rate_den = orig_rate_den;
+ time_discont = 0;
+ self->skipped_updates++;
}
+ }
- g_assert_not_reached ();
-
- /* log errors and keep going */
- select_error:
- {
- GST_WARNING_OBJECT (self, "select error %d: %s (%d)", ret,
- g_strerror (errno), errno);
- continue;
- }
+ /* Limit the polling to at most one per minimum_update_interval */
+ if (rtt < min_update_interval)
+ current_timeout = MAX (min_update_interval - rtt, current_timeout);
+
+ GST_OBJECT_LOCK (self);
+ if (self->busses) {
+ GstStructure *s;
+ GstMessage *msg;
+ GList *l;
+
+ /* Output a stats message, whether we updated the clock or not */
+ s = gst_structure_new ("gst-netclock-statistics",
+ "synchronised", G_TYPE_BOOLEAN, synched,
+ "rtt", G_TYPE_UINT64, rtt,
+ "rtt-average", G_TYPE_UINT64, self->rtt_avg,
+ "local", G_TYPE_UINT64, local_avg,
+ "remote", G_TYPE_UINT64, remote_avg,
+ "discontinuity", G_TYPE_INT64, time_discont,
+ "remote-min-estimate", G_TYPE_UINT64, min_guess,
+ "remote-max-estimate", G_TYPE_UINT64, time_before,
+ "remote-min-error", G_TYPE_INT64, GST_CLOCK_DIFF (remote_avg,
+ min_guess), "remote-max-error", G_TYPE_INT64,
+ GST_CLOCK_DIFF (remote_avg, time_before), "request-send", G_TYPE_UINT64,
+ local_1, "request-receive", G_TYPE_UINT64, local_2, "r-squared",
+ G_TYPE_DOUBLE, r_squared, "timeout", G_TYPE_UINT64, current_timeout,
+ "internal-time", G_TYPE_UINT64, internal_time, "external-time",
+ G_TYPE_UINT64, external_time, "rate-num", G_TYPE_UINT64, rate_num,
+ "rate-den", G_TYPE_UINT64, rate_den, "rate", G_TYPE_DOUBLE,
+ (gdouble) (rate_num) / rate_den, "local-clock-offset", G_TYPE_INT64,
+ GST_CLOCK_DIFF (internal_time, external_time), NULL);
+ msg = gst_message_new_element (GST_OBJECT (self), s);
+
+ for (l = self->busses; l; l = l->next)
+ gst_bus_post (l->data, gst_message_ref (msg));
+ gst_message_unref (msg);
}
+ GST_OBJECT_UNLOCK (self);
+
+ GST_INFO ("next timeout: %" GST_TIME_FORMAT, GST_TIME_ARGS (current_timeout));
+ self->timeout_expiration = gst_util_get_timestamp () + current_timeout;
+
+ return;
- g_assert_not_reached ();
- return -1;
+bogus_observation:
+ /* Schedule a new packet again soon */
+ self->timeout_expiration = gst_util_get_timestamp () + (GST_SECOND / 4);
+ return;
}
static gpointer
-gst_net_client_clock_thread (gpointer data)
+gst_net_client_internal_clock_thread (gpointer data)
{
- GstNetClientClock *self = data;
- struct sockaddr_in tmpaddr;
- socklen_t len;
- GstNetTimePacket *packet;
- gint ret;
- GstClock *clock = data;
-
- while (TRUE) {
- ret = gst_net_client_clock_do_select (self);
-
- if (ret < 0 && errno == EBUSY) {
- GST_LOG_OBJECT (self, "stop");
- goto stopped;
- } else if (ret == 0) {
- /* timed out, let's send another packet */
- GST_DEBUG_OBJECT (self, "timed out");
-
- packet = gst_net_time_packet_new (NULL);
-
- packet->local_time = gst_clock_get_internal_time (GST_CLOCK (self));
-
- GST_DEBUG_OBJECT (self, "sending packet, local time = %" GST_TIME_FORMAT,
- GST_TIME_ARGS (packet->local_time));
- gst_net_time_packet_send (packet, self->priv->sock.fd,
- (struct sockaddr *) self->servaddr, sizeof (struct sockaddr_in));
-
- g_free (packet);
-
- /* reset timeout */
- self->current_timeout = clock->timeout;
- continue;
- } else if (gst_poll_fd_can_read (self->priv->fdset, &self->priv->sock)) {
- /* got data in */
- GstClockTime new_local = gst_clock_get_internal_time (GST_CLOCK (self));
-
- len = sizeof (struct sockaddr);
- packet = gst_net_time_packet_receive (self->priv->sock.fd,
- (struct sockaddr *) &tmpaddr, &len);
-
- if (!packet)
- goto receive_error;
-
- GST_LOG_OBJECT (self, "got packet back");
- GST_LOG_OBJECT (self, "local_1 = %" GST_TIME_FORMAT,
- GST_TIME_ARGS (packet->local_time));
- GST_LOG_OBJECT (self, "remote = %" GST_TIME_FORMAT,
- GST_TIME_ARGS (packet->remote_time));
- GST_LOG_OBJECT (self, "local_2 = %" GST_TIME_FORMAT,
- GST_TIME_ARGS (new_local));
-
- /* observe_times will reset the timeout */
- gst_net_client_clock_observe_times (self, packet->local_time,
- packet->remote_time, new_local);
-
- g_free (packet);
- continue;
+ GstNetClientInternalClock *self = data;
+ GSocket *socket = self->socket;
+ GError *err = NULL;
+
+ GST_INFO_OBJECT (self, "net client clock thread running, socket=%p", socket);
+
+ g_socket_set_blocking (socket, TRUE);
+ g_socket_set_timeout (socket, 0);
+
+ while (!g_cancellable_is_cancelled (self->cancel)) {
+ GstClockTime expiration_time = self->timeout_expiration;
+ GstClockTime now = gst_util_get_timestamp ();
+ gint64 socket_timeout;
+
+ if (now >= expiration_time || (expiration_time - now) <= GST_MSECOND) {
+ socket_timeout = 0;
} else {
- GST_WARNING_OBJECT (self, "unhandled select return state?");
- continue;
+ socket_timeout = (expiration_time - now) / GST_USECOND;
}
- g_assert_not_reached ();
+ GST_TRACE_OBJECT (self, "timeout: %" G_GINT64_FORMAT "us", socket_timeout);
- stopped:
- {
- GST_DEBUG_OBJECT (self, "shutting down");
- /* socket gets closed in _stop() */
- return NULL;
- }
- receive_error:
- {
- GST_WARNING_OBJECT (self, "receive error");
- continue;
- }
+ if (!g_socket_condition_timed_wait (socket, G_IO_IN, socket_timeout,
+ self->cancel, &err)) {
+ /* cancelled, timeout or error */
+ if (err->code == G_IO_ERROR_CANCELLED) {
+ GST_INFO_OBJECT (self, "cancelled");
+ g_clear_error (&err);
+ break;
+ } else if (err->code == G_IO_ERROR_TIMED_OUT) {
+ /* timed out, let's send another packet */
+ GST_DEBUG_OBJECT (self, "timed out");
- g_assert_not_reached ();
+ if (self->is_ntp) {
+ GstNtpPacket *packet;
- }
+ packet = gst_ntp_packet_new (NULL, NULL);
+
+ packet->transmit_time =
+ gst_clock_get_internal_time (GST_CLOCK_CAST (self));
- g_assert_not_reached ();
+ GST_DEBUG_OBJECT (self,
+ "sending packet, local time = %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (packet->transmit_time));
+ gst_ntp_packet_send (packet, self->socket, self->servaddr, NULL);
+
+ g_free (packet);
+ } else {
+ GstNetTimePacket *packet;
+
+ packet = gst_net_time_packet_new (NULL);
+
+ packet->local_time =
+ gst_clock_get_internal_time (GST_CLOCK_CAST (self));
+
+ GST_DEBUG_OBJECT (self,
+ "sending packet, local time = %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (packet->local_time));
+
+ gst_net_time_packet_send (packet, self->socket, self->servaddr, NULL);
+
+ g_free (packet);
+ }
+
+ /* reset timeout (but are expecting a response sooner anyway) */
+ self->timeout_expiration =
+ gst_util_get_timestamp () +
+ gst_clock_get_timeout (GST_CLOCK_CAST (self));
+ } else {
+ GST_DEBUG_OBJECT (self, "socket error: %s", err->message);
+ g_usleep (G_USEC_PER_SEC / 10); /* throttle */
+ }
+ g_clear_error (&err);
+ } else {
+ GstClockTime new_local;
+
+ /* got packet */
+
+ new_local = gst_clock_get_internal_time (GST_CLOCK_CAST (self));
+
+ if (self->is_ntp) {
+ GstNtpPacket *packet;
+
+ packet = gst_ntp_packet_receive (socket, NULL, &err);
+
+ if (packet != NULL) {
+ GST_LOG_OBJECT (self, "got packet back");
+ GST_LOG_OBJECT (self, "local_1 = %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (packet->origin_time));
+ GST_LOG_OBJECT (self, "remote_1 = %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (packet->receive_time));
+ GST_LOG_OBJECT (self, "remote_2 = %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (packet->transmit_time));
+ GST_LOG_OBJECT (self, "local_2 = %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (new_local));
+ GST_LOG_OBJECT (self, "poll_interval = %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (packet->poll_interval));
+
+ /* Remember the last poll interval we ever got from the server */
+ if (packet->poll_interval != GST_CLOCK_TIME_NONE)
+ self->last_remote_poll_interval = packet->poll_interval;
+
+ /* observe_times will reset the timeout */
+ gst_net_client_internal_clock_observe_times (self,
+ packet->origin_time, packet->receive_time, packet->transmit_time,
+ new_local);
+
+ g_free (packet);
+ } else if (err != NULL) {
+ if (g_error_matches (err, GST_NTP_ERROR, GST_NTP_ERROR_WRONG_VERSION)
+ || g_error_matches (err, GST_NTP_ERROR, GST_NTP_ERROR_KOD_DENY)) {
+ GST_ERROR_OBJECT (self, "fatal receive error: %s", err->message);
+ g_clear_error (&err);
+ break;
+ } else if (g_error_matches (err, GST_NTP_ERROR,
+ GST_NTP_ERROR_KOD_RATE)) {
+ GST_WARNING_OBJECT (self, "need to limit rate");
+
+ /* If the server did not tell us a poll interval before, double
+ * our minimum poll interval. Otherwise we assume that the server
+ * already told us something sensible and that this error here
+ * was just a spurious error */
+ if (self->last_remote_poll_interval == GST_CLOCK_TIME_NONE)
+ self->minimum_update_interval *= 2;
+
+ /* And wait a bit before we send the next packet instead of
+ * sending it immediately */
+ self->timeout_expiration =
+ gst_util_get_timestamp () +
+ gst_clock_get_timeout (GST_CLOCK_CAST (self));
+ } else {
+ GST_WARNING_OBJECT (self, "receive error: %s", err->message);
+ }
+ g_clear_error (&err);
+ }
+ } else {
+ GstNetTimePacket *packet;
+
+ packet = gst_net_time_packet_receive (socket, NULL, &err);
+
+ if (packet != NULL) {
+ GST_LOG_OBJECT (self, "got packet back");
+ GST_LOG_OBJECT (self, "local_1 = %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (packet->local_time));
+ GST_LOG_OBJECT (self, "remote = %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (packet->remote_time));
+ GST_LOG_OBJECT (self, "local_2 = %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (new_local));
+
+ /* observe_times will reset the timeout */
+ gst_net_client_internal_clock_observe_times (self, packet->local_time,
+ packet->remote_time, packet->remote_time, new_local);
+
+ g_free (packet);
+ } else if (err != NULL) {
+ GST_WARNING_OBJECT (self, "receive error: %s", err->message);
+ g_clear_error (&err);
+ }
+ }
+ }
+ }
+ GST_INFO_OBJECT (self, "shutting down net client clock thread");
return NULL;
}
static gboolean
-gst_net_client_clock_start (GstNetClientClock * self)
+gst_net_client_internal_clock_start (GstNetClientInternalClock * self)
{
- struct sockaddr_in servaddr, myaddr;
- socklen_t len;
- gint ret;
- GError *error;
+ GSocketAddress *servaddr;
+ GSocketAddress *myaddr;
+ GSocketAddress *anyaddr;
+ GInetAddress *inetaddr;
+ GSocket *socket;
+ GError *error = NULL;
+ GSocketFamily family;
+ GPollFD dummy_pollfd;
+ GResolver *resolver = NULL;
+ GError *err = NULL;
g_return_val_if_fail (self->address != NULL, FALSE);
g_return_val_if_fail (self->servaddr == NULL, FALSE);
- if ((ret = socket (AF_INET, SOCK_DGRAM, 0)) < 0)
- goto no_socket;
+ /* create target address */
+ inetaddr = g_inet_address_new_from_string (self->address);
+ if (inetaddr == NULL) {
+ GList *results;
- self->priv->sock.fd = ret;
+ resolver = g_resolver_get_default ();
- len = sizeof (myaddr);
- ret = getsockname (self->priv->sock.fd, (struct sockaddr *) &myaddr, &len);
- if (ret < 0)
- goto getsockname_error;
+ results = g_resolver_lookup_by_name (resolver, self->address, NULL, &err);
+ if (!results)
+ goto failed_to_resolve;
- memset (&servaddr, 0, sizeof (servaddr));
- servaddr.sin_family = AF_INET; /* host byte order */
- servaddr.sin_port = htons (self->port); /* short, network byte order */
+ inetaddr = G_INET_ADDRESS (g_object_ref (results->data));
+ g_resolver_free_addresses (results);
+ g_object_unref (resolver);
+ }
- GST_DEBUG_OBJECT (self, "socket opened on UDP port %hd",
- ntohs (servaddr.sin_port));
+ family = g_inet_address_get_family (inetaddr);
- if (!inet_aton (self->address, &servaddr.sin_addr))
- goto bad_address;
+ servaddr = g_inet_socket_address_new (inetaddr, self->port);
+ g_object_unref (inetaddr);
- self->servaddr = g_malloc (sizeof (struct sockaddr_in));
- memcpy (self->servaddr, &servaddr, sizeof (servaddr));
+ g_assert (servaddr != NULL);
GST_DEBUG_OBJECT (self, "will communicate with %s:%d", self->address,
self->port);
- gst_poll_add_fd (self->priv->fdset, &self->priv->sock);
- gst_poll_fd_ctl_read (self->priv->fdset, &self->priv->sock, TRUE);
+ socket = g_socket_new (family, G_SOCKET_TYPE_DATAGRAM,
+ G_SOCKET_PROTOCOL_UDP, &error);
+
+ if (socket == NULL)
+ goto no_socket;
+
+ GST_DEBUG_OBJECT (self, "binding socket");
+ inetaddr = g_inet_address_new_any (family);
+ anyaddr = g_inet_socket_address_new (inetaddr, 0);
+ g_socket_bind (socket, anyaddr, TRUE, &error);
+ g_object_unref (anyaddr);
+ g_object_unref (inetaddr);
+
+ if (error != NULL)
+ goto bind_error;
+
+ /* check address we're bound to, mostly for debugging purposes */
+ myaddr = g_socket_get_local_address (socket, &error);
+
+ if (myaddr == NULL)
+ goto getsockname_error;
+
+ GST_DEBUG_OBJECT (self, "socket opened on UDP port %d",
+ g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (myaddr)));
+
+ g_object_unref (myaddr);
- self->thread = g_thread_create (gst_net_client_clock_thread, self, TRUE,
- &error);
- if (!self->thread)
+ self->cancel = g_cancellable_new ();
+ self->made_cancel_fd =
+ g_cancellable_make_pollfd (self->cancel, &dummy_pollfd);
+
+ self->socket = socket;
+ self->servaddr = G_SOCKET_ADDRESS (servaddr);
+
+ self->thread = g_thread_try_new ("GstNetClientInternalClock",
+ gst_net_client_internal_clock_thread, self, &error);
+
+ if (error != NULL)
goto no_thread;
return TRUE;
/* ERRORS */
no_socket:
{
- GST_ERROR_OBJECT (self, "socket failed %d: %s (%d)", ret,
- g_strerror (errno), errno);
+ GST_ERROR_OBJECT (self, "socket_new() failed: %s", error->message);
+ g_error_free (error);
+ return FALSE;
+ }
+bind_error:
+ {
+ GST_ERROR_OBJECT (self, "bind failed: %s", error->message);
+ g_error_free (error);
+ g_object_unref (socket);
return FALSE;
}
getsockname_error:
{
- GST_ERROR_OBJECT (self, "getsockname failed %d: %s (%d)", ret,
- g_strerror (errno), errno);
- close (self->priv->sock.fd);
- self->priv->sock.fd = -1;
+ GST_ERROR_OBJECT (self, "get_local_address() failed: %s", error->message);
+ g_error_free (error);
+ g_object_unref (socket);
return FALSE;
}
-bad_address:
+failed_to_resolve:
{
- GST_ERROR_OBJECT (self, "inet_aton failed %d: %s (%d)", ret,
- g_strerror (errno), errno);
- close (self->priv->sock.fd);
- self->priv->sock.fd = -1;
+ GST_ERROR_OBJECT (self, "resolving '%s' failed: %s",
+ self->address, err->message);
+ g_clear_error (&err);
+ g_object_unref (resolver);
return FALSE;
}
no_thread:
{
GST_ERROR_OBJECT (self, "could not create thread: %s", error->message);
- gst_poll_remove_fd (self->priv->fdset, &self->priv->sock);
- close (self->priv->sock.fd);
- self->priv->sock.fd = -1;
- g_free (self->servaddr);
+ g_object_unref (self->servaddr);
self->servaddr = NULL;
+ g_object_unref (self->socket);
+ self->socket = NULL;
g_error_free (error);
return FALSE;
}
}
static void
-gst_net_client_clock_stop (GstNetClientClock * self)
+gst_net_client_internal_clock_stop (GstNetClientInternalClock * self)
{
- gst_poll_set_flushing (self->priv->fdset, TRUE);
+ if (self->thread == NULL)
+ return;
+
+ GST_INFO_OBJECT (self, "stopping...");
+ g_cancellable_cancel (self->cancel);
+
g_thread_join (self->thread);
self->thread = NULL;
- if (self->priv->sock.fd != -1) {
- gst_poll_remove_fd (self->priv->fdset, &self->priv->sock);
- close (self->priv->sock.fd);
- self->priv->sock.fd = -1;
+ if (self->made_cancel_fd)
+ g_cancellable_release_fd (self->cancel);
+
+ g_object_unref (self->cancel);
+ self->cancel = NULL;
+
+ g_object_unref (self->servaddr);
+ self->servaddr = NULL;
+
+ g_object_unref (self->socket);
+ self->socket = NULL;
+
+ GST_INFO_OBJECT (self, "stopped");
+}
+
+#define GST_NET_CLIENT_CLOCK_GET_PRIVATE(obj) \
+ (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_NET_CLIENT_CLOCK, GstNetClientClockPrivate))
+
+struct _GstNetClientClockPrivate
+{
+ GstClock *internal_clock;
+
+ GstClockTime roundtrip_limit;
+ GstClockTime minimum_update_interval;
+
+ GstClockTime base_time, internal_base_time;
+
+ gchar *address;
+ gint port;
+
+ GstBus *bus;
+
+ gboolean is_ntp;
+
+ gulong synced_id;
+};
+
+G_DEFINE_TYPE (GstNetClientClock, gst_net_client_clock, GST_TYPE_SYSTEM_CLOCK);
+
+static void gst_net_client_clock_finalize (GObject * object);
+static void gst_net_client_clock_set_property (GObject * object, guint prop_id,
+ const GValue * value, GParamSpec * pspec);
+static void gst_net_client_clock_get_property (GObject * object, guint prop_id,
+ GValue * value, GParamSpec * pspec);
+static void gst_net_client_clock_constructed (GObject * object);
+
+static GstClockTime gst_net_client_clock_get_internal_time (GstClock * clock);
+
+static void
+gst_net_client_clock_class_init (GstNetClientClockClass * klass)
+{
+ GObjectClass *gobject_class;
+ GstClockClass *clock_class;
+
+ gobject_class = G_OBJECT_CLASS (klass);
+ clock_class = GST_CLOCK_CLASS (klass);
+
+ g_type_class_add_private (klass, sizeof (GstNetClientClockPrivate));
+
+ gobject_class->finalize = gst_net_client_clock_finalize;
+ gobject_class->get_property = gst_net_client_clock_get_property;
+ gobject_class->set_property = gst_net_client_clock_set_property;
+ gobject_class->constructed = gst_net_client_clock_constructed;
+
+ g_object_class_install_property (gobject_class, PROP_ADDRESS,
+ g_param_spec_string ("address", "address",
+ "The IP address of the machine providing a time server",
+ DEFAULT_ADDRESS,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+ g_object_class_install_property (gobject_class, PROP_PORT,
+ g_param_spec_int ("port", "port",
+ "The port on which the remote server is listening", 0, G_MAXUINT16,
+ DEFAULT_PORT,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
+ g_object_class_install_property (gobject_class, PROP_BUS,
+ g_param_spec_object ("bus", "bus",
+ "A GstBus on which to send clock status information", GST_TYPE_BUS,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ /**
+ * GstNetClientInternalClock::round-trip-limit:
+ *
+ * Maximum allowed round-trip for packets. If this property is set to a nonzero
+ * value, all packets with a round-trip interval larger than this limit will be
+ * ignored. This is useful for networks with severe and fluctuating transport
+ * delays. Filtering out these packets increases stability of the synchronization.
+ * On the other hand, the lower the limit, the higher the amount of filtered
+ * packets. Empirical tests are typically necessary to estimate a good value
+ * for the limit.
+ * If the property is set to zero, the limit is disabled.
+ *
+ * Since: 1.4
+ */
+ g_object_class_install_property (gobject_class, PROP_ROUNDTRIP_LIMIT,
+ g_param_spec_uint64 ("round-trip-limit", "round-trip limit",
+ "Maximum tolerable round-trip interval for packets, in nanoseconds "
+ "(0 = no limit)", 0, G_MAXUINT64, DEFAULT_ROUNDTRIP_LIMIT,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (gobject_class, PROP_MINIMUM_UPDATE_INTERVAL,
+ g_param_spec_uint64 ("minimum-update-interval", "minimum update interval",
+ "Minimum polling interval for packets, in nanoseconds"
+ "(0 = no limit)", 0, G_MAXUINT64, DEFAULT_MINIMUM_UPDATE_INTERVAL,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (gobject_class, PROP_BASE_TIME,
+ g_param_spec_uint64 ("base-time", "Base Time",
+ "Initial time that is reported before synchronization", 0,
+ G_MAXUINT64, DEFAULT_BASE_TIME,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (gobject_class, PROP_INTERNAL_CLOCK,
+ g_param_spec_object ("internal-clock", "Internal Clock",
+ "Internal clock that directly slaved to the remote clock",
+ GST_TYPE_CLOCK, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
+
+ clock_class->get_internal_time = gst_net_client_clock_get_internal_time;
+}
+
+static void
+gst_net_client_clock_init (GstNetClientClock * self)
+{
+ GstNetClientClockPrivate *priv;
+ GstClock *clock;
+
+ self->priv = priv = GST_NET_CLIENT_CLOCK_GET_PRIVATE (self);
+
+ GST_OBJECT_FLAG_SET (self, GST_CLOCK_FLAG_CAN_SET_MASTER);
+ GST_OBJECT_FLAG_SET (self, GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC);
+
+ priv->port = DEFAULT_PORT;
+ priv->address = g_strdup (DEFAULT_ADDRESS);
+
+ priv->roundtrip_limit = DEFAULT_ROUNDTRIP_LIMIT;
+ priv->minimum_update_interval = DEFAULT_MINIMUM_UPDATE_INTERVAL;
+
+ clock = gst_system_clock_obtain ();
+ priv->base_time = DEFAULT_BASE_TIME;
+ priv->internal_base_time = gst_clock_get_time (clock);
+ gst_object_unref (clock);
+}
+
+/* Must be called with clocks_lock */
+static void
+update_clock_cache (ClockCache * cache)
+{
+ GstClockTime roundtrip_limit = 0, minimum_update_interval = 0;
+ GList *l, *busses = NULL;
+
+ GST_OBJECT_LOCK (cache->clock);
+ g_list_free_full (GST_NET_CLIENT_INTERNAL_CLOCK (cache->clock)->busses,
+ (GDestroyNotify) gst_object_unref);
+
+ for (l = cache->clocks; l; l = l->next) {
+ GstNetClientClock *clock = l->data;
+
+ if (clock->priv->bus)
+ busses = g_list_prepend (busses, gst_object_ref (clock->priv->bus));
+
+ if (roundtrip_limit == 0)
+ roundtrip_limit = clock->priv->roundtrip_limit;
+ else
+ roundtrip_limit = MAX (roundtrip_limit, clock->priv->roundtrip_limit);
+
+ if (minimum_update_interval == 0)
+ minimum_update_interval = clock->priv->minimum_update_interval;
+ else
+ minimum_update_interval =
+ MIN (minimum_update_interval, clock->priv->minimum_update_interval);
}
+ GST_NET_CLIENT_INTERNAL_CLOCK (cache->clock)->busses = busses;
+ GST_NET_CLIENT_INTERNAL_CLOCK (cache->clock)->roundtrip_limit =
+ roundtrip_limit;
+ GST_NET_CLIENT_INTERNAL_CLOCK (cache->clock)->minimum_update_interval =
+ minimum_update_interval;
+
+ GST_OBJECT_UNLOCK (cache->clock);
+}
+
+static gboolean
+remove_clock_cache (GstClock * clock, GstClockTime time, GstClockID id,
+ gpointer user_data)
+{
+ ClockCache *cache = user_data;
+
+ G_LOCK (clocks_lock);
+ if (!cache->clocks) {
+ gst_clock_id_unref (cache->remove_id);
+ gst_object_unref (cache->clock);
+ clocks = g_list_remove (clocks, cache);
+ g_free (cache);
+ }
+ G_UNLOCK (clocks_lock);
+
+ return TRUE;
+}
+
+static void
+gst_net_client_clock_finalize (GObject * object)
+{
+ GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object);
+ GList *l;
+
+ if (self->priv->synced_id)
+ g_signal_handler_disconnect (self->priv->internal_clock,
+ self->priv->synced_id);
+ self->priv->synced_id = 0;
+
+ G_LOCK (clocks_lock);
+ for (l = clocks; l; l = l->next) {
+ ClockCache *cache = l->data;
+
+ if (cache->clock == self->priv->internal_clock) {
+ cache->clocks = g_list_remove (cache->clocks, self);
+
+ if (cache->clocks) {
+ update_clock_cache (cache);
+ } else {
+ GstClock *sysclock = gst_system_clock_obtain ();
+ GstClockTime time = gst_clock_get_time (sysclock) + 60 * GST_SECOND;
+
+ cache->remove_id = gst_clock_new_single_shot_id (sysclock, time);
+ gst_clock_id_wait_async (cache->remove_id, remove_clock_cache, cache,
+ NULL);
+ gst_object_unref (sysclock);
+ }
+ break;
+ }
+ }
+ G_UNLOCK (clocks_lock);
+
+ g_free (self->priv->address);
+ self->priv->address = NULL;
+
+ if (self->priv->bus != NULL) {
+ gst_object_unref (self->priv->bus);
+ self->priv->bus = NULL;
+ }
+
+ G_OBJECT_CLASS (gst_net_client_clock_parent_class)->finalize (object);
+}
+
+static void
+gst_net_client_clock_set_property (GObject * object, guint prop_id,
+ const GValue * value, GParamSpec * pspec)
+{
+ GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object);
+ gboolean update = FALSE;
+
+ switch (prop_id) {
+ case PROP_ADDRESS:
+ GST_OBJECT_LOCK (self);
+ g_free (self->priv->address);
+ self->priv->address = g_value_dup_string (value);
+ if (self->priv->address == NULL)
+ self->priv->address = g_strdup (DEFAULT_ADDRESS);
+ GST_OBJECT_UNLOCK (self);
+ break;
+ case PROP_PORT:
+ GST_OBJECT_LOCK (self);
+ self->priv->port = g_value_get_int (value);
+ GST_OBJECT_UNLOCK (self);
+ break;
+ case PROP_ROUNDTRIP_LIMIT:
+ GST_OBJECT_LOCK (self);
+ self->priv->roundtrip_limit = g_value_get_uint64 (value);
+ GST_OBJECT_UNLOCK (self);
+ update = TRUE;
+ break;
+ case PROP_MINIMUM_UPDATE_INTERVAL:
+ GST_OBJECT_LOCK (self);
+ self->priv->minimum_update_interval = g_value_get_uint64 (value);
+ GST_OBJECT_UNLOCK (self);
+ update = TRUE;
+ break;
+ case PROP_BUS:
+ GST_OBJECT_LOCK (self);
+ if (self->priv->bus)
+ gst_object_unref (self->priv->bus);
+ self->priv->bus = g_value_dup_object (value);
+ GST_OBJECT_UNLOCK (self);
+ update = TRUE;
+ break;
+ case PROP_BASE_TIME:{
+ GstClock *clock;
+
+ self->priv->base_time = g_value_get_uint64 (value);
+ clock = gst_system_clock_obtain ();
+ self->priv->internal_base_time = gst_clock_get_time (clock);
+ gst_object_unref (clock);
+ break;
+ }
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+
+ if (update && self->priv->internal_clock) {
+ GList *l;
+
+ G_LOCK (clocks_lock);
+ for (l = clocks; l; l = l->next) {
+ ClockCache *cache = l->data;
+
+ if (cache->clock == self->priv->internal_clock) {
+ update_clock_cache (cache);
+ }
+ }
+ G_UNLOCK (clocks_lock);
+ }
+}
+
+static void
+gst_net_client_clock_get_property (GObject * object, guint prop_id,
+ GValue * value, GParamSpec * pspec)
+{
+ GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object);
+
+ switch (prop_id) {
+ case PROP_ADDRESS:
+ GST_OBJECT_LOCK (self);
+ g_value_set_string (value, self->priv->address);
+ GST_OBJECT_UNLOCK (self);
+ break;
+ case PROP_PORT:
+ g_value_set_int (value, self->priv->port);
+ break;
+ case PROP_ROUNDTRIP_LIMIT:
+ GST_OBJECT_LOCK (self);
+ g_value_set_uint64 (value, self->priv->roundtrip_limit);
+ GST_OBJECT_UNLOCK (self);
+ break;
+ case PROP_MINIMUM_UPDATE_INTERVAL:
+ GST_OBJECT_LOCK (self);
+ g_value_set_uint64 (value, self->priv->minimum_update_interval);
+ GST_OBJECT_UNLOCK (self);
+ break;
+ case PROP_BUS:
+ GST_OBJECT_LOCK (self);
+ g_value_set_object (value, self->priv->bus);
+ GST_OBJECT_UNLOCK (self);
+ break;
+ case PROP_BASE_TIME:
+ g_value_set_uint64 (value, self->priv->base_time);
+ break;
+ case PROP_INTERNAL_CLOCK:
+ g_value_set_object (value, self->priv->internal_clock);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gst_net_client_clock_synced_cb (GstClock * internal_clock, gboolean synced,
+ GstClock * self)
+{
+ gst_clock_set_synced (self, synced);
+}
+
+static void
+gst_net_client_clock_constructed (GObject * object)
+{
+ GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object);
+ GstClock *internal_clock;
+ GList *l;
+ ClockCache *cache = NULL;
+
+ G_OBJECT_CLASS (gst_net_client_clock_parent_class)->constructed (object);
+
+ G_LOCK (clocks_lock);
+ for (l = clocks; l; l = l->next) {
+ ClockCache *tmp = l->data;
+ GstNetClientInternalClock *internal_clock =
+ GST_NET_CLIENT_INTERNAL_CLOCK (tmp->clock);
+
+ if (strcmp (internal_clock->address, self->priv->address) == 0 &&
+ internal_clock->port == self->priv->port) {
+ cache = tmp;
+
+ if (cache->remove_id) {
+ gst_clock_id_unschedule (cache->remove_id);
+ cache->remove_id = NULL;
+ }
+ break;
+ }
+ }
+
+ if (!cache) {
+ cache = g_new0 (ClockCache, 1);
+
+ cache->clock =
+ g_object_new (GST_TYPE_NET_CLIENT_INTERNAL_CLOCK, "address",
+ self->priv->address, "port", self->priv->port, "is-ntp",
+ self->priv->is_ntp, NULL);
+ clocks = g_list_prepend (clocks, cache);
+
+ /* Not actually leaked but is cached for a while before being disposed,
+ * see gst_net_client_clock_finalize, so pretend it is to not confuse
+ * tests. */
+ GST_OBJECT_FLAG_SET (cache->clock, GST_OBJECT_FLAG_MAY_BE_LEAKED);
+ }
+
+ cache->clocks = g_list_prepend (cache->clocks, self);
+
+ GST_OBJECT_LOCK (cache->clock);
+ if (gst_clock_is_synced (cache->clock))
+ gst_clock_set_synced (GST_CLOCK (self), TRUE);
+ self->priv->synced_id =
+ g_signal_connect (cache->clock, "synced",
+ G_CALLBACK (gst_net_client_clock_synced_cb), self);
+ GST_OBJECT_UNLOCK (cache->clock);
+
+ G_UNLOCK (clocks_lock);
+
+ self->priv->internal_clock = internal_clock = cache->clock;
+
+ /* all systems go, cap'n */
+}
+
+static GstClockTime
+gst_net_client_clock_get_internal_time (GstClock * clock)
+{
+ GstNetClientClock *self = GST_NET_CLIENT_CLOCK (clock);
+
+ if (!gst_clock_is_synced (self->priv->internal_clock)) {
+ GstClockTime now = gst_clock_get_internal_time (self->priv->internal_clock);
+ return gst_clock_adjust_with_calibration (self->priv->internal_clock, now,
+ self->priv->internal_base_time, self->priv->base_time, 1, 1);
+ }
+
+ return gst_clock_get_time (self->priv->internal_clock);
}
/**
* gst_net_client_clock_new:
* @name: a name for the clock
- * @remote_address: the address of the remote clock provider
+ * @remote_address: the address or hostname of the remote clock provider
* @remote_port: the port of the remote clock provider
* @base_time: initial time of the clock
*
- * Create a new #GstNetClientClock that will report the time
+ * Create a new #GstNetClientInternalClock that will report the time
* provided by the #GstNetTimeProvider on @remote_address and
* @remote_port.
*
* clock.
*/
GstClock *
-gst_net_client_clock_new (gchar * name, const gchar * remote_address,
+gst_net_client_clock_new (const gchar * name, const gchar * remote_address,
gint remote_port, GstClockTime base_time)
{
- GstNetClientClock *ret;
- GstClockTime internal;
+ GstClock *ret;
g_return_val_if_fail (remote_address != NULL, NULL);
g_return_val_if_fail (remote_port > 0, NULL);
g_return_val_if_fail (base_time != GST_CLOCK_TIME_NONE, NULL);
ret = g_object_new (GST_TYPE_NET_CLIENT_CLOCK, "address", remote_address,
- "port", remote_port, NULL);
+ "port", remote_port, "base-time", base_time, NULL);
- /* gst_clock_get_time() values are guaranteed to be increasing. because no one
- * has called get_time on this clock yet we are free to adjust to any value
- * without worrying about worrying about MAX() issues with the clock's
- * internal time.
- */
+ return ret;
+}
- /* update our internal time so get_time() give something around base_time.
- assume that the rate is 1 in the beginning. */
- internal = gst_clock_get_internal_time (GST_CLOCK (ret));
- gst_clock_set_calibration (GST_CLOCK (ret), internal, base_time, 1, 1);
+G_DEFINE_TYPE (GstNtpClock, gst_ntp_clock, GST_TYPE_NET_CLIENT_CLOCK);
- {
- GstClockTime now = gst_clock_get_time (GST_CLOCK (ret));
+static void
+gst_ntp_clock_class_init (GstNtpClockClass * klass)
+{
+}
- if (GST_CLOCK_DIFF (now, base_time) > 0 ||
- GST_CLOCK_DIFF (now, base_time + GST_SECOND) < 0) {
- g_warning ("unable to set the base time, expect sync problems!");
- }
- }
+static void
+gst_ntp_clock_init (GstNtpClock * self)
+{
+ GST_NET_CLIENT_CLOCK (self)->priv->is_ntp = TRUE;
+}
- if ((ret->priv->fdset = gst_poll_new (TRUE)) == NULL)
- goto no_fdset;
+/**
+ * gst_ntp_clock_new:
+ * @name: a name for the clock
+ * @remote_address: the address or hostname of the remote clock provider
+ * @remote_port: the port of the remote clock provider
+ * @base_time: initial time of the clock
+ *
+ * Create a new #GstNtpClock that will report the time provided by
+ * the NTPv4 server on @remote_address and @remote_port.
+ *
+ * Returns: a new #GstClock that receives a time from the remote
+ * clock.
+ *
+ * Since: 1.6
+ */
+GstClock *
+gst_ntp_clock_new (const gchar * name, const gchar * remote_address,
+ gint remote_port, GstClockTime base_time)
+{
+ GstClock *ret;
- if (!gst_net_client_clock_start (ret))
- goto failed_start;
+ g_return_val_if_fail (remote_address != NULL, NULL);
+ g_return_val_if_fail (remote_port > 0, NULL);
+ g_return_val_if_fail (remote_port <= G_MAXUINT16, NULL);
+ g_return_val_if_fail (base_time != GST_CLOCK_TIME_NONE, NULL);
- /* all systems go, cap'n */
- return (GstClock *) ret;
+ ret = g_object_new (GST_TYPE_NTP_CLOCK, "address", remote_address,
+ "port", remote_port, "base-time", base_time, NULL);
-no_fdset:
- {
- GST_ERROR_OBJECT (ret, "could not create an fdset: %s (%d)",
- g_strerror (errno), errno);
- gst_object_unref (ret);
- return NULL;
- }
-failed_start:
- {
- /* already printed a nice error */
- gst_object_unref (ret);
- return NULL;
- }
+ return ret;
}
projects / platform / upstream / gstreamer.git / blobdiff