GI.Gst.Objects.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 SystemClock.

The Clock returns a monotonically increasing time with the method clockGetTime. 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 Pipeline.

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 clockNewSingleShotId or clockNewPeriodicId.

To perform a blocking wait for the specific time of the GstClockID use the clockIdWait. To receive a callback when the specific time is reached in the clock use clockIdWaitAsync. Both these calls can be interrupted with the clockIdUnschedule 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, clockIdWait 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 clockIdUnref.

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 Clock with the clockSetMaster. 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 clockSetCalibration. This feature is mostly useful for plugins that have an internal clock but must operate with another clock selected by the Pipeline. They can track the offset and rate difference of their internal clock relative to the master clock by using the clockGetCalibration function.

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

Exported types

newtype Clock

Constructors

Clock (ManagedPtr Clock)

Instances

GObject Clock

Methods

gobjectType :: Clock -> IO GType

IsObject Clock

IsObject Clock

IsClock Clock

((~) * info (ResolveClockMethod t Clock), MethodInfo * info Clock p) => IsLabel t (Clock -> p)

Methods

fromLabel :: Proxy# Symbol t -> Clock -> p

((~) * info (ResolveClockMethod t Clock), MethodInfo * info Clock p) => IsLabelProxy t (Clock -> p)

Methods

fromLabelProxy :: Proxy Symbol t -> Clock -> p

HasAttributeList * Clock

type AttributeList Clock

type AttributeList Clock

type SignalList Clock

type SignalList Clock

class GObject o => IsClock o

Instances

(GObject a, UnknownAncestorError Constraint Clock a) => IsClock a

IsClock Clock

IsClock SystemClock

toClock :: IsClock o => o -> IO Clock

noClock :: Maybe Clock

Methods

addObservation

data ClockAddObservationMethodInfo

Instances

((~) * signature (Word64 -> Word64 -> m (Bool, Double)), MonadIO m, IsClock a) => MethodInfo * ClockAddObservationMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockAddObservationMethodInfo a -> signature -> s

clockAddObservation

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock

-> Word64

slave: a time on the slave

-> Word64

master: a time on the master

-> m (Bool, Double)

Returns: True if enough observations were added to run the regression algorithm.

MT safe.

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

addObservationUnapplied

data ClockAddObservationUnappliedMethodInfo

Instances

((~) * signature (Word64 -> Word64 -> m (Bool, Double, Word64, Word64, Word64, Word64)), MonadIO m, IsClock a) => MethodInfo * ClockAddObservationUnappliedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockAddObservationUnappliedMethodInfo a -> signature -> s

clockAddObservationUnapplied

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock

-> Word64

slave: a time on the slave

-> Word64

master: a time on the master

-> m (Bool, Double, Word64, Word64, Word64, Word64)

Add a clock observation to the internal slaving algorithm the same as clockAddObservation, and return the result of the master clock estimation, without updating the internal calibration.

The caller can then take the results and call clockSetCalibration with the values, or some modified version of them.

Since: 1.6

adjustUnlocked

data ClockAdjustUnlockedMethodInfo

Instances

((~) * signature (Word64 -> m Word64), MonadIO m, IsClock a) => MethodInfo * ClockAdjustUnlockedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockAdjustUnlockedMethodInfo a -> signature -> s

clockAdjustUnlocked

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock to use

-> Word64

internal: a clock time

-> m Word64

Returns: the converted time of the clock.

Converts the given internal clock time to the external time, adjusting for the rate and reference time set with clockSetCalibration 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 clockUnadjustUnlocked.

adjustWithCalibration

data ClockAdjustWithCalibrationMethodInfo

Instances

((~) * signature (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> m Word64), MonadIO m, IsClock a) => MethodInfo * ClockAdjustWithCalibrationMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockAdjustWithCalibrationMethodInfo a -> signature -> s

clockAdjustWithCalibration

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock to use

-> Word64

internalTarget: a clock time

-> Word64

cinternal: a reference internal time

-> Word64

cexternal: a reference external time

-> Word64

cnum: the numerator of the rate of the clock relative to its internal time

-> Word64

cdenom: the denominator of the rate of the clock

-> m Word64

