Copyright | Will Thompson Iñaki García Etxebarria and Jonas Platte |
---|---|
License | LGPL-2.1 |
Maintainer | Iñaki García Etxebarria (inaki@blueleaf.cc) |
Safe Haskell | None |
Language | Haskell2010 |
Synopsis
- type C_CollectDataDestroyNotify = Ptr CollectData -> IO ()
- type CollectDataDestroyNotify = CollectData -> IO ()
- dynamic_CollectDataDestroyNotify :: (HasCallStack, MonadIO m) => FunPtr C_CollectDataDestroyNotify -> CollectData -> m ()
- genClosure_CollectDataDestroyNotify :: MonadIO m => CollectDataDestroyNotify -> m (GClosure C_CollectDataDestroyNotify)
- mk_CollectDataDestroyNotify :: C_CollectDataDestroyNotify -> IO (FunPtr C_CollectDataDestroyNotify)
- noCollectDataDestroyNotify :: Maybe CollectDataDestroyNotify
- wrap_CollectDataDestroyNotify :: Maybe (Ptr (FunPtr C_CollectDataDestroyNotify)) -> CollectDataDestroyNotify -> C_CollectDataDestroyNotify
- type C_CollectPadsBufferFunction = Ptr CollectPads -> Ptr CollectData -> Ptr Buffer -> Ptr () -> IO CInt
- type CollectPadsBufferFunction = CollectPads -> CollectData -> Buffer -> IO FlowReturn
- type CollectPadsBufferFunction_WithClosures = CollectPads -> CollectData -> Buffer -> Ptr () -> IO FlowReturn
- drop_closures_CollectPadsBufferFunction :: CollectPadsBufferFunction -> CollectPadsBufferFunction_WithClosures
- dynamic_CollectPadsBufferFunction :: (HasCallStack, MonadIO m, IsCollectPads a) => FunPtr C_CollectPadsBufferFunction -> a -> CollectData -> Buffer -> Ptr () -> m FlowReturn
- genClosure_CollectPadsBufferFunction :: MonadIO m => CollectPadsBufferFunction -> m (GClosure C_CollectPadsBufferFunction)
- mk_CollectPadsBufferFunction :: C_CollectPadsBufferFunction -> IO (FunPtr C_CollectPadsBufferFunction)
- noCollectPadsBufferFunction :: Maybe CollectPadsBufferFunction
- noCollectPadsBufferFunction_WithClosures :: Maybe CollectPadsBufferFunction_WithClosures
- wrap_CollectPadsBufferFunction :: Maybe (Ptr (FunPtr C_CollectPadsBufferFunction)) -> CollectPadsBufferFunction_WithClosures -> C_CollectPadsBufferFunction
- type C_CollectPadsClipFunction = Ptr CollectPads -> Ptr CollectData -> Ptr Buffer -> Ptr (Ptr Buffer) -> Ptr () -> IO CInt
- type CollectPadsClipFunction = CollectPads -> CollectData -> Buffer -> IO (FlowReturn, Buffer)
- type CollectPadsClipFunction_WithClosures = CollectPads -> CollectData -> Buffer -> Ptr () -> IO (FlowReturn, Buffer)
- drop_closures_CollectPadsClipFunction :: CollectPadsClipFunction -> CollectPadsClipFunction_WithClosures
- dynamic_CollectPadsClipFunction :: (HasCallStack, MonadIO m, IsCollectPads a) => FunPtr C_CollectPadsClipFunction -> a -> CollectData -> Buffer -> Ptr () -> m (FlowReturn, Buffer)
- genClosure_CollectPadsClipFunction :: MonadIO m => CollectPadsClipFunction -> m (GClosure C_CollectPadsClipFunction)
- mk_CollectPadsClipFunction :: C_CollectPadsClipFunction -> IO (FunPtr C_CollectPadsClipFunction)
- noCollectPadsClipFunction :: Maybe CollectPadsClipFunction
- noCollectPadsClipFunction_WithClosures :: Maybe CollectPadsClipFunction_WithClosures
- wrap_CollectPadsClipFunction :: Maybe (Ptr (FunPtr C_CollectPadsClipFunction)) -> CollectPadsClipFunction_WithClosures -> C_CollectPadsClipFunction
- type C_CollectPadsCompareFunction = Ptr CollectPads -> Ptr CollectData -> Word64 -> Ptr CollectData -> Word64 -> Ptr () -> IO Int32
- type CollectPadsCompareFunction = CollectPads -> CollectData -> Word64 -> CollectData -> Word64 -> IO Int32
- type CollectPadsCompareFunction_WithClosures = CollectPads -> CollectData -> Word64 -> CollectData -> Word64 -> Ptr () -> IO Int32
- drop_closures_CollectPadsCompareFunction :: CollectPadsCompareFunction -> CollectPadsCompareFunction_WithClosures
- dynamic_CollectPadsCompareFunction :: (HasCallStack, MonadIO m, IsCollectPads a) => FunPtr C_CollectPadsCompareFunction -> a -> CollectData -> Word64 -> CollectData -> Word64 -> Ptr () -> m Int32
- genClosure_CollectPadsCompareFunction :: MonadIO m => CollectPadsCompareFunction -> m (GClosure C_CollectPadsCompareFunction)
- mk_CollectPadsCompareFunction :: C_CollectPadsCompareFunction -> IO (FunPtr C_CollectPadsCompareFunction)
- noCollectPadsCompareFunction :: Maybe CollectPadsCompareFunction
- noCollectPadsCompareFunction_WithClosures :: Maybe CollectPadsCompareFunction_WithClosures
- wrap_CollectPadsCompareFunction :: Maybe (Ptr (FunPtr C_CollectPadsCompareFunction)) -> CollectPadsCompareFunction_WithClosures -> C_CollectPadsCompareFunction
- type C_CollectPadsEventFunction = Ptr CollectPads -> Ptr CollectData -> Ptr Event -> Ptr () -> IO CInt
- type CollectPadsEventFunction = CollectPads -> CollectData -> Event -> IO Bool
- type CollectPadsEventFunction_WithClosures = CollectPads -> CollectData -> Event -> Ptr () -> IO Bool
- drop_closures_CollectPadsEventFunction :: CollectPadsEventFunction -> CollectPadsEventFunction_WithClosures
- dynamic_CollectPadsEventFunction :: (HasCallStack, MonadIO m, IsCollectPads a) => FunPtr C_CollectPadsEventFunction -> a -> CollectData -> Event -> Ptr () -> m Bool
- genClosure_CollectPadsEventFunction :: MonadIO m => CollectPadsEventFunction -> m (GClosure C_CollectPadsEventFunction)
- mk_CollectPadsEventFunction :: C_CollectPadsEventFunction -> IO (FunPtr C_CollectPadsEventFunction)
- noCollectPadsEventFunction :: Maybe CollectPadsEventFunction
- noCollectPadsEventFunction_WithClosures :: Maybe CollectPadsEventFunction_WithClosures
- wrap_CollectPadsEventFunction :: Maybe (Ptr (FunPtr C_CollectPadsEventFunction)) -> CollectPadsEventFunction_WithClosures -> C_CollectPadsEventFunction
- type C_CollectPadsFlushFunction = Ptr CollectPads -> Ptr () -> IO ()
- type CollectPadsFlushFunction = CollectPads -> IO ()
- type CollectPadsFlushFunction_WithClosures = CollectPads -> Ptr () -> IO ()
- drop_closures_CollectPadsFlushFunction :: CollectPadsFlushFunction -> CollectPadsFlushFunction_WithClosures
- dynamic_CollectPadsFlushFunction :: (HasCallStack, MonadIO m, IsCollectPads a) => FunPtr C_CollectPadsFlushFunction -> a -> Ptr () -> m ()
- genClosure_CollectPadsFlushFunction :: MonadIO m => CollectPadsFlushFunction -> m (GClosure C_CollectPadsFlushFunction)
- mk_CollectPadsFlushFunction :: C_CollectPadsFlushFunction -> IO (FunPtr C_CollectPadsFlushFunction)
- noCollectPadsFlushFunction :: Maybe CollectPadsFlushFunction
- noCollectPadsFlushFunction_WithClosures :: Maybe CollectPadsFlushFunction_WithClosures
- wrap_CollectPadsFlushFunction :: Maybe (Ptr (FunPtr C_CollectPadsFlushFunction)) -> CollectPadsFlushFunction_WithClosures -> C_CollectPadsFlushFunction
- type C_CollectPadsFunction = Ptr CollectPads -> Ptr () -> IO CInt
- type CollectPadsFunction = CollectPads -> IO FlowReturn
- type CollectPadsFunction_WithClosures = CollectPads -> Ptr () -> IO FlowReturn
- drop_closures_CollectPadsFunction :: CollectPadsFunction -> CollectPadsFunction_WithClosures
- dynamic_CollectPadsFunction :: (HasCallStack, MonadIO m, IsCollectPads a) => FunPtr C_CollectPadsFunction -> a -> Ptr () -> m FlowReturn
- genClosure_CollectPadsFunction :: MonadIO m => CollectPadsFunction -> m (GClosure C_CollectPadsFunction)
- mk_CollectPadsFunction :: C_CollectPadsFunction -> IO (FunPtr C_CollectPadsFunction)
- noCollectPadsFunction :: Maybe CollectPadsFunction
- noCollectPadsFunction_WithClosures :: Maybe CollectPadsFunction_WithClosures
- wrap_CollectPadsFunction :: Maybe (Ptr (FunPtr C_CollectPadsFunction)) -> CollectPadsFunction_WithClosures -> C_CollectPadsFunction
- type C_CollectPadsQueryFunction = Ptr CollectPads -> Ptr CollectData -> Ptr Query -> Ptr () -> IO CInt
- type CollectPadsQueryFunction = CollectPads -> CollectData -> Query -> IO Bool
- type CollectPadsQueryFunction_WithClosures = CollectPads -> CollectData -> Query -> Ptr () -> IO Bool
- drop_closures_CollectPadsQueryFunction :: CollectPadsQueryFunction -> CollectPadsQueryFunction_WithClosures
- dynamic_CollectPadsQueryFunction :: (HasCallStack, MonadIO m, IsCollectPads a) => FunPtr C_CollectPadsQueryFunction -> a -> CollectData -> Query -> Ptr () -> m Bool
- genClosure_CollectPadsQueryFunction :: MonadIO m => CollectPadsQueryFunction -> m (GClosure C_CollectPadsQueryFunction)
- mk_CollectPadsQueryFunction :: C_CollectPadsQueryFunction -> IO (FunPtr C_CollectPadsQueryFunction)
- noCollectPadsQueryFunction :: Maybe CollectPadsQueryFunction
- noCollectPadsQueryFunction_WithClosures :: Maybe CollectPadsQueryFunction_WithClosures
- wrap_CollectPadsQueryFunction :: Maybe (Ptr (FunPtr C_CollectPadsQueryFunction)) -> CollectPadsQueryFunction_WithClosures -> C_CollectPadsQueryFunction
- type C_DataQueueEmptyCallback = Ptr DataQueue -> Ptr () -> IO ()
- type DataQueueEmptyCallback = DataQueue -> Ptr () -> IO ()
- dynamic_DataQueueEmptyCallback :: (HasCallStack, MonadIO m, IsDataQueue a) => FunPtr C_DataQueueEmptyCallback -> a -> Ptr () -> m ()
- genClosure_DataQueueEmptyCallback :: MonadIO m => DataQueueEmptyCallback -> m (GClosure C_DataQueueEmptyCallback)
- mk_DataQueueEmptyCallback :: C_DataQueueEmptyCallback -> IO (FunPtr C_DataQueueEmptyCallback)
- noDataQueueEmptyCallback :: Maybe DataQueueEmptyCallback
- wrap_DataQueueEmptyCallback :: Maybe (Ptr (FunPtr C_DataQueueEmptyCallback)) -> DataQueueEmptyCallback -> C_DataQueueEmptyCallback
- type C_DataQueueFullCallback = Ptr DataQueue -> Ptr () -> IO ()
- type DataQueueFullCallback = DataQueue -> Ptr () -> IO ()
- dynamic_DataQueueFullCallback :: (HasCallStack, MonadIO m, IsDataQueue a) => FunPtr C_DataQueueFullCallback -> a -> Ptr () -> m ()
- genClosure_DataQueueFullCallback :: MonadIO m => DataQueueFullCallback -> m (GClosure C_DataQueueFullCallback)
- mk_DataQueueFullCallback :: C_DataQueueFullCallback -> IO (FunPtr C_DataQueueFullCallback)
- noDataQueueFullCallback :: Maybe DataQueueFullCallback
- wrap_DataQueueFullCallback :: Maybe (Ptr (FunPtr C_DataQueueFullCallback)) -> DataQueueFullCallback -> C_DataQueueFullCallback
- type C_TypeFindHelperGetRangeFunction = Ptr Object -> Ptr Object -> Word64 -> Word32 -> Ptr (Ptr Buffer) -> IO CInt
- type TypeFindHelperGetRangeFunction = Object -> Maybe Object -> Word64 -> Word32 -> IO (FlowReturn, Buffer)
- dynamic_TypeFindHelperGetRangeFunction :: (HasCallStack, MonadIO m, IsObject a, IsObject b) => FunPtr C_TypeFindHelperGetRangeFunction -> a -> Maybe b -> Word64 -> Word32 -> m (FlowReturn, Buffer)
- genClosure_TypeFindHelperGetRangeFunction :: MonadIO m => TypeFindHelperGetRangeFunction -> m (GClosure C_TypeFindHelperGetRangeFunction)
- mk_TypeFindHelperGetRangeFunction :: C_TypeFindHelperGetRangeFunction -> IO (FunPtr C_TypeFindHelperGetRangeFunction)
- noTypeFindHelperGetRangeFunction :: Maybe TypeFindHelperGetRangeFunction
- wrap_TypeFindHelperGetRangeFunction :: Maybe (Ptr (FunPtr C_TypeFindHelperGetRangeFunction)) -> TypeFindHelperGetRangeFunction -> C_TypeFindHelperGetRangeFunction
Signals
CollectDataDestroyNotify
type C_CollectDataDestroyNotify = Ptr CollectData -> IO () Source #
Type for the callback on the (unwrapped) C side.
type CollectDataDestroyNotify Source #
= CollectData |
|
-> IO () |
A function that will be called when the CollectData
will be freed.
It is passed the pointer to the structure and should free any custom
memory and resources allocated for it.
dynamic_CollectDataDestroyNotify Source #
:: (HasCallStack, MonadIO m) | |
=> FunPtr C_CollectDataDestroyNotify | |
-> CollectData |
|
-> m () |
Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
genClosure_CollectDataDestroyNotify :: MonadIO m => CollectDataDestroyNotify -> m (GClosure C_CollectDataDestroyNotify) Source #
Wrap the callback into a GClosure
.
mk_CollectDataDestroyNotify :: C_CollectDataDestroyNotify -> IO (FunPtr C_CollectDataDestroyNotify) Source #
Generate a function pointer callable from C code, from a C_CollectDataDestroyNotify
.
noCollectDataDestroyNotify :: Maybe CollectDataDestroyNotify Source #
A convenience synonym for
.Nothing
:: Maybe
CollectDataDestroyNotify
wrap_CollectDataDestroyNotify :: Maybe (Ptr (FunPtr C_CollectDataDestroyNotify)) -> CollectDataDestroyNotify -> C_CollectDataDestroyNotify Source #
Wrap a CollectDataDestroyNotify
into a C_CollectDataDestroyNotify
.
CollectPadsBufferFunction
type C_CollectPadsBufferFunction = Ptr CollectPads -> Ptr CollectData -> Ptr Buffer -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type CollectPadsBufferFunction Source #
= CollectPads |
|
-> CollectData |
|
-> Buffer |
|
-> IO FlowReturn | Returns: |
type CollectPadsBufferFunction_WithClosures Source #
= CollectPads |
|
-> CollectData |
|
-> Buffer |
|
-> Ptr () |
|
-> IO FlowReturn | Returns: |
drop_closures_CollectPadsBufferFunction :: CollectPadsBufferFunction -> CollectPadsBufferFunction_WithClosures Source #
A simple wrapper that ignores the closure arguments.
dynamic_CollectPadsBufferFunction Source #
:: (HasCallStack, MonadIO m, IsCollectPads a) | |
=> FunPtr C_CollectPadsBufferFunction | |
-> a |
|
-> CollectData |
|
-> Buffer |
|
-> Ptr () |
|
-> m FlowReturn | Returns: |
Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
genClosure_CollectPadsBufferFunction :: MonadIO m => CollectPadsBufferFunction -> m (GClosure C_CollectPadsBufferFunction) Source #
Wrap the callback into a GClosure
.
mk_CollectPadsBufferFunction :: C_CollectPadsBufferFunction -> IO (FunPtr C_CollectPadsBufferFunction) Source #
Generate a function pointer callable from C code, from a C_CollectPadsBufferFunction
.
noCollectPadsBufferFunction :: Maybe CollectPadsBufferFunction Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsBufferFunction
noCollectPadsBufferFunction_WithClosures :: Maybe CollectPadsBufferFunction_WithClosures Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsBufferFunction_WithClosures
wrap_CollectPadsBufferFunction :: Maybe (Ptr (FunPtr C_CollectPadsBufferFunction)) -> CollectPadsBufferFunction_WithClosures -> C_CollectPadsBufferFunction Source #
Wrap a CollectPadsBufferFunction
into a C_CollectPadsBufferFunction
.
CollectPadsClipFunction
type C_CollectPadsClipFunction = Ptr CollectPads -> Ptr CollectData -> Ptr Buffer -> Ptr (Ptr Buffer) -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type CollectPadsClipFunction Source #
= CollectPads |
|
-> CollectData |
|
-> Buffer |
|
-> IO (FlowReturn, Buffer) | Returns: a |
A function that will be called when inbuffer
is received on the pad managed
by data
in the collectpad object pads
.
The function should use the segment of data
and the negotiated media type on
the pad to perform clipping of inbuffer
.
This function takes ownership of inbuffer
and should output a buffer in
outbuffer
or return Nothing
in outbuffer
if the buffer should be dropped.
type CollectPadsClipFunction_WithClosures Source #
= CollectPads |
|
-> CollectData |
|
-> Buffer |
|
-> Ptr () |
|
-> IO (FlowReturn, Buffer) | Returns: a |
A function that will be called when inbuffer
is received on the pad managed
by data
in the collectpad object pads
.
The function should use the segment of data
and the negotiated media type on
the pad to perform clipping of inbuffer
.
This function takes ownership of inbuffer
and should output a buffer in
outbuffer
or return Nothing
in outbuffer
if the buffer should be dropped.
drop_closures_CollectPadsClipFunction :: CollectPadsClipFunction -> CollectPadsClipFunction_WithClosures Source #
A simple wrapper that ignores the closure arguments.
dynamic_CollectPadsClipFunction Source #
:: (HasCallStack, MonadIO m, IsCollectPads a) | |
=> FunPtr C_CollectPadsClipFunction | |
-> a |
|
-> CollectData |
|
-> Buffer |
|
-> Ptr () |
|
-> m (FlowReturn, Buffer) | Returns: a |
Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
genClosure_CollectPadsClipFunction :: MonadIO m => CollectPadsClipFunction -> m (GClosure C_CollectPadsClipFunction) Source #
Wrap the callback into a GClosure
.
mk_CollectPadsClipFunction :: C_CollectPadsClipFunction -> IO (FunPtr C_CollectPadsClipFunction) Source #
Generate a function pointer callable from C code, from a C_CollectPadsClipFunction
.
noCollectPadsClipFunction :: Maybe CollectPadsClipFunction Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsClipFunction
noCollectPadsClipFunction_WithClosures :: Maybe CollectPadsClipFunction_WithClosures Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsClipFunction_WithClosures
wrap_CollectPadsClipFunction :: Maybe (Ptr (FunPtr C_CollectPadsClipFunction)) -> CollectPadsClipFunction_WithClosures -> C_CollectPadsClipFunction Source #
Wrap a CollectPadsClipFunction
into a C_CollectPadsClipFunction
.
CollectPadsCompareFunction
type C_CollectPadsCompareFunction = Ptr CollectPads -> Ptr CollectData -> Word64 -> Ptr CollectData -> Word64 -> Ptr () -> IO Int32 Source #
Type for the callback on the (unwrapped) C side.
type CollectPadsCompareFunction Source #
= CollectPads |
|
-> CollectData |
|
-> Word64 |
|
-> CollectData |
|
-> Word64 |
|
-> IO Int32 | Returns: Integer less than zero when first timestamp is deemed older than the second one. Zero if the timestamps are deemed equally old. Integer greater than zero when second timestamp is deemed older than the first one. |
A function for comparing two timestamps of buffers or newsegments collected on one pad.
type CollectPadsCompareFunction_WithClosures Source #
= CollectPads |
|
-> CollectData |
|
-> Word64 |
|
-> CollectData |
|
-> Word64 |
|
-> Ptr () |
|
-> IO Int32 | Returns: Integer less than zero when first timestamp is deemed older than the second one. Zero if the timestamps are deemed equally old. Integer greater than zero when second timestamp is deemed older than the first one. |
A function for comparing two timestamps of buffers or newsegments collected on one pad.
drop_closures_CollectPadsCompareFunction :: CollectPadsCompareFunction -> CollectPadsCompareFunction_WithClosures Source #
A simple wrapper that ignores the closure arguments.
dynamic_CollectPadsCompareFunction Source #
:: (HasCallStack, MonadIO m, IsCollectPads a) | |
=> FunPtr C_CollectPadsCompareFunction | |
-> a |
|
-> CollectData |
|
-> Word64 |
|
-> CollectData |
|
-> Word64 |
|
-> Ptr () |
|
-> m Int32 | Returns: Integer less than zero when first timestamp is deemed older than the second one. Zero if the timestamps are deemed equally old. Integer greater than zero when second timestamp is deemed older than the first one. |
Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
genClosure_CollectPadsCompareFunction :: MonadIO m => CollectPadsCompareFunction -> m (GClosure C_CollectPadsCompareFunction) Source #
Wrap the callback into a GClosure
.
mk_CollectPadsCompareFunction :: C_CollectPadsCompareFunction -> IO (FunPtr C_CollectPadsCompareFunction) Source #
Generate a function pointer callable from C code, from a C_CollectPadsCompareFunction
.
noCollectPadsCompareFunction :: Maybe CollectPadsCompareFunction Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsCompareFunction
noCollectPadsCompareFunction_WithClosures :: Maybe CollectPadsCompareFunction_WithClosures Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsCompareFunction_WithClosures
wrap_CollectPadsCompareFunction :: Maybe (Ptr (FunPtr C_CollectPadsCompareFunction)) -> CollectPadsCompareFunction_WithClosures -> C_CollectPadsCompareFunction Source #
Wrap a CollectPadsCompareFunction
into a C_CollectPadsCompareFunction
.
CollectPadsEventFunction
type C_CollectPadsEventFunction = Ptr CollectPads -> Ptr CollectData -> Ptr Event -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type CollectPadsEventFunction Source #
= CollectPads |
|
-> CollectData |
|
-> Event |
|
-> IO Bool | Returns: |
A function that will be called while processing an event. It takes
ownership of the event and is responsible for chaining up (to
collectPadsEventDefault
) or dropping events (such typical cases
being handled by the default handler).
type CollectPadsEventFunction_WithClosures Source #
= CollectPads |
|
-> CollectData |
|
-> Event |
|
-> Ptr () |
|
-> IO Bool | Returns: |
A function that will be called while processing an event. It takes
ownership of the event and is responsible for chaining up (to
collectPadsEventDefault
) or dropping events (such typical cases
being handled by the default handler).
drop_closures_CollectPadsEventFunction :: CollectPadsEventFunction -> CollectPadsEventFunction_WithClosures Source #
A simple wrapper that ignores the closure arguments.
dynamic_CollectPadsEventFunction Source #
:: (HasCallStack, MonadIO m, IsCollectPads a) | |
=> FunPtr C_CollectPadsEventFunction | |
-> a |
|
-> CollectData |
|
-> Event |
|
-> Ptr () |
|
-> m Bool | Returns: |
Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
genClosure_CollectPadsEventFunction :: MonadIO m => CollectPadsEventFunction -> m (GClosure C_CollectPadsEventFunction) Source #
Wrap the callback into a GClosure
.
mk_CollectPadsEventFunction :: C_CollectPadsEventFunction -> IO (FunPtr C_CollectPadsEventFunction) Source #
Generate a function pointer callable from C code, from a C_CollectPadsEventFunction
.
noCollectPadsEventFunction :: Maybe CollectPadsEventFunction Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsEventFunction
noCollectPadsEventFunction_WithClosures :: Maybe CollectPadsEventFunction_WithClosures Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsEventFunction_WithClosures
wrap_CollectPadsEventFunction :: Maybe (Ptr (FunPtr C_CollectPadsEventFunction)) -> CollectPadsEventFunction_WithClosures -> C_CollectPadsEventFunction Source #
Wrap a CollectPadsEventFunction
into a C_CollectPadsEventFunction
.
CollectPadsFlushFunction
type C_CollectPadsFlushFunction = Ptr CollectPads -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type CollectPadsFlushFunction Source #
= CollectPads |
|
-> IO () |
A function that will be called while processing a flushing seek event.
The function should flush any internal state of the element and the state of
all the pads. It should clear only the state not directly managed by the
pads
object. It is therefore not necessary to call
gst_collect_pads_set_flushing nor gst_collect_pads_clear from this function.
Since: 1.4
type CollectPadsFlushFunction_WithClosures Source #
= CollectPads |
|
-> Ptr () |
|
-> IO () |
A function that will be called while processing a flushing seek event.
The function should flush any internal state of the element and the state of
all the pads. It should clear only the state not directly managed by the
pads
object. It is therefore not necessary to call
gst_collect_pads_set_flushing nor gst_collect_pads_clear from this function.
Since: 1.4
drop_closures_CollectPadsFlushFunction :: CollectPadsFlushFunction -> CollectPadsFlushFunction_WithClosures Source #
A simple wrapper that ignores the closure arguments.
dynamic_CollectPadsFlushFunction Source #
:: (HasCallStack, MonadIO m, IsCollectPads a) | |
=> FunPtr C_CollectPadsFlushFunction | |
-> a |
|
-> Ptr () |
|
-> m () |
Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
genClosure_CollectPadsFlushFunction :: MonadIO m => CollectPadsFlushFunction -> m (GClosure C_CollectPadsFlushFunction) Source #
Wrap the callback into a GClosure
.
mk_CollectPadsFlushFunction :: C_CollectPadsFlushFunction -> IO (FunPtr C_CollectPadsFlushFunction) Source #
Generate a function pointer callable from C code, from a C_CollectPadsFlushFunction
.
noCollectPadsFlushFunction :: Maybe CollectPadsFlushFunction Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsFlushFunction
noCollectPadsFlushFunction_WithClosures :: Maybe CollectPadsFlushFunction_WithClosures Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsFlushFunction_WithClosures
wrap_CollectPadsFlushFunction :: Maybe (Ptr (FunPtr C_CollectPadsFlushFunction)) -> CollectPadsFlushFunction_WithClosures -> C_CollectPadsFlushFunction Source #
Wrap a CollectPadsFlushFunction
into a C_CollectPadsFlushFunction
.
CollectPadsFunction
type C_CollectPadsFunction = Ptr CollectPads -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type CollectPadsFunction Source #
= CollectPads |
|
-> IO FlowReturn | Returns: |
A function that will be called when all pads have received data.
type CollectPadsFunction_WithClosures Source #
= CollectPads |
|
-> Ptr () |
|
-> IO FlowReturn | Returns: |
A function that will be called when all pads have received data.
drop_closures_CollectPadsFunction :: CollectPadsFunction -> CollectPadsFunction_WithClosures Source #
A simple wrapper that ignores the closure arguments.
dynamic_CollectPadsFunction Source #
:: (HasCallStack, MonadIO m, IsCollectPads a) | |
=> FunPtr C_CollectPadsFunction | |
-> a |
|
-> Ptr () |
|
-> m FlowReturn | Returns: |
Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
genClosure_CollectPadsFunction :: MonadIO m => CollectPadsFunction -> m (GClosure C_CollectPadsFunction) Source #
Wrap the callback into a GClosure
.
mk_CollectPadsFunction :: C_CollectPadsFunction -> IO (FunPtr C_CollectPadsFunction) Source #
Generate a function pointer callable from C code, from a C_CollectPadsFunction
.
noCollectPadsFunction :: Maybe CollectPadsFunction Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsFunction
noCollectPadsFunction_WithClosures :: Maybe CollectPadsFunction_WithClosures Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsFunction_WithClosures
wrap_CollectPadsFunction :: Maybe (Ptr (FunPtr C_CollectPadsFunction)) -> CollectPadsFunction_WithClosures -> C_CollectPadsFunction Source #
Wrap a CollectPadsFunction
into a C_CollectPadsFunction
.
CollectPadsQueryFunction
type C_CollectPadsQueryFunction = Ptr CollectPads -> Ptr CollectData -> Ptr Query -> Ptr () -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type CollectPadsQueryFunction Source #
= CollectPads |
|
-> CollectData |
|
-> Query |
|
-> IO Bool | Returns: |
A function that will be called while processing a query. It takes
ownership of the query and is responsible for chaining up (to
events downstream (with padEventDefault
).
type CollectPadsQueryFunction_WithClosures Source #
= CollectPads |
|
-> CollectData |
|
-> Query |
|
-> Ptr () |
|
-> IO Bool | Returns: |
A function that will be called while processing a query. It takes
ownership of the query and is responsible for chaining up (to
events downstream (with padEventDefault
).
drop_closures_CollectPadsQueryFunction :: CollectPadsQueryFunction -> CollectPadsQueryFunction_WithClosures Source #
A simple wrapper that ignores the closure arguments.
dynamic_CollectPadsQueryFunction Source #
:: (HasCallStack, MonadIO m, IsCollectPads a) | |
=> FunPtr C_CollectPadsQueryFunction | |
-> a |
|
-> CollectData |
|
-> Query |
|
-> Ptr () |
|
-> m Bool | Returns: |
Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
genClosure_CollectPadsQueryFunction :: MonadIO m => CollectPadsQueryFunction -> m (GClosure C_CollectPadsQueryFunction) Source #
Wrap the callback into a GClosure
.
mk_CollectPadsQueryFunction :: C_CollectPadsQueryFunction -> IO (FunPtr C_CollectPadsQueryFunction) Source #
Generate a function pointer callable from C code, from a C_CollectPadsQueryFunction
.
noCollectPadsQueryFunction :: Maybe CollectPadsQueryFunction Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsQueryFunction
noCollectPadsQueryFunction_WithClosures :: Maybe CollectPadsQueryFunction_WithClosures Source #
A convenience synonym for
.Nothing
:: Maybe
CollectPadsQueryFunction_WithClosures
wrap_CollectPadsQueryFunction :: Maybe (Ptr (FunPtr C_CollectPadsQueryFunction)) -> CollectPadsQueryFunction_WithClosures -> C_CollectPadsQueryFunction Source #
Wrap a CollectPadsQueryFunction
into a C_CollectPadsQueryFunction
.
DataQueueEmptyCallback
type C_DataQueueEmptyCallback = Ptr DataQueue -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type DataQueueEmptyCallback = DataQueue -> Ptr () -> IO () Source #
No description available in the introspection data.
dynamic_DataQueueEmptyCallback :: (HasCallStack, MonadIO m, IsDataQueue a) => FunPtr C_DataQueueEmptyCallback -> a -> Ptr () -> m () Source #
Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
genClosure_DataQueueEmptyCallback :: MonadIO m => DataQueueEmptyCallback -> m (GClosure C_DataQueueEmptyCallback) Source #
Wrap the callback into a GClosure
.
mk_DataQueueEmptyCallback :: C_DataQueueEmptyCallback -> IO (FunPtr C_DataQueueEmptyCallback) Source #
Generate a function pointer callable from C code, from a C_DataQueueEmptyCallback
.
noDataQueueEmptyCallback :: Maybe DataQueueEmptyCallback Source #
A convenience synonym for
.Nothing
:: Maybe
DataQueueEmptyCallback
wrap_DataQueueEmptyCallback :: Maybe (Ptr (FunPtr C_DataQueueEmptyCallback)) -> DataQueueEmptyCallback -> C_DataQueueEmptyCallback Source #
Wrap a DataQueueEmptyCallback
into a C_DataQueueEmptyCallback
.
DataQueueFullCallback
type C_DataQueueFullCallback = Ptr DataQueue -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type DataQueueFullCallback = DataQueue -> Ptr () -> IO () Source #
No description available in the introspection data.
dynamic_DataQueueFullCallback :: (HasCallStack, MonadIO m, IsDataQueue a) => FunPtr C_DataQueueFullCallback -> a -> Ptr () -> m () Source #
Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
genClosure_DataQueueFullCallback :: MonadIO m => DataQueueFullCallback -> m (GClosure C_DataQueueFullCallback) Source #
Wrap the callback into a GClosure
.
mk_DataQueueFullCallback :: C_DataQueueFullCallback -> IO (FunPtr C_DataQueueFullCallback) Source #
Generate a function pointer callable from C code, from a C_DataQueueFullCallback
.
noDataQueueFullCallback :: Maybe DataQueueFullCallback Source #
A convenience synonym for
.Nothing
:: Maybe
DataQueueFullCallback
wrap_DataQueueFullCallback :: Maybe (Ptr (FunPtr C_DataQueueFullCallback)) -> DataQueueFullCallback -> C_DataQueueFullCallback Source #
Wrap a DataQueueFullCallback
into a C_DataQueueFullCallback
.
TypeFindHelperGetRangeFunction
type C_TypeFindHelperGetRangeFunction = Ptr Object -> Ptr Object -> Word64 -> Word32 -> Ptr (Ptr Buffer) -> IO CInt Source #
Type for the callback on the (unwrapped) C side.
type TypeFindHelperGetRangeFunction Source #
= Object |
|
-> Maybe Object |
|
-> Word64 |
|
-> Word32 |
|
-> IO (FlowReturn, Buffer) | Returns: GST_FLOW_OK for success |
This function will be called by typeFindHelperGetRange
when
typefinding functions request to peek at the data of a stream at certain
offsets. If this function returns GST_FLOW_OK, the result buffer will be
stored in buffer
. The contents of buffer
is invalid for any other
return value.
This function is supposed to behave exactly like a PadGetRangeFunction
.
dynamic_TypeFindHelperGetRangeFunction Source #
:: (HasCallStack, MonadIO m, IsObject a, IsObject b) | |
=> FunPtr C_TypeFindHelperGetRangeFunction | |
-> a |
|
-> Maybe b |
|
-> Word64 |
|
-> Word32 |
|
-> m (FlowReturn, Buffer) | Returns: GST_FLOW_OK for success |
Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
genClosure_TypeFindHelperGetRangeFunction :: MonadIO m => TypeFindHelperGetRangeFunction -> m (GClosure C_TypeFindHelperGetRangeFunction) Source #
Wrap the callback into a GClosure
.
mk_TypeFindHelperGetRangeFunction :: C_TypeFindHelperGetRangeFunction -> IO (FunPtr C_TypeFindHelperGetRangeFunction) Source #
Generate a function pointer callable from C code, from a C_TypeFindHelperGetRangeFunction
.
noTypeFindHelperGetRangeFunction :: Maybe TypeFindHelperGetRangeFunction Source #
A convenience synonym for
.Nothing
:: Maybe
TypeFindHelperGetRangeFunction