*/
/**
* SECTION:gstptpclock
+ * @title: GstPtpClock
* @short_description: Special clock that synchronizes to a remote time
* provider via PTP (IEEE1588:2008).
* @see_also: #GstClock, #GstNetClientClock, #GstPipeline
* 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
* the possibility to collect all kinds of statistics from the clock
#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 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");
(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) {
#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
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) {
/**
* 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.
*
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;
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;
{
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
* 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;
-}
-
-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