Returns: the converted time of the clock.

Converts the given internalTarget clock time to the external time, using the passed calibration parameters. This function performs the same calculation as clockAdjustUnlocked when called using the current calibration parameters, but doesn't ensure a monotonically increasing result as clockAdjustUnlocked does.

Note: The clock parameter is unused and can be NULL

Since: 1.6

getCalibration

data ClockGetCalibrationMethodInfo

Instances

((~) * signature (m (Word64, Word64, Word64, Word64)), MonadIO m, IsClock a) => MethodInfo * ClockGetCalibrationMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockGetCalibrationMethodInfo a -> signature -> s

clockGetCalibration

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock

-> m (Word64, Word64, Word64, Word64)

Gets the internal rate and reference time of clock. See clockSetCalibration for more information.

internal, external, rateNum, and rateDenom can be left Nothing if the caller is not interested in the values.

MT safe.

getInternalTime

data ClockGetInternalTimeMethodInfo

Instances

((~) * signature (m Word64), MonadIO m, IsClock a) => MethodInfo * ClockGetInternalTimeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockGetInternalTimeMethodInfo a -> signature -> s

clockGetInternalTime

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock to query

-> m Word64

Returns: the internal time of the clock. Or GST_CLOCK_TIME_NONE when given invalid input.

MT safe.

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

getMaster

data ClockGetMasterMethodInfo

Instances

((~) * signature (m (Maybe Clock)), MonadIO m, IsClock a) => MethodInfo * ClockGetMasterMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockGetMasterMethodInfo a -> signature -> s

clockGetMaster

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock

-> m (Maybe Clock)

Returns: a master Clock or Nothing when this clock is not slaved to a master clock. Unref after usage.

MT safe.

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

getResolution

data ClockGetResolutionMethodInfo

Instances

((~) * signature (m Word64), MonadIO m, IsClock a) => MethodInfo * ClockGetResolutionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockGetResolutionMethodInfo a -> signature -> s

clockGetResolution

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock

-> m Word64

Returns: the resolution of the clock in units of GstClockTime.

MT safe.

Get the accuracy of the clock. The accuracy of the clock is the granularity of the values returned by clockGetTime.

getTime

data ClockGetTimeMethodInfo

Instances

((~) * signature (m Word64), MonadIO m, IsClock a) => MethodInfo * ClockGetTimeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockGetTimeMethodInfo a -> signature -> s

clockGetTime

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock to query

-> m Word64

Returns: the time of the clock. Or GST_CLOCK_TIME_NONE when given invalid input.

MT safe.

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

getTimeout

data ClockGetTimeoutMethodInfo

Instances

((~) * signature (m Word64), MonadIO m, IsClock a) => MethodInfo * ClockGetTimeoutMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockGetTimeoutMethodInfo a -> signature -> s

clockGetTimeout

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock

-> m Word64

Returns: the interval between samples.

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

idCompareFunc

clockIdCompareFunc

Arguments

:: (HasCallStack, MonadIO m)

=> Ptr ()

id1: A GstClockID

-> Ptr ()

id2: A GstClockID to compare with

-> m Int32

Returns: negative value if a < b; zero if a = b; positive value if a > b

MT safe.

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

idGetTime

clockIdGetTime

Arguments

:: (HasCallStack, MonadIO m)

=> Ptr ()

id: The GstClockID to query

-> m Word64

Returns: the time of the given clock id.

MT safe.

Get the time of the clock ID

idRef

clockIdRef

Arguments

:: (HasCallStack, MonadIO m)

=> Ptr ()

id: The GstClockID to ref

-> m (Ptr ())

Returns: The same GstClockID with increased refcount.

MT safe.

Increase the refcount of given id.

idUnref

clockIdUnref

Arguments

:: (HasCallStack, MonadIO m)

=> Ptr ()

id: The GstClockID to unref

-> m ()

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

MT safe.

idUnschedule

clockIdUnschedule

Arguments

:: (HasCallStack, MonadIO m)

=> Ptr ()

id: The id to unschedule

-> m ()

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

clockIdWait

Arguments

:: (HasCallStack, MonadIO m)

=> Ptr ()

id: The GstClockID to wait on

