Copyright | Will Thompson, Iñaki García Etxebarria and Jonas Platte |
---|---|
License | LGPL-2.1 |
Maintainer | Iñaki García Etxebarria (garetxe@gmail.com) |
Safe Haskell | None |
Language | Haskell2010 |
- Exported types
- Methods
- abortState
- addPad
- addPropertyDeepNotifyWatch
- addPropertyNotifyWatch
- callAsync
- changeState
- continueState
- createAllPads
- getBaseTime
- getBus
- getClock
- getCompatiblePad
- getCompatiblePadTemplate
- getContext
- getContextUnlocked
- getContexts
- getFactory
- getRequestPad
- getStartTime
- getState
- getStaticPad
- isLockedState
- iteratePads
- iterateSinkPads
- iterateSrcPads
- link
- linkFiltered
- linkPads
- linkPadsFiltered
- linkPadsFull
- lostState
- makeFromUri
- messageFull
- messageFullWithDetails
- noMorePads
- postMessage
- provideClock
- query
- queryConvert
- queryDuration
- queryPosition
- register
- releaseRequestPad
- removePad
- removePropertyNotifyWatch
- requestPad
- seek
- seekSimple
- sendEvent
- setBaseTime
- setBus
- setClock
- setContext
- setLockedState
- setStartTime
- setState
- stateChangeReturnGetName
- stateGetName
- syncStateWithParent
- unlink
- unlinkPads
- Signals
GstElement is the abstract base class needed to construct an element that
can be used in a GStreamer pipeline. Please refer to the plugin writers
guide for more information on creating Element
subclasses.
The name of a Element
can be get with gst_element_get_name()
and set with
gst_element_set_name()
. For speed, GST_ELEMENT_NAME()
can be used in the
core when using the appropriate locking. Do not use this in plug-ins or
applications in order to retain ABI compatibility.
Elements can have pads (of the type Pad
). These pads link to pads on
other elements. Buffer
flow between these linked pads.
A Element
has a List
of Pad
structures for all their input (or sink)
and output (or source) pads.
Core and plug-in writers can add and remove pads with elementAddPad
and elementRemovePad
.
An existing pad of an element can be retrieved by name with
elementGetStaticPad
. A new dynamic pad can be created using
elementRequestPad
with a PadTemplate
.
An iterator of all pads can be retrieved with elementIteratePads
.
Elements can be linked through their pads.
If the link is straightforward, use the elementLink
convenience function to link two elements, or gst_element_link_many()
for more elements in a row.
Use elementLinkFiltered
to link two elements constrained by
a specified set of Caps
.
For finer control, use elementLinkPads
and
elementLinkPadsFiltered
to specify the pads to link on
each element by name.
Each element has a state (see State
). You can get and set the state
of an element with elementGetState
and elementSetState
.
Setting a state triggers a StateChange
. To get a string representation
of a State
, use elementStateGetName
.
You can get and set a Clock
on an element using elementGetClock
and elementSetClock
.
Some elements can provide a clock for the pipeline if
the GST_ELEMENT_FLAG_PROVIDE_CLOCK
flag is set. With the
elementProvideClock
method one can retrieve the clock provided by
such an element.
Not all elements require a clock to operate correctly. If the
GST_ELEMENT_FLAG_REQUIRE_CLOCK
() flag is set, a clock should be set on the
element with elementSetClock
.
Note that clock selection and distribution is normally handled by the
toplevel Pipeline
so the clock functions are only to be used in very
specific situations.
- newtype Element = Element (ManagedPtr Element)
- class GObject o => IsElement o
- toElement :: IsElement o => o -> IO Element
- noElement :: Maybe Element
- data ElementAbortStateMethodInfo
- elementAbortState :: (HasCallStack, MonadIO m, IsElement a) => a -> m ()
- data ElementAddPadMethodInfo
- elementAddPad :: (HasCallStack, MonadIO m, IsElement a, IsPad b) => a -> b -> m Bool
- data ElementAddPropertyDeepNotifyWatchMethodInfo
- elementAddPropertyDeepNotifyWatch :: (HasCallStack, MonadIO m, IsElement a) => a -> Maybe Text -> Bool -> m CULong
- data ElementAddPropertyNotifyWatchMethodInfo
- elementAddPropertyNotifyWatch :: (HasCallStack, MonadIO m, IsElement a) => a -> Maybe Text -> Bool -> m CULong
- data ElementCallAsyncMethodInfo
- elementCallAsync :: (HasCallStack, MonadIO m, IsElement a) => a -> ElementCallAsyncFunc -> m ()
- data ElementChangeStateMethodInfo
- elementChangeState :: (HasCallStack, MonadIO m, IsElement a) => a -> StateChange -> m StateChangeReturn
- data ElementContinueStateMethodInfo
- elementContinueState :: (HasCallStack, MonadIO m, IsElement a) => a -> StateChangeReturn -> m StateChangeReturn
- data ElementCreateAllPadsMethodInfo
- elementCreateAllPads :: (HasCallStack, MonadIO m, IsElement a) => a -> m ()
- data ElementGetBaseTimeMethodInfo
- elementGetBaseTime :: (HasCallStack, MonadIO m, IsElement a) => a -> m Word64
- data ElementGetBusMethodInfo
- elementGetBus :: (HasCallStack, MonadIO m, IsElement a) => a -> m Bus
- data ElementGetClockMethodInfo
- elementGetClock :: (HasCallStack, MonadIO m, IsElement a) => a -> m Clock
- data ElementGetCompatiblePadMethodInfo
- elementGetCompatiblePad :: (HasCallStack, MonadIO m, IsElement a, IsPad b) => a -> b -> Maybe Caps -> m (Maybe Pad)
- data ElementGetCompatiblePadTemplateMethodInfo
- elementGetCompatiblePadTemplate :: (HasCallStack, MonadIO m, IsElement a, IsPadTemplate b) => a -> b -> m (Maybe PadTemplate)
- data ElementGetContextMethodInfo
- elementGetContext :: (HasCallStack, MonadIO m, IsElement a) => a -> Text -> m Context
- data ElementGetContextUnlockedMethodInfo
- elementGetContextUnlocked :: (HasCallStack, MonadIO m, IsElement a) => a -> Text -> m Context
- data ElementGetContextsMethodInfo
- elementGetContexts :: (HasCallStack, MonadIO m, IsElement a) => a -> m [Context]
- data ElementGetFactoryMethodInfo
- elementGetFactory :: (HasCallStack, MonadIO m, IsElement a) => a -> m ElementFactory
- data ElementGetRequestPadMethodInfo
- elementGetRequestPad :: (HasCallStack, MonadIO m, IsElement a) => a -> Text -> m (Maybe Pad)
- data ElementGetStartTimeMethodInfo
- elementGetStartTime :: (HasCallStack, MonadIO m, IsElement a) => a -> m Word64
- data ElementGetStateMethodInfo
- elementGetState :: (HasCallStack, MonadIO m, IsElement a) => a -> Word64 -> m (StateChangeReturn, State, State)
- data ElementGetStaticPadMethodInfo
- elementGetStaticPad :: (HasCallStack, MonadIO m, IsElement a) => a -> Text -> m (Maybe Pad)
- data ElementIsLockedStateMethodInfo
- elementIsLockedState :: (HasCallStack, MonadIO m, IsElement a) => a -> m Bool
- data ElementIteratePadsMethodInfo
- elementIteratePads :: (HasCallStack, MonadIO m, IsElement a) => a -> m Iterator
- data ElementIterateSinkPadsMethodInfo
- elementIterateSinkPads :: (HasCallStack, MonadIO m, IsElement a) => a -> m Iterator
- data ElementIterateSrcPadsMethodInfo
- elementIterateSrcPads :: (HasCallStack, MonadIO m, IsElement a) => a -> m Iterator
- data ElementLinkMethodInfo
- elementLink :: (HasCallStack, MonadIO m, IsElement a, IsElement b) => a -> b -> m Bool
- data ElementLinkFilteredMethodInfo
- elementLinkFiltered :: (HasCallStack, MonadIO m, IsElement a, IsElement b) => a -> b -> Maybe Caps -> m Bool
- data ElementLinkPadsMethodInfo
- elementLinkPads :: (HasCallStack, MonadIO m, IsElement a, IsElement b) => a -> Maybe Text -> b -> Maybe Text -> m Bool
- data ElementLinkPadsFilteredMethodInfo
- elementLinkPadsFiltered :: (HasCallStack, MonadIO m, IsElement a, IsElement b) => a -> Maybe Text -> b -> Maybe Text -> Maybe Caps -> m Bool
- data ElementLinkPadsFullMethodInfo
- elementLinkPadsFull :: (HasCallStack, MonadIO m, IsElement a, IsElement b) => a -> Maybe Text -> b -> Maybe Text -> [PadLinkCheck] -> m Bool
- data ElementLostStateMethodInfo
- elementLostState :: (HasCallStack, MonadIO m, IsElement a) => a -> m ()
- elementMakeFromUri :: (HasCallStack, MonadIO m) => URIType -> Text -> Maybe Text -> m Element
- data ElementMessageFullMethodInfo
- elementMessageFull :: (HasCallStack, MonadIO m, IsElement a) => a -> [MessageType] -> Word32 -> Int32 -> Maybe Text -> Maybe Text -> Text -> Text -> Int32 -> m ()
- data ElementMessageFullWithDetailsMethodInfo
- elementMessageFullWithDetails :: (HasCallStack, MonadIO m, IsElement a) => a -> [MessageType] -> Word32 -> Int32 -> Maybe Text -> Maybe Text -> Text -> Text -> Int32 -> Structure -> m ()
- data ElementNoMorePadsMethodInfo
- elementNoMorePads :: (HasCallStack, MonadIO m, IsElement a) => a -> m ()
- data ElementPostMessageMethodInfo
- elementPostMessage :: (HasCallStack, MonadIO m, IsElement a) => a -> Message -> m Bool
- data ElementProvideClockMethodInfo
- elementProvideClock :: (HasCallStack, MonadIO m, IsElement a) => a -> m (Maybe Clock)
- data ElementQueryMethodInfo
- elementQuery :: (HasCallStack, MonadIO m, IsElement a) => a -> Query -> m Bool
- data ElementQueryConvertMethodInfo
- elementQueryConvert :: (HasCallStack, MonadIO m, IsElement a) => a -> Format -> Int64 -> Format -> m (Bool, Int64)
- data ElementQueryDurationMethodInfo
- elementQueryDuration :: (HasCallStack, MonadIO m, IsElement a) => a -> Format -> m (Bool, Int64)
- data ElementQueryPositionMethodInfo
- elementQueryPosition :: (HasCallStack, MonadIO m, IsElement a) => a -> Format -> m (Bool, Int64)
- elementRegister :: (HasCallStack, MonadIO m, IsPlugin a) => Maybe a -> Text -> Word32 -> GType -> m Bool
- data ElementReleaseRequestPadMethodInfo
- elementReleaseRequestPad :: (HasCallStack, MonadIO m, IsElement a, IsPad b) => a -> b -> m ()
- data ElementRemovePadMethodInfo
- elementRemovePad :: (HasCallStack, MonadIO m, IsElement a, IsPad b) => a -> b -> m Bool
- data ElementRemovePropertyNotifyWatchMethodInfo
- elementRemovePropertyNotifyWatch :: (HasCallStack, MonadIO m, IsElement a) => a -> CULong -> m ()
- data ElementRequestPadMethodInfo
- elementRequestPad :: (HasCallStack, MonadIO m, IsElement a, IsPadTemplate b) => a -> b -> Maybe Text -> Maybe Caps -> m (Maybe Pad)
- data ElementSeekMethodInfo
- elementSeek :: (HasCallStack, MonadIO m, IsElement a) => a -> Double -> Format -> [SeekFlags] -> SeekType -> Int64 -> SeekType -> Int64 -> m Bool
- data ElementSeekSimpleMethodInfo
- elementSeekSimple :: (HasCallStack, MonadIO m, IsElement a) => a -> Format -> [SeekFlags] -> Int64 -> m Bool
- data ElementSendEventMethodInfo
- elementSendEvent :: (HasCallStack, MonadIO m, IsElement a) => a -> Event -> m Bool
- data ElementSetBaseTimeMethodInfo
- elementSetBaseTime :: (HasCallStack, MonadIO m, IsElement a) => a -> Word64 -> m ()
- data ElementSetBusMethodInfo
- elementSetBus :: (HasCallStack, MonadIO m, IsElement a, IsBus b) => a -> b -> m ()
- data ElementSetClockMethodInfo
- elementSetClock :: (HasCallStack, MonadIO m, IsElement a, IsClock b) => a -> b -> m Bool
- data ElementSetContextMethodInfo
- elementSetContext :: (HasCallStack, MonadIO m, IsElement a) => a -> Context -> m ()
- data ElementSetLockedStateMethodInfo
- elementSetLockedState :: (HasCallStack, MonadIO m, IsElement a) => a -> Bool -> m Bool
- data ElementSetStartTimeMethodInfo
- elementSetStartTime :: (HasCallStack, MonadIO m, IsElement a) => a -> Word64 -> m ()
- data ElementSetStateMethodInfo
- elementSetState :: (HasCallStack, MonadIO m, IsElement a) => a -> State -> m StateChangeReturn
- elementStateChangeReturnGetName :: (HasCallStack, MonadIO m) => StateChangeReturn -> m Text
- elementStateGetName :: (HasCallStack, MonadIO m) => State -> m Text
- data ElementSyncStateWithParentMethodInfo
- elementSyncStateWithParent :: (HasCallStack, MonadIO m, IsElement a) => a -> m Bool
- data ElementUnlinkMethodInfo
- elementUnlink :: (HasCallStack, MonadIO m, IsElement a, IsElement b) => a -> b -> m ()
- data ElementUnlinkPadsMethodInfo
- elementUnlinkPads :: (HasCallStack, MonadIO m, IsElement a, IsElement b) => a -> Text -> b -> Text -> m ()
- type C_ElementNoMorePadsCallback = Ptr () -> Ptr () -> IO ()
- type ElementNoMorePadsCallback = IO ()
- data ElementNoMorePadsSignalInfo
- afterElementNoMorePads :: (GObject a, MonadIO m) => a -> ElementNoMorePadsCallback -> m SignalHandlerId
- genClosure_ElementNoMorePads :: ElementNoMorePadsCallback -> IO Closure
- mk_ElementNoMorePadsCallback :: C_ElementNoMorePadsCallback -> IO (FunPtr C_ElementNoMorePadsCallback)
- noElementNoMorePadsCallback :: Maybe ElementNoMorePadsCallback
- onElementNoMorePads :: (GObject a, MonadIO m) => a -> ElementNoMorePadsCallback -> m SignalHandlerId
- wrap_ElementNoMorePadsCallback :: ElementNoMorePadsCallback -> Ptr () -> Ptr () -> IO ()
- type C_ElementPadAddedCallback = Ptr () -> Ptr Pad -> Ptr () -> IO ()
- type ElementPadAddedCallback = Pad -> IO ()
- data ElementPadAddedSignalInfo
- afterElementPadAdded :: (GObject a, MonadIO m) => a -> ElementPadAddedCallback -> m SignalHandlerId
- genClosure_ElementPadAdded :: ElementPadAddedCallback -> IO Closure
- mk_ElementPadAddedCallback :: C_ElementPadAddedCallback -> IO (FunPtr C_ElementPadAddedCallback)
- noElementPadAddedCallback :: Maybe ElementPadAddedCallback
- onElementPadAdded :: (GObject a, MonadIO m) => a -> ElementPadAddedCallback -> m SignalHandlerId
- wrap_ElementPadAddedCallback :: ElementPadAddedCallback -> Ptr () -> Ptr Pad -> Ptr () -> IO ()
- type C_ElementPadRemovedCallback = Ptr () -> Ptr Pad -> Ptr () -> IO ()
- type ElementPadRemovedCallback = Pad -> IO ()
- data ElementPadRemovedSignalInfo
- afterElementPadRemoved :: (GObject a, MonadIO m) => a -> ElementPadRemovedCallback -> m SignalHandlerId
- genClosure_ElementPadRemoved :: ElementPadRemovedCallback -> IO Closure
- mk_ElementPadRemovedCallback :: C_ElementPadRemovedCallback -> IO (FunPtr C_ElementPadRemovedCallback)
- noElementPadRemovedCallback :: Maybe ElementPadRemovedCallback
- onElementPadRemoved :: (GObject a, MonadIO m) => a -> ElementPadRemovedCallback -> m SignalHandlerId
- wrap_ElementPadRemovedCallback :: ElementPadRemovedCallback -> Ptr () -> Ptr Pad -> Ptr () -> IO ()
Exported types
GObject Element Source # | |
IsObject Element Source # | |
IsObject Element Source # | |
IsElement Element Source # | |
((~) * info (ResolveElementMethod t Element), MethodInfo * info Element p) => IsLabel t (Element -> p) Source # | |
((~) * info (ResolveElementMethod t Element), MethodInfo * info Element p) => IsLabelProxy t (Element -> p) Source # | |
HasAttributeList * Element Source # | |
type AttributeList Element Source # | |
type SignalList Element Source # | |
Methods
abortState
data ElementAbortStateMethodInfo Source #
((~) * signature (m ()), MonadIO m, IsElement a) => MethodInfo * ElementAbortStateMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m () |
Abort the state change of the element. This function is used by elements that do asynchronous state changes and find out something is wrong.
This function should be called with the STATE_LOCK held.
MT safe.
addPad
data ElementAddPadMethodInfo Source #
((~) * signature (b -> m Bool), MonadIO m, IsElement a, IsPad b) => MethodInfo * ElementAddPadMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a, IsPad b) | |
=> a |
|
-> b |
|
-> m Bool | Returns: MT safe. |
Adds a pad (link point) to element
. pad
's parent will be set to element
;
see objectSetParent
for refcounting information.
Pads are not automatically activated so elements should perform the needed
steps to activate the pad in case this pad is added in the PAUSED or PLAYING
state. See padSetActive
for more information about activating pads.
The pad and the element should be unlocked when calling this function.
This function will emit the Element
::pad-added
signal on the element.
addPropertyDeepNotifyWatch
elementAddPropertyDeepNotifyWatch Source #
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Maybe Text |
|
-> Bool |
|
-> m CULong | Returns: a watch id, which can be used in connection with
|
No description available in the introspection data.
Since: 1.10
addPropertyNotifyWatch
elementAddPropertyNotifyWatch Source #
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Maybe Text |
|
-> Bool |
|
-> m CULong | Returns: a watch id, which can be used in connection with
|
No description available in the introspection data.
Since: 1.10
callAsync
data ElementCallAsyncMethodInfo Source #
((~) * signature (ElementCallAsyncFunc -> m ()), MonadIO m, IsElement a) => MethodInfo * ElementCallAsyncMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> ElementCallAsyncFunc |
|
-> m () |
Calls func
from another thread and passes userData
to it. This is to be
used for cases when a state change has to be performed from a streaming
thread, directly via elementSetState
or indirectly e.g. via SEEK
events.
Calling those functions directly from the streaming thread will cause deadlocks in many situations, as they might involve waiting for the streaming thread to shut down from this very streaming thread.
MT safe.
Since: 1.10
changeState
data ElementChangeStateMethodInfo Source #
((~) * signature (StateChange -> m StateChangeReturn), MonadIO m, IsElement a) => MethodInfo * ElementChangeStateMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> StateChange |
|
-> m StateChangeReturn | Returns: the |
Perform transition
on element
.
This function must be called with STATE_LOCK held and is mainly used internally.
continueState
data ElementContinueStateMethodInfo Source #
((~) * signature (StateChangeReturn -> m StateChangeReturn), MonadIO m, IsElement a) => MethodInfo * ElementContinueStateMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> StateChangeReturn |
|
-> m StateChangeReturn | Returns: The result of the commit state change. MT safe. |
Commit the state change of the element and proceed to the next
pending state if any. This function is used
by elements that do asynchronous state changes.
The core will normally call this method automatically when an
element returned StateChangeReturnSuccess
from the state change function.
If after calling this method the element still has not reached the pending state, the next state change is performed.
This method is used internally and should normally not be called by plugins or applications.
createAllPads
data ElementCreateAllPadsMethodInfo Source #
((~) * signature (m ()), MonadIO m, IsElement a) => MethodInfo * ElementCreateAllPadsMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m () |
Creates a pad for each pad template that is always available.
This function is only useful during object initialization of
subclasses of Element
.
getBaseTime
data ElementGetBaseTimeMethodInfo Source #
((~) * signature (m Word64), MonadIO m, IsElement a) => MethodInfo * ElementGetBaseTimeMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m Word64 | Returns: the base time of the element. MT safe. |
Returns the base time of the element. The base time is the absolute time of the clock when this element was last put to PLAYING. Subtracting the base time from the clock time gives the running time of the element.
getBus
data ElementGetBusMethodInfo Source #
((~) * signature (m Bus), MonadIO m, IsElement a) => MethodInfo * ElementGetBusMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m Bus | Returns: the element's MT safe. |
Returns the bus of the element. Note that only a Pipeline
will provide a
bus for the application.
getClock
data ElementGetClockMethodInfo Source #
((~) * signature (m Clock), MonadIO m, IsElement a) => MethodInfo * ElementGetClockMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m Clock | Returns: the MT safe. |
Gets the currently configured clock of the element. This is the clock as was
last set with elementSetClock
.
Elements in a pipeline will only have their clock set when the pipeline is in the PLAYING state.
getCompatiblePad
elementGetCompatiblePad Source #
:: (HasCallStack, MonadIO m, IsElement a, IsPad b) | |
=> a |
|
-> b |
|
-> Maybe Caps |
|
-> m (Maybe Pad) | Returns: the |
Looks for an unlinked pad to which the given pad can link. It is not guaranteed that linking the pads will work, though it should work in most cases.
This function will first attempt to find a compatible unlinked ALWAYS pad,
and if none can be found, it will request a compatible REQUEST pad by looking
at the templates of element
.
getCompatiblePadTemplate
data ElementGetCompatiblePadTemplateMethodInfo Source #
((~) * signature (b -> m (Maybe PadTemplate)), MonadIO m, IsElement a, IsPadTemplate b) => MethodInfo * ElementGetCompatiblePadTemplateMethodInfo a signature Source # | |
elementGetCompatiblePadTemplate Source #
:: (HasCallStack, MonadIO m, IsElement a, IsPadTemplate b) | |
=> a |
|
-> b |
|
-> m (Maybe PadTemplate) | Returns: a compatible |
Retrieves a pad template from element
that is compatible with compattempl
.
Pads from compatible templates can be linked together.
getContext
data ElementGetContextMethodInfo Source #
((~) * signature (Text -> m Context), MonadIO m, IsElement a) => MethodInfo * ElementGetContextMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Text |
|
-> m Context | Returns: A |
Gets the context with contextType
set on the element or NULL.
MT safe.
Since: 1.8
getContextUnlocked
data ElementGetContextUnlockedMethodInfo Source #
((~) * signature (Text -> m Context), MonadIO m, IsElement a) => MethodInfo * ElementGetContextUnlockedMethodInfo a signature Source # | |
elementGetContextUnlocked Source #
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Text |
|
-> m Context | Returns: A |
Gets the context with contextType
set on the element or NULL.
Since: 1.8
getContexts
data ElementGetContextsMethodInfo Source #
((~) * signature (m [Context]), MonadIO m, IsElement a) => MethodInfo * ElementGetContextsMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m [Context] | Returns: List of |
Gets the contexts set on the element.
MT safe.
Since: 1.8
getFactory
data ElementGetFactoryMethodInfo Source #
((~) * signature (m ElementFactory), MonadIO m, IsElement a) => MethodInfo * ElementGetFactoryMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m ElementFactory | Returns: the |
Retrieves the factory that was used to create this element.
getRequestPad
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Text |
|
-> m (Maybe Pad) | Returns: requested |
Retrieves a pad from the element by name (e.g. "src_%d"). This version only
retrieves request pads. The pad should be released with
elementReleaseRequestPad
.
This method is slower than manually getting the pad template and calling
elementRequestPad
if the pads should have a specific name (e.g.
name
is "src_1" instead of "src_%u").
getStartTime
data ElementGetStartTimeMethodInfo Source #
((~) * signature (m Word64), MonadIO m, IsElement a) => MethodInfo * ElementGetStartTimeMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m Word64 | Returns: the start time of the element. |
Returns the start time of the element. The start time is the running time of the clock when this element was last put to PAUSED.
Usually the start_time is managed by a toplevel element such as
Pipeline
.
MT safe.
getState
data ElementGetStateMethodInfo Source #
((~) * signature (Word64 -> m (StateChangeReturn, State, State)), MonadIO m, IsElement a) => MethodInfo * ElementGetStateMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Word64 |
|
-> m (StateChangeReturn, State, State) | Returns: MT safe. |
Gets the state of the element.
For elements that performed an ASYNC state change, as reported by
elementSetState
, this function will block up to the
specified timeout value for the state change to complete.
If the element completes the state change or goes into
an error, this function returns immediately with a return value of
StateChangeReturnSuccess
or StateChangeReturnFailure
respectively.
For elements that did not return StateChangeReturnAsync
, this function
returns the current and pending state immediately.
This function returns StateChangeReturnNoPreroll
if the element
successfully changed its state but is not able to provide data yet.
This mostly happens for live sources that only produce data in
StatePlaying
. While the state change return is equivalent to
StateChangeReturnSuccess
, it is returned to the application to signal that
some sink elements might not be able to complete their state change because
an element is not producing data to complete the preroll. When setting the
element to playing, the preroll will complete and playback will start.
getStaticPad
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Text |
|
-> m (Maybe Pad) | Returns: the requested MT safe. |
Retrieves a pad from element
by name. This version only retrieves
already-existing (i.e. 'static') pads.
isLockedState
data ElementIsLockedStateMethodInfo Source #
((~) * signature (m Bool), MonadIO m, IsElement a) => MethodInfo * ElementIsLockedStateMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m Bool | Returns: |
Checks if the state of an element is locked.
If the state of an element is locked, state changes of the parent don't
affect the element.
This way you can leave currently unused elements inside bins. Just lock their
state before changing the state from GST_STATE_NULL
.
MT safe.
iteratePads
data ElementIteratePadsMethodInfo Source #
((~) * signature (m Iterator), MonadIO m, IsElement a) => MethodInfo * ElementIteratePadsMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m Iterator | MT safe. |
Retrieves an iterator of element
's pads. The iterator should
be freed after usage. Also more specialized iterators exists such as
elementIterateSrcPads
or elementIterateSinkPads
.
The order of pads returned by the iterator will be the order in which the pads were added to the element.
iterateSinkPads
data ElementIterateSinkPadsMethodInfo Source #
((~) * signature (m Iterator), MonadIO m, IsElement a) => MethodInfo * ElementIterateSinkPadsMethodInfo a signature Source # | |
elementIterateSinkPads Source #
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m Iterator | MT safe. |
Retrieves an iterator of element
's sink pads.
The order of pads returned by the iterator will be the order in which the pads were added to the element.
iterateSrcPads
data ElementIterateSrcPadsMethodInfo Source #
((~) * signature (m Iterator), MonadIO m, IsElement a) => MethodInfo * ElementIterateSrcPadsMethodInfo a signature Source # | |
elementIterateSrcPads Source #
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m Iterator | MT safe. |
Retrieves an iterator of element
's source pads.
The order of pads returned by the iterator will be the order in which the pads were added to the element.
link
data ElementLinkMethodInfo Source #
((~) * signature (b -> m Bool), MonadIO m, IsElement a, IsElement b) => MethodInfo * ElementLinkMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a, IsElement b) | |
=> a |
|
-> b |
|
-> m Bool | Returns: |
Links src
to dest
. The link must be from source to
destination; the other direction will not be tried. The function looks for
existing pads that aren't linked yet. It will request new pads if necessary.
Such pads need to be released manually when unlinking.
If multiple links are possible, only one is established.
Make sure you have added your elements to a bin or pipeline with
binAdd
before trying to link them.
linkFiltered
:: (HasCallStack, MonadIO m, IsElement a, IsElement b) | |
=> a |
|
-> b |
|
-> Maybe Caps |
|
-> m Bool |
Links src
to dest
using the given caps as filtercaps.
The link must be from source to
destination; the other direction will not be tried. The function looks for
existing pads that aren't linked yet. It will request new pads if necessary.
If multiple links are possible, only one is established.
Make sure you have added your elements to a bin or pipeline with
binAdd
before trying to link them.
linkPads
:: (HasCallStack, MonadIO m, IsElement a, IsElement b) | |
=> a |
|
-> Maybe Text |
|
-> b |
|
-> Maybe Text |
|
-> m Bool |
Links the two named pads of the source and destination elements. Side effect is that if one of the pads has no parent, it becomes a child of the parent of the other element. If they have different parents, the link fails.
linkPadsFiltered
elementLinkPadsFiltered Source #
:: (HasCallStack, MonadIO m, IsElement a, IsElement b) | |
=> a |
|
-> Maybe Text |
|
-> b |
|
-> Maybe Text |
|
-> Maybe Caps |
|
-> m Bool |
Links the two named pads of the source and destination elements. Side effect
is that if one of the pads has no parent, it becomes a child of the parent of
the other element. If they have different parents, the link fails. If caps
is not Nothing
, makes sure that the caps of the link is a subset of caps
.
linkPadsFull
data ElementLinkPadsFullMethodInfo Source #
((~) * signature (Maybe Text -> b -> Maybe Text -> [PadLinkCheck] -> m Bool), MonadIO m, IsElement a, IsElement b) => MethodInfo * ElementLinkPadsFullMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a, IsElement b) | |
=> a |
|
-> Maybe Text |
|
-> b |
|
-> Maybe Text |
|
-> [PadLinkCheck] |
|
-> m Bool |
Links the two named pads of the source and destination elements. Side effect is that if one of the pads has no parent, it becomes a child of the parent of the other element. If they have different parents, the link fails.
Calling elementLinkPadsFull
with flags
== PadLinkCheckDefault
is the same as calling elementLinkPads
and the recommended way of
linking pads with safety checks applied.
This is a convenience function for padLinkFull
.
lostState
data ElementLostStateMethodInfo Source #
((~) * signature (m ()), MonadIO m, IsElement a) => MethodInfo * ElementLostStateMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m () |
Brings the element to the lost state. The current state of the
element is copied to the pending state so that any call to
elementGetState
will return StateChangeReturnAsync
.
An ASYNC_START message is posted. If the element was PLAYING, it will go to PAUSED. The element will be restored to its PLAYING state by the parent pipeline when it prerolls again.
This is mostly used for elements that lost their preroll buffer
in the StatePaused
or StatePlaying
state after a flush,
they will go to their pending state again when a new preroll buffer is
queued. This function can only be called when the element is currently
not in error or an async state change.
This function is used internally and should normally not be called from plugins or applications.
makeFromUri
:: (HasCallStack, MonadIO m) | |
=> URIType |
|
-> Text |
|
-> Maybe Text |
|
-> m Element | Returns: a new element or |
Creates an element for handling the given URI.
messageFull
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> [MessageType] |
|
-> Word32 |
|
-> Int32 |
|
-> Maybe Text |
|
-> Maybe Text |
|
-> Text |
|
-> Text |
|
-> Int32 |
|
-> m () |
Post an error, warning or info message on the bus from inside an element.
type
must be of GST_MESSAGE_ERROR
, GST_MESSAGE_WARNING
or
GST_MESSAGE_INFO
.
MT safe.
messageFullWithDetails
elementMessageFullWithDetails Source #
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> [MessageType] |
|
-> Word32 |
|
-> Int32 |
|
-> Maybe Text |
|
-> Maybe Text |
|
-> Text |
|
-> Text |
|
-> Int32 |
|
-> Structure |
|
-> m () |
Post an error, warning or info message on the bus from inside an element.
type
must be of GST_MESSAGE_ERROR
, GST_MESSAGE_WARNING
or
GST_MESSAGE_INFO
.
Since: 1.10
noMorePads
data ElementNoMorePadsMethodInfo Source #
((~) * signature (m ()), MonadIO m, IsElement a) => MethodInfo * ElementNoMorePadsMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m () |
Use this function to signal that the element does not expect any more pads
to show up in the current pipeline. This function should be called whenever
pads have been added by the element itself. Elements with GST_PAD_SOMETIMES
pad templates use this in combination with autopluggers to figure out that
the element is done initializing its pads.
This function emits the Element
::no-more-pads
signal.
MT safe.
postMessage
data ElementPostMessageMethodInfo Source #
((~) * signature (Message -> m Bool), MonadIO m, IsElement a) => MethodInfo * ElementPostMessageMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Message |
|
-> m Bool | Returns: MT safe. |
Post a message on the element's Bus
. This function takes ownership of the
message; if you want to access the message after this call, you should add an
additional reference before calling.
provideClock
data ElementProvideClockMethodInfo Source #
((~) * signature (m (Maybe Clock)), MonadIO m, IsElement a) => MethodInfo * ElementProvideClockMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m (Maybe Clock) | Returns: the GstClock provided by the
element or MT safe. |
Get the clock provided by the given element. <note>An element is only required to provide a clock in the PAUSED state. Some elements can provide a clock in other states.</note>
query
data ElementQueryMethodInfo Source #
((~) * signature (Query -> m Bool), MonadIO m, IsElement a) => MethodInfo * ElementQueryMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Query |
|
-> m Bool | Returns: MT safe. |
Performs a query on the given element.
For elements that don't implement a query handler, this function forwards the query to a random srcpad or to the peer of a random linked sinkpad of this element.
Please note that some queries might need a running pipeline to work.
queryConvert
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Format |
|
-> Int64 |
|
-> Format |
|
-> m (Bool, Int64) | Returns: |
Queries an element to convert srcVal
in srcFormat
to destFormat
.
queryDuration
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Format |
|
-> m (Bool, Int64) | Returns: |
Queries an element (usually top-level pipeline or playbin element) for the total stream duration in nanoseconds. This query will only work once the pipeline is prerolled (i.e. reached PAUSED or PLAYING state). The application will receive an ASYNC_DONE message on the pipeline bus when that is the case.
If the duration changes for some reason, you will get a DURATION_CHANGED message on the pipeline bus, in which case you should re-query the duration using this function.
queryPosition
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Format |
|
-> m (Bool, Int64) | Returns: |
Queries an element (usually top-level pipeline or playbin element) for the stream position in nanoseconds. This will be a value between 0 and the stream duration (if the stream duration is known). This query will usually only work once the pipeline is prerolled (i.e. reached PAUSED or PLAYING state). The application will receive an ASYNC_DONE message on the pipeline bus when that is the case.
If one repeatedly calls this function one can also create a query and reuse
it in elementQuery
.
register
:: (HasCallStack, MonadIO m, IsPlugin a) | |
=> Maybe a |
|
-> Text |
|
-> Word32 |
|
-> GType |
|
-> m Bool |
Create a new elementfactory capable of instantiating objects of the
type
and add the factory to plugin
.
releaseRequestPad
data ElementReleaseRequestPadMethodInfo Source #
((~) * signature (b -> m ()), MonadIO m, IsElement a, IsPad b) => MethodInfo * ElementReleaseRequestPadMethodInfo a signature Source # | |
elementReleaseRequestPad Source #
:: (HasCallStack, MonadIO m, IsElement a, IsPad b) | |
=> a |
|
-> b |
|
-> m () |
Makes the element free the previously requested pad as obtained
with elementRequestPad
.
This does not unref the pad. If the pad was created by using
elementRequestPad
, elementReleaseRequestPad
needs to be
followed by objectUnref
to free the pad
.
MT safe.
removePad
data ElementRemovePadMethodInfo Source #
((~) * signature (b -> m Bool), MonadIO m, IsElement a, IsPad b) => MethodInfo * ElementRemovePadMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a, IsPad b) | |
=> a |
|
-> b |
|
-> m Bool | Returns: MT safe. |
Removes pad
from element
. pad
will be destroyed if it has not been
referenced elsewhere using objectUnparent
.
This function is used by plugin developers and should not be used
by applications. Pads that were dynamically requested from elements
with elementRequestPad
should be released with the
elementReleaseRequestPad
function instead.
Pads are not automatically deactivated so elements should perform the needed
steps to deactivate the pad in case this pad is removed in the PAUSED or
PLAYING state. See padSetActive
for more information about
deactivating pads.
The pad and the element should be unlocked when calling this function.
This function will emit the Element
::pad-removed
signal on the element.
removePropertyNotifyWatch
data ElementRemovePropertyNotifyWatchMethodInfo Source #
((~) * signature (CULong -> m ()), MonadIO m, IsElement a) => MethodInfo * ElementRemovePropertyNotifyWatchMethodInfo a signature Source # | |
elementRemovePropertyNotifyWatch Source #
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> CULong |
|
-> m () |
No description available in the introspection data.
Since: 1.10
requestPad
data ElementRequestPadMethodInfo Source #
((~) * signature (b -> Maybe Text -> Maybe Caps -> m (Maybe Pad)), MonadIO m, IsElement a, IsPadTemplate b) => MethodInfo * ElementRequestPadMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a, IsPadTemplate b) | |
=> a |
|
-> b |
|
-> Maybe Text |
|
-> Maybe Caps |
|
-> m (Maybe Pad) | Returns: requested |
Retrieves a request pad from the element according to the provided template.
Pad templates can be looked up using
elementFactoryGetStaticPadTemplates
.
The pad should be released with elementReleaseRequestPad
.
seek
data ElementSeekMethodInfo Source #
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Double |
|
-> Format |
|
-> [SeekFlags] |
|
-> SeekType |
|
-> Int64 |
|
-> SeekType |
|
-> Int64 |
|
-> m Bool | Returns: |
Sends a seek event to an element. See eventNewSeek
for the details of
the parameters. The seek event is sent to the element using
elementSendEvent
.
MT safe.
seekSimple
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Format |
|
-> [SeekFlags] |
|
-> Int64 |
|
-> m Bool | Returns: |
Simple API to perform a seek on the given element, meaning it just seeks
to the given position relative to the start of the stream. For more complex
operations like segment seeks (e.g. for looping) or changing the playback
rate or seeking relative to the last configured playback segment you should
use elementSeek
.
In a completely prerolled PAUSED or PLAYING pipeline, seeking is always
guaranteed to return True
on a seekable media type or False
when the media
type is certainly not seekable (such as a live stream).
Some elements allow for seeking in the READY state, in this
case they will store the seek event and execute it when they are put to
PAUSED. If the element supports seek in READY, it will always return True
when
it receives the event in the READY state.
sendEvent
data ElementSendEventMethodInfo Source #
((~) * signature (Event -> m Bool), MonadIO m, IsElement a) => MethodInfo * ElementSendEventMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Event |
|
-> m Bool | Returns: |
Sends an event to an element. If the element doesn't implement an event handler, the event will be pushed on a random linked sink pad for downstream events or a random linked source pad for upstream events.
This function takes ownership of the provided event so you should
gst_event_ref()
it if you want to reuse the event after this call.
MT safe.
setBaseTime
data ElementSetBaseTimeMethodInfo Source #
((~) * signature (Word64 -> m ()), MonadIO m, IsElement a) => MethodInfo * ElementSetBaseTimeMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Word64 |
|
-> m () |
Set the base time of an element. See elementGetBaseTime
.
MT safe.
setBus
data ElementSetBusMethodInfo Source #
((~) * signature (b -> m ()), MonadIO m, IsElement a, IsBus b) => MethodInfo * ElementSetBusMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a, IsBus b) | |
=> a |
|
-> b |
|
-> m () |
Sets the bus of the element. Increases the refcount on the bus. For internal use only, unless you're testing elements.
MT safe.
setClock
data ElementSetClockMethodInfo Source #
((~) * signature (b -> m Bool), MonadIO m, IsElement a, IsClock b) => MethodInfo * ElementSetClockMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a, IsClock b) | |
=> a |
|
-> b |
|
-> m Bool | Returns: MT safe. |
Sets the clock for the element. This function increases the refcount on the clock. Any previously set clock on the object is unreffed.
setContext
data ElementSetContextMethodInfo Source #
((~) * signature (Context -> m ()), MonadIO m, IsElement a) => MethodInfo * ElementSetContextMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Context |
|
-> m () |
Sets the context of the element. Increases the refcount of the context.
MT safe.
setLockedState
data ElementSetLockedStateMethodInfo Source #
((~) * signature (Bool -> m Bool), MonadIO m, IsElement a) => MethodInfo * ElementSetLockedStateMethodInfo a signature Source # | |
elementSetLockedState Source #
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Bool |
|
-> m Bool | Returns: |
Locks the state of an element, so state changes of the parent don't affect this element anymore.
MT safe.
setStartTime
data ElementSetStartTimeMethodInfo Source #
((~) * signature (Word64 -> m ()), MonadIO m, IsElement a) => MethodInfo * ElementSetStartTimeMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> Word64 |
|
-> m () |
Set the start time of an element. The start time of the element is the running time of the element when it last went to the PAUSED state. In READY or after a flushing seek, it is set to 0.
Toplevel elements like Pipeline
will manage the start_time and
base_time on its children. Setting the start_time to CLOCK_TIME_NONE
on such a toplevel element will disable the distribution of the base_time to
the children and can be useful if the application manages the base_time
itself, for example if you want to synchronize capture from multiple
pipelines, and you can also ensure that the pipelines have the same clock.
MT safe.
setState
data ElementSetStateMethodInfo Source #
((~) * signature (State -> m StateChangeReturn), MonadIO m, IsElement a) => MethodInfo * ElementSetStateMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> State |
|
-> m StateChangeReturn | Returns: Result of the state change using MT safe. |
Sets the state of the element. This function will try to set the requested state by going through all the intermediary states and calling the class's state change function for each.
This function can return GST_STATE_CHANGE_ASYNC
, in which case the
element will perform the remainder of the state change asynchronously in
another thread.
An application can use elementGetState
to wait for the completion
of the state change or it can wait for a MessageTypeAsyncDone
or
MessageTypeStateChanged
on the bus.
State changes to StateReady
or StateNull
never return
GST_STATE_CHANGE_ASYNC
.
stateChangeReturnGetName
elementStateChangeReturnGetName Source #
:: (HasCallStack, MonadIO m) | |
=> StateChangeReturn |
|
-> m Text | Returns: a string with the name of the state result. |
Gets a string representing the given state change result.
stateGetName
:: (HasCallStack, MonadIO m) | |
=> State |
|
-> m Text | Returns: a string with the name of the state. |
Gets a string representing the given state.
syncStateWithParent
data ElementSyncStateWithParentMethodInfo Source #
((~) * signature (m Bool), MonadIO m, IsElement a) => MethodInfo * ElementSyncStateWithParentMethodInfo a signature Source # | |
elementSyncStateWithParent Source #
:: (HasCallStack, MonadIO m, IsElement a) | |
=> a |
|
-> m Bool | Returns: MT safe. |
Tries to change the state of the element to the same as its parent.
If this function returns False
, the state of element is undefined.
unlink
data ElementUnlinkMethodInfo Source #
((~) * signature (b -> m ()), MonadIO m, IsElement a, IsElement b) => MethodInfo * ElementUnlinkMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsElement a, IsElement b) | |
=> a |
|
-> b |
|
-> m () |
Unlinks all source pads of the source element with all sink pads of the sink element to which they are linked.
If the link has been made using elementLink
, it could have created an
requestpad, which has to be released using elementReleaseRequestPad
.
unlinkPads
:: (HasCallStack, MonadIO m, IsElement a, IsElement b) | |
=> a |
|
-> Text |
|
-> b |
|
-> Text |
|
-> m () |
Unlinks the two named pads of the source and destination elements.
This is a convenience function for padUnlink
.
Signals
noMorePads
type ElementNoMorePadsCallback = IO () Source #
afterElementNoMorePads :: (GObject a, MonadIO m) => a -> ElementNoMorePadsCallback -> m SignalHandlerId Source #
mk_ElementNoMorePadsCallback :: C_ElementNoMorePadsCallback -> IO (FunPtr C_ElementNoMorePadsCallback) Source #
onElementNoMorePads :: (GObject a, MonadIO m) => a -> ElementNoMorePadsCallback -> m SignalHandlerId Source #
wrap_ElementNoMorePadsCallback :: ElementNoMorePadsCallback -> Ptr () -> Ptr () -> IO () Source #
padAdded
type ElementPadAddedCallback = Pad -> IO () Source #
afterElementPadAdded :: (GObject a, MonadIO m) => a -> ElementPadAddedCallback -> m SignalHandlerId Source #
mk_ElementPadAddedCallback :: C_ElementPadAddedCallback -> IO (FunPtr C_ElementPadAddedCallback) Source #
onElementPadAdded :: (GObject a, MonadIO m) => a -> ElementPadAddedCallback -> m SignalHandlerId Source #
wrap_ElementPadAddedCallback :: ElementPadAddedCallback -> Ptr () -> Ptr Pad -> Ptr () -> IO () Source #
padRemoved
type ElementPadRemovedCallback = Pad -> IO () Source #
afterElementPadRemoved :: (GObject a, MonadIO m) => a -> ElementPadRemovedCallback -> m SignalHandlerId Source #
mk_ElementPadRemovedCallback :: C_ElementPadRemovedCallback -> IO (FunPtr C_ElementPadRemovedCallback) Source #
onElementPadRemoved :: (GObject a, MonadIO m) => a -> ElementPadRemovedCallback -> m SignalHandlerId Source #
wrap_ElementPadRemovedCallback :: ElementPadRemovedCallback -> Ptr () -> Ptr Pad -> Ptr () -> IO () Source #