GI.GstBase.Objects.BaseSink

BaseSink is the base class for sink elements in GStreamer, such as xvimagesink or filesink. It is a layer on top of Element that provides a simplified interface to plugin writers. BaseSink handles many details for you, for example: preroll, clock synchronization, state changes, activation in push or pull mode, and queries.

In most cases, when writing sink elements, there is no need to implement class methods from Element or to set functions on pads, because the BaseSink infrastructure should be sufficient.

BaseSink provides support for exactly one sink pad, which should be named "sink". A sink implementation (subclass of BaseSink) should install a pad template in its class_init function, like so:

C code

static void
my_element_class_init (GstMyElementClass *klass)
{
  GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);

  // sinktemplate should be a #GstStaticPadTemplate with direction
  // %GST_PAD_SINK and name "sink"
  gst_element_class_add_static_pad_template (gstelement_class, &sinktemplate);

  gst_element_class_set_static_metadata (gstelement_class,
      "Sink name",
      "Sink",
      "My Sink element",
      "The author <[e-mail]>");
}

BaseSink will handle the prerolling correctly. This means that it will return StateChangeReturnAsync from a state change to PAUSED until the first buffer arrives in this element. The base class will call the BaseSinkClass.preroll() vmethod with this preroll buffer and will then commit the state change to the next asynchronously pending state.

When the element is set to PLAYING, BaseSink will synchronise on the clock using the times returned from BaseSinkClass.get_times(). If this function returns CLOCK_TIME_NONE for the start time, no synchronisation will be done. Synchronisation can be disabled entirely by setting the object BaseSink:sync property to False.

After synchronisation the virtual method BaseSinkClass.render() will be called. Subclasses should minimally implement this method.

Subclasses that synchronise on the clock in the BaseSinkClass.render() method are supported as well. These classes typically receive a buffer in the render method and can then potentially block on the clock while rendering. A typical example is an audiosink. These subclasses can use baseSinkWaitPreroll to perform the blocking wait.

Upon receiving the EOS event in the PLAYING state, BaseSink will wait for the clock to reach the time indicated by the stop time of the last BaseSinkClass.get_times() call before posting an EOS message. When the element receives EOS in PAUSED, preroll completes, the event is queued and an EOS message is posted when going to PLAYING.

BaseSink will internally use the EventTypeSegment events to schedule synchronisation and clipping of buffers. Buffers that fall completely outside of the current segment are dropped. Buffers that fall partially in the segment are rendered (and prerolled). Subclasses should do any subbuffer clipping themselves when needed.

BaseSink will by default report the current playback position in FormatTime based on the current clock time and segment information. If no clock has been set on the element, the query will be forwarded upstream.

The BaseSinkClass.set_caps() function will be called when the subclass should configure itself to process a specific media type.

The BaseSinkClass.start() and BaseSinkClass.stop() virtual methods will be called when resources should be allocated. Any BaseSinkClass.preroll(), BaseSinkClass.render() and BaseSinkClass.set_caps() function will be called between the BaseSinkClass.start() and BaseSinkClass.stop() calls.

The BaseSinkClass.event() virtual method will be called when an event is received by BaseSink. Normally this method should only be overridden by very specific elements (such as file sinks) which need to handle the newsegment event specially.

The BaseSinkClass.unlock() method is called when the elements should unblock any blocking operations they perform in the BaseSinkClass.render() method. This is mostly useful when the BaseSinkClass.render() method performs a blocking write on a file descriptor, for example.

The BaseSink:max-lateness property affects how the sink deals with buffers that arrive too late in the sink. A buffer arrives too late in the sink when the presentation time (as a combination of the last segment, buffer timestamp and element base_time) plus the duration is before the current time of the clock. If the frame is later than max-lateness, the sink will drop the buffer without calling the render method. This feature is disabled if sync is disabled, the BaseSinkClass.get_times() method does not return a valid start time or max-lateness is set to -1 (the default). Subclasses can use baseSinkSetMaxLateness to configure the max-lateness value.

The BaseSink:qos property will enable the quality-of-service features of the basesink which gather statistics about the real-time performance of the clock synchronisation. For each buffer received in the sink, statistics are gathered and a QOS event is sent upstream with these numbers. This information can then be used by upstream elements to reduce their processing rate, for example.

The BaseSink:async property can be used to instruct the sink to never perform an ASYNC state change. This feature is mostly usable when dealing with non-synchronized streams or sparse streams.

Exported types

newtype BaseSink

Constructors

BaseSink (ManagedPtr BaseSink)

Instances

GObject BaseSink

Methods

gobjectType :: BaseSink -> IO GType

IsObject BaseSink

IsElement BaseSink

IsObject BaseSink

IsBaseSink BaseSink