-> m (ClockReturn, Int64)

Returns: the result of the blocking wait. GST_CLOCK_EARLY will be returned if the current clock time is past the time of id, GST_CLOCK_OK if id was scheduled in time. GST_CLOCK_UNSCHEDULED if id was unscheduled with clockIdUnschedule.

MT safe.

Perform a blocking wait on id. id should have been created with clockNewSingleShotId or clockNewPeriodicId and should not have been unscheduled with a call to clockIdUnschedule.

If the jitter argument is not Nothing 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

clockIdWaitAsync

Arguments

:: (HasCallStack, MonadIO m)

=> Ptr ()

id: a GstClockID to wait on

-> ClockCallback

func: The callback function

-> m ClockReturn

Returns: the result of the non blocking wait.

MT safe.

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.

isSynced

data ClockIsSyncedMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsClock a) => MethodInfo * ClockIsSyncedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockIsSyncedMethodInfo a -> signature -> s

clockIsSynced

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a GstClock

-> m Bool

Returns: True if the clock is currently synced

Checks if the clock is currently synced.

This returns if GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC is not set on the clock.

Since: 1.6

newPeriodicId

data ClockNewPeriodicIdMethodInfo

Instances

((~) * signature (Word64 -> Word64 -> m (Ptr ())), MonadIO m, IsClock a) => MethodInfo * ClockNewPeriodicIdMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockNewPeriodicIdMethodInfo a -> signature -> s

clockNewPeriodicId

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: The GstClockID to get a periodic notification id from

-> Word64

startTime: the requested start time

-> Word64

interval: the requested interval

-> m (Ptr ())

Returns: a GstClockID that can be used to request the time notification.

MT safe.

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

Free-function: gst_clock_id_unref

newSingleShotId

data ClockNewSingleShotIdMethodInfo

Instances

((~) * signature (Word64 -> m (Ptr ())), MonadIO m, IsClock a) => MethodInfo * ClockNewSingleShotIdMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockNewSingleShotIdMethodInfo a -> signature -> s

clockNewSingleShotId

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: The GstClockID to get a single shot notification from

-> Word64

time: the requested time

-> m (Ptr ())

Returns: a GstClockID that can be used to request the time notification.

MT safe.

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

data ClockPeriodicIdReinitMethodInfo

Instances

((~) * signature (Ptr () -> Word64 -> Word64 -> m Bool), MonadIO m, IsClock a) => MethodInfo * ClockPeriodicIdReinitMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockPeriodicIdReinitMethodInfo a -> signature -> s

clockPeriodicIdReinit

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock

-> Ptr ()

id: a GstClockID

-> Word64

startTime: the requested start time

-> Word64

interval: the requested interval

-> m Bool

Returns: True if the GstClockID could be reinitialized to the provided time, else False.

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

setCalibration

data ClockSetCalibrationMethodInfo

Instances

((~) * signature (Word64 -> Word64 -> Word64 -> Word64 -> m ()), MonadIO m, IsClock a) => MethodInfo * ClockSetCalibrationMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockSetCalibrationMethodInfo a -> signature -> s

clockSetCalibration

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock to calibrate

-> Word64

internal: a reference internal time

-> Word64

external: a reference external time

-> Word64

rateNum: the numerator of the rate of the clock relative to its internal time

-> Word64

rateDenom: the denominator of the rate of the clock

-> m ()

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 clockGetTime 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 clockGetInternalTime when this function is called.

Subsequent calls to clockGetTime will return clock times computed as follows:

<programlisting> time = (internal_time - internal) * rate_num / rate_denom + external </programlisting>

This formula is implemented in clockAdjustUnlocked. Of course, it tries to do the integer arithmetic as precisely as possible.

Note that clockGetTime always returns increasing values so when you move the clock backwards, clockGetTime will report the previous value until the clock catches up.

MT safe.

setMaster

data ClockSetMasterMethodInfo

Instances

((~) * signature (Maybe b -> m Bool), MonadIO m, IsClock a, IsClock b) => MethodInfo * ClockSetMasterMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockSetMasterMethodInfo a -> signature -> s

clockSetMaster

Arguments

