GI.GstBase.Callbacks

Signals

CollectDataDestroyNotify

type C_CollectDataDestroyNotify = Ptr CollectData -> IO ()

Type for the callback on the (unwrapped) C side.

type CollectDataDestroyNotify

Arguments

 = CollectData

data: the CollectData that will be freed

-> 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

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_CollectDataDestroyNotify

-> CollectData

data: the CollectData that will be freed

-> 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)

Wrap the callback into a GClosure.

mk_CollectDataDestroyNotify :: C_CollectDataDestroyNotify -> IO (FunPtr C_CollectDataDestroyNotify)

Generate a function pointer callable from C code, from a C_CollectDataDestroyNotify.

noCollectDataDestroyNotify :: Maybe CollectDataDestroyNotify

A convenience synonym for Nothing :: Maybe CollectDataDestroyNotify.

wrap_CollectDataDestroyNotify :: Maybe (Ptr (FunPtr C_CollectDataDestroyNotify)) -> CollectDataDestroyNotify -> C_CollectDataDestroyNotify

Wrap a CollectDataDestroyNotify into a C_CollectDataDestroyNotify.

CollectPadsBufferFunction

type C_CollectPadsBufferFunction = Ptr CollectPads -> Ptr CollectData -> Ptr Buffer -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type CollectPadsBufferFunction

Arguments

 = CollectPads

pads: the CollectPads that triggered the callback

-> CollectData

data: the CollectData of pad that has received the buffer

-> Buffer

buffer: the Buffer

-> IO FlowReturn

Returns: FlowReturnOk for success

A function that will be called when a (considered oldest) buffer can be muxed. If all pads have reached EOS, this function is called with Nothing buffer and Nothing data.

type CollectPadsBufferFunction_WithClosures

Arguments

 = CollectPads

pads: the CollectPads that triggered the callback

-> CollectData

data: the CollectData of pad that has received the buffer

-> Buffer

buffer: the Buffer

-> Ptr ()

userData: user data passed to collectPadsSetBufferFunction

-> IO FlowReturn

Returns: FlowReturnOk for success

A function that will be called when a (considered oldest) buffer can be muxed. If all pads have reached EOS, this function is called with Nothing buffer and Nothing data.

drop_closures_CollectPadsBufferFunction :: CollectPadsBufferFunction -> CollectPadsBufferFunction_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_CollectPadsBufferFunction

Arguments

:: (HasCallStack, MonadIO m, IsCollectPads a)

=> FunPtr C_CollectPadsBufferFunction

-> a

pads: the CollectPads that triggered the callback

-> CollectData

data: the CollectData of pad that has received the buffer

-> Buffer

buffer: the Buffer

-> Ptr ()

userData: user data passed to collectPadsSetBufferFunction

-> m FlowReturn

Returns: FlowReturnOk for success

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)

Wrap the callback into a GClosure.

mk_CollectPadsBufferFunction :: C_CollectPadsBufferFunction -> IO (FunPtr C_CollectPadsBufferFunction)

Generate a function pointer callable from C code, from a C_CollectPadsBufferFunction.

noCollectPadsBufferFunction :: Maybe CollectPadsBufferFunction

A convenience synonym for Nothing :: Maybe CollectPadsBufferFunction.

noCollectPadsBufferFunction_WithClosures :: Maybe CollectPadsBufferFunction_WithClosures

A convenience synonym for Nothing :: Maybe CollectPadsBufferFunction_WithClosures.

wrap_CollectPadsBufferFunction :: Maybe (Ptr (FunPtr C_CollectPadsBufferFunction)) -> CollectPadsBufferFunction_WithClosures -> C_CollectPadsBufferFunction

Wrap a CollectPadsBufferFunction into a C_CollectPadsBufferFunction.

CollectPadsClipFunction

type C_CollectPadsClipFunction = Ptr CollectPads -> Ptr CollectData -> Ptr Buffer -> Ptr (Ptr Buffer) -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type CollectPadsClipFunction

