Clock

GStreamer uses a global clock to synchronize the plugins in a pipeline. Different clock implementations are possible by implementing this abstract base class or, more conveniently, by subclassing GstSystemClock.

The GstClock returns a monotonically increasing time with the method gst_clock_get_time(). Its accuracy and base time depend on the specific clock implementation but time is always expressed in nanoseconds. Since the baseline of the clock is undefined, the clock time returned is not meaningful in itself, what matters are the deltas between two clock times. The time returned by a clock is called the absolute time.

The pipeline uses the clock to calculate the running time. Usually all renderers synchronize to the global clock using the buffer timestamps, the newsegment events and the element's base time, see GstPipeline.

A clock implementation can support periodic and single shot clock notifications both synchronous and asynchronous.

One first needs to create a GstClockID for the periodic or single shot notification using gst_clock_new_single_shot_id() or gst_clock_new_periodic_id().

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 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.

Periodic callbacks scheduled async will be repeatedly called automatically until it is unscheduled. To schedule a sync periodic callback, gst_clock_id_wait() should be called repeatedly.

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.

A GstClockID that has been unscheduled cannot be used again for any wait operation, a new GstClockID should be created and the old unscheduled one should be destroyed with gst_clock_id_unref().

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 for the thread registering the entry last.

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 the entry would be unreffed automatically, the handle might become invalid without any notification.

These clock operations do not operate on the running 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.

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 repeatedly sampling the master clock and the slave clock and recalibrating the slave clock with gst_clock_set_calibration(). This feature is mostly useful 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.

The master/slave synchronisation can be tuned with the "timeout", "window-size" and "window-threshold" properties. The "timeout" property defines the interval to sample the master clock and run the calibration functions. "window-size" defines the number of samples to use when calibrating and "window-threshold" defines the minimum number of samples before the calibration is performed.

Last reviewed on 2012-03-28 (0.11.3)

Constructors

this
this(GstClock* gstClock)

Sets our main struct and passes it to the parent class

Members

Functions

addObservation
int addObservation(GstClockTime slave, GstClockTime master, double rSquared)

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. If this functions returns TRUE, r_squared will contain the correlation coefficient of the interpolation. A value of 1.0 means a perfect regression was performed. This value can be used to control the sampling frequency of the master and slave clocks.

adjustUnlocked
GstClockTime adjustUnlocked(GstClockTime internal)

Converts the given internal clock time to the external time, adjusting for the 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 clock's OBJECT_LOCK held and is mainly used by clock subclasses. This function is the reverse of gst_clock_unadjust_unlocked().

getCalibration
void getCalibration(GstClockTime internal, GstClockTime external, GstClockTime rateNum, GstClockTime rateDenom)

Gets the internal rate and reference time of clock. See gst_clock_set_calibration() for more information. internal, external, rate_num, and rate_denom can be left NULL if the caller is not interested in the values. MT safe.

getClockStruct
GstClock* getClockStruct()
Undocumented in source. Be warned that the author may not have intended to support it.
getInternalTime
GstClockTime getInternalTime()

Gets the current internal time of the given clock. The time is returned unadjusted for the offset and the rate.

getMaster
Clock getMaster()

Get the master clock that clock is slaved to or NULL when the clock is not slaved to any master clock.

getResolution
GstClockTime getResolution()

Get the accuracy of the clock. The accuracy of the clock is the granularity of the values returned by gst_clock_get_time().

getStruct
void* getStruct()

the main Gtk struct as a void*

getTime
GstClockTime getTime()

Gets the current time of the given clock. The time is always monotonically increasing and adjusted according to the current offset and rate.

getTimeout
GstClockTime getTimeout()

Get the amount of time that master and slave clocks are sampled.

newPeriodicId
GstClockID newPeriodicId(GstClockTime startTime, GstClockTime interval)

Get an ID from clock to trigger a periodic notification. The periodic notifications will start at time start_time and will then be fired with the given interval. id should be unreffed after usage. Free-function: gst_clock_id_unref

newSingleShotId
GstClockID newSingleShotId(GstClockTime time)

Get a GstClockID from clock to trigger a single shot notification at the requested time. The single shot id should be unreffed after usage. Free-function: gst_clock_id_unref

periodicIdReinit
int periodicIdReinit(GstClockID id, GstClockTime startTime, GstClockTime interval)

Reinitializes the provided periodic id to the provided start time and interval. Does not modify the reference count.

setCalibration
void setCalibration(GstClockTime internal, GstClockTime external, GstClockTime rateNum, GstClockTime rateDenom)

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. 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. Subsequent calls to gst_clock_get_time() will return clock times computed as

setMaster
int setMaster(Clock master)

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(). master can be NULL in which case clock will not be slaved anymore. It will however keep reporting its time adjusted with the last configured rate and time offsets.

setResolution
GstClockTime setResolution(GstClockTime resolution)

