2
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
3
* 2005 Wim Taymans <wim@fluendo.com>
4
* 2005 Andy Wingo <wingo@pobox.com>
5
* Copyright (C) 2012 Collabora Ltd. <tim.muller@collabora.co.uk>
7
* gstnetclientclock.h: clock that synchronizes itself to a time provider over
10
* This library is free software; you can redistribute it and/or
11
* modify it under the terms of the GNU Library General Public
12
* License as published by the Free Software Foundation; either
13
* version 2 of the License, or (at your option) any later version.
15
* This library is distributed in the hope that it will be useful,
16
* but WITHOUT ANY WARRANTY; without even the implied warranty of
17
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18
* Library General Public License for more details.
20
* You should have received a copy of the GNU Library General Public
21
* License along with this library; if not, write to the
22
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23
* Boston, MA 02111-1307, USA.
26
* SECTION:gstnetclientclock
27
* @short_description: Special clock that synchronizes to a remote time
29
* @see_also: #GstClock, #GstNetTimeProvider, #GstPipeline
31
* This object implements a custom #GstClock that synchronizes its time
32
* to a remote time provider such as #GstNetTimeProvider.
34
* A new clock is created with gst_net_client_clock_new() which takes the
35
* address and port of the remote time provider along with a name and
38
* This clock will poll the time provider and will update its calibration
39
* parameters based on the local and remote observations.
41
* Various parameters of the clock can be configured with the parent #GstClock
42
* "timeout", "window-size" and "window-threshold" object properties.
44
* A #GstNetClientClock is typically set on a #GstPipeline with
45
* gst_pipeline_use_clock().
47
* Last reviewed on 2005-11-23 (0.9.5)
54
#include "gstnettimepacket.h"
55
#include "gstnetclientclock.h"
59
GST_DEBUG_CATEGORY_STATIC (ncc_debug);
60
#define GST_CAT_DEFAULT (ncc_debug)
62
#define DEFAULT_ADDRESS "127.0.0.1"
63
#define DEFAULT_PORT 5637
64
#define DEFAULT_TIMEOUT GST_SECOND
73
#define GST_NET_CLIENT_CLOCK_GET_PRIVATE(obj) \
74
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_NET_CLIENT_CLOCK, GstNetClientClockPrivate))
76
struct _GstNetClientClockPrivate
81
GSocketAddress *servaddr;
84
GstClockTime timeout_expiration;
91
GST_DEBUG_CATEGORY_INIT (ncc_debug, "netclock", 0, "Network client clock");
92
#define gst_net_client_clock_parent_class parent_class
93
G_DEFINE_TYPE_WITH_CODE (GstNetClientClock, gst_net_client_clock,
94
GST_TYPE_SYSTEM_CLOCK, _do_init);
96
static void gst_net_client_clock_finalize (GObject * object);
97
static void gst_net_client_clock_set_property (GObject * object, guint prop_id,
98
const GValue * value, GParamSpec * pspec);
99
static void gst_net_client_clock_get_property (GObject * object, guint prop_id,
100
GValue * value, GParamSpec * pspec);
102
static void gst_net_client_clock_stop (GstNetClientClock * self);
105
gst_net_client_clock_class_init (GstNetClientClockClass * klass)
107
GObjectClass *gobject_class;
109
gobject_class = G_OBJECT_CLASS (klass);
111
g_type_class_add_private (klass, sizeof (GstNetClientClockPrivate));
113
gobject_class->finalize = gst_net_client_clock_finalize;
114
gobject_class->get_property = gst_net_client_clock_get_property;
115
gobject_class->set_property = gst_net_client_clock_set_property;
117
g_object_class_install_property (gobject_class, PROP_ADDRESS,
118
g_param_spec_string ("address", "address",
119
"The IP address of the machine providing a time server",
120
DEFAULT_ADDRESS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
121
g_object_class_install_property (gobject_class, PROP_PORT,
122
g_param_spec_int ("port", "port",
123
"The port on which the remote server is listening", 0, G_MAXUINT16,
124
DEFAULT_PORT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
128
gst_net_client_clock_init (GstNetClientClock * self)
130
GstClock *clock = GST_CLOCK_CAST (self);
131
GstNetClientClockPrivate *priv;
133
self->priv = priv = GST_NET_CLIENT_CLOCK_GET_PRIVATE (self);
135
priv->port = DEFAULT_PORT;
136
priv->address = g_strdup (DEFAULT_ADDRESS);
138
gst_clock_set_timeout (clock, DEFAULT_TIMEOUT);
142
priv->servaddr = NULL;
146
gst_net_client_clock_finalize (GObject * object)
148
GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object);
150
if (self->priv->thread) {
151
gst_net_client_clock_stop (self);
154
g_free (self->priv->address);
155
self->priv->address = NULL;
157
if (self->priv->servaddr != NULL) {
158
g_object_unref (self->priv->servaddr);
159
self->priv->servaddr = NULL;
162
if (self->priv->socket != NULL) {
163
g_socket_close (self->priv->socket, NULL);
164
g_object_unref (self->priv->socket);
165
self->priv->socket = NULL;
168
G_OBJECT_CLASS (parent_class)->finalize (object);
172
gst_net_client_clock_set_property (GObject * object, guint prop_id,
173
const GValue * value, GParamSpec * pspec)
175
GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object);
179
g_free (self->priv->address);
180
self->priv->address = g_value_dup_string (value);
181
if (self->priv->address == NULL)
182
self->priv->address = g_strdup (DEFAULT_ADDRESS);
185
self->priv->port = g_value_get_int (value);
188
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
194
gst_net_client_clock_get_property (GObject * object, guint prop_id,
195
GValue * value, GParamSpec * pspec)
197
GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object);
201
g_value_set_string (value, self->priv->address);
204
g_value_set_int (value, self->priv->port);
207
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
213
gst_net_client_clock_observe_times (GstNetClientClock * self,
214
GstClockTime local_1, GstClockTime remote, GstClockTime local_2)
216
GstClockTime current_timeout;
217
GstClockTime local_avg;
221
if (local_2 < local_1)
222
goto bogus_observation;
224
local_avg = (local_2 + local_1) / 2;
226
clock = GST_CLOCK_CAST (self);
228
if (gst_clock_add_observation (GST_CLOCK (self), local_avg, remote,
231
current_timeout = (1e-3 / (1 - MIN (r_squared, 0.99999))) * GST_SECOND;
232
current_timeout = MIN (current_timeout, gst_clock_get_timeout (clock));
237
GST_INFO ("next timeout: %" GST_TIME_FORMAT, GST_TIME_ARGS (current_timeout));
238
self->priv->timeout_expiration = gst_util_get_timestamp () + current_timeout;
244
GST_WARNING_OBJECT (self, "time packet receive time < send time (%"
245
GST_TIME_FORMAT " < %" GST_TIME_FORMAT ")", GST_TIME_ARGS (local_1),
246
GST_TIME_ARGS (local_2));
254
GstNetClientClock *clock;
256
} GstNetClientClockTimeoutSource;
259
gst_net_client_clock_timeout_source_prepare (GSource * s, gint * p_timeout)
261
GstNetClientClockTimeoutSource *source = (GstNetClientClockTimeoutSource *) s;
262
GstClockTime expiration_time = source->clock->priv->timeout_expiration;
263
GstClockTime now = gst_util_get_timestamp ();
265
if (now >= expiration_time || (expiration_time - now) <= GST_MSECOND) {
270
*p_timeout = (expiration_time - now) / GST_MSECOND;
271
GST_TRACE_OBJECT (source->clock, "time out in %d ms please", *p_timeout);
276
gst_net_client_clock_timeout_source_check (GSource * s)
278
GstNetClientClockTimeoutSource *source = (GstNetClientClockTimeoutSource *) s;
280
return (gst_util_get_timestamp () >= source->clock->priv->timeout_expiration);
284
gst_net_client_clock_timeout_source_dispatch (GSource * s, GSourceFunc cb,
287
GstNetClientClockTimeoutSource *source = (GstNetClientClockTimeoutSource *) s;
289
GST_TRACE_OBJECT (source->clock, "timed out");
290
*source->p_timeout = TRUE;
295
gst_net_client_clock_socket_cb (GSocket * socket, GIOCondition condition,
298
GIOCondition *p_cond = user_data;
300
GST_TRACE ("socket %p I/O condition: 0x%02x", socket, condition);
306
gst_net_client_clock_thread (gpointer data)
308
GstNetClientClock *self = data;
309
GstNetTimePacket *packet;
311
GSourceFuncs funcs = { NULL, };
315
GSocket *socket = self->priv->socket;
317
GstClock *clock = data;
319
GST_INFO_OBJECT (self, "net client clock thread running, socket=%p", socket);
321
g_socket_set_blocking (socket, TRUE);
322
g_socket_set_timeout (socket, 0);
324
ctx = g_main_context_new ();
326
source = g_socket_create_source (socket, G_IO_IN, self->priv->cancel);
327
g_source_set_name (source, "GStreamer net client clock thread socket");
328
g_source_set_callback (source, (GSourceFunc) gst_net_client_clock_socket_cb,
330
g_source_attach (source, ctx);
331
g_source_unref (source);
333
/* GSocket only support second granularity for timeouts, so roll our own
334
* timeout source (so we don't have to create a new source whenever the
335
* timeout changes, as we would have to do with the default timeout source) */
336
funcs.prepare = gst_net_client_clock_timeout_source_prepare;
337
funcs.check = gst_net_client_clock_timeout_source_check;
338
funcs.dispatch = gst_net_client_clock_timeout_source_dispatch;
339
funcs.finalize = NULL;
340
source = g_source_new (&funcs, sizeof (GstNetClientClockTimeoutSource));
341
((GstNetClientClockTimeoutSource *) source)->clock = self;
342
((GstNetClientClockTimeoutSource *) source)->p_timeout = &timeout;
343
g_source_set_name (source, "GStreamer net client clock timeout");
344
g_source_attach (source, ctx);
345
g_source_unref (source);
347
while (!g_cancellable_is_cancelled (self->priv->cancel)) {
350
g_main_context_iteration (ctx, TRUE);
352
if (g_cancellable_is_cancelled (self->priv->cancel))
356
/* timed out, let's send another packet */
357
GST_DEBUG_OBJECT (self, "timed out");
359
packet = gst_net_time_packet_new (NULL);
361
packet->local_time = gst_clock_get_internal_time (GST_CLOCK (self));
363
GST_DEBUG_OBJECT (self, "sending packet, local time = %" GST_TIME_FORMAT,
364
GST_TIME_ARGS (packet->local_time));
366
gst_net_time_packet_send (packet, self->priv->socket,
367
self->priv->servaddr, NULL);
371
/* reset timeout (but are expecting a response sooner anyway) */
372
self->priv->timeout_expiration =
373
gst_util_get_timestamp () + gst_clock_get_timeout (clock);
377
/* got data to read? */
378
if ((cond & G_IO_IN)) {
379
GstClockTime new_local;
381
new_local = gst_clock_get_internal_time (GST_CLOCK (self));
383
packet = gst_net_time_packet_receive (socket, NULL, &err);
386
GST_WARNING_OBJECT (self, "receive error: %s", err->message);
392
GST_LOG_OBJECT (self, "got packet back");
393
GST_LOG_OBJECT (self, "local_1 = %" GST_TIME_FORMAT,
394
GST_TIME_ARGS (packet->local_time));
395
GST_LOG_OBJECT (self, "remote = %" GST_TIME_FORMAT,
396
GST_TIME_ARGS (packet->remote_time));
397
GST_LOG_OBJECT (self, "local_2 = %" GST_TIME_FORMAT,
398
GST_TIME_ARGS (new_local));
400
/* observe_times will reset the timeout */
401
gst_net_client_clock_observe_times (self, packet->local_time,
402
packet->remote_time, new_local);
408
if ((cond & (G_IO_ERR | G_IO_HUP))) {
409
GST_DEBUG_OBJECT (self, "socket error?! %s", g_strerror (errno));
410
g_usleep (G_USEC_PER_SEC / 10);
415
GST_INFO_OBJECT (self, "shutting down net client clock thread");
416
g_main_context_unref (ctx);
421
gst_net_client_clock_start (GstNetClientClock * self)
423
GSocketAddress *servaddr;
424
GSocketAddress *myaddr;
425
GInetAddress *inetaddr;
427
GError *error = NULL;
429
g_return_val_if_fail (self->priv->address != NULL, FALSE);
430
g_return_val_if_fail (self->priv->servaddr == NULL, FALSE);
432
socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM,
433
G_SOCKET_PROTOCOL_UDP, &error);
438
/* check address we're bound to, mostly for debugging purposes */
439
myaddr = g_socket_get_local_address (socket, &error);
442
goto getsockname_error;
444
GST_DEBUG_OBJECT (self, "socket opened on UDP port %hd",
445
g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (myaddr)));
447
g_object_unref (myaddr);
449
/* create target address */
450
inetaddr = g_inet_address_new_from_string (self->priv->address);
452
if (inetaddr == NULL)
455
servaddr = g_inet_socket_address_new (inetaddr, self->priv->port);
456
g_object_unref (inetaddr);
458
g_assert (servaddr != NULL);
460
GST_DEBUG_OBJECT (self, "will communicate with %s:%d", self->priv->address,
463
self->priv->cancel = g_cancellable_new ();
464
self->priv->socket = socket;
465
self->priv->servaddr = G_SOCKET_ADDRESS (servaddr);
467
self->priv->thread = g_thread_try_new ("GstNetClientClock",
468
gst_net_client_clock_thread, self, &error);
478
GST_ERROR_OBJECT (self, "socket_new() failed: %s", error->message);
479
g_error_free (error);
484
GST_ERROR_OBJECT (self, "get_local_address() failed: %s", error->message);
485
g_error_free (error);
486
g_object_unref (socket);
491
GST_ERROR_OBJECT (self, "inet_address_new_from_string('%s') failed",
492
self->priv->address);
493
g_object_unref (socket);
498
GST_ERROR_OBJECT (self, "could not create thread: %s", error->message);
499
g_object_unref (self->priv->servaddr);
500
self->priv->servaddr = NULL;
501
g_object_unref (self->priv->socket);
502
self->priv->socket = NULL;
503
g_error_free (error);
509
gst_net_client_clock_stop (GstNetClientClock * self)
511
if (self->priv->thread == NULL)
514
GST_INFO_OBJECT (self, "stopping...");
515
g_cancellable_cancel (self->priv->cancel);
517
g_thread_join (self->priv->thread);
518
self->priv->thread = NULL;
520
g_object_unref (self->priv->cancel);
521
self->priv->cancel = NULL;
523
g_object_unref (self->priv->servaddr);
524
self->priv->servaddr = NULL;
526
g_object_unref (self->priv->socket);
527
self->priv->socket = NULL;
529
GST_INFO_OBJECT (self, "stopped");
533
* gst_net_client_clock_new:
534
* @name: a name for the clock
535
* @remote_address: the address of the remote clock provider
536
* @remote_port: the port of the remote clock provider
537
* @base_time: initial time of the clock
539
* Create a new #GstNetClientClock that will report the time
540
* provided by the #GstNetTimeProvider on @remote_address and
543
* Returns: a new #GstClock that receives a time from the remote
547
gst_net_client_clock_new (gchar * name, const gchar * remote_address,
548
gint remote_port, GstClockTime base_time)
550
/* FIXME: gst_net_client_clock_new() should be a thin wrapper for g_object_new() */
551
GstNetClientClock *ret;
552
GstClockTime internal;
554
g_return_val_if_fail (remote_address != NULL, NULL);
555
g_return_val_if_fail (remote_port > 0, NULL);
556
g_return_val_if_fail (remote_port <= G_MAXUINT16, NULL);
557
g_return_val_if_fail (base_time != GST_CLOCK_TIME_NONE, NULL);
559
ret = g_object_new (GST_TYPE_NET_CLIENT_CLOCK, "address", remote_address,
560
"port", remote_port, NULL);
562
/* gst_clock_get_time() values are guaranteed to be increasing. because no one
563
* has called get_time on this clock yet we are free to adjust to any value
564
* without worrying about worrying about MAX() issues with the clock's
568
/* update our internal time so get_time() give something around base_time.
569
assume that the rate is 1 in the beginning. */
570
internal = gst_clock_get_internal_time (GST_CLOCK (ret));
571
gst_clock_set_calibration (GST_CLOCK (ret), internal, base_time, 1, 1);
574
GstClockTime now = gst_clock_get_time (GST_CLOCK (ret));
576
if (GST_CLOCK_DIFF (now, base_time) > 0 ||
577
GST_CLOCK_DIFF (now, base_time + GST_SECOND) < 0) {
578
g_warning ("unable to set the base time, expect sync problems!");
582
if (!gst_net_client_clock_start (ret))
585
/* all systems go, cap'n */
586
return (GstClock *) ret;
590
/* already printed a nice error */
591
gst_object_unref (ret);
added
removed
.pc/0001-netclientclock-simplify-by-using-g_socket_condition_.patch/libs/gst/net/gstnetclientclock.c