:: (HasCallStack, MonadIO m, IsClock a, IsClock b)

=> a

clock: a Clock

-> Maybe b

master: a master Clock

-> m Bool

Returns: True if the clock is capable of being slaved to a master clock. Trying to set a master on a clock without the GST_CLOCK_FLAG_CAN_SET_MASTER flag will make this function return False.

MT safe.

Set master as the master clock for clock. clock will be automatically calibrated so that clockGetTime 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 clockGetCalibration.

master can be Nothing 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

data ClockSetResolutionMethodInfo

Instances

((~) * signature (Word64 -> m Word64), MonadIO m, IsClock a) => MethodInfo * ClockSetResolutionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockSetResolutionMethodInfo a -> signature -> s

clockSetResolution

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock

-> Word64

resolution: The resolution to set

-> m Word64

Returns: the new resolution of the clock.

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.

setSynced

data ClockSetSyncedMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsClock a) => MethodInfo * ClockSetSyncedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockSetSyncedMethodInfo a -> signature -> s

clockSetSynced

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a GstClock

-> Bool

synced: if the clock is synced

-> m ()

Sets clock to synced and emits the GstClock::synced signal, and wakes up any thread waiting in clockWaitForSync.

This function must only be called if GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC is set on the clock, and is intended to be called by subclasses only.

Since: 1.6

setTimeout

data ClockSetTimeoutMethodInfo

Instances

((~) * signature (Word64 -> m ()), MonadIO m, IsClock a) => MethodInfo * ClockSetTimeoutMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockSetTimeoutMethodInfo a -> signature -> s

clockSetTimeout

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock

-> Word64

timeout: a timeout

-> m ()

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

singleShotIdReinit

data ClockSingleShotIdReinitMethodInfo

Instances

((~) * signature (Ptr () -> Word64 -> m Bool), MonadIO m, IsClock a) => MethodInfo * ClockSingleShotIdReinitMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockSingleShotIdReinitMethodInfo a -> signature -> s

clockSingleShotIdReinit

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock

-> Ptr ()

id: a GstClockID

-> Word64

time: The requested time.

-> m Bool

Returns: True if the GstClockID could be reinitialized to the provided time, else False.

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

unadjustUnlocked

data ClockUnadjustUnlockedMethodInfo

Instances

((~) * signature (Word64 -> m Word64), MonadIO m, IsClock a) => MethodInfo * ClockUnadjustUnlockedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockUnadjustUnlockedMethodInfo a -> signature -> s

clockUnadjustUnlocked

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock to use

-> Word64

external: an external clock time

-> m Word64

Returns: the internal time of the clock corresponding to external.

Converts the given external clock time to the internal time of clock, using the rate and reference time set with clockSetCalibration. 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 clockAdjustUnlocked.

unadjustWithCalibration

data ClockUnadjustWithCalibrationMethodInfo

Instances

((~) * signature (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> m Word64), MonadIO m, IsClock a) => MethodInfo * ClockUnadjustWithCalibrationMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockUnadjustWithCalibrationMethodInfo a -> signature -> s

clockUnadjustWithCalibration

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a Clock to use

-> Word64

externalTarget: a clock time

-> Word64

cinternal: a reference internal time

-> Word64

cexternal: a reference external time

-> Word64

cnum: the numerator of the rate of the clock relative to its internal time

-> Word64

cdenom: the denominator of the rate of the clock

-> m Word64

Returns: the converted time of the clock.

Converts the given externalTarget clock time to the internal time, using the passed calibration parameters. This function performs the same calculation as clockUnadjustUnlocked when called using the current calibration parameters.

Note: The clock parameter is unused and can be NULL

Since: 1.8

waitForSync

data ClockWaitForSyncMethodInfo

Instances

((~) * signature (Word64 -> m Bool), MonadIO m, IsClock a) => MethodInfo * ClockWaitForSyncMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ClockWaitForSyncMethodInfo a -> signature -> s

clockWaitForSync

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> a

clock: a GstClock

-> Word64

timeout: timeout for waiting or CLOCK_TIME_NONE

-> m Bool

Returns: True if waiting was successful, or False on timeout