Arguments

 = CollectPads

pads: a CollectPads

-> CollectData

data: a CollectData

-> Buffer

inbuffer: the input Buffer

-> IO (FlowReturn, Buffer)

Returns: a FlowReturn that corresponds to the result of clipping.

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

Arguments

 = CollectPads

pads: a CollectPads

-> CollectData

data: a CollectData

-> Buffer

inbuffer: the input Buffer

-> Ptr ()

userData: user data

-> IO (FlowReturn, Buffer)

Returns: a FlowReturn that corresponds to the result of clipping.

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

A simple wrapper that ignores the closure arguments.

dynamic_CollectPadsClipFunction

Arguments

:: (HasCallStack, MonadIO m, IsCollectPads a)

=> FunPtr C_CollectPadsClipFunction

-> a

pads: a CollectPads

-> CollectData

data: a CollectData

-> Buffer

inbuffer: the input Buffer

-> Ptr ()

userData: user data

-> m (FlowReturn, Buffer)

Returns: a FlowReturn that corresponds to the result of clipping.

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)

Wrap the callback into a GClosure.

mk_CollectPadsClipFunction :: C_CollectPadsClipFunction -> IO (FunPtr C_CollectPadsClipFunction)

Generate a function pointer callable from C code, from a C_CollectPadsClipFunction.

noCollectPadsClipFunction :: Maybe CollectPadsClipFunction

A convenience synonym for Nothing :: Maybe CollectPadsClipFunction.

noCollectPadsClipFunction_WithClosures :: Maybe CollectPadsClipFunction_WithClosures

A convenience synonym for Nothing :: Maybe CollectPadsClipFunction_WithClosures.

wrap_CollectPadsClipFunction :: Maybe (Ptr (FunPtr C_CollectPadsClipFunction)) -> CollectPadsClipFunction_WithClosures -> C_CollectPadsClipFunction

Wrap a CollectPadsClipFunction into a C_CollectPadsClipFunction.

CollectPadsCompareFunction

type C_CollectPadsCompareFunction = Ptr CollectPads -> Ptr CollectData -> Word64 -> Ptr CollectData -> Word64 -> Ptr () -> IO Int32

Type for the callback on the (unwrapped) C side.

type CollectPadsCompareFunction

Arguments

 = CollectPads

pads: the CollectPads that is comparing the timestamps

-> CollectData

data1: the first CollectData

-> Word64

timestamp1: the first timestamp

-> CollectData

data2: the second CollectData

-> Word64

timestamp2: the second timestamp

-> 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

Arguments

 = CollectPads

pads: the CollectPads that is comparing the timestamps

-> CollectData

data1: the first CollectData

-> Word64

timestamp1: the first timestamp

-> CollectData

data2: the second CollectData

-> Word64

timestamp2: the second timestamp

-> Ptr ()

userData: user data passed to collectPadsSetCompareFunction

-> 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

A simple wrapper that ignores the closure arguments.

dynamic_CollectPadsCompareFunction

Arguments

:: (HasCallStack, MonadIO m, IsCollectPads a)

=> FunPtr C_CollectPadsCompareFunction

-> a

pads: the CollectPads that is comparing the timestamps

-> CollectData

data1: the first CollectData

-> Word64

timestamp1: the first timestamp

-> CollectData

data2: the second CollectData

-> Word64

timestamp2: the second timestamp

-> Ptr ()

userData: user data passed to collectPadsSetCompareFunction

-> 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)

Wrap the callback into a GClosure.

mk_CollectPadsCompareFunction :: C_CollectPadsCompareFunction -> IO (FunPtr C_CollectPadsCompareFunction)

Generate a function pointer callable from C code, from a C_CollectPadsCompareFunction.

noCollectPadsCompareFunction :: Maybe CollectPadsCompareFunction

A convenience synonym for Nothing :: Maybe CollectPadsCompareFunction.

noCollectPadsCompareFunction_WithClosures :: Maybe CollectPadsCompareFunction_WithClosures

