2000-12-28 22:12:02 +00:00
|
|
|
/* GStreamer
|
|
|
|
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
|
|
|
|
* 2000 Wim Taymans <wtay@chello.be>
|
2005-03-07 18:27:42 +00:00
|
|
|
* 2004 Wim Taymans <wim@fluendo.com>
|
2000-12-28 22:12:02 +00:00
|
|
|
*
|
|
|
|
* gstclock.c: Clock subsystem for maintaining time sync
|
2000-04-09 21:38:17 +00:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Library General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Library General Public License for more details.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-10-15 16:01:57 +00:00
|
|
|
|
2005-08-27 10:57:00 +00:00
|
|
|
/**
|
|
|
|
* SECTION:gstclock
|
|
|
|
* @short_description: Abstract class for global clocks
|
|
|
|
* @see_also: #GstSystemClock
|
|
|
|
*
|
2005-10-28 17:35:05 +00:00
|
|
|
* GStreamer uses a global clock to synchronize the plugins in a pipeline.
|
2005-08-27 10:57:00 +00:00
|
|
|
* Different clock implementations are possible by implementing this abstract
|
|
|
|
* base class.
|
|
|
|
*
|
2005-10-28 17:35:05 +00:00
|
|
|
* The #GstClock returns a monotonically increasing time with the method
|
2005-11-28 17:59:25 +00:00
|
|
|
* gst_clock_get_time(). Its accuracy and base time depends on the specific
|
|
|
|
* clock implementation but time is always expessed in nanoseconds. Since the
|
2005-10-28 17:35:05 +00:00
|
|
|
* baseline of the clock is undefined, the clock time returned is not
|
2005-11-28 17:59:25 +00:00
|
|
|
* meaningful in itself, what matters are the deltas between two clock times.
|
2005-10-28 17:35:05 +00:00
|
|
|
*
|
2005-11-28 17:59:25 +00:00
|
|
|
* The pipeline uses the clock to calculate the stream time. Usually all
|
|
|
|
* renderers synchronize to the global clock using the buffer timestamps, the
|
|
|
|
* newsegment events and the element's base time.
|
2005-09-24 14:14:03 +00:00
|
|
|
*
|
2005-10-13 15:27:40 +00:00
|
|
|
* The time of the clock in itself is not very useful for an application.
|
2005-10-28 17:35:05 +00:00
|
|
|
*
|
2005-11-28 17:59:25 +00:00
|
|
|
* A clock implementation can support periodic and single shot clock
|
|
|
|
* notifications both synchronous and asynchronous.
|
2005-10-28 17:35:05 +00:00
|
|
|
*
|
|
|
|
* One first needs to create a #GstClockID for the periodic or single shot
|
2005-11-28 17:59:25 +00:00
|
|
|
* notification using gst_clock_new_single_shot_id() or
|
|
|
|
* gst_clock_new_periodic_id().
|
2005-10-28 17:35:05 +00:00
|
|
|
*
|
|
|
|
* To perform a blocking wait for the specific time of the #GstClockID use the
|
|
|
|
* gst_clock_id_wait(). To receive a callback when the specific time is reached
|
2005-11-28 17:59:25 +00:00
|
|
|
* in the clock use gst_clock_id_wait_async(). Both these calls can be
|
|
|
|
* interrupted with the gst_clock_id_unschedule() call. If the blocking wait is
|
|
|
|
* unscheduled a return value of GST_CLOCK_UNSCHEDULED is returned.
|
2005-10-28 17:35:05 +00:00
|
|
|
*
|
2005-11-28 17:59:25 +00:00
|
|
|
* Periodic callbacks scheduled async will be repeadedly called automatically
|
|
|
|
* until it is unscheduled. To schedule an async periodic callback,
|
|
|
|
* gst_clock_id_wait() should be called repeadedly.
|
2005-11-09 12:36:17 +00:00
|
|
|
*
|
2005-11-28 17:59:25 +00:00
|
|
|
* The async callbacks can happen from any thread, either provided by the core
|
|
|
|
* or from a streaming thread. The application should be prepared for this.
|
2005-10-28 17:35:05 +00:00
|
|
|
*
|
|
|
|
* A #GstClockID that has been unscheduled cannot be used again for any wait
|
|
|
|
* operation.
|
|
|
|
*
|
2005-11-28 17:59:25 +00:00
|
|
|
* It is possible to perform a blocking wait on the same #GstClockID from
|
|
|
|
* multiple threads. However, registering the same #GstClockID for multiple
|
|
|
|
* async notifications is not possible, the callback will only be called once.
|
2005-10-28 17:35:05 +00:00
|
|
|
*
|
2005-11-28 17:59:25 +00:00
|
|
|
* None of the wait operations unref the #GstClockID, the owner is responsible
|
|
|
|
* for unreffing the ids itself. This holds for both periodic and single shot
|
|
|
|
* notifications. The reason being that the owner of the #GstClockID has to
|
|
|
|
* keep a handle to the #GstClockID to unblock the wait on FLUSHING events or
|
|
|
|
* state changes and if we unref it automatically, the handle might be invalid.
|
2005-10-28 17:35:05 +00:00
|
|
|
*
|
|
|
|
* These clock operations do not operate on the stream time, so the callbacks
|
|
|
|
* will also occur when not in PLAYING state as if the clock just keeps on
|
|
|
|
* running. Some clocks however do not progress when the element that provided
|
|
|
|
* the clock is not PLAYING.
|
|
|
|
*
|
2005-11-28 17:59:25 +00:00
|
|
|
* When a clock has the GST_CLOCK_FLAG_CAN_SET_MASTER flag set, it can be
|
|
|
|
* slaved to another #GstClock with the gst_clock_set_master(). The clock will
|
|
|
|
* then automatically be synchronized to this master clock by repeadedly
|
|
|
|
* sampling the master clock and the slave clock and recalibrating the slave
|
|
|
|
* clock with gst_clock_set_calibration(). This feature is mostly usefull for
|
|
|
|
* plugins that have an internal clock but must operate with another clock
|
|
|
|
* selected by the #GstPipeline. They can track the offset and rate difference
|
|
|
|
* of their internal clock relative to the master clock by using the
|
|
|
|
* gst_clock_get_calibration() function.
|
2005-11-24 09:44:07 +00:00
|
|
|
*
|
2005-10-28 17:35:05 +00:00
|
|
|
* Last reviewed on 2005-10-28 (0.9.4)
|
2005-08-27 10:57:00 +00:00
|
|
|
*/
|
2005-10-15 16:01:57 +00:00
|
|
|
|
2004-04-28 23:26:06 +00:00
|
|
|
#include <time.h>
|
2000-12-28 22:12:02 +00:00
|
|
|
|
|
|
|
#include "gst_private.h"
|
2003-06-29 14:05:49 +00:00
|
|
|
|
2000-12-15 01:57:34 +00:00
|
|
|
#include "gstclock.h"
|
2003-06-29 14:05:49 +00:00
|
|
|
#include "gstinfo.h"
|
2005-04-24 22:49:45 +00:00
|
|
|
#include "gstutils.h"
|
2000-04-09 21:38:17 +00:00
|
|
|
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_TRACE
|
2003-02-02 19:21:06 +00:00
|
|
|
/* #define GST_WITH_ALLOC_TRACE */
|
2003-02-10 20:32:32 +00:00
|
|
|
#include "gsttrace.h"
|
|
|
|
static GstAllocTrace *_gst_clock_entry_trace;
|
|
|
|
#endif
|
2003-02-02 19:21:06 +00:00
|
|
|
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
/* #define DEBUGGING_ENABLED */
|
|
|
|
|
2005-12-06 19:29:15 +00:00
|
|
|
#define DEFAULT_STATS FALSE
|
|
|
|
#define DEFAULT_WINDOW_SIZE 32
|
|
|
|
#define DEFAULT_WINDOW_THRESHOLD 4
|
|
|
|
#define DEFAULT_TIMEOUT GST_SECOND / 10
|
2002-12-27 04:11:59 +00:00
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
enum
|
|
|
|
{
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
PROP_0,
|
|
|
|
PROP_STATS,
|
|
|
|
PROP_WINDOW_SIZE,
|
|
|
|
PROP_WINDOW_THRESHOLD,
|
|
|
|
PROP_TIMEOUT
|
2002-11-02 13:54:34 +00:00
|
|
|
};
|
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
static void gst_clock_class_init (GstClockClass * klass);
|
|
|
|
static void gst_clock_init (GstClock * clock);
|
gst/gstbin.c: Clean up references to the clock provider when disposed or when handling a clock-lost message from it.
Original commit message from CVS:
* gst/gstbin.c: (gst_bin_dispose), (gst_bin_provide_clock_func),
(gst_bin_remove_func), (gst_bin_handle_message_func),
(bin_query_duration_fold), (bin_query_generic_fold):
Clean up references to the clock provider when disposed or when
handling a clock-lost message from it.
Unref sinks when performing a query via gst_iterator_fold, as the
gst_bin_iterate_sinks iterator refs each item. (Fixes #323874)
* gst/gstclock.c: (gst_clock_class_init), (gst_clock_dispose),
(gst_clock_set_master):
Drop our reference to the master clock, if any, when we are disposed.
* gst/gsttypefindfactory.c: (gst_type_find_factory_dispose):
Chain up in dispose.
2006-01-27 01:48:37 +00:00
|
|
|
static void gst_clock_dispose (GObject * object);
|
gst/: Fix name lookup in GstBin.
Original commit message from CVS:
* gst/gstbin.c: (gst_bin_send_event), (compare_name),
(gst_bin_get_by_name):
* gst/gstbuffer.h:
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_class_init),
(gst_clock_finalize):
* gst/gstdata.c: (gst_data_replace):
* gst/gstdata.h:
* gst/gstelement.c: (gst_element_request_pad),
(gst_element_pads_activate):
* gst/gstobject.c: (gst_object_init), (gst_object_ref),
(gst_object_unref):
* gst/gstpad.c: (gst_pad_set_active), (gst_pad_peer_set_active),
(gst_pad_set_checkgetrange_function),
(gst_pad_link_check_compatible_unlocked), (gst_pad_set_caps),
(gst_pad_check_pull_range), (gst_pad_pull_range),
(gst_static_pad_template_get_caps), (gst_pad_start_task),
(gst_pad_pause_task), (gst_pad_stop_task):
* gst/gstutils.c: (gst_element_get_compatible_pad_template),
(gst_element_request_pad), (gst_pad_proxy_getcaps):
Fix name lookup in GstBin.
Added _data_replace() function and _buffer_replace()
Use finalize method to clean up clock.
Fix refcounting on request pads.
Fix pad schedule mode error.
Some more object refcounting debug info,
2005-05-05 09:28:01 +00:00
|
|
|
static void gst_clock_finalize (GObject * object);
|
2003-02-02 19:21:06 +00:00
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
static void gst_clock_set_property (GObject * object, guint prop_id,
|
|
|
|
const GValue * value, GParamSpec * pspec);
|
|
|
|
static void gst_clock_get_property (GObject * object, guint prop_id,
|
|
|
|
GValue * value, GParamSpec * pspec);
|
|
|
|
static void gst_clock_update_stats (GstClock * clock);
|
2002-02-03 20:07:09 +00:00
|
|
|
|
2002-03-30 17:05:03 +00:00
|
|
|
|
2002-02-03 20:07:09 +00:00
|
|
|
static GstObjectClass *parent_class = NULL;
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2002-02-03 20:07:09 +00:00
|
|
|
/* static guint gst_clock_signals[LAST_SIGNAL] = { 0 }; */
|
|
|
|
|
2003-01-15 18:29:40 +00:00
|
|
|
static GstClockID
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_clock_entry_new (GstClock * clock, GstClockTime time,
|
|
|
|
GstClockTime interval, GstClockEntryType type)
|
2002-11-02 13:54:34 +00:00
|
|
|
{
|
|
|
|
GstClockEntry *entry;
|
2002-03-30 17:05:03 +00:00
|
|
|
|
2005-09-20 06:28:33 +00:00
|
|
|
entry = g_malloc0 (sizeof (GstClockEntry));
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_TRACE
|
2003-02-02 19:21:06 +00:00
|
|
|
gst_alloc_trace_new (_gst_clock_entry_trace, entry);
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock,
|
|
|
|
"created entry %p, time %" GST_TIME_FORMAT, entry, GST_TIME_ARGS (time));
|
2002-03-30 17:05:03 +00:00
|
|
|
|
2005-04-24 22:49:45 +00:00
|
|
|
gst_atomic_int_set (&entry->refcount, 1);
|
2002-11-02 13:54:34 +00:00
|
|
|
entry->clock = clock;
|
|
|
|
entry->time = time;
|
2004-02-11 19:02:00 +00:00
|
|
|
entry->interval = interval;
|
2002-11-02 13:54:34 +00:00
|
|
|
entry->type = type;
|
2005-03-07 18:27:42 +00:00
|
|
|
entry->status = GST_CLOCK_BUSY;
|
2002-03-30 17:05:03 +00:00
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
return (GstClockID) entry;
|
|
|
|
}
|
2002-03-30 17:05:03 +00:00
|
|
|
|
2005-03-07 18:27:42 +00:00
|
|
|
/**
|
|
|
|
* gst_clock_id_ref:
|
|
|
|
* @id: The clockid to ref
|
|
|
|
*
|
|
|
|
* Increase the refcount of the given clockid.
|
|
|
|
*
|
|
|
|
* Returns: The same #GstClockID with increased refcount.
|
|
|
|
*
|
|
|
|
* MT safe.
|
|
|
|
*/
|
|
|
|
GstClockID
|
|
|
|
gst_clock_id_ref (GstClockID id)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (id != NULL, NULL);
|
|
|
|
|
2005-04-24 22:49:45 +00:00
|
|
|
g_atomic_int_inc (&((GstClockEntry *) id)->refcount);
|
2005-03-07 18:27:42 +00:00
|
|
|
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_gst_clock_id_free (GstClockID id)
|
|
|
|
{
|
|
|
|
g_return_if_fail (id != NULL);
|
|
|
|
|
|
|
|
GST_CAT_DEBUG (GST_CAT_CLOCK, "freed entry %p", id);
|
|
|
|
|
|
|
|
#ifndef GST_DISABLE_TRACE
|
|
|
|
gst_alloc_trace_free (_gst_clock_entry_trace, id);
|
|
|
|
#endif
|
2005-09-20 09:28:56 +00:00
|
|
|
g_free (id);
|
2005-03-07 18:27:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_clock_id_unref:
|
|
|
|
* @id: The clockid to unref
|
|
|
|
*
|
|
|
|
* Unref the given clockid. When the refcount reaches 0 the
|
|
|
|
* #GstClockID will be freed.
|
|
|
|
*
|
|
|
|
* MT safe.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_clock_id_unref (GstClockID id)
|
|
|
|
{
|
|
|
|
gint zero;
|
|
|
|
|
|
|
|
g_return_if_fail (id != NULL);
|
|
|
|
|
2005-04-24 22:49:45 +00:00
|
|
|
zero = g_atomic_int_dec_and_test (&((GstClockEntry *) id)->refcount);
|
2005-03-07 18:27:42 +00:00
|
|
|
/* if we ended up with the refcount at zero, free the id */
|
|
|
|
if (zero) {
|
|
|
|
_gst_clock_id_free (id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
/**
|
|
|
|
* gst_clock_new_single_shot_id
|
|
|
|
* @clock: The clockid to get a single shot notification from
|
|
|
|
* @time: the requested time
|
|
|
|
*
|
2005-08-20 12:39:05 +00:00
|
|
|
* Get an ID from the given clock to trigger a single shot
|
2005-03-07 18:27:42 +00:00
|
|
|
* notification at the requested time. The single shot id should be
|
|
|
|
* unreffed after usage.
|
2002-11-02 13:54:34 +00:00
|
|
|
*
|
|
|
|
* Returns: An id that can be used to request the time notification.
|
2005-03-07 18:27:42 +00:00
|
|
|
*
|
|
|
|
* MT safe.
|
2002-11-02 13:54:34 +00:00
|
|
|
*/
|
|
|
|
GstClockID
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_clock_new_single_shot_id (GstClock * clock, GstClockTime time)
|
2002-11-02 13:54:34 +00:00
|
|
|
{
|
2002-11-27 20:47:39 +00:00
|
|
|
g_return_val_if_fail (GST_IS_CLOCK (clock), NULL);
|
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
return gst_clock_entry_new (clock,
|
|
|
|
time, GST_CLOCK_TIME_NONE, GST_CLOCK_ENTRY_SINGLE);
|
2002-11-02 13:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2002-12-14 13:02:16 +00:00
|
|
|
* gst_clock_new_periodic_id
|
2002-11-02 13:54:34 +00:00
|
|
|
* @clock: The clockid to get a periodic notification id from
|
|
|
|
* @start_time: the requested start time
|
|
|
|
* @interval: the requested interval
|
|
|
|
*
|
|
|
|
* Get an ID from the given clock to trigger a periodic notification.
|
|
|
|
* The periodeic notifications will be start at time start_time and
|
2005-03-07 18:27:42 +00:00
|
|
|
* will then be fired with the given interval. The id should be unreffed
|
|
|
|
* after usage.
|
2002-11-02 13:54:34 +00:00
|
|
|
*
|
|
|
|
* Returns: An id that can be used to request the time notification.
|
2005-03-07 18:27:42 +00:00
|
|
|
*
|
|
|
|
* MT safe.
|
2002-11-02 13:54:34 +00:00
|
|
|
*/
|
|
|
|
GstClockID
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_clock_new_periodic_id (GstClock * clock, GstClockTime start_time,
|
|
|
|
GstClockTime interval)
|
2002-11-02 13:54:34 +00:00
|
|
|
{
|
2002-11-27 20:47:39 +00:00
|
|
|
g_return_val_if_fail (GST_IS_CLOCK (clock), NULL);
|
2003-04-13 03:07:07 +00:00
|
|
|
g_return_val_if_fail (GST_CLOCK_TIME_IS_VALID (start_time), NULL);
|
2002-11-27 20:47:39 +00:00
|
|
|
g_return_val_if_fail (interval != 0, NULL);
|
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
return gst_clock_entry_new (clock,
|
|
|
|
start_time, interval, GST_CLOCK_ENTRY_PERIODIC);
|
2002-11-02 13:54:34 +00:00
|
|
|
}
|
|
|
|
|
2005-03-07 18:27:42 +00:00
|
|
|
/**
|
|
|
|
* gst_clock_id_compare_func
|
|
|
|
* @id1: A clockid
|
|
|
|
* @id2: A clockid to compare with
|
|
|
|
*
|
|
|
|
* Compares the two GstClockID instances. This function can be used
|
|
|
|
* as a GCompareFunc when sorting ids.
|
|
|
|
*
|
|
|
|
* Returns: negative value if a < b; zero if a = b; positive value if a > b
|
|
|
|
*
|
|
|
|
* MT safe.
|
|
|
|
*/
|
|
|
|
gint
|
|
|
|
gst_clock_id_compare_func (gconstpointer id1, gconstpointer id2)
|
|
|
|
{
|
|
|
|
GstClockEntry *entry1, *entry2;
|
|
|
|
|
|
|
|
entry1 = (GstClockEntry *) id1;
|
|
|
|
entry2 = (GstClockEntry *) id2;
|
|
|
|
|
|
|
|
if (GST_CLOCK_ENTRY_TIME (entry1) > GST_CLOCK_ENTRY_TIME (entry2)) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (GST_CLOCK_ENTRY_TIME (entry1) < GST_CLOCK_ENTRY_TIME (entry2)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return entry1 - entry2;
|
|
|
|
}
|
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
/**
|
|
|
|
* gst_clock_id_get_time
|
|
|
|
* @id: The clockid to query
|
|
|
|
*
|
|
|
|
* Get the time of the clock ID
|
|
|
|
*
|
2005-03-07 18:27:42 +00:00
|
|
|
* Returns: the time of the given clock id.
|
|
|
|
*
|
|
|
|
* MT safe.
|
2002-11-02 13:54:34 +00:00
|
|
|
*/
|
|
|
|
GstClockTime
|
|
|
|
gst_clock_id_get_time (GstClockID id)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (id != NULL, GST_CLOCK_TIME_NONE);
|
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
return GST_CLOCK_ENTRY_TIME ((GstClockEntry *) id);
|
2002-11-02 13:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_clock_id_wait
|
|
|
|
* @id: The clockid to wait on
|
|
|
|
* @jitter: A pointer that will contain the jitter
|
|
|
|
*
|
|
|
|
* Perform a blocking wait on the given ID. The jitter arg can be
|
2005-03-07 18:27:42 +00:00
|
|
|
* NULL.
|
2002-11-02 13:54:34 +00:00
|
|
|
*
|
|
|
|
* Returns: the result of the blocking wait.
|
2005-03-07 18:27:42 +00:00
|
|
|
*
|
|
|
|
* MT safe.
|
2002-11-02 13:54:34 +00:00
|
|
|
*/
|
|
|
|
GstClockReturn
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_clock_id_wait (GstClockID id, GstClockTimeDiff * jitter)
|
2002-03-30 17:05:03 +00:00
|
|
|
{
|
|
|
|
GstClockEntry *entry;
|
2002-11-02 13:54:34 +00:00
|
|
|
GstClock *clock;
|
2005-03-07 18:27:42 +00:00
|
|
|
GstClockReturn res;
|
2002-11-02 13:54:34 +00:00
|
|
|
GstClockTime requested;
|
2002-12-19 21:31:03 +00:00
|
|
|
GstClockClass *cclass;
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
g_return_val_if_fail (id != NULL, GST_CLOCK_ERROR);
|
2002-03-30 17:05:03 +00:00
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
entry = (GstClockEntry *) id;
|
|
|
|
requested = GST_CLOCK_ENTRY_TIME (entry);
|
2002-11-27 20:47:39 +00:00
|
|
|
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
clock = GST_CLOCK_ENTRY_CLOCK (entry);
|
|
|
|
|
2005-03-07 18:27:42 +00:00
|
|
|
if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (requested)))
|
|
|
|
goto invalid_time;
|
|
|
|
|
|
|
|
if (G_UNLIKELY (entry->status == GST_CLOCK_UNSCHEDULED))
|
|
|
|
goto unscheduled;
|
2002-12-27 04:11:59 +00:00
|
|
|
|
2002-12-19 21:31:03 +00:00
|
|
|
cclass = GST_CLOCK_GET_CLASS (clock);
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2005-03-07 18:27:42 +00:00
|
|
|
if (G_LIKELY (cclass->wait)) {
|
2004-03-13 15:27:01 +00:00
|
|
|
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock, "waiting on clock entry %p",
|
|
|
|
id);
|
2005-03-07 18:27:42 +00:00
|
|
|
res = cclass->wait (clock, entry);
|
2006-01-18 18:01:54 +00:00
|
|
|
GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock,
|
|
|
|
"done waiting entry %p, res: %d", id, res);
|
2002-12-27 04:11:59 +00:00
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
if (jitter) {
|
2005-03-07 18:27:42 +00:00
|
|
|
GstClockTime now = gst_clock_get_time (clock);
|
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
*jitter = now - requested;
|
|
|
|
}
|
2005-03-07 18:27:42 +00:00
|
|
|
if (entry->type == GST_CLOCK_ENTRY_PERIODIC) {
|
|
|
|
entry->time += entry->interval;
|
|
|
|
}
|
2002-11-02 13:54:34 +00:00
|
|
|
|
|
|
|
if (clock->stats) {
|
|
|
|
gst_clock_update_stats (clock);
|
|
|
|
}
|
2005-03-07 18:27:42 +00:00
|
|
|
} else {
|
|
|
|
res = GST_CLOCK_UNSUPPORTED;
|
2002-11-02 13:54:34 +00:00
|
|
|
}
|
|
|
|
return res;
|
2005-03-07 18:27:42 +00:00
|
|
|
|
|
|
|
/* ERRORS */
|
|
|
|
invalid_time:
|
|
|
|
{
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock,
|
|
|
|
"invalid time requested, returning _BADTIME");
|
2005-03-07 18:27:42 +00:00
|
|
|
return GST_CLOCK_BADTIME;
|
|
|
|
}
|
|
|
|
unscheduled:
|
|
|
|
{
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock,
|
|
|
|
"entry was unscheduled return _UNSCHEDULED");
|
2005-03-07 18:27:42 +00:00
|
|
|
return GST_CLOCK_UNSCHEDULED;
|
|
|
|
}
|
2002-11-02 13:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2002-12-14 13:02:16 +00:00
|
|
|
* gst_clock_id_wait_async:
|
|
|
|
* @id: a #GstClockID to wait on
|
2005-10-15 15:30:24 +00:00
|
|
|
* @func: The callback function
|
2002-11-02 13:54:34 +00:00
|
|
|
* @user_data: User data passed in the calback
|
|
|
|
*
|
2002-12-14 13:02:16 +00:00
|
|
|
* Register a callback on the given clockid with the given
|
2005-03-07 18:27:42 +00:00
|
|
|
* function and user_data. When passing an id with an invalid
|
|
|
|
* time to this function, the callback will be called immediatly
|
|
|
|
* with a time set to GST_CLOCK_TIME_NONE. The callback will
|
|
|
|
* be called when the time of the id has been reached.
|
2002-11-02 13:54:34 +00:00
|
|
|
*
|
2002-11-27 20:47:39 +00:00
|
|
|
* Returns: the result of the non blocking wait.
|
2005-03-07 18:27:42 +00:00
|
|
|
*
|
|
|
|
* MT safe.
|
2002-11-02 13:54:34 +00:00
|
|
|
*/
|
|
|
|
GstClockReturn
|
|
|
|
gst_clock_id_wait_async (GstClockID id,
|
2004-03-13 15:27:01 +00:00
|
|
|
GstClockCallback func, gpointer user_data)
|
2002-11-02 13:54:34 +00:00
|
|
|
{
|
|
|
|
GstClockEntry *entry;
|
|
|
|
GstClock *clock;
|
2005-03-07 18:27:42 +00:00
|
|
|
GstClockReturn res;
|
2002-12-19 21:31:03 +00:00
|
|
|
GstClockClass *cclass;
|
2005-03-07 18:27:42 +00:00
|
|
|
GstClockTime requested;
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
g_return_val_if_fail (id != NULL, GST_CLOCK_ERROR);
|
2002-11-27 20:47:39 +00:00
|
|
|
g_return_val_if_fail (func != NULL, GST_CLOCK_ERROR);
|
2002-11-02 13:54:34 +00:00
|
|
|
|
|
|
|
entry = (GstClockEntry *) id;
|
2005-03-07 18:27:42 +00:00
|
|
|
requested = GST_CLOCK_ENTRY_TIME (entry);
|
|
|
|
clock = GST_CLOCK_ENTRY_CLOCK (entry);
|
2002-11-02 13:54:34 +00:00
|
|
|
|
2005-03-07 18:27:42 +00:00
|
|
|
if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (requested)))
|
|
|
|
goto invalid_time;
|
|
|
|
|
|
|
|
if (G_UNLIKELY (entry->status == GST_CLOCK_UNSCHEDULED))
|
|
|
|
goto unscheduled;
|
2002-11-27 20:47:39 +00:00
|
|
|
|
2002-12-19 21:31:03 +00:00
|
|
|
cclass = GST_CLOCK_GET_CLASS (clock);
|
|
|
|
|
|
|
|
if (cclass->wait_async) {
|
|
|
|
entry->func = func;
|
|
|
|
entry->user_data = user_data;
|
|
|
|
|
|
|
|
res = cclass->wait_async (clock, entry);
|
2005-03-07 18:27:42 +00:00
|
|
|
} else {
|
|
|
|
res = GST_CLOCK_UNSUPPORTED;
|
2002-11-02 13:54:34 +00:00
|
|
|
}
|
|
|
|
return res;
|
|
|
|
|
2005-03-07 18:27:42 +00:00
|
|
|
/* ERRORS */
|
|
|
|
invalid_time:
|
|
|
|
{
|
|
|
|
(func) (clock, GST_CLOCK_TIME_NONE, id, user_data);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock,
|
|
|
|
"invalid time requested, returning _BADTIME");
|
2005-03-07 18:27:42 +00:00
|
|
|
return GST_CLOCK_BADTIME;
|
|
|
|
}
|
|
|
|
unscheduled:
|
|
|
|
{
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock,
|
|
|
|
"entry was unscheduled return _UNSCHEDULED");
|
2005-03-07 18:27:42 +00:00
|
|
|
return GST_CLOCK_UNSCHEDULED;
|
|
|
|
}
|
2002-12-27 04:11:59 +00:00
|
|
|
}
|
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
/**
|
2002-12-14 13:02:16 +00:00
|
|
|
* gst_clock_id_unschedule:
|
|
|
|
* @id: The id to unschedule
|
2002-11-02 13:54:34 +00:00
|
|
|
*
|
2005-03-07 18:27:42 +00:00
|
|
|
* Cancel an outstanding request with the given ID. This can either
|
|
|
|
* be an outstanding async notification or a pending sync notification.
|
|
|
|
* After this call, the @id cannot be used anymore to receive sync or
|
|
|
|
* async notifications, you need to create a new GstClockID.
|
|
|
|
*
|
|
|
|
* MT safe.
|
2002-11-02 13:54:34 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
gst_clock_id_unschedule (GstClockID id)
|
|
|
|
{
|
|
|
|
GstClockEntry *entry;
|
|
|
|
GstClock *clock;
|
2002-12-19 21:31:03 +00:00
|
|
|
GstClockClass *cclass;
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
g_return_if_fail (id != NULL);
|
|
|
|
|
|
|
|
entry = (GstClockEntry *) id;
|
|
|
|
clock = entry->clock;
|
2002-03-30 17:05:03 +00:00
|
|
|
|
2002-12-19 21:31:03 +00:00
|
|
|
cclass = GST_CLOCK_GET_CLASS (clock);
|
|
|
|
|
|
|
|
if (cclass->unschedule)
|
|
|
|
cclass->unschedule (clock, entry);
|
2002-03-30 17:05:03 +00:00
|
|
|
}
|
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* GstClock abstract base class implementation
|
|
|
|
*/
|
2002-02-03 20:07:09 +00:00
|
|
|
GType
|
|
|
|
gst_clock_get_type (void)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2002-02-03 20:07:09 +00:00
|
|
|
static GType clock_type = 0;
|
|
|
|
|
|
|
|
if (!clock_type) {
|
|
|
|
static const GTypeInfo clock_info = {
|
2002-03-30 17:05:03 +00:00
|
|
|
sizeof (GstClockClass),
|
2002-02-03 20:07:09 +00:00
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
(GClassInitFunc) gst_clock_class_init,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
2002-03-30 17:05:03 +00:00
|
|
|
sizeof (GstClock),
|
2004-04-09 19:05:03 +00:00
|
|
|
0,
|
2002-02-03 20:07:09 +00:00
|
|
|
(GInstanceInitFunc) gst_clock_init,
|
|
|
|
NULL
|
|
|
|
};
|
2004-03-15 19:27:17 +00:00
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
clock_type = g_type_register_static (GST_TYPE_OBJECT, "GstClock",
|
2004-03-15 19:27:17 +00:00
|
|
|
&clock_info, G_TYPE_FLAG_ABSTRACT);
|
2002-02-03 20:07:09 +00:00
|
|
|
}
|
|
|
|
return clock_type;
|
|
|
|
}
|
2001-01-29 00:06:02 +00:00
|
|
|
|
2002-02-03 20:07:09 +00:00
|
|
|
static void
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_clock_class_init (GstClockClass * klass)
|
2002-02-03 20:07:09 +00:00
|
|
|
{
|
|
|
|
GObjectClass *gobject_class;
|
|
|
|
GstObjectClass *gstobject_class;
|
2001-01-29 00:06:02 +00:00
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
gobject_class = (GObjectClass *) klass;
|
|
|
|
gstobject_class = (GstObjectClass *) klass;
|
2001-01-29 00:06:02 +00:00
|
|
|
|
2002-02-03 20:07:09 +00:00
|
|
|
parent_class = g_type_class_ref (GST_TYPE_OBJECT);
|
2002-03-30 17:05:03 +00:00
|
|
|
|
2002-03-31 14:04:50 +00:00
|
|
|
if (!g_thread_supported ())
|
|
|
|
g_thread_init (NULL);
|
|
|
|
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_TRACE
|
2004-03-13 15:27:01 +00:00
|
|
|
_gst_clock_entry_trace =
|
|
|
|
gst_alloc_trace_register (GST_CLOCK_ENTRY_TRACE_NAME);
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif
|
2002-11-02 13:54:34 +00:00
|
|
|
|
gst/gstbin.c: Clean up references to the clock provider when disposed or when handling a clock-lost message from it.
Original commit message from CVS:
* gst/gstbin.c: (gst_bin_dispose), (gst_bin_provide_clock_func),
(gst_bin_remove_func), (gst_bin_handle_message_func),
(bin_query_duration_fold), (bin_query_generic_fold):
Clean up references to the clock provider when disposed or when
handling a clock-lost message from it.
Unref sinks when performing a query via gst_iterator_fold, as the
gst_bin_iterate_sinks iterator refs each item. (Fixes #323874)
* gst/gstclock.c: (gst_clock_class_init), (gst_clock_dispose),
(gst_clock_set_master):
Drop our reference to the master clock, if any, when we are disposed.
* gst/gsttypefindfactory.c: (gst_type_find_factory_dispose):
Chain up in dispose.
2006-01-27 01:48:37 +00:00
|
|
|
gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_clock_dispose);
|
gst/: Fix name lookup in GstBin.
Original commit message from CVS:
* gst/gstbin.c: (gst_bin_send_event), (compare_name),
(gst_bin_get_by_name):
* gst/gstbuffer.h:
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_class_init),
(gst_clock_finalize):
* gst/gstdata.c: (gst_data_replace):
* gst/gstdata.h:
* gst/gstelement.c: (gst_element_request_pad),
(gst_element_pads_activate):
* gst/gstobject.c: (gst_object_init), (gst_object_ref),
(gst_object_unref):
* gst/gstpad.c: (gst_pad_set_active), (gst_pad_peer_set_active),
(gst_pad_set_checkgetrange_function),
(gst_pad_link_check_compatible_unlocked), (gst_pad_set_caps),
(gst_pad_check_pull_range), (gst_pad_pull_range),
(gst_static_pad_template_get_caps), (gst_pad_start_task),
(gst_pad_pause_task), (gst_pad_stop_task):
* gst/gstutils.c: (gst_element_get_compatible_pad_template),
(gst_element_request_pad), (gst_pad_proxy_getcaps):
Fix name lookup in GstBin.
Added _data_replace() function and _buffer_replace()
Use finalize method to clean up clock.
Fix refcounting on request pads.
Fix pad schedule mode error.
Some more object refcounting debug info,
2005-05-05 09:28:01 +00:00
|
|
|
gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_clock_finalize);
|
2002-11-02 13:54:34 +00:00
|
|
|
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_clock_set_property);
|
|
|
|
gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_clock_get_property);
|
|
|
|
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_STATS,
|
2004-03-13 15:27:01 +00:00
|
|
|
g_param_spec_boolean ("stats", "Stats", "Enable clock stats",
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
DEFAULT_STATS, G_PARAM_READWRITE));
|
|
|
|
g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_WINDOW_SIZE,
|
|
|
|
g_param_spec_int ("window-size", "Window size",
|
|
|
|
"The size of the window used to calculate rate and offset", 2, 1024,
|
|
|
|
DEFAULT_WINDOW_SIZE, G_PARAM_READWRITE));
|
|
|
|
g_object_class_install_property (G_OBJECT_CLASS (klass),
|
|
|
|
PROP_WINDOW_THRESHOLD, g_param_spec_int ("window-threshold",
|
|
|
|
"Window threshold",
|
|
|
|
"The threshold to start calculating rate and offset", 2, 1024,
|
|
|
|
DEFAULT_WINDOW_THRESHOLD, G_PARAM_READWRITE));
|
|
|
|
g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_TIMEOUT,
|
|
|
|
g_param_spec_uint64 ("timeout", "Timeout",
|
|
|
|
"The amount of time, in nanoseconds, to sample master and slave clocks",
|
|
|
|
0, G_MAXUINT64, DEFAULT_TIMEOUT, G_PARAM_READWRITE));
|
2000-04-09 21:38:17 +00:00
|
|
|
}
|
|
|
|
|
2002-02-03 20:07:09 +00:00
|
|
|
static void
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_clock_init (GstClock * clock)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2002-03-30 17:05:03 +00:00
|
|
|
clock->last_time = 0;
|
|
|
|
clock->entries = NULL;
|
2005-03-07 18:27:42 +00:00
|
|
|
clock->entries_changed = g_cond_new ();
|
2002-11-02 13:54:34 +00:00
|
|
|
clock->stats = FALSE;
|
2005-11-17 11:51:49 +00:00
|
|
|
|
2005-11-19 18:06:56 +00:00
|
|
|
clock->internal_calibration = 0;
|
|
|
|
clock->external_calibration = 0;
|
2005-11-23 12:36:00 +00:00
|
|
|
clock->rate_numerator = 1;
|
|
|
|
clock->rate_denominator = 1;
|
|
|
|
|
|
|
|
clock->slave_lock = g_mutex_new ();
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
clock->filling = TRUE;
|
|
|
|
clock->window_size = DEFAULT_WINDOW_SIZE;
|
|
|
|
clock->window_threshold = DEFAULT_WINDOW_THRESHOLD;
|
|
|
|
clock->time_index = 0;
|
|
|
|
clock->timeout = DEFAULT_TIMEOUT;
|
|
|
|
clock->times = g_new0 (GstClockTime, 4 * clock->window_size);
|
2000-04-09 21:38:17 +00:00
|
|
|
}
|
|
|
|
|
gst/gstbin.c: Clean up references to the clock provider when disposed or when handling a clock-lost message from it.
Original commit message from CVS:
* gst/gstbin.c: (gst_bin_dispose), (gst_bin_provide_clock_func),
(gst_bin_remove_func), (gst_bin_handle_message_func),
(bin_query_duration_fold), (bin_query_generic_fold):
Clean up references to the clock provider when disposed or when
handling a clock-lost message from it.
Unref sinks when performing a query via gst_iterator_fold, as the
gst_bin_iterate_sinks iterator refs each item. (Fixes #323874)
* gst/gstclock.c: (gst_clock_class_init), (gst_clock_dispose),
(gst_clock_set_master):
Drop our reference to the master clock, if any, when we are disposed.
* gst/gsttypefindfactory.c: (gst_type_find_factory_dispose):
Chain up in dispose.
2006-01-27 01:48:37 +00:00
|
|
|
static void
|
|
|
|
gst_clock_dispose (GObject * object)
|
|
|
|
{
|
|
|
|
GstClock *clock = GST_CLOCK (object);
|
|
|
|
|
|
|
|
GST_OBJECT_LOCK (clock);
|
|
|
|
gst_object_replace ((GstObject **) & clock->master, NULL);
|
|
|
|
GST_OBJECT_UNLOCK (clock);
|
|
|
|
|
|
|
|
G_OBJECT_CLASS (parent_class)->dispose (object);
|
|
|
|
}
|
|
|
|
|
2003-02-02 19:21:06 +00:00
|
|
|
static void
|
gst/: Fix name lookup in GstBin.
Original commit message from CVS:
* gst/gstbin.c: (gst_bin_send_event), (compare_name),
(gst_bin_get_by_name):
* gst/gstbuffer.h:
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_class_init),
(gst_clock_finalize):
* gst/gstdata.c: (gst_data_replace):
* gst/gstdata.h:
* gst/gstelement.c: (gst_element_request_pad),
(gst_element_pads_activate):
* gst/gstobject.c: (gst_object_init), (gst_object_ref),
(gst_object_unref):
* gst/gstpad.c: (gst_pad_set_active), (gst_pad_peer_set_active),
(gst_pad_set_checkgetrange_function),
(gst_pad_link_check_compatible_unlocked), (gst_pad_set_caps),
(gst_pad_check_pull_range), (gst_pad_pull_range),
(gst_static_pad_template_get_caps), (gst_pad_start_task),
(gst_pad_pause_task), (gst_pad_stop_task):
* gst/gstutils.c: (gst_element_get_compatible_pad_template),
(gst_element_request_pad), (gst_pad_proxy_getcaps):
Fix name lookup in GstBin.
Added _data_replace() function and _buffer_replace()
Use finalize method to clean up clock.
Fix refcounting on request pads.
Fix pad schedule mode error.
Some more object refcounting debug info,
2005-05-05 09:28:01 +00:00
|
|
|
gst_clock_finalize (GObject * object)
|
2003-02-02 19:21:06 +00:00
|
|
|
{
|
|
|
|
GstClock *clock = GST_CLOCK (object);
|
|
|
|
|
2005-11-28 16:05:35 +00:00
|
|
|
GST_CLOCK_SLAVE_LOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
if (clock->clockid) {
|
|
|
|
gst_clock_id_unschedule (clock->clockid);
|
|
|
|
gst_clock_id_unref (clock->clockid);
|
|
|
|
clock->clockid = NULL;
|
|
|
|
}
|
|
|
|
g_free (clock->times);
|
|
|
|
clock->times = NULL;
|
2005-11-28 16:05:35 +00:00
|
|
|
GST_CLOCK_SLAVE_UNLOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
|
2005-11-28 16:05:35 +00:00
|
|
|
g_cond_free (clock->entries_changed);
|
2005-11-23 12:36:00 +00:00
|
|
|
g_mutex_free (clock->slave_lock);
|
|
|
|
|
gst/: Fix name lookup in GstBin.
Original commit message from CVS:
* gst/gstbin.c: (gst_bin_send_event), (compare_name),
(gst_bin_get_by_name):
* gst/gstbuffer.h:
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_class_init),
(gst_clock_finalize):
* gst/gstdata.c: (gst_data_replace):
* gst/gstdata.h:
* gst/gstelement.c: (gst_element_request_pad),
(gst_element_pads_activate):
* gst/gstobject.c: (gst_object_init), (gst_object_ref),
(gst_object_unref):
* gst/gstpad.c: (gst_pad_set_active), (gst_pad_peer_set_active),
(gst_pad_set_checkgetrange_function),
(gst_pad_link_check_compatible_unlocked), (gst_pad_set_caps),
(gst_pad_check_pull_range), (gst_pad_pull_range),
(gst_static_pad_template_get_caps), (gst_pad_start_task),
(gst_pad_pause_task), (gst_pad_stop_task):
* gst/gstutils.c: (gst_element_get_compatible_pad_template),
(gst_element_request_pad), (gst_pad_proxy_getcaps):
Fix name lookup in GstBin.
Added _data_replace() function and _buffer_replace()
Use finalize method to clean up clock.
Fix refcounting on request pads.
Fix pad schedule mode error.
Some more object refcounting debug info,
2005-05-05 09:28:01 +00:00
|
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
2003-02-02 19:21:06 +00:00
|
|
|
}
|
|
|
|
|
2002-03-31 14:04:50 +00:00
|
|
|
/**
|
2002-11-02 13:54:34 +00:00
|
|
|
* gst_clock_set_resolution
|
2005-11-19 18:17:29 +00:00
|
|
|
* @clock: a #GstClock
|
2002-11-02 13:54:34 +00:00
|
|
|
* @resolution: The resolution to set
|
2002-03-31 14:04:50 +00:00
|
|
|
*
|
2002-11-02 13:54:34 +00:00
|
|
|
* Set the accuracy of the clock.
|
|
|
|
*
|
|
|
|
* Returns: the new resolution of the clock.
|
2002-03-31 14:04:50 +00:00
|
|
|
*/
|
2005-11-19 18:17:29 +00:00
|
|
|
GstClockTime
|
|
|
|
gst_clock_set_resolution (GstClock * clock, GstClockTime resolution)
|
2000-11-11 15:13:50 +00:00
|
|
|
{
|
2002-12-19 21:31:03 +00:00
|
|
|
GstClockClass *cclass;
|
|
|
|
|
2005-11-19 18:17:29 +00:00
|
|
|
g_return_val_if_fail (GST_IS_CLOCK (clock), 0);
|
|
|
|
g_return_val_if_fail (resolution != 0, 0);
|
2002-03-30 17:05:03 +00:00
|
|
|
|
2002-12-19 21:31:03 +00:00
|
|
|
cclass = GST_CLOCK_GET_CLASS (clock);
|
|
|
|
|
|
|
|
if (cclass->change_resolution)
|
2004-03-13 15:27:01 +00:00
|
|
|
clock->resolution =
|
2004-03-15 19:27:17 +00:00
|
|
|
cclass->change_resolution (clock, clock->resolution, resolution);
|
2002-02-03 20:07:09 +00:00
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
return clock->resolution;
|
|
|
|
}
|
2002-02-03 20:07:09 +00:00
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
/**
|
|
|
|
* gst_clock_get_resolution
|
2005-11-19 18:17:29 +00:00
|
|
|
* @clock: a #GstClock
|
2002-11-02 13:54:34 +00:00
|
|
|
*
|
|
|
|
* Get the accuracy of the clock.
|
|
|
|
*
|
2005-11-19 18:17:29 +00:00
|
|
|
* Returns: the resolution of the clock in units of #GstClockTime.
|
2005-03-07 18:27:42 +00:00
|
|
|
*
|
|
|
|
* MT safe.
|
2002-11-02 13:54:34 +00:00
|
|
|
*/
|
2005-11-19 18:17:29 +00:00
|
|
|
GstClockTime
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_clock_get_resolution (GstClock * clock)
|
2002-11-02 13:54:34 +00:00
|
|
|
{
|
2002-12-19 21:31:03 +00:00
|
|
|
GstClockClass *cclass;
|
|
|
|
|
2005-11-19 18:17:29 +00:00
|
|
|
g_return_val_if_fail (GST_IS_CLOCK (clock), 0);
|
2002-11-02 13:54:34 +00:00
|
|
|
|
2002-12-19 21:31:03 +00:00
|
|
|
cclass = GST_CLOCK_GET_CLASS (clock);
|
|
|
|
|
|
|
|
if (cclass->get_resolution)
|
|
|
|
return cclass->get_resolution (clock);
|
2002-11-02 13:54:34 +00:00
|
|
|
|
2005-11-19 18:17:29 +00:00
|
|
|
return 1;
|
2000-04-09 21:38:17 +00:00
|
|
|
}
|
|
|
|
|
2002-03-31 14:04:50 +00:00
|
|
|
/**
|
2005-03-07 18:27:42 +00:00
|
|
|
* gst_clock_adjust_unlocked
|
|
|
|
* @clock: a #GstClock to use
|
|
|
|
* @internal: a clock time
|
2002-03-31 14:04:50 +00:00
|
|
|
*
|
2005-11-17 11:51:49 +00:00
|
|
|
* Converts the given @internal clock time to the real time, adjusting for the
|
2005-11-18 15:30:18 +00:00
|
|
|
* rate and reference time set with gst_clock_set_calibration() and making sure
|
|
|
|
* that the returned time is increasing. This function should be called with the
|
2005-11-23 12:36:00 +00:00
|
|
|
* clock's OBJECT_LOCK held and is mainly used by clock subclasses.
|
2002-03-31 14:04:50 +00:00
|
|
|
*
|
2005-03-07 18:27:42 +00:00
|
|
|
* Returns: the converted time of the clock.
|
2002-11-02 13:54:34 +00:00
|
|
|
*
|
2005-03-07 18:27:42 +00:00
|
|
|
* MT safe.
|
2002-11-02 13:54:34 +00:00
|
|
|
*/
|
2005-03-07 18:27:42 +00:00
|
|
|
GstClockTime
|
|
|
|
gst_clock_adjust_unlocked (GstClock * clock, GstClockTime internal)
|
2002-11-02 13:54:34 +00:00
|
|
|
{
|
2005-03-07 18:27:42 +00:00
|
|
|
GstClockTime ret;
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2005-11-23 12:36:00 +00:00
|
|
|
ret = gst_util_uint64_scale (internal - clock->internal_calibration,
|
|
|
|
clock->rate_numerator, clock->rate_denominator);
|
2005-11-19 18:06:56 +00:00
|
|
|
ret += clock->external_calibration;
|
2005-11-17 11:51:49 +00:00
|
|
|
|
|
|
|
/* make sure the time is increasing */
|
|
|
|
clock->last_time = MAX (ret, clock->last_time);
|
|
|
|
|
|
|
|
return clock->last_time;
|
2002-05-26 21:54:27 +00:00
|
|
|
}
|
|
|
|
|
2002-03-31 14:04:50 +00:00
|
|
|
/**
|
2005-11-17 11:51:49 +00:00
|
|
|
* gst_clock_get_internal_time
|
2002-04-23 15:01:56 +00:00
|
|
|
* @clock: a #GstClock to query
|
2002-03-31 14:04:50 +00:00
|
|
|
*
|
2005-11-17 11:51:49 +00:00
|
|
|
* Gets the current internal time of the given clock. The time is returned
|
|
|
|
* unadjusted for the offset and the rate.
|
2002-12-11 21:33:07 +00:00
|
|
|
*
|
2005-11-17 11:51:49 +00:00
|
|
|
* Returns: the internal time of the clock. Or GST_CLOCK_TIME_NONE when
|
2005-03-07 18:27:42 +00:00
|
|
|
* giving wrong input.
|
|
|
|
*
|
|
|
|
* MT safe.
|
2002-03-31 14:04:50 +00:00
|
|
|
*/
|
2002-02-03 20:07:09 +00:00
|
|
|
GstClockTime
|
2005-11-17 11:51:49 +00:00
|
|
|
gst_clock_get_internal_time (GstClock * clock)
|
2002-02-03 20:07:09 +00:00
|
|
|
{
|
2005-03-07 18:27:42 +00:00
|
|
|
GstClockTime ret;
|
2004-01-16 22:56:34 +00:00
|
|
|
GstClockClass *cclass;
|
2002-03-30 17:05:03 +00:00
|
|
|
|
2005-03-07 18:27:42 +00:00
|
|
|
g_return_val_if_fail (GST_IS_CLOCK (clock), GST_CLOCK_TIME_NONE);
|
2002-02-03 20:07:09 +00:00
|
|
|
|
2004-01-16 22:56:34 +00:00
|
|
|
cclass = GST_CLOCK_GET_CLASS (clock);
|
2002-12-19 21:31:03 +00:00
|
|
|
|
2004-01-16 22:56:34 +00:00
|
|
|
if (cclass->get_internal_time) {
|
2005-03-07 18:27:42 +00:00
|
|
|
ret = cclass->get_internal_time (clock);
|
2004-03-13 15:27:01 +00:00
|
|
|
} else {
|
2005-03-07 18:27:42 +00:00
|
|
|
ret = G_GINT64_CONSTANT (0);
|
2004-01-16 22:56:34 +00:00
|
|
|
}
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock, "internal time %" GST_TIME_FORMAT,
|
2005-03-07 18:27:42 +00:00
|
|
|
GST_TIME_ARGS (ret));
|
2002-02-03 20:07:09 +00:00
|
|
|
|
2005-11-17 11:51:49 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_clock_get_time
|
|
|
|
* @clock: a #GstClock to query
|
|
|
|
*
|
|
|
|
* Gets the current time of the given clock. The time is always
|
|
|
|
* monotonically increasing and adjusted according to the current
|
|
|
|
* offset and rate.
|
|
|
|
*
|
|
|
|
* Returns: the time of the clock. Or GST_CLOCK_TIME_NONE when
|
|
|
|
* giving wrong input.
|
|
|
|
*
|
|
|
|
* MT safe.
|
|
|
|
*/
|
|
|
|
GstClockTime
|
|
|
|
gst_clock_get_time (GstClock * clock)
|
|
|
|
{
|
|
|
|
GstClockTime ret;
|
|
|
|
|
|
|
|
g_return_val_if_fail (GST_IS_CLOCK (clock), GST_CLOCK_TIME_NONE);
|
|
|
|
|
|
|
|
ret = gst_clock_get_internal_time (clock);
|
|
|
|
|
2005-11-21 16:34:26 +00:00
|
|
|
GST_OBJECT_LOCK (clock);
|
2005-11-17 11:51:49 +00:00
|
|
|
/* this will scale for rate and offset */
|
2005-03-07 18:27:42 +00:00
|
|
|
ret = gst_clock_adjust_unlocked (clock, ret);
|
2005-11-21 16:34:26 +00:00
|
|
|
GST_OBJECT_UNLOCK (clock);
|
2004-03-13 15:27:01 +00:00
|
|
|
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock, "adjusted time %" GST_TIME_FORMAT,
|
2005-03-07 18:27:42 +00:00
|
|
|
GST_TIME_ARGS (ret));
|
gst/gstclock.*: deprecate old interface and disable functions that aren't in use anymore.
Original commit message from CVS:
2004-01-13 Benjamin Otte <in7y118@public.uni-hamburg.de>
* gst/gstclock.c: (gst_clock_class_init), (gst_clock_init),
(gst_clock_set_speed), (gst_clock_set_active),
(gst_clock_is_active), (gst_clock_reset),
(gst_clock_handle_discont):
* gst/gstclock.h:
deprecate old interface and disable functions that aren't in use
anymore.
* gst/gstelement.h:
* gst/gstelement.c: (gst_element_get_time), (gst_element_wait),
(gst_element_set_time), (gst_element_adjust_time):
add concept of "element time" and functions to get/set this time.
* gst/gstelement.c: (gst_element_change_state):
update element time correctly.
* gst/gstelement.c: (gst_element_get_compatible_pad_filtered):
This is a debug message, not a g_critical.
* gst/gstpad.c: (gst_pad_event_default):
handle discontinuous events right with element time.
* gst/gstscheduler.c: (gst_scheduler_state_transition):
update to clocking fixes.
set clocks on elements in READY=>PAUSED. The old behaviour caused
a wrong element time on the first element that started playing.
* gst/schedulers/gstbasicscheduler.c:
(gst_basic_scheduler_class_init):
* gst/schedulers/gstoptimalscheduler.c:
(gst_opt_scheduler_class_init):
remove code that just implements the default behaviour.
* gst/elements/gstfakesink.c: (gst_fakesink_chain):
update to use new clocking functions
* testsuite/clock/clock1.c: (gst_clock_debug), (main):
* testsuite/clock/clock2.c: (gst_clock_debug), (main):
update to test new element time.
* gst/autoplug/gstspideridentity.c: (gst_spider_identity_getcaps):
use _get_allowed_caps instead of _get_caps. This catches filtered
caps correctly.
* testsuite/debug/commandline.c:
update for new GST_DEBUG syntax.
* testsuite/threads/Makefile.am:
disable a test that only works sometimes.
2004-01-14 00:46:48 +00:00
|
|
|
|
2005-03-07 18:27:42 +00:00
|
|
|
return ret;
|
gst/gstclock.*: deprecate old interface and disable functions that aren't in use anymore.
Original commit message from CVS:
2004-01-13 Benjamin Otte <in7y118@public.uni-hamburg.de>
* gst/gstclock.c: (gst_clock_class_init), (gst_clock_init),
(gst_clock_set_speed), (gst_clock_set_active),
(gst_clock_is_active), (gst_clock_reset),
(gst_clock_handle_discont):
* gst/gstclock.h:
deprecate old interface and disable functions that aren't in use
anymore.
* gst/gstelement.h:
* gst/gstelement.c: (gst_element_get_time), (gst_element_wait),
(gst_element_set_time), (gst_element_adjust_time):
add concept of "element time" and functions to get/set this time.
* gst/gstelement.c: (gst_element_change_state):
update element time correctly.
* gst/gstelement.c: (gst_element_get_compatible_pad_filtered):
This is a debug message, not a g_critical.
* gst/gstpad.c: (gst_pad_event_default):
handle discontinuous events right with element time.
* gst/gstscheduler.c: (gst_scheduler_state_transition):
update to clocking fixes.
set clocks on elements in READY=>PAUSED. The old behaviour caused
a wrong element time on the first element that started playing.
* gst/schedulers/gstbasicscheduler.c:
(gst_basic_scheduler_class_init):
* gst/schedulers/gstoptimalscheduler.c:
(gst_opt_scheduler_class_init):
remove code that just implements the default behaviour.
* gst/elements/gstfakesink.c: (gst_fakesink_chain):
update to use new clocking functions
* testsuite/clock/clock1.c: (gst_clock_debug), (main):
* testsuite/clock/clock2.c: (gst_clock_debug), (main):
update to test new element time.
* gst/autoplug/gstspideridentity.c: (gst_spider_identity_getcaps):
use _get_allowed_caps instead of _get_caps. This catches filtered
caps correctly.
* testsuite/debug/commandline.c:
update for new GST_DEBUG syntax.
* testsuite/threads/Makefile.am:
disable a test that only works sometimes.
2004-01-14 00:46:48 +00:00
|
|
|
}
|
|
|
|
|
2005-11-18 15:30:18 +00:00
|
|
|
/**
|
|
|
|
* gst_clock_set_calibration
|
|
|
|
* @clock: a #GstClock to calibrate
|
|
|
|
* @internal: a reference internal time
|
|
|
|
* @external: a reference external time
|
2005-11-23 12:36:00 +00:00
|
|
|
* @rate_num: the numerator of the rate of the clock relative to its
|
|
|
|
* internal time
|
|
|
|
* @rate_denom: the denominator of the rate of the clock
|
2005-11-18 15:30:18 +00:00
|
|
|
*
|
2005-11-23 12:36:00 +00:00
|
|
|
* Adjusts the rate and time of @clock. A rate of 1/1 is the normal speed of
|
|
|
|
* the clock. Values bigger than 1/1 make the clock go faster.
|
2005-11-18 15:30:18 +00:00
|
|
|
*
|
|
|
|
* @internal and @external are calibration parameters that arrange that
|
|
|
|
* gst_clock_get_time() should have been @external at internal time @internal.
|
|
|
|
* This internal time should not be in the future; that is, it should be less
|
|
|
|
* than the value of gst_clock_get_internal_time() when this function is called.
|
2005-11-17 11:51:49 +00:00
|
|
|
*
|
|
|
|
* Subsequent calls to gst_clock_get_time() will return clock times computed as
|
|
|
|
* follows:
|
|
|
|
*
|
|
|
|
* <programlisting>
|
2005-11-23 12:36:00 +00:00
|
|
|
* time = (internal_time - @internal) * @rate_num / @rate_denom + @external
|
2005-11-17 11:51:49 +00:00
|
|
|
* </programlisting>
|
|
|
|
*
|
2005-11-23 12:36:00 +00:00
|
|
|
* This formula is implemented in gst_clock_adjust_unlocked(). Of course, it
|
|
|
|
* tries to do the integer arithmetic as precisely as possible.
|
|
|
|
*
|
2005-11-17 11:51:49 +00:00
|
|
|
* Note that gst_clock_get_time() always returns increasing values so when you
|
|
|
|
* move the clock backwards, gst_clock_get_time() will report the previous value
|
|
|
|
* until the clock catches up.
|
|
|
|
*
|
|
|
|
* MT safe.
|
|
|
|
*/
|
|
|
|
void
|
2005-11-18 15:30:18 +00:00
|
|
|
gst_clock_set_calibration (GstClock * clock, GstClockTime internal, GstClockTime
|
2005-11-23 12:36:00 +00:00
|
|
|
external, GstClockTime rate_num, GstClockTime rate_denom)
|
2005-11-17 11:51:49 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (GST_IS_CLOCK (clock));
|
2005-11-23 12:36:00 +00:00
|
|
|
g_return_if_fail (rate_num > 0);
|
|
|
|
g_return_if_fail (rate_denom > 0);
|
2005-11-18 19:21:50 +00:00
|
|
|
g_return_if_fail (internal <= gst_clock_get_internal_time (clock));
|
2005-11-17 11:51:49 +00:00
|
|
|
|
2005-11-21 16:34:26 +00:00
|
|
|
GST_OBJECT_LOCK (clock);
|
2005-11-19 18:06:56 +00:00
|
|
|
clock->internal_calibration = internal;
|
|
|
|
clock->external_calibration = external;
|
2005-11-23 12:36:00 +00:00
|
|
|
clock->rate_numerator = rate_num;
|
|
|
|
clock->rate_denominator = rate_denom;
|
2005-11-21 16:34:26 +00:00
|
|
|
GST_OBJECT_UNLOCK (clock);
|
2005-11-17 11:51:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2005-11-18 19:21:50 +00:00
|
|
|
* gst_clock_get_calibration
|
|
|
|
* @clock: a #GstClock
|
|
|
|
* @internal: a location to store the internal time
|
|
|
|
* @external: a location to store the external time
|
2005-11-23 12:36:00 +00:00
|
|
|
* @rate_num: a location to store the rate numerator
|
|
|
|
* @rate_denom: a location to store the rate denominator
|
2005-11-17 11:51:49 +00:00
|
|
|
*
|
2005-11-18 15:30:18 +00:00
|
|
|
* Gets the internal rate and reference time of @clock. See
|
|
|
|
* gst_clock_set_calibration() for more information.
|
2005-11-17 11:51:49 +00:00
|
|
|
*
|
2005-11-23 12:36:00 +00:00
|
|
|
* @internal, @external, @rate_num, and @rate_denom can be left NULL if the
|
|
|
|
* caller is not interested in the values.
|
2005-11-18 19:21:50 +00:00
|
|
|
*
|
2005-11-17 11:51:49 +00:00
|
|
|
* MT safe.
|
|
|
|
*/
|
|
|
|
void
|
2005-11-18 15:30:18 +00:00
|
|
|
gst_clock_get_calibration (GstClock * clock, GstClockTime * internal,
|
2005-11-23 12:36:00 +00:00
|
|
|
GstClockTime * external, GstClockTime * rate_num, GstClockTime * rate_denom)
|
2005-11-17 11:51:49 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (GST_IS_CLOCK (clock));
|
|
|
|
|
2005-11-21 16:34:26 +00:00
|
|
|
GST_OBJECT_LOCK (clock);
|
2005-11-23 12:36:00 +00:00
|
|
|
if (rate_num)
|
|
|
|
*rate_num = clock->rate_numerator;
|
|
|
|
if (rate_denom)
|
|
|
|
*rate_denom = clock->rate_denominator;
|
2005-11-18 19:21:50 +00:00
|
|
|
if (external)
|
2005-11-19 18:06:56 +00:00
|
|
|
*external = clock->external_calibration;
|
2005-11-18 19:21:50 +00:00
|
|
|
if (internal)
|
2005-11-19 18:06:56 +00:00
|
|
|
*internal = clock->internal_calibration;
|
2005-11-21 16:34:26 +00:00
|
|
|
GST_OBJECT_UNLOCK (clock);
|
2005-11-17 11:51:49 +00:00
|
|
|
}
|
|
|
|
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
/* will be called repeadedly to sample the master and slave clock
|
|
|
|
* to recalibrate the clock */
|
|
|
|
static gboolean
|
|
|
|
gst_clock_slave_callback (GstClock * master, GstClockTime time,
|
|
|
|
GstClockID id, GstClock * clock)
|
|
|
|
{
|
|
|
|
GstClockTime stime, mtime;
|
|
|
|
gdouble r_squared;
|
|
|
|
|
|
|
|
stime = gst_clock_get_internal_time (clock);
|
|
|
|
mtime = gst_clock_get_time (master);
|
|
|
|
|
|
|
|
GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock,
|
|
|
|
"master %" GST_TIME_FORMAT ", slave %" GST_TIME_FORMAT,
|
|
|
|
GST_TIME_ARGS (mtime), GST_TIME_ARGS (stime));
|
|
|
|
|
|
|
|
gst_clock_add_observation (clock, stime, mtime, &r_squared);
|
|
|
|
|
|
|
|
/* FIXME, we can use the r_squared value to adjust the timeout
|
|
|
|
* value of the clockid */
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2005-11-21 17:12:50 +00:00
|
|
|
/**
|
|
|
|
* gst_clock_set_master
|
|
|
|
* @clock: a #GstClock
|
|
|
|
* @master: a master #GstClock
|
|
|
|
*
|
|
|
|
* Set @master as the master clock for @clock. @clock will be automatically
|
|
|
|
* calibrated so that gst_clock_get_time() reports the same time as the
|
|
|
|
* master clock.
|
|
|
|
*
|
|
|
|
* A clock provider that slaves its clock to a master can get the current
|
|
|
|
* calibration values with gst_clock_get_calibration().
|
|
|
|
*
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
* Returns: TRUE if the clock is capable of being slaved to a master clock.
|
|
|
|
*
|
2005-11-21 17:12:50 +00:00
|
|
|
* MT safe.
|
|
|
|
*/
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
gboolean
|
2005-11-21 17:12:50 +00:00
|
|
|
gst_clock_set_master (GstClock * clock, GstClock * master)
|
|
|
|
{
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
g_return_val_if_fail (GST_IS_CLOCK (clock), FALSE);
|
gst/gstbin.c: Clean up references to the clock provider when disposed or when handling a clock-lost message from it.
Original commit message from CVS:
* gst/gstbin.c: (gst_bin_dispose), (gst_bin_provide_clock_func),
(gst_bin_remove_func), (gst_bin_handle_message_func),
(bin_query_duration_fold), (bin_query_generic_fold):
Clean up references to the clock provider when disposed or when
handling a clock-lost message from it.
Unref sinks when performing a query via gst_iterator_fold, as the
gst_bin_iterate_sinks iterator refs each item. (Fixes #323874)
* gst/gstclock.c: (gst_clock_class_init), (gst_clock_dispose),
(gst_clock_set_master):
Drop our reference to the master clock, if any, when we are disposed.
* gst/gsttypefindfactory.c: (gst_type_find_factory_dispose):
Chain up in dispose.
2006-01-27 01:48:37 +00:00
|
|
|
g_return_val_if_fail (master != clock, FALSE);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
|
2005-11-21 17:12:50 +00:00
|
|
|
GST_OBJECT_LOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
/* we always allow setting the master to NULL */
|
|
|
|
if (master && !GST_OBJECT_FLAG_IS_SET (clock, GST_CLOCK_FLAG_CAN_SET_MASTER))
|
|
|
|
goto not_supported;
|
|
|
|
|
|
|
|
GST_DEBUG_OBJECT (clock, "slaving to master clock %p", master);
|
2005-11-21 17:12:50 +00:00
|
|
|
gst_object_replace ((GstObject **) & clock->master, (GstObject *) master);
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_OBJECT_UNLOCK (clock);
|
|
|
|
|
|
|
|
GST_CLOCK_SLAVE_LOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
if (clock->clockid) {
|
|
|
|
gst_clock_id_unschedule (clock->clockid);
|
|
|
|
gst_clock_id_unref (clock->clockid);
|
|
|
|
clock->clockid = NULL;
|
|
|
|
}
|
|
|
|
if (master) {
|
|
|
|
clock->filling = TRUE;
|
|
|
|
clock->time_index = 0;
|
|
|
|
/* use the master periodic id to schedule sampling and
|
|
|
|
* clock calibration. */
|
|
|
|
clock->clockid = gst_clock_new_periodic_id (master,
|
|
|
|
gst_clock_get_time (master), clock->timeout);
|
|
|
|
gst_clock_id_wait_async (clock->clockid,
|
|
|
|
(GstClockCallback) gst_clock_slave_callback, clock);
|
|
|
|
}
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_UNLOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
not_supported:
|
|
|
|
{
|
|
|
|
GST_DEBUG_OBJECT (clock, "cannot be slaved to a master clock");
|
2005-11-28 16:05:35 +00:00
|
|
|
GST_OBJECT_UNLOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2005-11-21 17:12:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_clock_get_master
|
|
|
|
* @clock: a #GstClock
|
|
|
|
*
|
|
|
|
* Get the master clock that @clock is slaved to or NULL when the clock is
|
|
|
|
* not slaved to any master clock.
|
|
|
|
*
|
|
|
|
* Returns: a master #GstClock or NULL when this clock is not slaved to a master
|
|
|
|
* clock. Unref after usage.
|
|
|
|
*
|
|
|
|
* MT safe.
|
|
|
|
*/
|
|
|
|
GstClock *
|
|
|
|
gst_clock_get_master (GstClock * clock)
|
|
|
|
{
|
|
|
|
GstClock *result = NULL;
|
|
|
|
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
g_return_val_if_fail (GST_IS_CLOCK (clock), NULL);
|
|
|
|
|
2005-11-21 17:12:50 +00:00
|
|
|
GST_OBJECT_LOCK (clock);
|
|
|
|
if (clock->master)
|
|
|
|
result = gst_object_ref (clock->master);
|
|
|
|
GST_OBJECT_UNLOCK (clock);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2005-11-23 12:36:00 +00:00
|
|
|
/* http://mathworld.wolfram.com/LeastSquaresFitting.html
|
|
|
|
* with SLAVE_LOCK
|
|
|
|
*/
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
static gboolean
|
2005-11-23 12:36:00 +00:00
|
|
|
do_linear_regression (GstClock * clock, GstClockTime * m_num,
|
|
|
|
GstClockTime * m_denom, GstClockTime * b, GstClockTime * xbase,
|
|
|
|
gdouble * r_squared)
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
{
|
|
|
|
GstClockTime *newx, *newy;
|
|
|
|
GstClockTime xmin, ymin, xbar, ybar, xbar4, ybar4;
|
|
|
|
GstClockTimeDiff sxx, sxy, syy;
|
|
|
|
GstClockTime *x, *y;
|
|
|
|
gint i, j;
|
|
|
|
guint n;
|
|
|
|
|
|
|
|
xbar = ybar = sxx = syy = sxy = 0;
|
|
|
|
|
|
|
|
x = clock->times;
|
2005-11-23 12:36:00 +00:00
|
|
|
y = clock->times + 2;
|
|
|
|
n = clock->filling ? clock->time_index : clock->window_size;
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
|
|
|
|
#ifdef DEBUGGING_ENABLED
|
2005-11-30 09:18:15 +00:00
|
|
|
GST_DEBUG ("doing regression on:");
|
2005-11-23 12:36:00 +00:00
|
|
|
for (i = j = 0; i < n; i++, j += 4)
|
2005-11-30 09:18:15 +00:00
|
|
|
GST_DEBUG (" %" G_GUINT64_FORMAT " %" G_GUINT64_FORMAT, x[j], y[j]);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
xmin = ymin = G_MAXUINT64;
|
|
|
|
for (i = j = 0; i < n; i++, j += 4) {
|
|
|
|
xmin = MIN (xmin, x[j]);
|
|
|
|
ymin = MIN (ymin, y[j]);
|
|
|
|
}
|
|
|
|
|
2005-11-30 09:18:15 +00:00
|
|
|
#ifdef DEBUGGING_ENABLED
|
|
|
|
GST_DEBUG ("min x: %" G_GUINT64_FORMAT, xmin);
|
|
|
|
GST_DEBUG ("min y: %" G_GUINT64_FORMAT, ymin);
|
|
|
|
#endif
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
|
|
|
|
newx = clock->times + 1;
|
|
|
|
newy = clock->times + 3;
|
|
|
|
|
|
|
|
/* strip off unnecessary bits of precision */
|
|
|
|
for (i = j = 0; i < n; i++, j += 4) {
|
|
|
|
newx[j] = x[j] - xmin;
|
|
|
|
newy[j] = y[j] - ymin;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUGGING_ENABLED
|
2005-11-30 09:18:15 +00:00
|
|
|
GST_DEBUG ("reduced numbers:");
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
for (i = j = 0; i < n; i++, j += 4)
|
2005-11-30 09:18:15 +00:00
|
|
|
GST_DEBUG (" %" G_GUINT64_FORMAT " %" G_GUINT64_FORMAT, newx[j], newy[j]);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* have to do this precisely otherwise the results are pretty much useless.
|
|
|
|
* should guarantee that none of these accumulators can overflow */
|
|
|
|
|
|
|
|
/* quantities on the order of 1e10 -> 30 bits; window size a max of 2^10, so
|
|
|
|
this addition could end up around 2^40 or so -- ample headroom */
|
|
|
|
for (i = j = 0; i < n; i++, j += 4) {
|
|
|
|
xbar += newx[j];
|
|
|
|
ybar += newy[j];
|
|
|
|
}
|
|
|
|
xbar /= n;
|
|
|
|
ybar /= n;
|
|
|
|
|
2005-11-30 09:18:15 +00:00
|
|
|
#ifdef DEBUGGING_ENABLED
|
|
|
|
GST_DEBUG (" xbar = %" G_GUINT64_FORMAT, xbar);
|
|
|
|
GST_DEBUG (" ybar = %" G_GUINT64_FORMAT, ybar);
|
|
|
|
#endif
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
|
|
|
|
/* multiplying directly would give quantities on the order of 1e20 -> 60 bits;
|
|
|
|
times the window size that's 70 which is too much. Instead we (1) subtract
|
|
|
|
off the xbar*ybar in the loop instead of after, to avoid accumulation; (2)
|
|
|
|
shift off 4 bits from each multiplicand, giving an expected ceiling of 52
|
|
|
|
bits, which should be enough. Need to check the incoming range and domain
|
|
|
|
to ensure this is an appropriate loss of precision though. */
|
|
|
|
xbar4 = xbar >> 4;
|
|
|
|
ybar4 = ybar >> 4;
|
|
|
|
for (i = j = 0; i < n; i++, j += 4) {
|
|
|
|
GstClockTime newx4, newy4;
|
|
|
|
|
|
|
|
newx4 = newx[j] >> 4;
|
|
|
|
newy4 = newy[j] >> 4;
|
|
|
|
|
|
|
|
sxx += newx4 * newx4 - xbar4 * xbar4;
|
|
|
|
syy += newy4 * newy4 - ybar4 * ybar4;
|
|
|
|
sxy += newx4 * newy4 - xbar4 * ybar4;
|
|
|
|
}
|
|
|
|
|
2005-11-28 16:05:35 +00:00
|
|
|
if (sxx == 0)
|
|
|
|
goto invalid;
|
|
|
|
|
2005-11-23 12:36:00 +00:00
|
|
|
*m_num = sxy;
|
|
|
|
*m_denom = sxx;
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
*xbase = xmin;
|
2005-11-23 12:36:00 +00:00
|
|
|
*b = (ybar + ymin) - gst_util_uint64_scale (xbar, *m_num, *m_denom);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
*r_squared = ((double) sxy * (double) sxy) / ((double) sxx * (double) syy);
|
|
|
|
|
2005-11-30 09:18:15 +00:00
|
|
|
#ifdef DEBUGGING_ENABLED
|
|
|
|
GST_DEBUG (" m = %g", ((double) *m_num) / *m_denom);
|
|
|
|
GST_DEBUG (" b = %" G_GUINT64_FORMAT, *b);
|
|
|
|
GST_DEBUG (" xbase = %" G_GUINT64_FORMAT, *xbase);
|
|
|
|
GST_DEBUG (" r2 = %g", *r_squared);
|
|
|
|
#endif
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
|
|
|
|
return TRUE;
|
2005-11-28 16:05:35 +00:00
|
|
|
|
|
|
|
invalid:
|
|
|
|
{
|
|
|
|
return FALSE;
|
|
|
|
}
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_clock_add_observation
|
|
|
|
* @clock: a #GstClock
|
2005-11-23 12:36:00 +00:00
|
|
|
* @slave: a time on the slave
|
|
|
|
* @master: a time on the master
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
* @r_squared: a pointer to hold the result
|
|
|
|
*
|
|
|
|
* The time @master of the master clock and the time @slave of the slave
|
|
|
|
* clock are added to the list of observations. If enough observations
|
|
|
|
* are available, a linear regression algorithm is run on the
|
|
|
|
* observations and @clock is recalibrated.
|
|
|
|
*
|
|
|
|
* Returns: TRUE if enough observations were added to run the
|
|
|
|
* regression algorithm.
|
|
|
|
*
|
|
|
|
* MT safe.
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
gst_clock_add_observation (GstClock * clock, GstClockTime slave,
|
|
|
|
GstClockTime master, gdouble * r_squared)
|
|
|
|
{
|
2005-11-23 12:36:00 +00:00
|
|
|
GstClockTime m_num, m_denom, b, xbase;
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
|
|
|
|
g_return_val_if_fail (GST_IS_CLOCK (clock), FALSE);
|
|
|
|
g_return_val_if_fail (r_squared != NULL, FALSE);
|
|
|
|
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_LOCK (clock);
|
|
|
|
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
clock->times[(4 * clock->time_index)] = slave;
|
|
|
|
clock->times[(4 * clock->time_index) + 2] = master;
|
|
|
|
|
|
|
|
clock->time_index++;
|
|
|
|
if (clock->time_index == clock->window_size) {
|
|
|
|
clock->filling = FALSE;
|
|
|
|
clock->time_index = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (clock->filling && clock->time_index < clock->window_threshold)
|
|
|
|
goto filling;
|
|
|
|
|
2005-11-28 16:05:35 +00:00
|
|
|
if (!do_linear_regression (clock, &m_num, &m_denom, &b, &xbase, r_squared))
|
|
|
|
goto invalid;
|
2005-11-23 12:36:00 +00:00
|
|
|
|
|
|
|
GST_CLOCK_SLAVE_UNLOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
|
|
|
|
GST_CAT_LOG_OBJECT (GST_CAT_CLOCK, clock,
|
2005-11-23 12:36:00 +00:00
|
|
|
"adjusting clock to m=%" G_GUINT64_FORMAT "/%" G_GUINT64_FORMAT ", b=%"
|
|
|
|
G_GUINT64_FORMAT " (rsquared=%g)", m_num, m_denom, b, *r_squared);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
|
2005-11-28 16:05:35 +00:00
|
|
|
/* if we have a valid regression, adjust the clock */
|
2005-11-23 12:36:00 +00:00
|
|
|
gst_clock_set_calibration (clock, xbase, b, m_num, m_denom);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
filling:
|
|
|
|
{
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_UNLOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2005-11-28 16:05:35 +00:00
|
|
|
invalid:
|
|
|
|
{
|
|
|
|
/* no valid regression has been done, ignore the result then */
|
|
|
|
GST_CLOCK_SLAVE_UNLOCK (clock);
|
|
|
|
return TRUE;
|
|
|
|
}
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
}
|
|
|
|
|
2002-03-30 17:05:03 +00:00
|
|
|
static void
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_clock_update_stats (GstClock * clock)
|
2002-03-30 17:05:03 +00:00
|
|
|
{
|
2002-02-03 20:07:09 +00:00
|
|
|
}
|
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
static void
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_clock_set_property (GObject * object, guint prop_id,
|
|
|
|
const GValue * value, GParamSpec * pspec)
|
2002-02-03 20:07:09 +00:00
|
|
|
{
|
2002-11-02 13:54:34 +00:00
|
|
|
GstClock *clock;
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
clock = GST_CLOCK (object);
|
|
|
|
|
|
|
|
switch (prop_id) {
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
case PROP_STATS:
|
|
|
|
GST_OBJECT_LOCK (clock);
|
2002-11-02 13:54:34 +00:00
|
|
|
clock->stats = g_value_get_boolean (value);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
GST_OBJECT_UNLOCK (clock);
|
gst/gstclock.*: deprecate old interface and disable functions that aren't in use anymore.
Original commit message from CVS:
2004-01-13 Benjamin Otte <in7y118@public.uni-hamburg.de>
* gst/gstclock.c: (gst_clock_class_init), (gst_clock_init),
(gst_clock_set_speed), (gst_clock_set_active),
(gst_clock_is_active), (gst_clock_reset),
(gst_clock_handle_discont):
* gst/gstclock.h:
deprecate old interface and disable functions that aren't in use
anymore.
* gst/gstelement.h:
* gst/gstelement.c: (gst_element_get_time), (gst_element_wait),
(gst_element_set_time), (gst_element_adjust_time):
add concept of "element time" and functions to get/set this time.
* gst/gstelement.c: (gst_element_change_state):
update element time correctly.
* gst/gstelement.c: (gst_element_get_compatible_pad_filtered):
This is a debug message, not a g_critical.
* gst/gstpad.c: (gst_pad_event_default):
handle discontinuous events right with element time.
* gst/gstscheduler.c: (gst_scheduler_state_transition):
update to clocking fixes.
set clocks on elements in READY=>PAUSED. The old behaviour caused
a wrong element time on the first element that started playing.
* gst/schedulers/gstbasicscheduler.c:
(gst_basic_scheduler_class_init):
* gst/schedulers/gstoptimalscheduler.c:
(gst_opt_scheduler_class_init):
remove code that just implements the default behaviour.
* gst/elements/gstfakesink.c: (gst_fakesink_chain):
update to use new clocking functions
* testsuite/clock/clock1.c: (gst_clock_debug), (main):
* testsuite/clock/clock2.c: (gst_clock_debug), (main):
update to test new element time.
* gst/autoplug/gstspideridentity.c: (gst_spider_identity_getcaps):
use _get_allowed_caps instead of _get_caps. This catches filtered
caps correctly.
* testsuite/debug/commandline.c:
update for new GST_DEBUG syntax.
* testsuite/threads/Makefile.am:
disable a test that only works sometimes.
2004-01-14 00:46:48 +00:00
|
|
|
g_object_notify (object, "stats");
|
2002-11-02 13:54:34 +00:00
|
|
|
break;
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
case PROP_WINDOW_SIZE:
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_LOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
clock->window_size = g_value_get_int (value);
|
|
|
|
clock->window_threshold =
|
|
|
|
MIN (clock->window_threshold, clock->window_size);
|
|
|
|
clock->times =
|
|
|
|
g_renew (GstClockTime, clock->times, 4 * clock->window_size);
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_UNLOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
break;
|
|
|
|
case PROP_WINDOW_THRESHOLD:
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_LOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
clock->window_threshold =
|
|
|
|
MIN (g_value_get_int (value), clock->window_size);
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_UNLOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
break;
|
|
|
|
case PROP_TIMEOUT:
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_LOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
clock->timeout = g_value_get_uint64 (value);
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_UNLOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
break;
|
2002-11-02 13:54:34 +00:00
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
break;
|
2004-03-13 15:27:01 +00:00
|
|
|
}
|
2000-04-09 21:38:17 +00:00
|
|
|
}
|
2002-02-03 20:07:09 +00:00
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
static void
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_clock_get_property (GObject * object, guint prop_id,
|
|
|
|
GValue * value, GParamSpec * pspec)
|
2002-02-03 20:07:09 +00:00
|
|
|
{
|
2002-11-02 13:54:34 +00:00
|
|
|
GstClock *clock;
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2002-11-02 13:54:34 +00:00
|
|
|
clock = GST_CLOCK (object);
|
|
|
|
|
|
|
|
switch (prop_id) {
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
case PROP_STATS:
|
|
|
|
GST_OBJECT_LOCK (clock);
|
2002-11-02 13:54:34 +00:00
|
|
|
g_value_set_boolean (value, clock->stats);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
GST_OBJECT_UNLOCK (clock);
|
|
|
|
break;
|
|
|
|
case PROP_WINDOW_SIZE:
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_LOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
g_value_set_int (value, clock->window_size);
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_UNLOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
break;
|
|
|
|
case PROP_WINDOW_THRESHOLD:
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_LOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
g_value_set_int (value, clock->window_threshold);
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_UNLOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
break;
|
|
|
|
case PROP_TIMEOUT:
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_LOCK (clock);
|
gst/base/gstbasesink.*: No need to store the clock, the parent element class already has it.
Original commit message from CVS:
* gst/base/gstbasesink.c: (gst_base_sink_class_init),
(gst_base_sink_wait), (gst_base_sink_do_sync),
(gst_base_sink_handle_event):
* gst/base/gstbasesink.h:
No need to store the clock, the parent element class already
has it.
* gst/gstbin.c: (gst_bin_set_clock_func), (gst_bin_add_func):
Updates for clock_set returning a gboolean
* gst/gstclock.c: (gst_clock_entry_new), (gst_clock_id_wait),
(gst_clock_id_wait_async), (gst_clock_class_init),
(gst_clock_init), (gst_clock_finalize),
(gst_clock_get_internal_time), (gst_clock_get_time),
(gst_clock_slave_callback), (gst_clock_set_master),
(gst_clock_get_master), (do_linear_regression),
(gst_clock_add_observation), (gst_clock_set_property),
(gst_clock_get_property):
* gst/gstclock.h:
Implement master/slave. When setting a clock as a slave, a
periodic timeout is scheduled to sample master and slave times.
Then the slave clock is recalibrated to match offset and rate
of the master clock.
Update logging a bit.
Add flag so that a clock can state that is cannot be slaved to
another clock.
* gst/gstelement.c: (gst_element_set_clock):
* gst/gstelement.h:
The set_clock returns a gboolean for when an element cannot
deal with the selected clock in the pipeline.
* gst/gstpipeline.c: (gst_pipeline_change_state),
(gst_pipeline_set_clock):
* gst/gstpipeline.h:
Handle the case where the selected clock cannot be set on
the pipeline.
* gst/net/gstnetclientclock.c: (gst_net_client_clock_class_init),
(gst_net_client_clock_init), (gst_net_client_clock_finalize),
(gst_net_client_clock_set_property),
(gst_net_client_clock_get_property),
(gst_net_client_clock_observe_times):
* gst/net/gstnetclientclock.h:
Use regression code in GstClock parent, remove duplicated
functionality.
2005-11-22 18:28:44 +00:00
|
|
|
g_value_set_uint64 (value, clock->timeout);
|
2005-11-23 12:36:00 +00:00
|
|
|
GST_CLOCK_SLAVE_UNLOCK (clock);
|
2002-11-02 13:54:34 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
break;
|
2004-03-13 15:27:01 +00:00
|
|
|
}
|
2002-02-03 20:07:09 +00:00
|
|
|
}
|