((~) * info (ResolveBaseSinkMethod t BaseSink), MethodInfo * info BaseSink p) => IsLabel t (BaseSink -> p)

Methods

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

((~) * info (ResolveBaseSinkMethod t BaseSink), MethodInfo * info BaseSink p) => IsLabelProxy t (BaseSink -> p)

Methods

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

HasAttributeList * BaseSink

type AttributeList BaseSink

type AttributeList BaseSink

type SignalList BaseSink

type SignalList BaseSink

class GObject o => IsBaseSink o

Instances

(GObject a, UnknownAncestorError Constraint BaseSink a) => IsBaseSink a

IsBaseSink BaseSink

toBaseSink :: IsBaseSink o => o -> IO BaseSink

noBaseSink :: Maybe BaseSink

Methods

doPreroll

data BaseSinkDoPrerollMethodInfo

Instances

((~) * signature (MiniObject -> m FlowReturn), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkDoPrerollMethodInfo a signature

Methods

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

baseSinkDoPreroll

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> MiniObject

obj: the mini object that caused the preroll

-> m FlowReturn

Returns: FlowReturnOk if the preroll completed and processing can continue. Any other return value should be returned from the render vmethod.

If the sink spawns its own thread for pulling buffers from upstream it should call this method after it has pulled a buffer. If the element needed to preroll, this function will perform the preroll and will then block until the element state is changed.

This function should be called with the PREROLL_LOCK held.

getBlocksize

data BaseSinkGetBlocksizeMethodInfo

Instances

((~) * signature (m Word32), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkGetBlocksizeMethodInfo a signature

Methods

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

baseSinkGetBlocksize

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: a BaseSink

-> m Word32

Returns: the number of bytes sink will pull in pull mode.

Get the number of bytes that the sink will pull when it is operating in pull mode.

getLastSample

data BaseSinkGetLastSampleMethodInfo

Instances

((~) * signature (m (Maybe Sample)), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkGetLastSampleMethodInfo a signature

Methods

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

baseSinkGetLastSample

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> m (Maybe Sample)

Returns: a Sample. gst_sample_unref() after usage. This function returns Nothing when no buffer has arrived in the sink yet or when the sink is not in PAUSED or PLAYING.

Get the last sample that arrived in the sink and was used for preroll or for rendering. This property can be used to generate thumbnails.

The Caps on the sample can be used to determine the type of the buffer.

Free-function: gst_sample_unref

getLatency

data BaseSinkGetLatencyMethodInfo

Instances

((~) * signature (m Word64), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkGetLatencyMethodInfo a signature

Methods

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

baseSinkGetLatency

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> m Word64

Returns: The configured latency.

Get the currently configured latency.

getMaxBitrate

data BaseSinkGetMaxBitrateMethodInfo

Instances

((~) * signature (m Word64), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkGetMaxBitrateMethodInfo a signature

Methods

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

baseSinkGetMaxBitrate

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: a BaseSink

-> m Word64

Returns: the maximum number of bits per second sink will render.

Get the maximum amount of bits per second that the sink will render.

Since: 1.2

getMaxLateness

data BaseSinkGetMaxLatenessMethodInfo

Instances

((~) * signature (m Int64), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkGetMaxLatenessMethodInfo a signature

Methods

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

baseSinkGetMaxLateness

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> m Int64

Returns: The maximum time in nanoseconds that a buffer can be late before it is dropped and not rendered. A value of -1 means an unlimited time.

Gets the max lateness value. See gst_base_sink_set_max_lateness for more details.

getRenderDelay

data BaseSinkGetRenderDelayMethodInfo

Instances

((~) * signature (m Word64), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkGetRenderDelayMethodInfo a signature

Methods

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

baseSinkGetRenderDelay

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: a BaseSink

-> m Word64

Returns: the render delay of sink.

Get the render delay of sink. see baseSinkSetRenderDelay for more information about the render delay.

getSync

data BaseSinkGetSyncMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkGetSyncMethodInfo a signature

Methods

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

baseSinkGetSync

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> m Bool

Returns: True if the sink is configured to synchronize against the clock.

Checks if sink is currently configured to synchronize against the clock.

getThrottleTime

data BaseSinkGetThrottleTimeMethodInfo

Instances

((~) * signature (m Word64), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkGetThrottleTimeMethodInfo a signature

Methods

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

baseSinkGetThrottleTime

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: a BaseSink

-> m Word64

Returns: the number of nanoseconds sink will put between frames.

Get the time that will be inserted between frames to control the maximum buffers per second.

getTsOffset

data BaseSinkGetTsOffsetMethodInfo

Instances

((~) * signature (m Int64), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkGetTsOffsetMethodInfo a signature

Methods

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

baseSinkGetTsOffset

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> m Int64

Returns: The synchronisation offset.

Get the synchronisation offset of sink.

isAsyncEnabled

data BaseSinkIsAsyncEnabledMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkIsAsyncEnabledMethodInfo a signature

Methods

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

baseSinkIsAsyncEnabled

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> m Bool

Returns: True if the sink is configured to perform asynchronous state changes.

Checks if sink is currently configured to perform asynchronous state changes to PAUSED.

isLastSampleEnabled

data BaseSinkIsLastSampleEnabledMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkIsLastSampleEnabledMethodInfo a signature

Methods

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

baseSinkIsLastSampleEnabled

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> m Bool

Returns: True if the sink is configured to store the last received sample.

Checks if sink is currently configured to store the last received sample in the last-sample property.

isQosEnabled

data BaseSinkIsQosEnabledMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkIsQosEnabledMethodInfo a signature

Methods

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

baseSinkIsQosEnabled

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> m Bool

Returns: True if the sink is configured to perform Quality-of-Service.

Checks if sink is currently configured to send Quality-of-Service events upstream.

queryLatency

data BaseSinkQueryLatencyMethodInfo

Instances

((~) * signature (m (Bool, Bool, Bool, Word64, Word64)), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkQueryLatencyMethodInfo a signature

Methods

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

baseSinkQueryLatency

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

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

Returns: True if the query succeeded.

Query the sink for the latency parameters. The latency will be queried from the upstream elements. live will be True if sink is configured to synchronize against the clock. upstreamLive will be True if an upstream element is live.

If both live and upstreamLive are True, the sink will want to compensate for the latency introduced by the upstream elements by setting the minLatency to a strictly positive value.

This function is mostly used by subclasses.

setAsyncEnabled

data BaseSinkSetAsyncEnabledMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkSetAsyncEnabledMethodInfo a signature

Methods

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

baseSinkSetAsyncEnabled

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> Bool

enabled: the new async value.

-> m ()

Configures sink to perform all state changes asynchronously. When async is disabled, the sink will immediately go to PAUSED instead of waiting for a preroll buffer. This feature is useful if the sink does not synchronize against the clock or when it is dealing with sparse streams.

setBlocksize

data BaseSinkSetBlocksizeMethodInfo

Instances

((~) * signature (Word32 -> m ()), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkSetBlocksizeMethodInfo a signature

Methods

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

baseSinkSetBlocksize

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: a BaseSink

-> Word32

blocksize: the blocksize in bytes

-> m ()

Set the number of bytes that the sink will pull when it is operating in pull mode.

setLastSampleEnabled

data BaseSinkSetLastSampleEnabledMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkSetLastSampleEnabledMethodInfo a signature

Methods

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

baseSinkSetLastSampleEnabled

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> Bool

enabled: the new enable-last-sample value.

-> m ()

Configures sink to store the last received sample in the last-sample property.

setMaxBitrate

data BaseSinkSetMaxBitrateMethodInfo

Instances

((~) * signature (Word64 -> m ()), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkSetMaxBitrateMethodInfo a signature

Methods

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

baseSinkSetMaxBitrate

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: a BaseSink

-> Word64

maxBitrate: the max_bitrate in bits per second

-> m ()

Set the maximum amount of bits per second that the sink will render.

Since: 1.2

setMaxLateness

data BaseSinkSetMaxLatenessMethodInfo

Instances

((~) * signature (Int64 -> m ()), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkSetMaxLatenessMethodInfo a signature

Methods

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

baseSinkSetMaxLateness

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> Int64

maxLateness: the new max lateness value.

-> m ()

Sets the new max lateness value to maxLateness. This value is used to decide if a buffer should be dropped or not based on the buffer timestamp and the current clock time. A value of -1 means an unlimited time.

setQosEnabled

data BaseSinkSetQosEnabledMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkSetQosEnabledMethodInfo a signature

Methods

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

baseSinkSetQosEnabled

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> Bool

enabled: the new qos value.

-> m ()

Configures sink to send Quality-of-Service events upstream.

setRenderDelay

data BaseSinkSetRenderDelayMethodInfo

Instances

((~) * signature (Word64 -> m ()), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkSetRenderDelayMethodInfo a signature

Methods

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

baseSinkSetRenderDelay

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: a BaseSink

-> Word64

delay: the new delay

-> m ()

Set the render delay in sink to delay. The render delay is the time between actual rendering of a buffer and its synchronisation time. Some devices might delay media rendering which can be compensated for with this function.

After calling this function, this sink will report additional latency and other sinks will adjust their latency to delay the rendering of their media.

This function is usually called by subclasses.

setSync

data BaseSinkSetSyncMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkSetSyncMethodInfo a signature

Methods

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

baseSinkSetSync

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> Bool

sync: the new sync value.

-> m ()

Configures sink to synchronize on the clock or not. When sync is False, incoming samples will be played as fast as possible. If sync is True, the timestamps of the incoming buffers will be used to schedule the exact render time of its contents.

setThrottleTime

data BaseSinkSetThrottleTimeMethodInfo

Instances

((~) * signature (Word64 -> m ()), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkSetThrottleTimeMethodInfo a signature

Methods

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

baseSinkSetThrottleTime

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: a BaseSink

-> Word64

throttle: the throttle time in nanoseconds

-> m ()

Set the time that will be inserted between rendered buffers. This can be used to control the maximum buffers per second that the sink will render.

setTsOffset

data BaseSinkSetTsOffsetMethodInfo

Instances

((~) * signature (Int64 -> m ()), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkSetTsOffsetMethodInfo a signature

Methods

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

baseSinkSetTsOffset

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> Int64

offset: the new offset

-> m ()

Adjust the synchronisation of sink with offset. A negative value will render buffers earlier than their timestamp. A positive value will delay rendering. This function can be used to fix playback of badly timestamped buffers.

wait

data BaseSinkWaitMethodInfo

Instances

((~) * signature (Word64 -> m (FlowReturn, Int64)), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkWaitMethodInfo a signature

Methods

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

baseSinkWait

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> Word64

time: the running_time to be reached

-> m (FlowReturn, Int64)

Returns: FlowReturn

This function will wait for preroll to complete and will then block until time is reached. It is usually called by subclasses that use their own internal synchronisation but want to let some synchronization (like EOS) be handled by the base class.

This function should only be called with the PREROLL_LOCK held (like when receiving an EOS event in the ::event vmethod or when handling buffers in ::render).

The time argument should be the running_time of when the timeout should happen and will be adjusted with any latency and offset configured in the sink.

waitClock

data BaseSinkWaitClockMethodInfo

Instances

((~) * signature (Word64 -> m (ClockReturn, Int64)), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkWaitClockMethodInfo a signature

Methods

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

baseSinkWaitClock

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> Word64

time: the running_time to be reached

-> m (ClockReturn, Int64)

Returns: ClockReturn

This function will block until time is reached. It is usually called by subclasses that use their own internal synchronisation.

If time is not valid, no synchronisation is done and ClockReturnBadtime is returned. Likewise, if synchronisation is disabled in the element or there is no clock, no synchronisation is done and ClockReturnBadtime is returned.

This function should only be called with the PREROLL_LOCK held, like when receiving an EOS event in the BaseSinkClass.event() vmethod or when receiving a buffer in the BaseSinkClass.render() vmethod.

The time argument should be the running_time of when this method should return and is not adjusted with any latency or offset configured in the sink.

waitPreroll

data BaseSinkWaitPrerollMethodInfo

Instances

((~) * signature (m FlowReturn), MonadIO m, IsBaseSink a) => MethodInfo * BaseSinkWaitPrerollMethodInfo a signature

Methods

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

baseSinkWaitPreroll

Arguments

:: (HasCallStack, MonadIO m, IsBaseSink a)

=> a

sink: the sink

-> m FlowReturn

Returns: FlowReturnOk if the preroll completed and processing can continue. Any other return value should be returned from the render vmethod.

If the BaseSinkClass.render() method performs its own synchronisation against the clock it must unblock when going from PLAYING to the PAUSED state and call this method before continuing to render the remaining data.

This function will block until a state change to PLAYING happens (in which case this function returns FlowReturnOk) or the processing must be stopped due to a state change to READY or a FLUSH event (in which case this function returns FlowReturnFlushing).

This function should only be called with the PREROLL_LOCK held, like in the render function.

Properties

async

data BaseSinkAsyncPropertyInfo

Instances

AttrInfo BaseSinkAsyncPropertyInfo

Associated Types

type AttrAllowedOps BaseSinkAsyncPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint BaseSinkAsyncPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint BaseSinkAsyncPropertyInfo :: * -> Constraint

type AttrGetType BaseSinkAsyncPropertyInfo :: *

type AttrLabel BaseSinkAsyncPropertyInfo :: Symbol

type AttrOrigin BaseSinkAsyncPropertyInfo :: *

Methods

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

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

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

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

type AttrOrigin BaseSinkAsyncPropertyInfo

type AttrOrigin BaseSinkAsyncPropertyInfo = BaseSink

type AttrLabel BaseSinkAsyncPropertyInfo

type AttrLabel BaseSinkAsyncPropertyInfo = "async"

type AttrGetType BaseSinkAsyncPropertyInfo

type AttrGetType BaseSinkAsyncPropertyInfo = Bool

type AttrBaseTypeConstraint BaseSinkAsyncPropertyInfo

type AttrBaseTypeConstraint BaseSinkAsyncPropertyInfo = IsBaseSink

type AttrSetTypeConstraint BaseSinkAsyncPropertyInfo

type AttrSetTypeConstraint BaseSinkAsyncPropertyInfo = * ~ Bool

type AttrAllowedOps BaseSinkAsyncPropertyInfo

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

baseSinkAsync :: AttrLabelProxy "async"

constructBaseSinkAsync :: IsBaseSink o => Bool -> IO (GValueConstruct o)

getBaseSinkAsync :: (MonadIO m, IsBaseSink o) => o -> m Bool

setBaseSinkAsync :: (MonadIO m, IsBaseSink o) => o -> Bool -> m ()

blocksize

data BaseSinkBlocksizePropertyInfo

Instances

AttrInfo BaseSinkBlocksizePropertyInfo

Associated Types

type AttrAllowedOps BaseSinkBlocksizePropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint BaseSinkBlocksizePropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint BaseSinkBlocksizePropertyInfo :: * -> Constraint

type AttrGetType BaseSinkBlocksizePropertyInfo :: *

type AttrLabel BaseSinkBlocksizePropertyInfo :: Symbol

type AttrOrigin BaseSinkBlocksizePropertyInfo :: *

Methods

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

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

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

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

type AttrOrigin BaseSinkBlocksizePropertyInfo

type AttrOrigin BaseSinkBlocksizePropertyInfo = BaseSink

type AttrLabel BaseSinkBlocksizePropertyInfo

type AttrLabel BaseSinkBlocksizePropertyInfo = "blocksize"

type AttrGetType BaseSinkBlocksizePropertyInfo

type AttrGetType BaseSinkBlocksizePropertyInfo = Word32

type AttrBaseTypeConstraint BaseSinkBlocksizePropertyInfo

type AttrBaseTypeConstraint BaseSinkBlocksizePropertyInfo = IsBaseSink

type AttrSetTypeConstraint BaseSinkBlocksizePropertyInfo

type AttrSetTypeConstraint BaseSinkBlocksizePropertyInfo = * ~ Word32

type AttrAllowedOps BaseSinkBlocksizePropertyInfo

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

baseSinkBlocksize :: AttrLabelProxy "blocksize"

constructBaseSinkBlocksize :: IsBaseSink o => Word32 -> IO (GValueConstruct o)

getBaseSinkBlocksize :: (MonadIO m, IsBaseSink o) => o -> m Word32

setBaseSinkBlocksize :: (MonadIO m, IsBaseSink o) => o -> Word32 -> m ()

enableLastSample

data BaseSinkEnableLastSamplePropertyInfo

Instances

AttrInfo BaseSinkEnableLastSamplePropertyInfo

Associated Types

type AttrAllowedOps BaseSinkEnableLastSamplePropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint BaseSinkEnableLastSamplePropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint BaseSinkEnableLastSamplePropertyInfo :: * -> Constraint

type AttrGetType BaseSinkEnableLastSamplePropertyInfo :: *

type AttrLabel BaseSinkEnableLastSamplePropertyInfo :: Symbol

type AttrOrigin BaseSinkEnableLastSamplePropertyInfo :: *

Methods

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

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

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

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

type AttrOrigin BaseSinkEnableLastSamplePropertyInfo

type AttrOrigin BaseSinkEnableLastSamplePropertyInfo = BaseSink

type AttrLabel BaseSinkEnableLastSamplePropertyInfo

type AttrLabel BaseSinkEnableLastSamplePropertyInfo = "enable-last-sample"

type AttrGetType BaseSinkEnableLastSamplePropertyInfo

type AttrGetType BaseSinkEnableLastSamplePropertyInfo = Bool

type AttrBaseTypeConstraint BaseSinkEnableLastSamplePropertyInfo

type AttrBaseTypeConstraint BaseSinkEnableLastSamplePropertyInfo = IsBaseSink

type AttrSetTypeConstraint BaseSinkEnableLastSamplePropertyInfo

type AttrSetTypeConstraint BaseSinkEnableLastSamplePropertyInfo = * ~ Bool

type AttrAllowedOps BaseSinkEnableLastSamplePropertyInfo

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

baseSinkEnableLastSample :: AttrLabelProxy "enableLastSample"

constructBaseSinkEnableLastSample :: IsBaseSink o => Bool -> IO (GValueConstruct o)

getBaseSinkEnableLastSample :: (MonadIO m, IsBaseSink o) => o -> m Bool

setBaseSinkEnableLastSample :: (MonadIO m, IsBaseSink o) => o -> Bool -> m ()

lastSample

data BaseSinkLastSamplePropertyInfo

Instances

AttrInfo BaseSinkLastSamplePropertyInfo

Associated Types

type AttrAllowedOps BaseSinkLastSamplePropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint BaseSinkLastSamplePropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint BaseSinkLastSamplePropertyInfo :: * -> Constraint

type AttrGetType BaseSinkLastSamplePropertyInfo :: *

type AttrLabel BaseSinkLastSamplePropertyInfo :: Symbol

type AttrOrigin BaseSinkLastSamplePropertyInfo :: *

Methods

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

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

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

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

type AttrOrigin BaseSinkLastSamplePropertyInfo

type AttrOrigin BaseSinkLastSamplePropertyInfo = BaseSink

type AttrLabel BaseSinkLastSamplePropertyInfo

type AttrLabel BaseSinkLastSamplePropertyInfo = "last-sample"

type AttrGetType BaseSinkLastSamplePropertyInfo

type AttrGetType BaseSinkLastSamplePropertyInfo = Maybe Sample

type AttrBaseTypeConstraint BaseSinkLastSamplePropertyInfo

type AttrBaseTypeConstraint BaseSinkLastSamplePropertyInfo = IsBaseSink

type AttrSetTypeConstraint BaseSinkLastSamplePropertyInfo

type AttrSetTypeConstraint BaseSinkLastSamplePropertyInfo = * ~ ()

type AttrAllowedOps BaseSinkLastSamplePropertyInfo

type AttrAllowedOps BaseSinkLastSamplePropertyInfo = (:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))

baseSinkLastSample :: AttrLabelProxy "lastSample"

getBaseSinkLastSample :: (MonadIO m, IsBaseSink o) => o -> m (Maybe Sample)

maxBitrate

data BaseSinkMaxBitratePropertyInfo

Instances

AttrInfo BaseSinkMaxBitratePropertyInfo

Associated Types

type AttrAllowedOps BaseSinkMaxBitratePropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint BaseSinkMaxBitratePropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint BaseSinkMaxBitratePropertyInfo :: * -> Constraint

type AttrGetType BaseSinkMaxBitratePropertyInfo :: *

type AttrLabel BaseSinkMaxBitratePropertyInfo :: Symbol

type AttrOrigin BaseSinkMaxBitratePropertyInfo :: *

Methods

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

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

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

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

type AttrOrigin BaseSinkMaxBitratePropertyInfo

type AttrOrigin BaseSinkMaxBitratePropertyInfo = BaseSink

type AttrLabel BaseSinkMaxBitratePropertyInfo

type AttrLabel BaseSinkMaxBitratePropertyInfo = "max-bitrate"

type AttrGetType BaseSinkMaxBitratePropertyInfo

type AttrGetType BaseSinkMaxBitratePropertyInfo = Word64

type AttrBaseTypeConstraint BaseSinkMaxBitratePropertyInfo

type AttrBaseTypeConstraint BaseSinkMaxBitratePropertyInfo = IsBaseSink

type AttrSetTypeConstraint BaseSinkMaxBitratePropertyInfo

type AttrSetTypeConstraint BaseSinkMaxBitratePropertyInfo = * ~ Word64

type AttrAllowedOps BaseSinkMaxBitratePropertyInfo

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

baseSinkMaxBitrate :: AttrLabelProxy "maxBitrate"

constructBaseSinkMaxBitrate :: IsBaseSink o => Word64 -> IO (GValueConstruct o)

getBaseSinkMaxBitrate :: (MonadIO m, IsBaseSink o) => o -> m Word64

setBaseSinkMaxBitrate :: (MonadIO m, IsBaseSink o) => o -> Word64 -> m ()

maxLateness

data BaseSinkMaxLatenessPropertyInfo

Instances

AttrInfo BaseSinkMaxLatenessPropertyInfo

Associated Types

type AttrAllowedOps BaseSinkMaxLatenessPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint BaseSinkMaxLatenessPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint BaseSinkMaxLatenessPropertyInfo :: * -> Constraint

type AttrGetType BaseSinkMaxLatenessPropertyInfo :: *

type AttrLabel BaseSinkMaxLatenessPropertyInfo :: Symbol

type AttrOrigin BaseSinkMaxLatenessPropertyInfo :: *

Methods

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

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

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

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

type AttrOrigin BaseSinkMaxLatenessPropertyInfo

type AttrOrigin BaseSinkMaxLatenessPropertyInfo = BaseSink

type AttrLabel BaseSinkMaxLatenessPropertyInfo

type AttrLabel BaseSinkMaxLatenessPropertyInfo = "max-lateness"

type AttrGetType BaseSinkMaxLatenessPropertyInfo

type AttrGetType BaseSinkMaxLatenessPropertyInfo = Int64

type AttrBaseTypeConstraint BaseSinkMaxLatenessPropertyInfo

type AttrBaseTypeConstraint BaseSinkMaxLatenessPropertyInfo = IsBaseSink

type AttrSetTypeConstraint BaseSinkMaxLatenessPropertyInfo

type AttrSetTypeConstraint BaseSinkMaxLatenessPropertyInfo = * ~ Int64

type AttrAllowedOps BaseSinkMaxLatenessPropertyInfo

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

baseSinkMaxLateness :: AttrLabelProxy "maxLateness"

constructBaseSinkMaxLateness :: IsBaseSink o => Int64 -> IO (GValueConstruct o)

getBaseSinkMaxLateness :: (MonadIO m, IsBaseSink o) => o -> m Int64

setBaseSinkMaxLateness :: (MonadIO m, IsBaseSink o) => o -> Int64 -> m ()

qos

data BaseSinkQosPropertyInfo

Instances

AttrInfo BaseSinkQosPropertyInfo

Associated Types

type AttrAllowedOps BaseSinkQosPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint BaseSinkQosPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint BaseSinkQosPropertyInfo :: * -> Constraint

type AttrGetType BaseSinkQosPropertyInfo :: *

type AttrLabel BaseSinkQosPropertyInfo :: Symbol

type AttrOrigin BaseSinkQosPropertyInfo :: *

Methods

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

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

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

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

type AttrOrigin BaseSinkQosPropertyInfo

type AttrOrigin BaseSinkQosPropertyInfo = BaseSink

type AttrLabel BaseSinkQosPropertyInfo

type AttrLabel BaseSinkQosPropertyInfo = "qos"

type AttrGetType BaseSinkQosPropertyInfo

type AttrGetType BaseSinkQosPropertyInfo = Bool

type AttrBaseTypeConstraint BaseSinkQosPropertyInfo

type AttrBaseTypeConstraint BaseSinkQosPropertyInfo = IsBaseSink

type AttrSetTypeConstraint BaseSinkQosPropertyInfo

type AttrSetTypeConstraint BaseSinkQosPropertyInfo = * ~ Bool

type AttrAllowedOps BaseSinkQosPropertyInfo

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

baseSinkQos :: AttrLabelProxy "qos"

constructBaseSinkQos :: IsBaseSink o => Bool -> IO (GValueConstruct o)

getBaseSinkQos :: (MonadIO m, IsBaseSink o) => o -> m Bool

setBaseSinkQos :: (MonadIO m, IsBaseSink o) => o -> Bool -> m ()

renderDelay

data BaseSinkRenderDelayPropertyInfo

Instances

AttrInfo BaseSinkRenderDelayPropertyInfo

Associated Types

type AttrAllowedOps BaseSinkRenderDelayPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint BaseSinkRenderDelayPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint BaseSinkRenderDelayPropertyInfo :: * -> Constraint

type AttrGetType BaseSinkRenderDelayPropertyInfo :: *

type AttrLabel BaseSinkRenderDelayPropertyInfo :: Symbol

type AttrOrigin BaseSinkRenderDelayPropertyInfo :: *

Methods

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

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

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

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

type AttrOrigin BaseSinkRenderDelayPropertyInfo

type AttrOrigin BaseSinkRenderDelayPropertyInfo = BaseSink

type AttrLabel BaseSinkRenderDelayPropertyInfo

type AttrLabel BaseSinkRenderDelayPropertyInfo = "render-delay"

type AttrGetType BaseSinkRenderDelayPropertyInfo

type AttrGetType BaseSinkRenderDelayPropertyInfo = Word64

type AttrBaseTypeConstraint BaseSinkRenderDelayPropertyInfo

type AttrBaseTypeConstraint BaseSinkRenderDelayPropertyInfo = IsBaseSink

type AttrSetTypeConstraint BaseSinkRenderDelayPropertyInfo

type AttrSetTypeConstraint BaseSinkRenderDelayPropertyInfo = * ~ Word64

type AttrAllowedOps BaseSinkRenderDelayPropertyInfo

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

baseSinkRenderDelay :: AttrLabelProxy "renderDelay"

constructBaseSinkRenderDelay :: IsBaseSink o => Word64 -> IO (GValueConstruct o)

getBaseSinkRenderDelay :: (MonadIO m, IsBaseSink o) => o -> m Word64

setBaseSinkRenderDelay :: (MonadIO m, IsBaseSink o) => o -> Word64 -> m ()

sync

data BaseSinkSyncPropertyInfo

Instances

AttrInfo BaseSinkSyncPropertyInfo

Associated Types

type AttrAllowedOps BaseSinkSyncPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint BaseSinkSyncPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint BaseSinkSyncPropertyInfo :: * -> Constraint

type AttrGetType BaseSinkSyncPropertyInfo :: *

type AttrLabel BaseSinkSyncPropertyInfo :: Symbol

type AttrOrigin BaseSinkSyncPropertyInfo :: *

Methods

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

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

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

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

type AttrOrigin BaseSinkSyncPropertyInfo

type AttrOrigin BaseSinkSyncPropertyInfo = BaseSink

type AttrLabel BaseSinkSyncPropertyInfo

type AttrLabel BaseSinkSyncPropertyInfo = "sync"

type AttrGetType BaseSinkSyncPropertyInfo

type AttrGetType BaseSinkSyncPropertyInfo = Bool

type AttrBaseTypeConstraint BaseSinkSyncPropertyInfo

type AttrBaseTypeConstraint BaseSinkSyncPropertyInfo = IsBaseSink

type AttrSetTypeConstraint BaseSinkSyncPropertyInfo

type AttrSetTypeConstraint BaseSinkSyncPropertyInfo = * ~ Bool

type AttrAllowedOps BaseSinkSyncPropertyInfo

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

baseSinkSync :: AttrLabelProxy "sync"

constructBaseSinkSync :: IsBaseSink o => Bool -> IO (GValueConstruct o)

getBaseSinkSync :: (MonadIO m, IsBaseSink o) => o -> m Bool

setBaseSinkSync :: (MonadIO m, IsBaseSink o) => o -> Bool -> m ()

throttleTime

data BaseSinkThrottleTimePropertyInfo

Instances

AttrInfo BaseSinkThrottleTimePropertyInfo

Associated Types

type AttrAllowedOps BaseSinkThrottleTimePropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint BaseSinkThrottleTimePropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint BaseSinkThrottleTimePropertyInfo :: * -> Constraint

type AttrGetType BaseSinkThrottleTimePropertyInfo :: *

type AttrLabel BaseSinkThrottleTimePropertyInfo :: Symbol

type AttrOrigin BaseSinkThrottleTimePropertyInfo :: *

Methods

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

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

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

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

type AttrOrigin BaseSinkThrottleTimePropertyInfo

type AttrOrigin BaseSinkThrottleTimePropertyInfo = BaseSink

type AttrLabel BaseSinkThrottleTimePropertyInfo

type AttrLabel BaseSinkThrottleTimePropertyInfo = "throttle-time"

type AttrGetType BaseSinkThrottleTimePropertyInfo

type AttrGetType BaseSinkThrottleTimePropertyInfo = Word64

type AttrBaseTypeConstraint BaseSinkThrottleTimePropertyInfo

type AttrBaseTypeConstraint BaseSinkThrottleTimePropertyInfo = IsBaseSink

type AttrSetTypeConstraint BaseSinkThrottleTimePropertyInfo

type AttrSetTypeConstraint BaseSinkThrottleTimePropertyInfo = * ~ Word64

type AttrAllowedOps BaseSinkThrottleTimePropertyInfo

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

baseSinkThrottleTime :: AttrLabelProxy "throttleTime"

constructBaseSinkThrottleTime :: IsBaseSink o => Word64 -> IO (GValueConstruct o)

getBaseSinkThrottleTime :: (MonadIO m, IsBaseSink o) => o -> m Word64

setBaseSinkThrottleTime :: (MonadIO m, IsBaseSink o) => o -> Word64 -> m ()

tsOffset

data BaseSinkTsOffsetPropertyInfo

Instances

AttrInfo BaseSinkTsOffsetPropertyInfo

Associated Types

type AttrAllowedOps BaseSinkTsOffsetPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint BaseSinkTsOffsetPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint BaseSinkTsOffsetPropertyInfo :: * -> Constraint

type AttrGetType BaseSinkTsOffsetPropertyInfo :: *

type AttrLabel BaseSinkTsOffsetPropertyInfo :: Symbol

type AttrOrigin BaseSinkTsOffsetPropertyInfo :: *

Methods

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

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

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

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

type AttrOrigin BaseSinkTsOffsetPropertyInfo

type AttrOrigin BaseSinkTsOffsetPropertyInfo = BaseSink

type AttrLabel BaseSinkTsOffsetPropertyInfo

type AttrLabel BaseSinkTsOffsetPropertyInfo = "ts-offset"

type AttrGetType BaseSinkTsOffsetPropertyInfo

type AttrGetType BaseSinkTsOffsetPropertyInfo = Int64

type AttrBaseTypeConstraint BaseSinkTsOffsetPropertyInfo

type AttrBaseTypeConstraint BaseSinkTsOffsetPropertyInfo = IsBaseSink

type AttrSetTypeConstraint BaseSinkTsOffsetPropertyInfo

type AttrSetTypeConstraint BaseSinkTsOffsetPropertyInfo = * ~ Int64

type AttrAllowedOps BaseSinkTsOffsetPropertyInfo

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

baseSinkTsOffset :: AttrLabelProxy "tsOffset"

constructBaseSinkTsOffset :: IsBaseSink o => Int64 -> IO (GValueConstruct o)

getBaseSinkTsOffset :: (MonadIO m, IsBaseSink o) => o -> m Int64

setBaseSinkTsOffset :: (MonadIO m, IsBaseSink o) => o -> Int64 -> m ()