A convenience synonym for Nothing :: Maybe CollectPadsCompareFunction_WithClosures.

wrap_CollectPadsCompareFunction :: Maybe (Ptr (FunPtr C_CollectPadsCompareFunction)) -> CollectPadsCompareFunction_WithClosures -> C_CollectPadsCompareFunction

Wrap a CollectPadsCompareFunction into a C_CollectPadsCompareFunction.

CollectPadsEventFunction

type C_CollectPadsEventFunction = Ptr CollectPads -> Ptr CollectData -> Ptr Event -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type CollectPadsEventFunction

Arguments

 = CollectPads

pads: the CollectPads that triggered the callback

-> CollectData

pad: the Pad that received an event

-> Event

event: the Event received

-> IO Bool

Returns: True if the pad could handle the event

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

Arguments

 = CollectPads

pads: the CollectPads that triggered the callback

-> CollectData

pad: the Pad that received an event

-> Event

event: the Event received

-> Ptr ()

userData: user data passed to collectPadsSetEventFunction

-> IO Bool

Returns: True if the pad could handle the event

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

A simple wrapper that ignores the closure arguments.

dynamic_CollectPadsEventFunction

Arguments

:: (HasCallStack, MonadIO m, IsCollectPads a)

=> FunPtr C_CollectPadsEventFunction

-> a

pads: the CollectPads that triggered the callback

-> CollectData

pad: the Pad that received an event

-> Event

event: the Event received

-> Ptr ()

userData: user data passed to collectPadsSetEventFunction

-> m Bool

Returns: True if the pad could handle the event

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)

Wrap the callback into a GClosure.

mk_CollectPadsEventFunction :: C_CollectPadsEventFunction -> IO (FunPtr C_CollectPadsEventFunction)

Generate a function pointer callable from C code, from a C_CollectPadsEventFunction.

noCollectPadsEventFunction :: Maybe CollectPadsEventFunction

A convenience synonym for Nothing :: Maybe CollectPadsEventFunction.

noCollectPadsEventFunction_WithClosures :: Maybe CollectPadsEventFunction_WithClosures

A convenience synonym for Nothing :: Maybe CollectPadsEventFunction_WithClosures.

wrap_CollectPadsEventFunction :: Maybe (Ptr (FunPtr C_CollectPadsEventFunction)) -> CollectPadsEventFunction_WithClosures -> C_CollectPadsEventFunction

Wrap a CollectPadsEventFunction into a C_CollectPadsEventFunction.

CollectPadsFlushFunction

type C_CollectPadsFlushFunction = Ptr CollectPads -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type CollectPadsFlushFunction

Arguments

 = CollectPads

pads: a 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

Arguments

 = CollectPads

pads: a CollectPads

-> Ptr ()

userData: user data

-> 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

A simple wrapper that ignores the closure arguments.

dynamic_CollectPadsFlushFunction

Arguments

:: (HasCallStack, MonadIO m, IsCollectPads a)

=> FunPtr C_CollectPadsFlushFunction

-> a

pads: a CollectPads

-> Ptr ()

userData: user data

-> 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)

Wrap the callback into a GClosure.

mk_CollectPadsFlushFunction :: C_CollectPadsFlushFunction -> IO (FunPtr C_CollectPadsFlushFunction)

Generate a function pointer callable from C code, from a C_CollectPadsFlushFunction.

noCollectPadsFlushFunction :: Maybe CollectPadsFlushFunction

A convenience synonym for Nothing :: Maybe CollectPadsFlushFunction.

noCollectPadsFlushFunction_WithClosures :: Maybe CollectPadsFlushFunction_WithClosures

A convenience synonym for Nothing :: Maybe CollectPadsFlushFunction_WithClosures.

wrap_CollectPadsFlushFunction :: Maybe (Ptr (FunPtr C_CollectPadsFlushFunction)) -> CollectPadsFlushFunction_WithClosures -> C_CollectPadsFlushFunction