Waits until clock is synced for reporting the current time. If timeout is CLOCK_TIME_NONE it will wait forever, otherwise it will time out after timeout nanoseconds.

For asynchronous waiting, the GstClock::synced signal can be used.

This returns immediately with TRUE if GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC is not set on the clock, or if the clock is already synced.

Since: 1.6

Properties

timeout

data ClockTimeoutPropertyInfo

Instances

AttrInfo ClockTimeoutPropertyInfo

Associated Types

type AttrAllowedOps ClockTimeoutPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint ClockTimeoutPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint ClockTimeoutPropertyInfo :: * -> Constraint

type AttrGetType ClockTimeoutPropertyInfo :: *

type AttrLabel ClockTimeoutPropertyInfo :: Symbol

type AttrOrigin ClockTimeoutPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint ClockTimeoutPropertyInfo o => Proxy * ClockTimeoutPropertyInfo -> o -> IO (AttrGetType ClockTimeoutPropertyInfo)

attrSet :: (AttrBaseTypeConstraint ClockTimeoutPropertyInfo o, AttrSetTypeConstraint ClockTimeoutPropertyInfo b) => Proxy * ClockTimeoutPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint ClockTimeoutPropertyInfo o => Proxy * ClockTimeoutPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint ClockTimeoutPropertyInfo o, AttrSetTypeConstraint ClockTimeoutPropertyInfo b) => Proxy * ClockTimeoutPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin ClockTimeoutPropertyInfo

type AttrOrigin ClockTimeoutPropertyInfo = Clock

type AttrLabel ClockTimeoutPropertyInfo

type AttrLabel ClockTimeoutPropertyInfo = "timeout"

type AttrGetType ClockTimeoutPropertyInfo

type AttrGetType ClockTimeoutPropertyInfo = Word64

type AttrBaseTypeConstraint ClockTimeoutPropertyInfo

type AttrBaseTypeConstraint ClockTimeoutPropertyInfo = IsClock

type AttrSetTypeConstraint ClockTimeoutPropertyInfo

type AttrSetTypeConstraint ClockTimeoutPropertyInfo = * ~ Word64

type AttrAllowedOps ClockTimeoutPropertyInfo

type AttrAllowedOps ClockTimeoutPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

clockTimeout :: AttrLabelProxy "timeout"

constructClockTimeout :: IsClock o => Word64 -> IO (GValueConstruct o)

getClockTimeout :: (MonadIO m, IsClock o) => o -> m Word64

setClockTimeout :: (MonadIO m, IsClock o) => o -> Word64 -> m ()

windowSize

data ClockWindowSizePropertyInfo

Instances

AttrInfo ClockWindowSizePropertyInfo

Associated Types

type AttrAllowedOps ClockWindowSizePropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint ClockWindowSizePropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint ClockWindowSizePropertyInfo :: * -> Constraint

type AttrGetType ClockWindowSizePropertyInfo :: *

type AttrLabel ClockWindowSizePropertyInfo :: Symbol

type AttrOrigin ClockWindowSizePropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint ClockWindowSizePropertyInfo o => Proxy * ClockWindowSizePropertyInfo -> o -> IO (AttrGetType ClockWindowSizePropertyInfo)

attrSet :: (AttrBaseTypeConstraint ClockWindowSizePropertyInfo o, AttrSetTypeConstraint ClockWindowSizePropertyInfo b) => Proxy * ClockWindowSizePropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint ClockWindowSizePropertyInfo o => Proxy * ClockWindowSizePropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint ClockWindowSizePropertyInfo o, AttrSetTypeConstraint ClockWindowSizePropertyInfo b) => Proxy * ClockWindowSizePropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin ClockWindowSizePropertyInfo

type AttrOrigin ClockWindowSizePropertyInfo = Clock

type AttrLabel ClockWindowSizePropertyInfo

type AttrLabel ClockWindowSizePropertyInfo = "window-size"

type AttrGetType ClockWindowSizePropertyInfo

type AttrGetType ClockWindowSizePropertyInfo = Int32

type AttrBaseTypeConstraint ClockWindowSizePropertyInfo

type AttrBaseTypeConstraint ClockWindowSizePropertyInfo = IsClock

type AttrSetTypeConstraint ClockWindowSizePropertyInfo

