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.
Add a clock observation to the internal slaving algorithm the same as gst.clock.Clock.addObservation, and return the result of the master clock estimation, without updating the internal calibration.
Converts the given internal clock time to the external time, adjusting for the rate and reference time set with gst.clock.Clock.setCalibration 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.
Converts the given internal_target clock time to the external time, using the passed calibration parameters. This function performs the same calculation as gst.clock.Clock.adjustUnlocked when called using the current calibration parameters, but doesn't ensure a monotonically increasing result as gst.clock.Clock.adjustUnlocked does.
Connect to Synced signal.
Gets the internal rate and reference time of clock. See gst.clock.Clock.setCalibration for more information.
Gets the current internal time of the given clock. The time is returned unadjusted for the offset and the rate.
Gets the master clock that clock is slaved to or null when the clock is not slaved to any master clock.
Gets the accuracy of the clock. The accuracy of the clock is the granularity of the values returned by gst.clock.Clock.getTime.
Gets the current time of the given clock. The time is always monotonically increasing and adjusted according to the current offset and rate.
Gets the amount of time that master and slave clocks are sampled.
Checks if the clock is currently synced, by looking at whether gst.types.ClockFlags.NeedsStartupSync is set.
Gets 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.
Gets a #GstClockID from clock to trigger a single shot notification at the requested time.
Reinitializes the provided periodic id to the provided start time and interval. Does not modify the reference count.
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.
Sets master as the master clock for clock. clock will be automatically calibrated so that gst.clock.Clock.getTime reports the same time as the master clock.
Sets 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.
Sets clock to synced and emits the #GstClock::synced signal, and wakes up any thread waiting in gst.clock.Clock.waitForSync.
Sets the amount of time, in nanoseconds, to sample master and slave clocks
Reinitializes the provided single shot id to the provided time. Does not modify the reference count.
Converts the given external clock time to the internal time of clock, using the rate and reference time set with gst.clock.Clock.setCalibration. This function should be called with the clock's OBJECT_LOCK held and is mainly used by clock subclasses.
Converts the given external_target clock time to the internal time, using the passed calibration parameters. This function performs the same calculation as gst.clock.Clock.unadjustUnlocked when called using the current calibration parameters.
Waits until clock is synced for reporting the current time. If timeout is GST_CLOCK_TIME_NONE it will wait forever, otherwise it will time out after timeout nanoseconds.
Compares the two #GstClockID instances. This function can be used as a GCompareFunc when sorting ids.
This function returns the underlying clock.
Gets the time of the clock ID
Increases the refcount of given id.
Unrefs given id. When the refcount reaches 0 the #GstClockID will be freed.
Cancels 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.
This function returns whether id uses clock as the underlying clock. clock can be NULL, in which case the return value indicates whether the underlying clock has been freed. If this is the case, the id is no longer usable and should be freed.
Performs a blocking wait on id. id should have been created with gst.clock.Clock.newSingleShotId or gst.clock.Clock.newPeriodicId and should not have been unscheduled with a call to gst.clock.Clock.idUnschedule.
Registers 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.
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 careful when passing a list with a locked object.
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.
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.
Attach the #GstControlBinding to the object. If there already was a #GstControlBinding for this property it will be replaced.
A default error function that uses glib.global.printerr to display the error message and the optional debug string..
Gets the corresponding #GstControlBinding for the property. This should be unreferenced again after use.
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.ObjectGst.syncValues in between. The length of the processing segment should be up to control-rate nanoseconds.
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.
Returns a copy of the name of object. Caller should glib.global.gfree the return value after usage. For a nameless object, this returns null, which you can safely glib.global.gfree as well.
Returns the parent of object. This function increases the refcount of the parent object so you should gst.object.ObjectGst.unref it after usage.
Generates a string describing the path of object in the object hierarchy. Only useful (or used) for debugging.
Gets the value for the given controlled property at the requested time.
Check if the object has active controlled properties.
Check if object has an ancestor ancestor somewhere up in the hierarchy. One can e.g. check if a #GstElement is inside a #GstPipeline.
Check if object has an ancestor ancestor somewhere up in the hierarchy. One can e.g. check if a #GstElement is inside a #GstPipeline.
Check if parent is the parent of object. E.g. a #GstElement can check if it owns a given #GstPad.
Removes the corresponding #GstControlBinding. If it was the last ref of the binding, it will be disposed.
This function is used to disable the control bindings on a property for some time, i.e. gst.object.ObjectGst.syncValues will do nothing for the property.
This function is used to disable all controlled properties of the object for some time, i.e. gst.object.ObjectGst.syncValues will do nothing.
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.ObjectGst.syncValues in between. The length of the processing segment should be up to control-rate nanoseconds.
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.
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.ObjectGst.refSink).
Returns a suggestion for timestamps where buffers should be split to get best controller results.
Sets the properties of the object, according to the #GstControlSources that (maybe) handle them and for the given timestamp.
Clear the parent of object, removing the associated reference. This function decreases the refcount of object.
Connect to DeepNotify signal.
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.Clock.getTime. 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 #GST_EVENT_SEGMENT 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.Clock.newSingleShotId or gst.clock.Clock.newPeriodicId.
To perform a blocking wait for the specific time of the #GstClockID use gst.clock.Clock.idWait. To receive a callback when the specific time is reached in the clock use gst.clock.Clock.idWaitAsync. Both these calls can be interrupted with the gst.clock.Clock.idUnschedule 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 they are unscheduled. To schedule a sync periodic callback, gst.clock.Clock.idWait 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.Clock.idUnref.
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 gst.clock.Clock.setMaster. 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.Clock.setCalibration. 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.Clock.getCalibration function.
The master/slave synchronisation can be tuned with the #GstClock:timeout, #GstClock:window-size and #GstClock:window-threshold properties. The #GstClock:timeout property defines the interval to sample the master clock and run the calibration functions. #GstClock:window-size defines the number of samples to use when calibrating and #GstClock:window-threshold defines the minimum number of samples before the calibration is performed.