Wrap a CollectPadsFlushFunction into a C_CollectPadsFlushFunction.

CollectPadsFunction

type C_CollectPadsFunction = Ptr CollectPads -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type CollectPadsFunction

Arguments

 = CollectPads

pads: the CollectPads that triggered the callback

-> IO FlowReturn

Returns: FlowReturnOk for success

A function that will be called when all pads have received data.

type CollectPadsFunction_WithClosures

Arguments

 = CollectPads

pads: the CollectPads that triggered the callback

-> Ptr ()

userData: user data passed to collectPadsSetFunction

-> IO FlowReturn

Returns: FlowReturnOk for success

A function that will be called when all pads have received data.

drop_closures_CollectPadsFunction :: CollectPadsFunction -> CollectPadsFunction_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_CollectPadsFunction

Arguments

:: (HasCallStack, MonadIO m, IsCollectPads a)

=> FunPtr C_CollectPadsFunction

-> a

pads: the CollectPads that triggered the callback

-> Ptr ()

userData: user data passed to collectPadsSetFunction

-> m FlowReturn

Returns: FlowReturnOk for success

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)

Wrap the callback into a GClosure.

mk_CollectPadsFunction :: C_CollectPadsFunction -> IO (FunPtr C_CollectPadsFunction)

Generate a function pointer callable from C code, from a C_CollectPadsFunction.

noCollectPadsFunction :: Maybe CollectPadsFunction

A convenience synonym for Nothing :: Maybe CollectPadsFunction.

noCollectPadsFunction_WithClosures :: Maybe CollectPadsFunction_WithClosures

A convenience synonym for Nothing :: Maybe CollectPadsFunction_WithClosures.

wrap_CollectPadsFunction :: Maybe (Ptr (FunPtr C_CollectPadsFunction)) -> CollectPadsFunction_WithClosures -> C_CollectPadsFunction

Wrap a CollectPadsFunction into a C_CollectPadsFunction.

CollectPadsQueryFunction

type C_CollectPadsQueryFunction = Ptr CollectPads -> Ptr CollectData -> Ptr Query -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type CollectPadsQueryFunction

Arguments

 = CollectPads

pads: the CollectPads that triggered the callback

-> CollectData

pad: the Pad that received an event

-> Query

query: the Event received

-> IO Bool

Returns: True if the pad could handle the event

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

Arguments

 = CollectPads

pads: the CollectPads that triggered the callback

-> CollectData

pad: the Pad that received an event

-> Query

query: the Event received

-> Ptr ()

userData: user data passed to collectPadsSetQueryFunction

-> IO Bool

Returns: True if the pad could handle the event

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

A simple wrapper that ignores the closure arguments.

dynamic_CollectPadsQueryFunction

Arguments

:: (HasCallStack, MonadIO m, IsCollectPads a)

=> FunPtr C_CollectPadsQueryFunction

-> a

pads: the CollectPads that triggered the callback

-> CollectData

pad: the Pad that received an event

-> Query

query: the Event received

-> Ptr ()

userData: user data passed to collectPadsSetQueryFunction

-> m Bool

Returns: True if the pad could handle the event

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)

Wrap the callback into a GClosure.

mk_CollectPadsQueryFunction :: C_CollectPadsQueryFunction -> IO (FunPtr C_CollectPadsQueryFunction)

Generate a function pointer callable from C code, from a C_CollectPadsQueryFunction.

noCollectPadsQueryFunction :: Maybe CollectPadsQueryFunction

A convenience synonym for Nothing :: Maybe CollectPadsQueryFunction.

noCollectPadsQueryFunction_WithClosures :: Maybe CollectPadsQueryFunction_WithClosures

A convenience synonym for Nothing :: Maybe CollectPadsQueryFunction_WithClosures.

wrap_CollectPadsQueryFunction :: Maybe (Ptr (FunPtr C_CollectPadsQueryFunction)) -> CollectPadsQueryFunction_WithClosures -> C_CollectPadsQueryFunction