Set the accuracy of the clock. Some clocks have the possibility to operate with different accuracy at the expense of more resource usage. There is normally no need to change the default resolution of a clock. The resolution of a clock can only be changed if the clock has the GST_CLOCK_FLAG_CAN_SET_RESOLUTION flag set.

setStruct
void setStruct(GObject* obj)
Undocumented in source. Be warned that the author may not have intended to support it.
setTimeout
void setTimeout(GstClockTime timeout)

Set the amount of time, in nanoseconds, to sample master and slave clocks

singleShotIdReinit
int singleShotIdReinit(GstClockID id, GstClockTime time)

Reinitializes the provided single shot id to the provided time. Does not modify the reference count.

unadjustUnlocked
GstClockTime unadjustUnlocked(GstClockTime external)

Converts the given external clock time to the internal time of clock, using the rate and reference time set with gst_clock_set_calibration(). This function should be called with the clock's OBJECT_LOCK held and is mainly used by clock subclasses. This function is the reverse of gst_clock_adjust_unlocked().

Static functions

idCompareFunc
int idCompareFunc(void* id1, void* id2)

Compares the two GstClockID instances. This function can be used as a GCompareFunc when sorting ids.

idGetTime
GstClockTime idGetTime(GstClockID id)

Get the time of the clock ID

idRef
GstClockID idRef(GstClockID id)

Increase the refcount of given id.

idUnref
void idUnref(GstClockID id)

Unref given id. When the refcount reaches 0 the GstClockID will be freed. MT safe.

idUnschedule
void idUnschedule(GstClockID id)

Cancel an outstanding request with id. This can either be an outstanding async notification or a pending sync notification. After this call, id cannot be used anymore to receive sync or async notifications, you need to create a new GstClockID. MT safe.

idWait
GstClockReturn idWait(GstClockID id, GstClockTimeDiff jitter)

Perform a blocking wait on id. id should have been created with gst_clock_new_single_shot_id() or gst_clock_new_periodic_id() and should not have been unscheduled with a call to gst_clock_id_unschedule(). If the jitter argument is not NULL and this function returns GST_CLOCK_OK or GST_CLOCK_EARLY, it will contain the difference against the clock and the time of id when this method was called. Positive values indicate how late id was relative to the clock (in which case this function will return GST_CLOCK_EARLY). Negative values indicate how much time was spent waiting on the clock before this function returned.

idWaitAsync
GstClockReturn idWaitAsync(GstClockID id, GstClockCallback func, void* userData, GDestroyNotify destroyData)

Register a callback on the given GstClockID id with the given function and user_data. When passing a GstClockID with an invalid time to this function, the callback will be called immediately with a time set to GST_CLOCK_TIME_NONE. The callback will be called when the time of id has been reached. The callback func can be invoked from any thread, either provided by the core or from a streaming thread. The application should be prepared for this.

Variables

gstClock
GstClock* gstClock;

the main Gtk struct

Inherited Members

From ObjectGst

gstObject
GstObject* gstObject;

the main Gtk struct

getObjectGstStruct
GstObject* getObjectGstStruct()
Undocumented in source. Be warned that the author may not have intended to support it.
getStruct
void* getStruct()

the main Gtk struct as a void*

setStruct
void setStruct(GObject* obj)
Undocumented in source. Be warned that the author may not have intended to support it.
connectedSignals
int[string] connectedSignals;
onDeepNotifyListeners
void delegate(ObjectGst, ParamSpec, ObjectGst)[] onDeepNotifyListeners;
Undocumented in source.
addOnDeepNotify
void addOnDeepNotify(void delegate(ObjectGst, ParamSpec, ObjectGst) dlg, ConnectFlags connectFlags)

The deep notify signal is used to be notified of property changes. It is typically attached to the toplevel bin to receive notifications from all the elements contained in that bin.

callBackDeepNotify
void callBackDeepNotify(GstObject* gstobjectStruct, GstObject* propObject, GParamSpec* prop, ObjectGst _objectGst)
Undocumented in source. Be warned that the author may not have intended to support it.
setName
int setName(string name)

Sets the name of object, or gives object a guaranteed unique name (if name is NULL). This function makes a copy of the provided name, so the caller retains ownership of the name it sent.

getName
string getName()

Returns a copy of the name of object. Caller should g_free() the return value after usage. For a nameless object, this returns NULL, which you can safely g_free() as well. Free-function: g_free

setParent
int setParent(ObjectGst parent)

Sets the parent of object to parent. The object's reference count will be incremented, and any floating reference will be removed (see gst_object_ref_sink()).

getParent
ObjectGst getParent()

Returns the parent of object. This function increases the refcount of the parent object so you should gst_object_unref() it after usage.

unparent
void unparent()

Clear the parent of object, removing the associated reference. This function decreases the refcount of object. MT safe. Grabs and releases object's lock.

defaultDeepNotify
void defaultDeepNotify(ObjectG object, ObjectGst orig, ParamSpec pspec, string[] excludedProps)

