*/
/**
* SECTION:gstptpclock
+ * @title: GstPtpClock
* @short_description: Special clock that synchronizes to a remote time
* provider via PTP (IEEE1588:2008).
* @see_also: #GstClock, #GstNetClientClock, #GstPipeline
* gst_ptp_clock_new() then allows to create a GstClock that provides the PTP
* time from a master clock inside a specific PTP domain. This clock will only
* return valid timestamps once the timestamps in the PTP domain are known. To
- * check this, the GstPtpClock::internal-clock property and the related
- * notify::clock signal can be used. Once the internal clock is not NULL, the
- * PTP domain's time is known. Alternatively you can wait for this with
- * gst_ptp_clock_wait_ready().
- *
+ * check this, you can use gst_clock_wait_for_sync(), the GstClock::synced
+ * signal and gst_clock_is_synced().
*
* To gather statistics about the PTP clock synchronization,
* gst_ptp_statistics_callback_add() can be used. This gives the application
#include "gstptpclock.h"
-#ifdef HAVE_PTP
-
#include "gstptp_private.h"
+#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
+#endif
+#ifdef G_OS_WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
#include <sys/types.h>
+
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
+#elif defined(G_OS_WIN32)
+#include <io.h>
+#endif
#include <gst/base/base.h>
static GMutex ptp_lock;
static GCond ptp_cond;
static gboolean initted = FALSE;
+#ifdef HAVE_PTP
static gboolean supported = TRUE;
+#else
+static gboolean supported = FALSE;
+#endif
static GPid ptp_helper_pid;
static GThread *ptp_helper_thread;
static GMainContext *main_context;
static GMainLoop *main_loop;
static GIOChannel *stdin_channel, *stdout_channel;
static GRand *delay_req_rand;
+static GstClock *observation_system_clock;
static PtpClockIdentity ptp_clock_id = { GST_PTP_CLOCK_ID_NONE, 0 };
typedef struct
static void
ptp_pending_sync_free (PtpPendingSync * sync)
{
- if (sync->timeout_source)
+ if (sync->timeout_source) {
g_source_destroy (sync->timeout_source);
+ g_source_unref (sync->timeout_source);
+ }
g_free (sync);
}
clock_name = g_strdup_printf ("ptp-clock-%u", domain->domain);
domain->domain_clock =
g_object_new (GST_TYPE_SYSTEM_CLOCK, "name", clock_name, NULL);
+ gst_object_ref_sink (domain->domain_clock);
g_free (clock_name);
g_queue_init (&domain->pending_syncs);
domain->last_path_delays_missing = 9;
sizeof (header), &written, &err);
if (status == G_IO_STATUS_ERROR) {
g_warning ("Failed to write to stdout: %s", err->message);
+ g_clear_error (&err);
return G_SOURCE_REMOVE;
} else if (status == G_IO_STATUS_EOF) {
g_message ("EOF on stdout");
return G_SOURCE_REMOVE;
}
- sync->delay_req_send_time_local = gst_util_get_timestamp ();
+ sync->delay_req_send_time_local =
+ gst_clock_get_time (observation_system_clock);
status =
g_io_channel_write_chars (stdout_channel,
(const gchar *) delay_req, 44, &written, &err);
if (status == G_IO_STATUS_ERROR) {
g_warning ("Failed to write to stdout: %s", err->message);
+ g_clear_error (&err);
g_main_loop_quit (main_loop);
return G_SOURCE_REMOVE;
} else if (status == G_IO_STATUS_EOF) {
static gboolean
send_delay_req (PtpDomainData * domain, PtpPendingSync * sync)
{
- GstClockTime now = gst_util_get_timestamp ();
+ GstClockTime now = gst_clock_get_time (observation_system_clock);
guint timeout;
GSource *timeout_source;
#endif
#ifdef USE_ONLY_SYNC_WITH_DELAY
+ GstClockTime mean_path_delay;
+
if (sync->delay_req_send_time_local == GST_CLOCK_TIME_NONE)
return;
+
+ /* IEEE 1588 11.3 */
+ mean_path_delay =
+ (sync->delay_req_recv_time_remote - sync->sync_send_time_remote +
+ sync->sync_recv_time_local - sync->delay_req_send_time_local -
+ (sync->correction_field_sync + sync->correction_field_delay +
+ 32768) / 65536) / 2;
#endif
/* IEEE 1588 11.2 */
corrected_ptp_time =
sync->sync_send_time_remote +
(sync->correction_field_sync + 32768) / 65536;
+
+#ifdef USE_ONLY_SYNC_WITH_DELAY
+ corrected_local_time = sync->sync_recv_time_local - mean_path_delay;
+#else
corrected_local_time = sync->sync_recv_time_local - domain->mean_path_delay;
+#endif
#ifdef USE_MEASUREMENT_FILTERING
/* We check this here and when updating the mean path delay, because
GST_TIME_ARGS (sync->follow_up_recv_time_local),
GST_TIME_ARGS (domain->mean_path_delay));
synced = FALSE;
+ gst_clock_get_calibration (GST_CLOCK_CAST (domain->domain_clock),
+ &internal_time, &external_time, &rate_num, &rate_den);
goto out;
}
#endif
update_mean_path_delay (PtpDomainData * domain, PtpPendingSync * sync)
{
#ifdef USE_MEDIAN_PRE_FILTERING
- GstClockTime last_path_delays[G_N_ELEMENTS (domain->last_path_delays)];
+ GstClockTime last_path_delays[MEDIAN_PRE_FILTERING_WINDOW];
GstClockTime median;
gint i;
#endif
32768) / 65536) / 2;
#ifdef USE_MEDIAN_PRE_FILTERING
- for (i = 1; i < G_N_ELEMENTS (domain->last_path_delays); i++)
+ for (i = 1; i < MEDIAN_PRE_FILTERING_WINDOW; i++)
domain->last_path_delays[i - 1] = domain->last_path_delays[i];
domain->last_path_delays[i - 1] = mean_path_delay;
memcpy (&last_path_delays, &domain->last_path_delays,
sizeof (last_path_delays));
g_qsort_with_data (&last_path_delays,
- G_N_ELEMENTS (domain->last_path_delays), sizeof (GstClockTime),
+ MEDIAN_PRE_FILTERING_WINDOW, sizeof (GstClockTime),
(GCompareDataFunc) compare_clock_time, NULL);
- median = last_path_delays[G_N_ELEMENTS (last_path_delays) / 2];
+ median = last_path_delays[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
sync->sync_recv_time_local + 2 * domain->mean_path_delay) {
GST_WARNING ("Sync-follow-up delay for domain %u too big: %" GST_TIME_FORMAT
" > 2 * %" GST_TIME_FORMAT, domain->domain,
- GST_TIME_ARGS (sync->follow_up_recv_time_local),
+ GST_TIME_ARGS (sync->follow_up_recv_time_local -
+ sync->sync_recv_time_local),
GST_TIME_ARGS (domain->mean_path_delay));
ret = FALSE;
goto out;
GST_DEBUG ("Delay request delay for domain %u: %" GST_TIME_FORMAT,
domain->domain, GST_TIME_ARGS (delay_req_delay));
-#ifdef USE_MEASUREMENT_FILTERING
+#if defined(USE_MEASUREMENT_FILTERING) || defined(USE_MEDIAN_PRE_FILTERING)
out:
#endif
if (g_atomic_int_get (&domain_stats_n_hooks)) {
clock_name = g_strdup_printf ("ptp-clock-%u", domain->domain);
domain->domain_clock =
g_object_new (GST_TYPE_SYSTEM_CLOCK, "name", clock_name, NULL);
+ gst_object_ref_sink (domain->domain_clock);
g_free (clock_name);
g_queue_init (&domain->pending_syncs);
domain->last_path_delays_missing = 9;
&read, &err);
if (status == G_IO_STATUS_ERROR) {
GST_ERROR ("Failed to read from stdin: %s", err->message);
+ g_clear_error (&err);
g_main_loop_quit (main_loop);
return G_SOURCE_REMOVE;
} else if (status == G_IO_STATUS_EOF) {
status = g_io_channel_read_chars (channel, buffer, header.size, &read, &err);
if (status == G_IO_STATUS_ERROR) {
GST_ERROR ("Failed to read from stdin: %s", err->message);
+ g_clear_error (&err);
g_main_loop_quit (main_loop);
return G_SOURCE_REMOVE;
} else if (status == G_IO_STATUS_EOF) {
switch (header.type) {
case TYPE_EVENT:
case TYPE_GENERAL:{
- GstClockTime receive_time = gst_util_get_timestamp ();
+ GstClockTime receive_time = gst_clock_get_time (observation_system_clock);
PtpMessage msg;
if (parse_ptp_message (&msg, (const guint8 *) buffer, header.size)) {
static gboolean
cleanup_cb (gpointer data)
{
- GstClockTime now = gst_util_get_timestamp ();
+ GstClockTime now = gst_clock_get_time (observation_system_clock);
GList *l, *m, *n;
for (l = domain_data; l; l = l->next) {
/**
* gst_ptp_init:
* @clock_id: PTP clock id of this process' clock or %GST_PTP_CLOCK_ID_NONE
- * @interfaces: (transfer none) (array zero-terminated=1): network interfaces to run the clock on
+ * @interfaces: (transfer none) (array zero-terminated=1) (allow-none): network interfaces to run the clock on
*
* Initialize the GStreamer PTP subsystem and create a PTP ordinary clock in
* slave-only mode for all domains on the given @interfaces with the
* If @clock_id is %GST_PTP_CLOCK_ID_NONE, a clock id is automatically
* generated from the MAC address of the first network interface.
*
- *
* This function is automatically called by gst_ptp_clock_new() with default
* parameters if it wasn't called before.
*
g_io_channel_set_buffered (stdout_channel, FALSE);
delay_req_rand = g_rand_new ();
+ observation_system_clock =
+ g_object_new (GST_TYPE_SYSTEM_CLOCK, "name", "ptp-observation-clock",
+ NULL);
+ gst_object_ref_sink (observation_system_clock);
initted = TRUE;
if (!ret) {
if (ptp_helper_pid) {
+#ifndef G_OS_WIN32
kill (ptp_helper_pid, SIGKILL);
waitpid (ptp_helper_pid, NULL, 0);
+#else
+ TerminateProcess (ptp_helper_pid, 1);
+ WaitForSingleObject (ptp_helper_pid, INFINITE);
+#endif
g_spawn_close_pid (ptp_helper_pid);
}
ptp_helper_pid = 0;
if (delay_req_rand)
g_rand_free (delay_req_rand);
delay_req_rand = NULL;
+
+ if (observation_system_clock)
+ gst_object_unref (observation_system_clock);
+ observation_system_clock = NULL;
}
g_mutex_unlock (&ptp_lock);
g_mutex_lock (&ptp_lock);
if (ptp_helper_pid) {
+#ifndef G_OS_WIN32
kill (ptp_helper_pid, SIGKILL);
waitpid (ptp_helper_pid, NULL, 0);
+#else
+ TerminateProcess (ptp_helper_pid, 1);
+ WaitForSingleObject (ptp_helper_pid, INFINITE);
+#endif
g_spawn_close_pid (ptp_helper_pid);
}
ptp_helper_pid = 0;
if (delay_req_rand)
g_rand_free (delay_req_rand);
delay_req_rand = NULL;
+ if (observation_system_clock)
+ gst_object_unref (observation_system_clock);
+ observation_system_clock = NULL;
for (l = domain_data; l; l = l->next) {
PtpDomainData *domain = l->data;
{
PROP_0,
PROP_DOMAIN,
- PROP_INTERNAL_CLOCK
+ PROP_INTERNAL_CLOCK,
+ PROP_MASTER_CLOCK_ID,
+ PROP_GRANDMASTER_CLOCK_ID
};
#define GST_PTP_CLOCK_GET_PRIVATE(obj) \
"Internal clock", GST_TYPE_CLOCK,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
+ g_object_class_install_property (gobject_class, PROP_MASTER_CLOCK_ID,
+ g_param_spec_uint64 ("master-clock-id", "Master Clock ID",
+ "Master Clock ID", 0, G_MAXUINT64, 0,
+ G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (gobject_class, PROP_GRANDMASTER_CLOCK_ID,
+ g_param_spec_uint64 ("grandmaster-clock-id", "Grand Master Clock ID",
+ "Grand Master Clock ID", 0, G_MAXUINT64, 0,
+ G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
+
clock_class->get_internal_time = gst_ptp_clock_get_internal_time;
}
gst_ptp_clock_ensure_domain_clock (self);
g_value_set_object (value, self->priv->domain_clock);
break;
+ case PROP_MASTER_CLOCK_ID:
+ case PROP_GRANDMASTER_CLOCK_ID:{
+ GList *l;
+
+ g_mutex_lock (&domain_clocks_lock);
+ g_value_set_uint64 (value, 0);
+
+ for (l = domain_clocks; l; l = l->next) {
+ PtpDomainData *clock_data = l->data;
+
+ if (clock_data->domain == self->priv->domain) {
+ if (prop_id == PROP_MASTER_CLOCK_ID)
+ g_value_set_uint64 (value,
+ clock_data->master_clock_identity.clock_identity);
+ else
+ g_value_set_uint64 (value, clock_data->grandmaster_identity);
+ break;
+ }
+ }
+ g_mutex_unlock (&domain_clocks_lock);
+ break;
+ }
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
* If gst_ptp_init() was not called before, this will call gst_ptp_init() with
* default parameters.
*
- *
* This clock only returns valid timestamps after it received the first
* times from the PTP master clock on the network. Once this happens the
- * GstPtpClock::internal-clock property will become non-NULL. You can connect
- * to the notify::internal-clock signal to get notified about this, or
- * alternatively use gst_ptp_clock_wait_ready() to wait for this to happen.
+ * GstPtpClock::internal-clock property will become non-NULL. You can
+ * check this with gst_clock_wait_for_sync(), the GstClock::synced signal and
+ * gst_clock_is_synced().
+ *
+ * Returns: (transfer full): A new #GstClock
*
* Since: 1.6
*/
GstClock *
gst_ptp_clock_new (const gchar * name, guint domain)
{
- g_return_val_if_fail (name != NULL, NULL);
+ GstClock *clock;
+
g_return_val_if_fail (domain <= G_MAXUINT8, NULL);
if (!initted && !gst_ptp_init (GST_PTP_CLOCK_ID_NONE, NULL)) {
return NULL;
}
- return g_object_new (GST_TYPE_PTP_CLOCK, "name", name, "domain", domain,
+ clock = g_object_new (GST_TYPE_PTP_CLOCK, "name", name, "domain", domain,
NULL);
+
+ /* Clear floating flag */
+ gst_object_ref_sink (clock);
+
+ return clock;
}
typedef struct
g_atomic_int_add (&domain_stats_n_hooks, -1);
g_mutex_unlock (&ptp_lock);
}
-
-#else /* HAVE_PTP */
-
-GType
-gst_ptp_clock_get_type (void)
-{
- return G_TYPE_INVALID;
-}
-
-gboolean
-gst_ptp_is_supported (void)
-{
- return FALSE;
-}
-
-gboolean
-gst_ptp_is_initialized (void)
-{
- return FALSE;
-}
-
-gboolean
-gst_ptp_init (guint64 clock_id, gchar ** interfaces)
-{
- return FALSE;
-}
-
-void
-gst_ptp_deinit (void)
-{
-}
-
-GstClock *
-gst_ptp_clock_new (const gchar * name, guint domain)
-{
- return NULL;
-}
-
-gboolean
-gst_ptp_clock_wait_ready (GstPtpClock * self, GstClockTime timeout)
-{
- return FALSE;
-}
-
-gulong
-gst_ptp_statistics_callback_add (GstPtpStatisticsCallback callback,
- gpointer user_data, GDestroyNotify destroy_data)
-{
- return 0;
-}
-
-void
-gst_ptp_statistics_callback_remove (gulong id)
-{
- return;
-}
-
-#endif
projects / platform / upstream / gstreamer.git / blobdiff