Wrap a CollectPadsQueryFunction into a C_CollectPadsQueryFunction.

DataQueueEmptyCallback

type C_DataQueueEmptyCallback = Ptr DataQueue -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type DataQueueEmptyCallback = DataQueue -> Ptr () -> IO ()

No description available in the introspection data.

dynamic_DataQueueEmptyCallback :: (HasCallStack, MonadIO m, IsDataQueue a) => FunPtr C_DataQueueEmptyCallback -> a -> Ptr () -> m ()

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)

Wrap the callback into a GClosure.

mk_DataQueueEmptyCallback :: C_DataQueueEmptyCallback -> IO (FunPtr C_DataQueueEmptyCallback)

Generate a function pointer callable from C code, from a C_DataQueueEmptyCallback.

noDataQueueEmptyCallback :: Maybe DataQueueEmptyCallback

A convenience synonym for Nothing :: Maybe DataQueueEmptyCallback.

wrap_DataQueueEmptyCallback :: Maybe (Ptr (FunPtr C_DataQueueEmptyCallback)) -> DataQueueEmptyCallback -> C_DataQueueEmptyCallback

Wrap a DataQueueEmptyCallback into a C_DataQueueEmptyCallback.

DataQueueFullCallback

type C_DataQueueFullCallback = Ptr DataQueue -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type DataQueueFullCallback = DataQueue -> Ptr () -> IO ()

No description available in the introspection data.

dynamic_DataQueueFullCallback :: (HasCallStack, MonadIO m, IsDataQueue a) => FunPtr C_DataQueueFullCallback -> a -> Ptr () -> m ()

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)

Wrap the callback into a GClosure.

mk_DataQueueFullCallback :: C_DataQueueFullCallback -> IO (FunPtr C_DataQueueFullCallback)

Generate a function pointer callable from C code, from a C_DataQueueFullCallback.

noDataQueueFullCallback :: Maybe DataQueueFullCallback

A convenience synonym for Nothing :: Maybe DataQueueFullCallback.

wrap_DataQueueFullCallback :: Maybe (Ptr (FunPtr C_DataQueueFullCallback)) -> DataQueueFullCallback -> C_DataQueueFullCallback

Wrap a DataQueueFullCallback into a C_DataQueueFullCallback.

TypeFindHelperGetRangeFunction

type C_TypeFindHelperGetRangeFunction = Ptr Object -> Ptr Object -> Word64 -> Word32 -> Ptr (Ptr Buffer) -> IO CInt

Type for the callback on the (unwrapped) C side.

type TypeFindHelperGetRangeFunction

Arguments

 = Object

obj: a Object that will handle the getrange request

-> Maybe Object

parent: the parent of obj or Nothing

-> Word64

offset: the offset of the range

-> Word32

length: the length of the range

-> 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

Arguments

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

=> FunPtr C_TypeFindHelperGetRangeFunction

-> a

obj: a Object that will handle the getrange request

-> Maybe b

parent: the parent of obj or Nothing

-> Word64

offset: the offset of the range

-> Word32

length: the length of the range

-> 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)

Wrap the callback into a GClosure.

mk_TypeFindHelperGetRangeFunction :: C_TypeFindHelperGetRangeFunction -> IO (FunPtr C_TypeFindHelperGetRangeFunction)

Generate a function pointer callable from C code, from a C_TypeFindHelperGetRangeFunction.

noTypeFindHelperGetRangeFunction :: Maybe TypeFindHelperGetRangeFunction

A convenience synonym for Nothing :: Maybe TypeFindHelperGetRangeFunction.

wrap_TypeFindHelperGetRangeFunction :: Maybe (Ptr (FunPtr C_TypeFindHelperGetRangeFunction)) -> TypeFindHelperGetRangeFunction -> C_TypeFindHelperGetRangeFunction

Wrap a TypeFindHelperGetRangeFunction into a C_TypeFindHelperGetRangeFunction.