type AttrSetTypeConstraint ClockWindowSizePropertyInfo = * ~ Int32

type AttrAllowedOps ClockWindowSizePropertyInfo

type AttrAllowedOps ClockWindowSizePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

clockWindowSize :: AttrLabelProxy "windowSize"

constructClockWindowSize :: IsClock o => Int32 -> IO (GValueConstruct o)

getClockWindowSize :: (MonadIO m, IsClock o) => o -> m Int32

setClockWindowSize :: (MonadIO m, IsClock o) => o -> Int32 -> m ()

windowThreshold

data ClockWindowThresholdPropertyInfo

Instances

AttrInfo ClockWindowThresholdPropertyInfo

Associated Types

type AttrAllowedOps ClockWindowThresholdPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint ClockWindowThresholdPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint ClockWindowThresholdPropertyInfo :: * -> Constraint

type AttrGetType ClockWindowThresholdPropertyInfo :: *

type AttrLabel ClockWindowThresholdPropertyInfo :: Symbol

type AttrOrigin ClockWindowThresholdPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint ClockWindowThresholdPropertyInfo o => Proxy * ClockWindowThresholdPropertyInfo -> o -> IO (AttrGetType ClockWindowThresholdPropertyInfo)

attrSet :: (AttrBaseTypeConstraint ClockWindowThresholdPropertyInfo o, AttrSetTypeConstraint ClockWindowThresholdPropertyInfo b) => Proxy * ClockWindowThresholdPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint ClockWindowThresholdPropertyInfo o => Proxy * ClockWindowThresholdPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint ClockWindowThresholdPropertyInfo o, AttrSetTypeConstraint ClockWindowThresholdPropertyInfo b) => Proxy * ClockWindowThresholdPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin ClockWindowThresholdPropertyInfo

type AttrOrigin ClockWindowThresholdPropertyInfo = Clock

type AttrLabel ClockWindowThresholdPropertyInfo

type AttrLabel ClockWindowThresholdPropertyInfo = "window-threshold"

type AttrGetType ClockWindowThresholdPropertyInfo

type AttrGetType ClockWindowThresholdPropertyInfo = Int32

type AttrBaseTypeConstraint ClockWindowThresholdPropertyInfo

type AttrBaseTypeConstraint ClockWindowThresholdPropertyInfo = IsClock

type AttrSetTypeConstraint ClockWindowThresholdPropertyInfo

type AttrSetTypeConstraint ClockWindowThresholdPropertyInfo = * ~ Int32

type AttrAllowedOps ClockWindowThresholdPropertyInfo

type AttrAllowedOps ClockWindowThresholdPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

clockWindowThreshold :: AttrLabelProxy "windowThreshold"

constructClockWindowThreshold :: IsClock o => Int32 -> IO (GValueConstruct o)

getClockWindowThreshold :: (MonadIO m, IsClock o) => o -> m Int32

setClockWindowThreshold :: (MonadIO m, IsClock o) => o -> Int32 -> m ()

Signals

synced

type C_ClockSyncedCallback = Ptr () -> CInt -> Ptr () -> IO ()

type ClockSyncedCallback = Bool -> IO ()

data ClockSyncedSignalInfo

Instances

SignalInfo ClockSyncedSignalInfo

Associated Types

type HaskellCallbackType ClockSyncedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o ClockSyncedSignalInfo -> o -> HaskellCallbackType ClockSyncedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType ClockSyncedSignalInfo

type HaskellCallbackType ClockSyncedSignalInfo = ClockSyncedCallback

afterClockSynced :: (GObject a, MonadIO m) => a -> ClockSyncedCallback -> m SignalHandlerId

genClosure_ClockSynced :: ClockSyncedCallback -> IO Closure

mk_ClockSyncedCallback :: C_ClockSyncedCallback -> IO (FunPtr C_ClockSyncedCallback)

noClockSyncedCallback :: Maybe ClockSyncedCallback

onClockSynced :: (GObject a, MonadIO m) => a -> ClockSyncedCallback -> m SignalHandlerId

wrap_ClockSyncedCallback :: ClockSyncedCallback -> Ptr () -> CInt -> Ptr () -> IO ()