A default deep_notify signal callback for an object. The user data should contain a pointer to an array of strings that should be excluded from the notify. The default handler will print the new value of the property using g_print. MT safe. This function grabs and releases object's LOCK for getting its path string.

defaultError
void defaultError(ErrorG error, char dbug)

A default error function that uses g_printerr() to display the error message and the optional debug sting.. The default handler will simply print the error string using g_print.

checkUniqueness
int checkUniqueness(ListG list, string name)

Checks to see if there is any object named name in list. This function does not do any locking of any kind. You might want to protect the provided list with the lock of the owner of the list. This function will lock each GstObject in the list to compare the name, so be carefull when passing a list with a locked object.

hasAncestor
int hasAncestor(ObjectGst ancestor)

Check if object has an ancestor ancestor somewhere up in the hierarchy. One can e.g. check if a GstElement is inside a GstPipeline.

doref
void* doref(void* object)

Increments the reference count on object. This function does not take the lock on object because it relies on atomic refcounting. This object returns the input parameter to ease writing

unref
void unref(void* object)

Decrements the reference count on object. If reference count hits zero, destroy object. This function does not take the lock on object as it relies on atomic refcounting. The unref method should never be called with the LOCK held since this might deadlock the dispose function.

refSink
void* refSink(void* object)

Increase the reference count of object, and possibly remove the floating reference, if object has a floating reference. In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one.

replace
int replace(ObjectGst oldobj, ObjectGst newobj)

Atomically modifies a pointer to point to a new object. The reference count of oldobj is decreased and the reference count of newobj is increased. Either newobj and the value pointed to by oldobj may be NULL.

getPathString
string getPathString()

Generates a string describing the path of object in the object hierarchy. Only useful (or used) for debugging. Free-function: g_free

suggestNextSync
GstClockTime suggestNextSync()

Returns a suggestion for timestamps where buffers should be split to get best controller results.

syncValues
int syncValues(GstClockTime timestamp)

Sets the properties of the object, according to the GstControlSources that (maybe) handle them and for the given timestamp. If this function fails, it is most likely the application developers fault. Most probably the control sources are not setup correctly.

hasActiveControlBindings
int hasActiveControlBindings()

Check if the object has an active controlled properties.

setControlBindingsDisabled
void setControlBindingsDisabled(int disabled)

This function is used to disable all controlled properties of the object for some time, i.e. gst_object_sync_values() will do nothing.

setControlBindingDisabled
void setControlBindingDisabled(string propertyName, int disabled)

This function is used to disable the GstController on a property for some time, i.e. gst_controller_sync_values() will do nothing for the property.

addControlBinding
int addControlBinding(ControlBinding binding)

Attach the GstControlBinding to the object. If there already was a GstControlBinding for this property it will be replaced. The object will take ownership of the binding.

getControlBinding
ControlBinding getControlBinding(string propertyName)

Gets the corresponding GstControlBinding for the property. This should be unreferenced again after use.

removeControlBinding
int removeControlBinding(ControlBinding binding)

Removes the corresponding GstControlBinding. If it was the last ref of the binding, it will be disposed.

getValue
Value getValue(string propertyName, GstClockTime timestamp)

Gets the value for the given controlled property at the requested time.

getValueArray
int getValueArray(string propertyName, GstClockTime timestamp, GstClockTime interval, void[] values)

Gets a number of values for the given controlled property starting at the requested time. The array values need to hold enough space for n_values of the same type as the objects property's type. This function is useful if one wants to e.g. draw a graph of the control curve or apply a control curve sample by sample. The values are unboxed and ready to be used. The similar function gst_object_get_g_value_array() returns the array as GValues and is better suites for bindings.

getGValueArray
int getGValueArray(string propertyName, GstClockTime timestamp, GstClockTime interval, uint nValues, Value values)

Gets a number of GValues for the given controlled property starting at the requested time. The array values need to hold enough space for n_values of GValue. This function is useful if one wants to e.g. draw a graph of the control curve or apply a control curve sample by sample.

getControlRate
GstClockTime getControlRate()

Obtain the control-rate for this object. Audio processing GstElement objects will use this rate to sub-divide their processing loop and call gst_object_sync_values() inbetween. The length of the processing segment should be up to control-rate nanoseconds. If the object is not under property control, this will return GST_CLOCK_TIME_NONE. This allows the element to avoid the sub-dividing. The control-rate is not expected to change if the element is in GST_STATE_PAUSED or GST_STATE_PLAYING.

setControlRate
void setControlRate(GstClockTime controlRate)

Change the control-rate for this object. Audio processing GstElement objects will use this rate to sub-divide their processing loop and call gst_object_sync_values() inbetween. The length of the processing segment should be up to control-rate nanoseconds. The control-rate should not change if the element is in GST_STATE_PAUSED or GST_STATE_PLAYING.

Meta