Creates a new test clock with its time set to zero.
Advances the time of the test_clock by the amount given by delta. The time of test_clock is monotonically increasing, therefore providing a delta which is negative or zero is a programming error.
A "crank" consists of three steps: 1: Wait for a #GstClockID to be registered with the #GstTestClock. 2: Advance the #GstTestClock to the time the #GstClockID is waiting, unless the clock time is already passed the clock id (Since: 1.18). 3: Release the #GstClockID wait. A "crank" can be though of as the notion of manually driving the clock forward to its next logical step.
Retrieve the requested time for the next pending clock notification.
Checks whether test_clock was requested to provide the clock notification given by id.
Determine the number of pending clock notifications that have been requested from the test_clock.
Determines if the pending_id is the next clock notification scheduled to be triggered given the current time of the test_clock.
Processes and releases the pending ID.
Processes and releases the pending IDs in the list.
MT safe.
Sets the time of test_clock to the time given by new_time. The time of test_clock is monotonically increasing, therefore providing a new_time which is earlier or equal to the time of the clock as given by gst.clock.Clock.getTime is a programming error.
Blocks until at least count clock notifications have been requested from test_clock, or the timeout expires.
Blocks until at least count clock notifications have been requested from test_clock. There is no timeout for this wait, see the main description of #GstTestClock.
Waits until a clock notification is requested from test_clock. There is no timeout for this wait, see the main description of #GstTestClock. A reference to the pending clock notification is stored in pending_id.
Blocks until at least count clock notifications have been requested from test_clock. There is no timeout for this wait, see the main description of #GstTestClock.
Finds the latest time inside the list.
Creates a new test clock with its time set to the specified time.
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.
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.
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.
Connect to Synced signal.
GstTestClock is an implementation of #GstClock which has different behaviour compared to #GstSystemClock. Time for #GstSystemClock advances according to the system time, while time for #GstTestClock changes only when gstcheck.test_clock.TestClock.setTime or gstcheck.test_clock.TestClock.advanceTime are called. #GstTestClock provides unit tests with the possibility to precisely advance the time in a deterministic manner, independent of the system time or any other external factors.
Advancing the time of a #GstTestClock
#GstClock allows for setting up single shot or periodic clock notifications as well as waiting for these notifications synchronously (using gst.clock.Clock.idWait) or asynchronously (using gst.clock.Clock.idWaitAsync or gst.clock.Clock.idWaitAsync). This is used by many GStreamer elements, among them #GstBaseSrc and #GstBaseSink.
#GstTestClock keeps track of these clock notifications. By calling gstcheck.test_clock.TestClock.waitForNextPendingId or gstcheck.test_clock.TestClock.waitForMultiplePendingIds a unit tests may wait for the next one or several clock notifications to be requested. Additionally unit tests may release blocked waits in a controlled fashion by calling gstcheck.test_clock.TestClock.processNextClockId. This way a unit test can control the inaccuracy (jitter) of clock notifications, since the test can decide to release blocked waits when the clock time has advanced exactly to, or past, the requested clock notification time.
There are also interfaces for determining if a notification belongs to a #GstTestClock or not, as well as getting the number of requested clock notifications so far.
N.B.: When a unit test waits for a certain amount of clock notifications to be requested in gstcheck.test_clock.TestClock.waitForNextPendingId or gstcheck.test_clock.TestClock.waitForMultiplePendingIds then these functions may block for a long time. If they block forever then the expected clock notifications were never requested from #GstTestClock, and so the assumptions in the code of the unit test are wrong. The unit test case runner in gstcheck is expected to catch these cases either by the default test case timeout or the one set for the unit test by calling tcase_set_timeout\(\).
The sample code below assumes that the element under test will delay a buffer pushed on the source pad by some latency until it arrives on the sink pad. Moreover it is assumed that the element will at some point call gst.clock.Clock.idWait to synchronously wait for a specific time. The first buffer sent will arrive exactly on time only delayed by the latency. The second buffer will arrive a little late (7ms) due to simulated jitter in the clock notification.
Demonstration of how to work with clock notifications and #GstTestClock
Since #GstTestClock is only supposed to be used in unit tests it calls g_assert(), g_assert_cmpint() or g_assert_cmpuint() to validate all function arguments. This will highlight any issues with the unit test code itself.