GI.Gst.Callbacks

Signals

BufferForeachMetaFunc

type BufferForeachMetaFunc

Arguments

 = Buffer

buffer: a Buffer

-> IO (Bool, Maybe Meta)

Returns: False when bufferForeachMeta should stop

A function that will be called from bufferForeachMeta. The meta field will point to a the reference of the meta.

buffer should not be modified from this callback.

When this function returns True, the next meta will be returned. When False is returned, bufferForeachMeta will return.

When meta is set to Nothing, the item will be removed from the buffer.

type BufferForeachMetaFunc_WithClosures

Arguments

 = Buffer

buffer: a Buffer

-> Ptr ()

userData: user data passed to bufferForeachMeta

-> IO (Bool, Maybe Meta)

Returns: False when bufferForeachMeta should stop

A function that will be called from bufferForeachMeta. The meta field will point to a the reference of the meta.

buffer should not be modified from this callback.

When this function returns True, the next meta will be returned. When False is returned, bufferForeachMeta will return.

When meta is set to Nothing, the item will be removed from the buffer.

type C_BufferForeachMetaFunc = Ptr Buffer -> Ptr (Ptr Meta) -> Ptr () -> IO CInt

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

drop_closures_BufferForeachMetaFunc :: BufferForeachMetaFunc -> BufferForeachMetaFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_BufferForeachMetaFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_BufferForeachMetaFunc

-> Buffer

buffer: a Buffer

-> Ptr ()

userData: user data passed to bufferForeachMeta

-> m (Bool, Maybe Meta)

Returns: False when bufferForeachMeta should stop

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BufferForeachMetaFunc :: MonadIO m => BufferForeachMetaFunc -> m (GClosure C_BufferForeachMetaFunc)

Wrap the callback into a GClosure.

mk_BufferForeachMetaFunc :: C_BufferForeachMetaFunc -> IO (FunPtr C_BufferForeachMetaFunc)

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

noBufferForeachMetaFunc :: Maybe BufferForeachMetaFunc

A convenience synonym for Nothing :: Maybe BufferForeachMetaFunc.

noBufferForeachMetaFunc_WithClosures :: Maybe BufferForeachMetaFunc_WithClosures

A convenience synonym for Nothing :: Maybe BufferForeachMetaFunc_WithClosures.

wrap_BufferForeachMetaFunc :: Maybe (Ptr (FunPtr C_BufferForeachMetaFunc)) -> BufferForeachMetaFunc_WithClosures -> C_BufferForeachMetaFunc

Wrap a BufferForeachMetaFunc into a C_BufferForeachMetaFunc.

BufferListFunc

type BufferListFunc

Arguments

 = Word32

idx: the index of buffer

-> IO (Bool, Maybe Buffer)

Returns: False when bufferListForeach should stop

A function that will be called from bufferListForeach. The buffer field will point to a the reference of the buffer at idx.

When this function returns True, the next buffer will be returned. When False is returned, bufferListForeach will return.

When buffer is set to Nothing, the item will be removed from the bufferlist. When buffer has been made writable, the new buffer reference can be assigned to buffer. This function is responsible for unreffing the old buffer when removing or modifying.

type BufferListFunc_WithClosures

Arguments

 = Word32

idx: the index of buffer

-> Ptr ()

userData: user data passed to bufferListForeach

-> IO (Bool, Maybe Buffer)

Returns: False when bufferListForeach should stop

A function that will be called from bufferListForeach. The buffer field will point to a the reference of the buffer at idx.

When this function returns True, the next buffer will be returned. When False is returned, bufferListForeach will return.

When buffer is set to Nothing, the item will be removed from the bufferlist. When buffer has been made writable, the new buffer reference can be assigned to buffer. This function is responsible for unreffing the old buffer when removing or modifying.

type C_BufferListFunc = Ptr (Ptr Buffer) -> Word32 -> Ptr () -> IO CInt

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

drop_closures_BufferListFunc :: BufferListFunc -> BufferListFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_BufferListFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_BufferListFunc

-> Word32

idx: the index of buffer

-> Ptr ()

userData: user data passed to bufferListForeach

-> m (Bool, Maybe Buffer)

Returns: False when bufferListForeach should stop

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BufferListFunc :: MonadIO m => BufferListFunc -> m (GClosure C_BufferListFunc)

Wrap the callback into a GClosure.

mk_BufferListFunc :: C_BufferListFunc -> IO (FunPtr C_BufferListFunc)

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

noBufferListFunc :: Maybe BufferListFunc

A convenience synonym for Nothing :: Maybe BufferListFunc.

noBufferListFunc_WithClosures :: Maybe BufferListFunc_WithClosures

A convenience synonym for Nothing :: Maybe BufferListFunc_WithClosures.

wrap_BufferListFunc :: Maybe (Ptr (FunPtr C_BufferListFunc)) -> BufferListFunc_WithClosures -> C_BufferListFunc

Wrap a BufferListFunc into a C_BufferListFunc.

BusFunc

type BusFunc

Arguments

 = Bus

bus: the Bus that sent the message

-> Message

message: the Message

-> IO Bool

Returns: False if the event source should be removed.

Specifies the type of function passed to gst_bus_add_watch() or busAddWatch, which is called from the mainloop when a message is available on the bus.

The message passed to the function will be unreffed after execution of this function so it should not be freed in the function.

Note that this function is used as a GSourceFunc which means that returning False will remove the GSource from the mainloop.

type BusFunc_WithClosures

Arguments

 = Bus

bus: the Bus that sent the message

-> Message

message: the Message

-> Ptr ()

userData: user data that has been given, when registering the handler

-> IO Bool

Returns: False if the event source should be removed.

Specifies the type of function passed to gst_bus_add_watch() or busAddWatch, which is called from the mainloop when a message is available on the bus.

The message passed to the function will be unreffed after execution of this function so it should not be freed in the function.

Note that this function is used as a GSourceFunc which means that returning False will remove the GSource from the mainloop.

type C_BusFunc = Ptr Bus -> Ptr Message -> Ptr () -> IO CInt

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

drop_closures_BusFunc :: BusFunc -> BusFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_BusFunc

Arguments

:: (HasCallStack, MonadIO m, IsBus a)

=> FunPtr C_BusFunc

-> a

bus: the Bus that sent the message

-> Message

message: the Message

-> Ptr ()

userData: user data that has been given, when registering the handler

-> m Bool

Returns: False if the event source should be removed.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BusFunc :: MonadIO m => BusFunc -> m (GClosure C_BusFunc)

Wrap the callback into a GClosure.

mk_BusFunc :: C_BusFunc -> IO (FunPtr C_BusFunc)

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

noBusFunc :: Maybe BusFunc

A convenience synonym for Nothing :: Maybe BusFunc.

noBusFunc_WithClosures :: Maybe BusFunc_WithClosures

A convenience synonym for Nothing :: Maybe BusFunc_WithClosures.

wrap_BusFunc :: Maybe (Ptr (FunPtr C_BusFunc)) -> BusFunc_WithClosures -> C_BusFunc

Wrap a BusFunc into a C_BusFunc.

BusSyncHandler

type BusSyncHandler

Arguments

 = Bus

bus: the Bus that sent the message

-> Message

message: the Message

-> IO BusSyncReply

Returns: BusSyncReply stating what to do with the message

Handler will be invoked synchronously, when a new message has been injected into the bus. This function is mostly used internally. Only one sync handler can be attached to a given bus.

If the handler returns GST_BUS_DROP, it should unref the message, else the message should not be unreffed by the sync handler.

type BusSyncHandler_WithClosures

Arguments

 = Bus

bus: the Bus that sent the message

-> Message

message: the Message

-> Ptr ()

userData: user data that has been given, when registering the handler

-> IO BusSyncReply

Returns: BusSyncReply stating what to do with the message

Handler will be invoked synchronously, when a new message has been injected into the bus. This function is mostly used internally. Only one sync handler can be attached to a given bus.

If the handler returns GST_BUS_DROP, it should unref the message, else the message should not be unreffed by the sync handler.

type C_BusSyncHandler = Ptr Bus -> Ptr Message -> Ptr () -> IO CUInt

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

drop_closures_BusSyncHandler :: BusSyncHandler -> BusSyncHandler_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_BusSyncHandler

Arguments

:: (HasCallStack, MonadIO m, IsBus a)

=> FunPtr C_BusSyncHandler

-> a

bus: the Bus that sent the message

-> Message

message: the Message

-> Ptr ()

userData: user data that has been given, when registering the handler

-> m BusSyncReply

Returns: BusSyncReply stating what to do with the message

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BusSyncHandler :: MonadIO m => BusSyncHandler -> m (GClosure C_BusSyncHandler)

Wrap the callback into a GClosure.

mk_BusSyncHandler :: C_BusSyncHandler -> IO (FunPtr C_BusSyncHandler)

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

noBusSyncHandler :: Maybe BusSyncHandler

A convenience synonym for Nothing :: Maybe BusSyncHandler.

noBusSyncHandler_WithClosures :: Maybe BusSyncHandler_WithClosures

A convenience synonym for Nothing :: Maybe BusSyncHandler_WithClosures.

wrap_BusSyncHandler :: Maybe (Ptr (FunPtr C_BusSyncHandler)) -> BusSyncHandler_WithClosures -> C_BusSyncHandler

Wrap a BusSyncHandler into a C_BusSyncHandler.

CapsFilterMapFunc

type C_CapsFilterMapFunc = Ptr CapsFeatures -> Ptr Structure -> Ptr () -> IO CInt

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

type CapsFilterMapFunc

Arguments

 = CapsFeatures

features: the CapsFeatures

-> Structure

structure: the Structure

-> IO Bool

Returns: True if the features and structure should be preserved, False if it should be removed.

A function that will be called in capsFilterAndMapInPlace. The function may modify features and structure, and both will be removed from the caps if False is returned.

type CapsFilterMapFunc_WithClosures

Arguments

 = CapsFeatures

features: the CapsFeatures

-> Structure

structure: the Structure

-> Ptr ()

userData: user data

-> IO Bool

Returns: True if the features and structure should be preserved, False if it should be removed.

A function that will be called in capsFilterAndMapInPlace. The function may modify features and structure, and both will be removed from the caps if False is returned.

drop_closures_CapsFilterMapFunc :: CapsFilterMapFunc -> CapsFilterMapFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_CapsFilterMapFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_CapsFilterMapFunc

-> CapsFeatures

features: the CapsFeatures

-> Structure

structure: the Structure

-> Ptr ()

userData: user data

-> m Bool

Returns: True if the features and structure should be preserved, False if it should be removed.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_CapsFilterMapFunc :: MonadIO m => CapsFilterMapFunc -> m (GClosure C_CapsFilterMapFunc)

Wrap the callback into a GClosure.

mk_CapsFilterMapFunc :: C_CapsFilterMapFunc -> IO (FunPtr C_CapsFilterMapFunc)

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

noCapsFilterMapFunc :: Maybe CapsFilterMapFunc

A convenience synonym for Nothing :: Maybe CapsFilterMapFunc.

noCapsFilterMapFunc_WithClosures :: Maybe CapsFilterMapFunc_WithClosures

A convenience synonym for Nothing :: Maybe CapsFilterMapFunc_WithClosures.

wrap_CapsFilterMapFunc :: Maybe (Ptr (FunPtr C_CapsFilterMapFunc)) -> CapsFilterMapFunc_WithClosures -> C_CapsFilterMapFunc

Wrap a CapsFilterMapFunc into a C_CapsFilterMapFunc.

CapsForeachFunc

type C_CapsForeachFunc = Ptr CapsFeatures -> Ptr Structure -> Ptr () -> IO CInt

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

type CapsForeachFunc

Arguments

 = CapsFeatures

features: the CapsFeatures

-> Structure

structure: the Structure

-> IO Bool

Returns: True if the foreach operation should continue, False if the foreach operation should stop with False.

A function that will be called in capsForeach. The function may not modify features or structure.

Since: 1.6

type CapsForeachFunc_WithClosures

Arguments

 = CapsFeatures

features: the CapsFeatures

-> Structure

structure: the Structure

-> Ptr ()

userData: user data

-> IO Bool

Returns: True if the foreach operation should continue, False if the foreach operation should stop with False.

A function that will be called in capsForeach. The function may not modify features or structure.

Since: 1.6

drop_closures_CapsForeachFunc :: CapsForeachFunc -> CapsForeachFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_CapsForeachFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_CapsForeachFunc

-> CapsFeatures

features: the CapsFeatures

-> Structure

structure: the Structure

-> Ptr ()

userData: user data

-> m Bool

Returns: True if the foreach operation should continue, False if the foreach operation should stop with False.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_CapsForeachFunc :: MonadIO m => CapsForeachFunc -> m (GClosure C_CapsForeachFunc)

Wrap the callback into a GClosure.

mk_CapsForeachFunc :: C_CapsForeachFunc -> IO (FunPtr C_CapsForeachFunc)

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

noCapsForeachFunc :: Maybe CapsForeachFunc

A convenience synonym for Nothing :: Maybe CapsForeachFunc.

noCapsForeachFunc_WithClosures :: Maybe CapsForeachFunc_WithClosures

A convenience synonym for Nothing :: Maybe CapsForeachFunc_WithClosures.

wrap_CapsForeachFunc :: Maybe (Ptr (FunPtr C_CapsForeachFunc)) -> CapsForeachFunc_WithClosures -> C_CapsForeachFunc

Wrap a CapsForeachFunc into a C_CapsForeachFunc.

CapsMapFunc

type C_CapsMapFunc = Ptr CapsFeatures -> Ptr Structure -> Ptr () -> IO CInt

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

type CapsMapFunc

Arguments

 = CapsFeatures

features: the CapsFeatures

-> Structure

structure: the Structure

-> IO Bool

Returns: True if the map operation should continue, False if the map operation should stop with False.

A function that will be called in capsMapInPlace. The function may modify features and structure.

type CapsMapFunc_WithClosures

Arguments

 = CapsFeatures

features: the CapsFeatures

-> Structure

structure: the Structure

-> Ptr ()

userData: user data

-> IO Bool

Returns: True if the map operation should continue, False if the map operation should stop with False.

A function that will be called in capsMapInPlace. The function may modify features and structure.

drop_closures_CapsMapFunc :: CapsMapFunc -> CapsMapFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_CapsMapFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_CapsMapFunc

-> CapsFeatures

features: the CapsFeatures

-> Structure

structure: the Structure

-> Ptr ()

userData: user data

-> m Bool

Returns: True if the map operation should continue, False if the map operation should stop with False.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_CapsMapFunc :: MonadIO m => CapsMapFunc -> m (GClosure C_CapsMapFunc)

Wrap the callback into a GClosure.

mk_CapsMapFunc :: C_CapsMapFunc -> IO (FunPtr C_CapsMapFunc)

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

noCapsMapFunc :: Maybe CapsMapFunc

A convenience synonym for Nothing :: Maybe CapsMapFunc.

noCapsMapFunc_WithClosures :: Maybe CapsMapFunc_WithClosures

A convenience synonym for Nothing :: Maybe CapsMapFunc_WithClosures.

wrap_CapsMapFunc :: Maybe (Ptr (FunPtr C_CapsMapFunc)) -> CapsMapFunc_WithClosures -> C_CapsMapFunc

Wrap a CapsMapFunc into a C_CapsMapFunc.

ClockCallback

type C_ClockCallback = Ptr Clock -> Word64 -> Ptr () -> Ptr () -> IO CInt

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

type ClockCallback

Arguments

 = Clock

clock: The clock that triggered the callback

-> Word64

time: The time it was triggered

-> Ptr ()

id: The GstClockID that expired

-> IO Bool

Returns: True or False (currently unused)

The function prototype of the callback.

type ClockCallback_WithClosures

Arguments

 = Clock

clock: The clock that triggered the callback

-> Word64

time: The time it was triggered

-> Ptr ()

id: The GstClockID that expired

-> Ptr ()

userData: user data passed in the clockIdWaitAsync function

-> IO Bool

Returns: True or False (currently unused)

The function prototype of the callback.

drop_closures_ClockCallback :: ClockCallback -> ClockCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ClockCallback

Arguments

:: (HasCallStack, MonadIO m, IsClock a)

=> FunPtr C_ClockCallback

-> a

clock: The clock that triggered the callback

-> Word64

time: The time it was triggered

-> Ptr ()

id: The GstClockID that expired

-> Ptr ()

userData: user data passed in the clockIdWaitAsync function

-> m Bool

Returns: True or False (currently unused)

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ClockCallback :: MonadIO m => ClockCallback -> m (GClosure C_ClockCallback)

Wrap the callback into a GClosure.

mk_ClockCallback :: C_ClockCallback -> IO (FunPtr C_ClockCallback)

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

noClockCallback :: Maybe ClockCallback

A convenience synonym for Nothing :: Maybe ClockCallback.

noClockCallback_WithClosures :: Maybe ClockCallback_WithClosures

A convenience synonym for Nothing :: Maybe ClockCallback_WithClosures.

wrap_ClockCallback :: Maybe (Ptr (FunPtr C_ClockCallback)) -> ClockCallback_WithClosures -> C_ClockCallback

Wrap a ClockCallback into a C_ClockCallback.

ControlBindingConvert

type C_ControlBindingConvert = Ptr ControlBinding -> CDouble -> Ptr GValue -> IO ()

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

type ControlBindingConvert = ControlBinding -> Double -> GValue -> IO ()

No description available in the introspection data.

dynamic_ControlBindingConvert :: (HasCallStack, MonadIO m, IsControlBinding a) => FunPtr C_ControlBindingConvert -> a -> Double -> GValue -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ControlBindingConvert :: MonadIO m => ControlBindingConvert -> m (GClosure C_ControlBindingConvert)

Wrap the callback into a GClosure.

mk_ControlBindingConvert :: C_ControlBindingConvert -> IO (FunPtr C_ControlBindingConvert)

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

noControlBindingConvert :: Maybe ControlBindingConvert

A convenience synonym for Nothing :: Maybe ControlBindingConvert.

wrap_ControlBindingConvert :: Maybe (Ptr (FunPtr C_ControlBindingConvert)) -> ControlBindingConvert -> C_ControlBindingConvert

Wrap a ControlBindingConvert into a C_ControlBindingConvert.

ControlSourceGetValue

type C_ControlSourceGetValue = Ptr ControlSource -> Word64 -> CDouble -> IO CInt

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

type ControlSourceGetValue

Arguments

 = ControlSource

self: the ControlSource instance

-> Word64

timestamp: timestamp for which a value should be calculated

-> Double

value: a value which will be set to the result.

-> IO Bool

Returns: True if the value was successfully calculated.

Function for returning a value for a given timestamp.

dynamic_ControlSourceGetValue

Arguments

:: (HasCallStack, MonadIO m, IsControlSource a)

=> FunPtr C_ControlSourceGetValue

-> a

self: the ControlSource instance

-> Word64

timestamp: timestamp for which a value should be calculated

-> Double

value: a value which will be set to the result.

-> m Bool

Returns: True if the value was successfully calculated.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ControlSourceGetValue :: MonadIO m => ControlSourceGetValue -> m (GClosure C_ControlSourceGetValue)

Wrap the callback into a GClosure.

mk_ControlSourceGetValue :: C_ControlSourceGetValue -> IO (FunPtr C_ControlSourceGetValue)

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

noControlSourceGetValue :: Maybe ControlSourceGetValue

A convenience synonym for Nothing :: Maybe ControlSourceGetValue.

wrap_ControlSourceGetValue :: Maybe (Ptr (FunPtr C_ControlSourceGetValue)) -> ControlSourceGetValue -> C_ControlSourceGetValue

Wrap a ControlSourceGetValue into a C_ControlSourceGetValue.

ControlSourceGetValueArray

type C_ControlSourceGetValueArray = Ptr ControlSource -> Word64 -> Word64 -> Word32 -> CDouble -> IO CInt

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

type ControlSourceGetValueArray

Arguments

 = ControlSource

self: the ControlSource instance

-> Word64

timestamp: timestamp for which a value should be calculated

-> Word64

interval: the time spacing between subsequent values

-> Word32

nValues: the number of values

-> Double

values: array to put control-values in

-> IO Bool

Returns: True if the values were successfully calculated.

Function for returning an array of values for starting at a given timestamp.

dynamic_ControlSourceGetValueArray

Arguments

:: (HasCallStack, MonadIO m, IsControlSource a)

=> FunPtr C_ControlSourceGetValueArray

-> a

self: the ControlSource instance

-> Word64

timestamp: timestamp for which a value should be calculated

-> Word64

interval: the time spacing between subsequent values

-> Word32

nValues: the number of values

-> Double

values: array to put control-values in

-> m Bool

Returns: True if the values were successfully calculated.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ControlSourceGetValueArray :: MonadIO m => ControlSourceGetValueArray -> m (GClosure C_ControlSourceGetValueArray)

Wrap the callback into a GClosure.

mk_ControlSourceGetValueArray :: C_ControlSourceGetValueArray -> IO (FunPtr C_ControlSourceGetValueArray)

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

noControlSourceGetValueArray :: Maybe ControlSourceGetValueArray

A convenience synonym for Nothing :: Maybe ControlSourceGetValueArray.

wrap_ControlSourceGetValueArray :: Maybe (Ptr (FunPtr C_ControlSourceGetValueArray)) -> ControlSourceGetValueArray -> C_ControlSourceGetValueArray

Wrap a ControlSourceGetValueArray into a C_ControlSourceGetValueArray.

DebugFuncPtr

type C_DebugFuncPtr = IO ()

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

type DebugFuncPtr = IO ()

No description available in the introspection data.

dynamic_DebugFuncPtr :: (HasCallStack, MonadIO m) => FunPtr C_DebugFuncPtr -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_DebugFuncPtr :: MonadIO m => DebugFuncPtr -> m (GClosure C_DebugFuncPtr)

Wrap the callback into a GClosure.

mk_DebugFuncPtr :: C_DebugFuncPtr -> IO (FunPtr C_DebugFuncPtr)

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

noDebugFuncPtr :: Maybe DebugFuncPtr

A convenience synonym for Nothing :: Maybe DebugFuncPtr.

wrap_DebugFuncPtr :: Maybe (Ptr (FunPtr C_DebugFuncPtr)) -> DebugFuncPtr -> C_DebugFuncPtr

Wrap a DebugFuncPtr into a C_DebugFuncPtr.

ElementCallAsyncFunc

type C_ElementCallAsyncFunc = Ptr Element -> Ptr () -> IO ()

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

type ElementCallAsyncFunc = Element -> IO ()

No description available in the introspection data.

type ElementCallAsyncFunc_WithClosures = Element -> Ptr () -> IO ()

No description available in the introspection data.

drop_closures_ElementCallAsyncFunc :: ElementCallAsyncFunc -> ElementCallAsyncFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ElementCallAsyncFunc :: (HasCallStack, MonadIO m, IsElement a) => FunPtr C_ElementCallAsyncFunc -> a -> Ptr () -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ElementCallAsyncFunc :: MonadIO m => ElementCallAsyncFunc -> m (GClosure C_ElementCallAsyncFunc)

Wrap the callback into a GClosure.

mk_ElementCallAsyncFunc :: C_ElementCallAsyncFunc -> IO (FunPtr C_ElementCallAsyncFunc)

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

noElementCallAsyncFunc :: Maybe ElementCallAsyncFunc

A convenience synonym for Nothing :: Maybe ElementCallAsyncFunc.

noElementCallAsyncFunc_WithClosures :: Maybe ElementCallAsyncFunc_WithClosures

A convenience synonym for Nothing :: Maybe ElementCallAsyncFunc_WithClosures.

wrap_ElementCallAsyncFunc :: Maybe (Ptr (FunPtr C_ElementCallAsyncFunc)) -> ElementCallAsyncFunc_WithClosures -> C_ElementCallAsyncFunc

Wrap a ElementCallAsyncFunc into a C_ElementCallAsyncFunc.

ElementForeachPadFunc

type C_ElementForeachPadFunc = Ptr Element -> Ptr Pad -> Ptr () -> IO CInt

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

type ElementForeachPadFunc

Arguments

 = Element

element: the Element

-> Pad

pad: a Pad

-> IO Bool

Returns: False to stop iterating pads, True to continue

Function called for each pad when using elementForeachSinkPad, elementForeachSrcPad, or elementForeachPad.

Since: 1.14

type ElementForeachPadFunc_WithClosures

Arguments

 = Element

element: the Element

-> Pad

pad: a Pad

-> Ptr ()

userData: user data passed to the foreach function

-> IO Bool

Returns: False to stop iterating pads, True to continue

Function called for each pad when using elementForeachSinkPad, elementForeachSrcPad, or elementForeachPad.

Since: 1.14

drop_closures_ElementForeachPadFunc :: ElementForeachPadFunc -> ElementForeachPadFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ElementForeachPadFunc

Arguments

:: (HasCallStack, MonadIO m, IsElement a, IsPad b)

=> FunPtr C_ElementForeachPadFunc

-> a

element: the Element

-> b

pad: a Pad

-> Ptr ()

userData: user data passed to the foreach function

-> m Bool

Returns: False to stop iterating pads, True to continue

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ElementForeachPadFunc :: MonadIO m => ElementForeachPadFunc -> m (GClosure C_ElementForeachPadFunc)

Wrap the callback into a GClosure.

mk_ElementForeachPadFunc :: C_ElementForeachPadFunc -> IO (FunPtr C_ElementForeachPadFunc)

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

noElementForeachPadFunc :: Maybe ElementForeachPadFunc

A convenience synonym for Nothing :: Maybe ElementForeachPadFunc.

noElementForeachPadFunc_WithClosures :: Maybe ElementForeachPadFunc_WithClosures

A convenience synonym for Nothing :: Maybe ElementForeachPadFunc_WithClosures.

wrap_ElementForeachPadFunc :: Maybe (Ptr (FunPtr C_ElementForeachPadFunc)) -> ElementForeachPadFunc_WithClosures -> C_ElementForeachPadFunc

Wrap a ElementForeachPadFunc into a C_ElementForeachPadFunc.

IteratorCopyFunction

type C_IteratorCopyFunction = Ptr Iterator -> Ptr Iterator -> IO ()

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

type IteratorCopyFunction

Arguments

 = Iterator

it: The original iterator

-> Iterator

copy: The copied iterator

-> IO ()

This function will be called when creating a copy of it and should create a copy of all custom iterator fields or increase their reference counts.

dynamic_IteratorCopyFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IteratorCopyFunction

-> Iterator

it: The original iterator

-> Iterator

copy: The copied iterator

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_IteratorCopyFunction :: MonadIO m => IteratorCopyFunction -> m (GClosure C_IteratorCopyFunction)

Wrap the callback into a GClosure.

mk_IteratorCopyFunction :: C_IteratorCopyFunction -> IO (FunPtr C_IteratorCopyFunction)

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

noIteratorCopyFunction :: Maybe IteratorCopyFunction

A convenience synonym for Nothing :: Maybe IteratorCopyFunction.

wrap_IteratorCopyFunction :: Maybe (Ptr (FunPtr C_IteratorCopyFunction)) -> IteratorCopyFunction -> C_IteratorCopyFunction

Wrap a IteratorCopyFunction into a C_IteratorCopyFunction.

IteratorFoldFunction

type C_IteratorFoldFunction = Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt

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

type IteratorFoldFunction

Arguments

 = GValue

item: the item to fold

-> GValue

ret: a Value collecting the result

-> IO Bool

Returns: True if the fold should continue, False if it should stop.

A function to be passed to iteratorFold.

type IteratorFoldFunction_WithClosures

Arguments

 = GValue

item: the item to fold

-> GValue

ret: a Value collecting the result

-> Ptr ()

userData: data passed to iteratorFold

-> IO Bool

Returns: True if the fold should continue, False if it should stop.

A function to be passed to iteratorFold.

drop_closures_IteratorFoldFunction :: IteratorFoldFunction -> IteratorFoldFunction_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_IteratorFoldFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IteratorFoldFunction

-> GValue

item: the item to fold

-> GValue

ret: a Value collecting the result

-> Ptr ()

userData: data passed to iteratorFold

-> m Bool

Returns: True if the fold should continue, False if it should stop.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_IteratorFoldFunction :: MonadIO m => IteratorFoldFunction -> m (GClosure C_IteratorFoldFunction)

Wrap the callback into a GClosure.

mk_IteratorFoldFunction :: C_IteratorFoldFunction -> IO (FunPtr C_IteratorFoldFunction)

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

noIteratorFoldFunction :: Maybe IteratorFoldFunction

A convenience synonym for Nothing :: Maybe IteratorFoldFunction.

noIteratorFoldFunction_WithClosures :: Maybe IteratorFoldFunction_WithClosures

A convenience synonym for Nothing :: Maybe IteratorFoldFunction_WithClosures.

wrap_IteratorFoldFunction :: Maybe (Ptr (FunPtr C_IteratorFoldFunction)) -> IteratorFoldFunction_WithClosures -> C_IteratorFoldFunction

Wrap a IteratorFoldFunction into a C_IteratorFoldFunction.

IteratorForeachFunction

type C_IteratorForeachFunction = Ptr GValue -> Ptr () -> IO ()

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

type IteratorForeachFunction

Arguments

 = GValue

item: The item

-> IO ()

A function that is called by iteratorForeach for every element.

type IteratorForeachFunction_WithClosures

Arguments

 = GValue

item: The item

-> Ptr ()

userData: User data

-> IO ()

A function that is called by iteratorForeach for every element.

drop_closures_IteratorForeachFunction :: IteratorForeachFunction -> IteratorForeachFunction_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_IteratorForeachFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IteratorForeachFunction

-> GValue

item: The item

-> Ptr ()

userData: User data

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_IteratorForeachFunction :: MonadIO m => IteratorForeachFunction -> m (GClosure C_IteratorForeachFunction)

Wrap the callback into a GClosure.

mk_IteratorForeachFunction :: C_IteratorForeachFunction -> IO (FunPtr C_IteratorForeachFunction)

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

noIteratorForeachFunction :: Maybe IteratorForeachFunction

A convenience synonym for Nothing :: Maybe IteratorForeachFunction.

noIteratorForeachFunction_WithClosures :: Maybe IteratorForeachFunction_WithClosures

A convenience synonym for Nothing :: Maybe IteratorForeachFunction_WithClosures.

wrap_IteratorForeachFunction :: Maybe (Ptr (FunPtr C_IteratorForeachFunction)) -> IteratorForeachFunction_WithClosures -> C_IteratorForeachFunction

Wrap a IteratorForeachFunction into a C_IteratorForeachFunction.

IteratorFreeFunction

type C_IteratorFreeFunction = Ptr Iterator -> IO ()

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

type IteratorFreeFunction

Arguments

 = Iterator

it: the iterator

-> IO ()

This function will be called when the iterator is freed.

Implementors of a Iterator should implement this function and pass it to the constructor of the custom iterator. The function will be called with the iterator lock held.

dynamic_IteratorFreeFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IteratorFreeFunction

-> Iterator

it: the iterator

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_IteratorFreeFunction :: MonadIO m => IteratorFreeFunction -> m (GClosure C_IteratorFreeFunction)

Wrap the callback into a GClosure.

mk_IteratorFreeFunction :: C_IteratorFreeFunction -> IO (FunPtr C_IteratorFreeFunction)

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

noIteratorFreeFunction :: Maybe IteratorFreeFunction

A convenience synonym for Nothing :: Maybe IteratorFreeFunction.

wrap_IteratorFreeFunction :: Maybe (Ptr (FunPtr C_IteratorFreeFunction)) -> IteratorFreeFunction -> C_IteratorFreeFunction

Wrap a IteratorFreeFunction into a C_IteratorFreeFunction.

IteratorItemFunction

type C_IteratorItemFunction = Ptr Iterator -> Ptr GValue -> IO CUInt

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

type IteratorItemFunction

Arguments

 = Iterator

it: the iterator

-> GValue

item: the item being retrieved.

-> IO IteratorItem

Returns: the result of the operation.

The function that will be called after the next item of the iterator has been retrieved. This function can be used to skip items or stop the iterator.

The function will be called with the iterator lock held.

dynamic_IteratorItemFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IteratorItemFunction

-> Iterator

it: the iterator

-> GValue

item: the item being retrieved.

-> m IteratorItem

Returns: the result of the operation.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_IteratorItemFunction :: MonadIO m => IteratorItemFunction -> m (GClosure C_IteratorItemFunction)

Wrap the callback into a GClosure.

mk_IteratorItemFunction :: C_IteratorItemFunction -> IO (FunPtr C_IteratorItemFunction)

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

noIteratorItemFunction :: Maybe IteratorItemFunction

A convenience synonym for Nothing :: Maybe IteratorItemFunction.

wrap_IteratorItemFunction :: Maybe (Ptr (FunPtr C_IteratorItemFunction)) -> IteratorItemFunction -> C_IteratorItemFunction

Wrap a IteratorItemFunction into a C_IteratorItemFunction.

IteratorNextFunction

type C_IteratorNextFunction = Ptr Iterator -> Ptr GValue -> IO CUInt

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

type IteratorNextFunction

Arguments

 = Iterator

it: the iterator

-> GValue

result: a pointer to hold the next item

-> IO IteratorResult

Returns: the result of the operation.

The function that will be called when the next element of the iterator should be retrieved.

Implementors of a Iterator should implement this function and pass it to the constructor of the custom iterator. The function will be called with the iterator lock held.

dynamic_IteratorNextFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IteratorNextFunction

-> Iterator

it: the iterator

-> GValue

result: a pointer to hold the next item

-> m IteratorResult

Returns: the result of the operation.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_IteratorNextFunction :: MonadIO m => IteratorNextFunction -> m (GClosure C_IteratorNextFunction)

Wrap the callback into a GClosure.

mk_IteratorNextFunction :: C_IteratorNextFunction -> IO (FunPtr C_IteratorNextFunction)

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

noIteratorNextFunction :: Maybe IteratorNextFunction

A convenience synonym for Nothing :: Maybe IteratorNextFunction.

wrap_IteratorNextFunction :: Maybe (Ptr (FunPtr C_IteratorNextFunction)) -> IteratorNextFunction -> C_IteratorNextFunction

Wrap a IteratorNextFunction into a C_IteratorNextFunction.

IteratorResyncFunction

type C_IteratorResyncFunction = Ptr Iterator -> IO ()

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

type IteratorResyncFunction

Arguments

 = Iterator

it: the iterator

-> IO ()

This function will be called whenever a concurrent update happened to the iterated datastructure. The implementor of the iterator should restart the iterator from the beginning and clean up any state it might have.

Implementors of a Iterator should implement this function and pass it to the constructor of the custom iterator. The function will be called with the iterator lock held.

dynamic_IteratorResyncFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IteratorResyncFunction

-> Iterator

it: the iterator

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_IteratorResyncFunction :: MonadIO m => IteratorResyncFunction -> m (GClosure C_IteratorResyncFunction)

Wrap the callback into a GClosure.

mk_IteratorResyncFunction :: C_IteratorResyncFunction -> IO (FunPtr C_IteratorResyncFunction)

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

noIteratorResyncFunction :: Maybe IteratorResyncFunction

A convenience synonym for Nothing :: Maybe IteratorResyncFunction.

wrap_IteratorResyncFunction :: Maybe (Ptr (FunPtr C_IteratorResyncFunction)) -> IteratorResyncFunction -> C_IteratorResyncFunction

Wrap a IteratorResyncFunction into a C_IteratorResyncFunction.

LogFunction

type C_LogFunction = Ptr DebugCategory -> CUInt -> CString -> CString -> Int32 -> Ptr Object -> Ptr DebugMessage -> Ptr () -> IO ()

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

type LogFunction

Arguments

 = DebugCategory

category: a DebugCategory

-> DebugLevel

level: a DebugLevel

-> Text

file: file name

-> Text

function: function name

-> Int32

line: line number

-> Object

object: a Object

-> DebugMessage

message: the message

-> IO ()

Function prototype for a logging function that can be registered with debugAddLogFunction. Use G_GNUC_NO_INSTRUMENT on that function.

type LogFunction_WithClosures

Arguments

 = DebugCategory

category: a DebugCategory

-> DebugLevel

level: a DebugLevel

-> Text

file: file name

-> Text

function: function name

-> Int32

line: line number

-> Object

object: a Object

-> DebugMessage

message: the message

-> Ptr ()

userData: user data for the log function

-> IO ()

Function prototype for a logging function that can be registered with debugAddLogFunction. Use G_GNUC_NO_INSTRUMENT on that function.

drop_closures_LogFunction :: LogFunction -> LogFunction_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_LogFunction

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_LogFunction

-> DebugCategory

category: a DebugCategory

-> DebugLevel

level: a DebugLevel

-> Text

file: file name

-> Text

function: function name

-> Int32

line: line number

-> a

object: a Object

-> DebugMessage

message: the message

-> Ptr ()

userData: user data for the log function

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_LogFunction :: MonadIO m => LogFunction -> m (GClosure C_LogFunction)

Wrap the callback into a GClosure.

mk_LogFunction :: C_LogFunction -> IO (FunPtr C_LogFunction)

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

noLogFunction :: Maybe LogFunction

A convenience synonym for Nothing :: Maybe LogFunction.

noLogFunction_WithClosures :: Maybe LogFunction_WithClosures

A convenience synonym for Nothing :: Maybe LogFunction_WithClosures.

wrap_LogFunction :: Maybe (Ptr (FunPtr C_LogFunction)) -> LogFunction_WithClosures -> C_LogFunction

Wrap a LogFunction into a C_LogFunction.

MemoryCopyFunction

type C_MemoryCopyFunction = Ptr Memory -> Int64 -> Int64 -> IO (Ptr Memory)

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

type MemoryCopyFunction

Arguments

 = Memory

mem: a Memory

-> Int64

offset: an offset

-> Int64

size: a size or -1

-> IO Memory

Returns: a new Memory object wrapping a copy of the requested region in mem.

Copy size bytes from mem starting at offset and return them wrapped in a new GstMemory object. If size is set to -1, all bytes starting at offset are copied.

dynamic_MemoryCopyFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MemoryCopyFunction

-> Memory

mem: a Memory

-> Int64

offset: an offset

-> Int64

size: a size or -1

-> m Memory

Returns: a new Memory object wrapping a copy of the requested region in mem.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MemoryCopyFunction :: MonadIO m => MemoryCopyFunction -> m (GClosure C_MemoryCopyFunction)

Wrap the callback into a GClosure.

mk_MemoryCopyFunction :: C_MemoryCopyFunction -> IO (FunPtr C_MemoryCopyFunction)

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

noMemoryCopyFunction :: Maybe MemoryCopyFunction

A convenience synonym for Nothing :: Maybe MemoryCopyFunction.

wrap_MemoryCopyFunction :: Maybe (Ptr (FunPtr C_MemoryCopyFunction)) -> MemoryCopyFunction -> C_MemoryCopyFunction

Wrap a MemoryCopyFunction into a C_MemoryCopyFunction.

MemoryIsSpanFunction

type C_MemoryIsSpanFunction = Ptr Memory -> Ptr Memory -> Word64 -> IO CInt

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

type MemoryIsSpanFunction

Arguments

 = Memory

mem1: a Memory

-> Memory

mem2: a Memory

-> Word64

offset: a result offset

-> IO Bool

Returns: True if mem1 and mem2 are in contiguous memory.

Check if mem1 and mem2 occupy contiguous memory and return the offset of mem1 in the parent buffer in offset.

dynamic_MemoryIsSpanFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MemoryIsSpanFunction

-> Memory

mem1: a Memory

-> Memory

mem2: a Memory

-> Word64

offset: a result offset

-> m Bool

Returns: True if mem1 and mem2 are in contiguous memory.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MemoryIsSpanFunction :: MonadIO m => MemoryIsSpanFunction -> m (GClosure C_MemoryIsSpanFunction)

Wrap the callback into a GClosure.

mk_MemoryIsSpanFunction :: C_MemoryIsSpanFunction -> IO (FunPtr C_MemoryIsSpanFunction)

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

noMemoryIsSpanFunction :: Maybe MemoryIsSpanFunction

A convenience synonym for Nothing :: Maybe MemoryIsSpanFunction.

wrap_MemoryIsSpanFunction :: Maybe (Ptr (FunPtr C_MemoryIsSpanFunction)) -> MemoryIsSpanFunction -> C_MemoryIsSpanFunction

Wrap a MemoryIsSpanFunction into a C_MemoryIsSpanFunction.

MemoryMapFullFunction

type C_MemoryMapFullFunction = Ptr Memory -> Ptr MapInfo -> Word64 -> IO (Ptr ())

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

type MemoryMapFullFunction

Arguments

 = Memory

mem: a Memory

-> MapInfo

info: the MapInfo to map with

-> Word64

maxsize: size to map

-> IO (Ptr ())

Returns: a pointer to memory of which at least maxsize bytes can be accessed according to the access pattern in info's flags.

Get the memory of mem that can be accessed according to the mode specified in info's flags. The function should return a pointer that contains at least maxsize bytes.

dynamic_MemoryMapFullFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MemoryMapFullFunction

-> Memory

mem: a Memory

-> MapInfo

info: the MapInfo to map with

-> Word64

maxsize: size to map

-> m (Ptr ())

Returns: a pointer to memory of which at least maxsize bytes can be accessed according to the access pattern in info's flags.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MemoryMapFullFunction :: MonadIO m => MemoryMapFullFunction -> m (GClosure C_MemoryMapFullFunction)

Wrap the callback into a GClosure.

mk_MemoryMapFullFunction :: C_MemoryMapFullFunction -> IO (FunPtr C_MemoryMapFullFunction)

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

noMemoryMapFullFunction :: Maybe MemoryMapFullFunction

A convenience synonym for Nothing :: Maybe MemoryMapFullFunction.

wrap_MemoryMapFullFunction :: Maybe (Ptr (FunPtr C_MemoryMapFullFunction)) -> MemoryMapFullFunction -> C_MemoryMapFullFunction

Wrap a MemoryMapFullFunction into a C_MemoryMapFullFunction.

MemoryMapFunction

type C_MemoryMapFunction = Ptr Memory -> Word64 -> CUInt -> IO (Ptr ())

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

type MemoryMapFunction

Arguments

 = Memory

mem: a Memory

-> Word64

maxsize: size to map

-> [MapFlags]

flags: access mode for the memory

-> IO (Ptr ())

Returns: a pointer to memory of which at least maxsize bytes can be accessed according to the access pattern in flags.

Get the memory of mem that can be accessed according to the mode specified in flags. The function should return a pointer that contains at least maxsize bytes.

dynamic_MemoryMapFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MemoryMapFunction

-> Memory

mem: a Memory

-> Word64

maxsize: size to map

-> [MapFlags]

flags: access mode for the memory

-> m (Ptr ())

Returns: a pointer to memory of which at least maxsize bytes can be accessed according to the access pattern in flags.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MemoryMapFunction :: MonadIO m => MemoryMapFunction -> m (GClosure C_MemoryMapFunction)

Wrap the callback into a GClosure.

mk_MemoryMapFunction :: C_MemoryMapFunction -> IO (FunPtr C_MemoryMapFunction)

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

noMemoryMapFunction :: Maybe MemoryMapFunction

A convenience synonym for Nothing :: Maybe MemoryMapFunction.

wrap_MemoryMapFunction :: Maybe (Ptr (FunPtr C_MemoryMapFunction)) -> MemoryMapFunction -> C_MemoryMapFunction

Wrap a MemoryMapFunction into a C_MemoryMapFunction.

MemoryShareFunction

type C_MemoryShareFunction = Ptr Memory -> Int64 -> Int64 -> IO (Ptr Memory)

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

type MemoryShareFunction

Arguments

 = Memory

mem: a Memory

-> Int64

offset: an offset

-> Int64

size: a size or -1

-> IO Memory

Returns: a new Memory object sharing the requested region in mem.

Share size bytes from mem starting at offset and return them wrapped in a new GstMemory object. If size is set to -1, all bytes starting at offset are shared. This function does not make a copy of the bytes in mem.

dynamic_MemoryShareFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MemoryShareFunction

-> Memory

mem: a Memory

-> Int64

offset: an offset

-> Int64

size: a size or -1

-> m Memory

Returns: a new Memory object sharing the requested region in mem.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MemoryShareFunction :: MonadIO m => MemoryShareFunction -> m (GClosure C_MemoryShareFunction)

Wrap the callback into a GClosure.

mk_MemoryShareFunction :: C_MemoryShareFunction -> IO (FunPtr C_MemoryShareFunction)

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

noMemoryShareFunction :: Maybe MemoryShareFunction

A convenience synonym for Nothing :: Maybe MemoryShareFunction.

wrap_MemoryShareFunction :: Maybe (Ptr (FunPtr C_MemoryShareFunction)) -> MemoryShareFunction -> C_MemoryShareFunction

Wrap a MemoryShareFunction into a C_MemoryShareFunction.

MemoryUnmapFullFunction

type C_MemoryUnmapFullFunction = Ptr Memory -> Ptr MapInfo -> IO ()

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

type MemoryUnmapFullFunction

Arguments

 = Memory

mem: a Memory

-> MapInfo

info: a MapInfo

-> IO ()

Return the pointer previously retrieved with memoryMap with info.

dynamic_MemoryUnmapFullFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MemoryUnmapFullFunction

-> Memory

mem: a Memory

-> MapInfo

info: a MapInfo

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MemoryUnmapFullFunction :: MonadIO m => MemoryUnmapFullFunction -> m (GClosure C_MemoryUnmapFullFunction)

Wrap the callback into a GClosure.

mk_MemoryUnmapFullFunction :: C_MemoryUnmapFullFunction -> IO (FunPtr C_MemoryUnmapFullFunction)

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

noMemoryUnmapFullFunction :: Maybe MemoryUnmapFullFunction

A convenience synonym for Nothing :: Maybe MemoryUnmapFullFunction.

wrap_MemoryUnmapFullFunction :: Maybe (Ptr (FunPtr C_MemoryUnmapFullFunction)) -> MemoryUnmapFullFunction -> C_MemoryUnmapFullFunction

Wrap a MemoryUnmapFullFunction into a C_MemoryUnmapFullFunction.

MemoryUnmapFunction

type C_MemoryUnmapFunction = Ptr Memory -> IO ()

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

type MemoryUnmapFunction

Arguments

 = Memory

mem: a Memory

-> IO ()

Return the pointer previously retrieved with memoryMap.

dynamic_MemoryUnmapFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MemoryUnmapFunction

-> Memory

mem: a Memory

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MemoryUnmapFunction :: MonadIO m => MemoryUnmapFunction -> m (GClosure C_MemoryUnmapFunction)

Wrap the callback into a GClosure.

mk_MemoryUnmapFunction :: C_MemoryUnmapFunction -> IO (FunPtr C_MemoryUnmapFunction)

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

noMemoryUnmapFunction :: Maybe MemoryUnmapFunction

A convenience synonym for Nothing :: Maybe MemoryUnmapFunction.

wrap_MemoryUnmapFunction :: Maybe (Ptr (FunPtr C_MemoryUnmapFunction)) -> MemoryUnmapFunction -> C_MemoryUnmapFunction

Wrap a MemoryUnmapFunction into a C_MemoryUnmapFunction.

MetaFreeFunction

type C_MetaFreeFunction = Ptr Meta -> Ptr Buffer -> IO ()

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

type MetaFreeFunction

Arguments

 = Meta

meta: a Meta

-> Buffer

buffer: a Buffer

-> IO ()

Function called when meta is freed in buffer.

dynamic_MetaFreeFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MetaFreeFunction

-> Meta

meta: a Meta

-> Buffer

buffer: a Buffer

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MetaFreeFunction :: MonadIO m => MetaFreeFunction -> m (GClosure C_MetaFreeFunction)

Wrap the callback into a GClosure.

mk_MetaFreeFunction :: C_MetaFreeFunction -> IO (FunPtr C_MetaFreeFunction)

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

noMetaFreeFunction :: Maybe MetaFreeFunction

A convenience synonym for Nothing :: Maybe MetaFreeFunction.

wrap_MetaFreeFunction :: Maybe (Ptr (FunPtr C_MetaFreeFunction)) -> MetaFreeFunction -> C_MetaFreeFunction

Wrap a MetaFreeFunction into a C_MetaFreeFunction.

MetaInitFunction

type C_MetaInitFunction = Ptr Meta -> Ptr () -> Ptr Buffer -> IO CInt

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

type MetaInitFunction

Arguments

 = Meta

meta: a Meta

-> Ptr ()

params: parameters passed to the init function

-> Buffer

buffer: a Buffer

-> IO Bool

Function called when meta is initialized in buffer.

dynamic_MetaInitFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MetaInitFunction

-> Meta

meta: a Meta

-> Ptr ()

params: parameters passed to the init function

-> Buffer

buffer: a Buffer

-> m Bool

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MetaInitFunction :: MonadIO m => MetaInitFunction -> m (GClosure C_MetaInitFunction)

Wrap the callback into a GClosure.

mk_MetaInitFunction :: C_MetaInitFunction -> IO (FunPtr C_MetaInitFunction)

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

noMetaInitFunction :: Maybe MetaInitFunction

A convenience synonym for Nothing :: Maybe MetaInitFunction.

wrap_MetaInitFunction :: Maybe (Ptr (FunPtr C_MetaInitFunction)) -> MetaInitFunction -> C_MetaInitFunction

Wrap a MetaInitFunction into a C_MetaInitFunction.

MetaTransformFunction

type C_MetaTransformFunction = Ptr Buffer -> Ptr Meta -> Ptr Buffer -> Word32 -> Ptr () -> IO CInt

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

type MetaTransformFunction

Arguments

 = Buffer

transbuf: a Buffer

-> Meta

meta: a Meta

-> Buffer

buffer: a Buffer

-> Word32

type: the transform type

-> Ptr ()

data: transform specific data.

-> IO Bool

Returns: True if the transform could be performed

Function called for each meta in buffer as a result of performing a transformation on transbuf. Additional type specific transform data is passed to the function as data.

Implementations should check the type of the transform and parse additional type specific fields in data that should be used to update the metadata on transbuf.

dynamic_MetaTransformFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MetaTransformFunction

-> Buffer

transbuf: a Buffer

-> Meta

meta: a Meta

-> Buffer

buffer: a Buffer

-> Word32

type: the transform type

-> Ptr ()

data: transform specific data.

-> m Bool

Returns: True if the transform could be performed

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MetaTransformFunction :: MonadIO m => MetaTransformFunction -> m (GClosure C_MetaTransformFunction)

Wrap the callback into a GClosure.

mk_MetaTransformFunction :: C_MetaTransformFunction -> IO (FunPtr C_MetaTransformFunction)

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

noMetaTransformFunction :: Maybe MetaTransformFunction

A convenience synonym for Nothing :: Maybe MetaTransformFunction.

wrap_MetaTransformFunction :: Maybe (Ptr (FunPtr C_MetaTransformFunction)) -> MetaTransformFunction -> C_MetaTransformFunction

Wrap a MetaTransformFunction into a C_MetaTransformFunction.

MiniObjectDisposeFunction

type C_MiniObjectDisposeFunction = Ptr MiniObject -> IO CInt

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

type MiniObjectDisposeFunction

Arguments

 = MiniObject

obj: MiniObject to dispose

-> IO Bool

Returns: True if the object should be cleaned up.

Function prototype for when a miniobject has lost its last refcount. Implementation of the mini object are allowed to revive the passed object by doing a gst_mini_object_ref(). If the object is not revived after the dispose function, the function should return True and the memory associated with the object is freed.

dynamic_MiniObjectDisposeFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MiniObjectDisposeFunction

-> MiniObject

obj: MiniObject to dispose

-> m Bool

Returns: True if the object should be cleaned up.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MiniObjectDisposeFunction :: MonadIO m => MiniObjectDisposeFunction -> m (GClosure C_MiniObjectDisposeFunction)

Wrap the callback into a GClosure.

mk_MiniObjectDisposeFunction :: C_MiniObjectDisposeFunction -> IO (FunPtr C_MiniObjectDisposeFunction)

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

noMiniObjectDisposeFunction :: Maybe MiniObjectDisposeFunction

A convenience synonym for Nothing :: Maybe MiniObjectDisposeFunction.

wrap_MiniObjectDisposeFunction :: Maybe (Ptr (FunPtr C_MiniObjectDisposeFunction)) -> MiniObjectDisposeFunction -> C_MiniObjectDisposeFunction

Wrap a MiniObjectDisposeFunction into a C_MiniObjectDisposeFunction.

MiniObjectFreeFunction

type C_MiniObjectFreeFunction = Ptr MiniObject -> IO ()

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

type MiniObjectFreeFunction

Arguments

 = MiniObject

obj: MiniObject to free

-> IO ()

Virtual function prototype for methods to free resources used by mini-objects.

dynamic_MiniObjectFreeFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MiniObjectFreeFunction

-> MiniObject

obj: MiniObject to free

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MiniObjectFreeFunction :: MonadIO m => MiniObjectFreeFunction -> m (GClosure C_MiniObjectFreeFunction)

Wrap the callback into a GClosure.

mk_MiniObjectFreeFunction :: C_MiniObjectFreeFunction -> IO (FunPtr C_MiniObjectFreeFunction)

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

noMiniObjectFreeFunction :: Maybe MiniObjectFreeFunction

A convenience synonym for Nothing :: Maybe MiniObjectFreeFunction.

wrap_MiniObjectFreeFunction :: Maybe (Ptr (FunPtr C_MiniObjectFreeFunction)) -> MiniObjectFreeFunction -> C_MiniObjectFreeFunction

Wrap a MiniObjectFreeFunction into a C_MiniObjectFreeFunction.

MiniObjectNotify

type C_MiniObjectNotify = Ptr () -> Ptr MiniObject -> IO ()

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

type MiniObjectNotify

Arguments

 = MiniObject

obj: the mini object

-> IO ()

A MiniObjectNotify function can be added to a mini object as a callback that gets triggered when gst_mini_object_unref() drops the last ref and obj is about to be freed.

type MiniObjectNotify_WithClosures

Arguments

 = Ptr ()

userData: data that was provided when the notify was added

-> MiniObject

obj: the mini object

-> IO ()

A MiniObjectNotify function can be added to a mini object as a callback that gets triggered when gst_mini_object_unref() drops the last ref and obj is about to be freed.

drop_closures_MiniObjectNotify :: MiniObjectNotify -> MiniObjectNotify_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_MiniObjectNotify

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MiniObjectNotify

-> Ptr ()

userData: data that was provided when the notify was added

-> MiniObject

obj: the mini object

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MiniObjectNotify :: MonadIO m => MiniObjectNotify -> m (GClosure C_MiniObjectNotify)

Wrap the callback into a GClosure.

mk_MiniObjectNotify :: C_MiniObjectNotify -> IO (FunPtr C_MiniObjectNotify)

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

noMiniObjectNotify :: Maybe MiniObjectNotify

A convenience synonym for Nothing :: Maybe MiniObjectNotify.

noMiniObjectNotify_WithClosures :: Maybe MiniObjectNotify_WithClosures

A convenience synonym for Nothing :: Maybe MiniObjectNotify_WithClosures.

wrap_MiniObjectNotify :: Maybe (Ptr (FunPtr C_MiniObjectNotify)) -> MiniObjectNotify_WithClosures -> C_MiniObjectNotify

Wrap a MiniObjectNotify into a C_MiniObjectNotify.

PadActivateFunction

type C_PadActivateFunction = Ptr Pad -> Ptr Object -> IO CInt

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

type PadActivateFunction

Arguments

 = Pad

pad: a Pad

-> Object

parent: the parent of pad

-> IO Bool

Returns: True if the pad could be activated.

This function is called when the pad is activated during the element READY to PAUSED state change. By default this function will call the activate function that puts the pad in push mode but elements can override this function to activate the pad in pull mode if they wish.

dynamic_PadActivateFunction

Arguments

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

=> FunPtr C_PadActivateFunction

-> a

pad: a Pad

-> b

parent: the parent of pad

-> m Bool

Returns: True if the pad could be activated.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PadActivateFunction :: MonadIO m => PadActivateFunction -> m (GClosure C_PadActivateFunction)

Wrap the callback into a GClosure.

mk_PadActivateFunction :: C_PadActivateFunction -> IO (FunPtr C_PadActivateFunction)

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

noPadActivateFunction :: Maybe PadActivateFunction

A convenience synonym for Nothing :: Maybe PadActivateFunction.

wrap_PadActivateFunction :: Maybe (Ptr (FunPtr C_PadActivateFunction)) -> PadActivateFunction -> C_PadActivateFunction

Wrap a PadActivateFunction into a C_PadActivateFunction.

PadActivateModeFunction

type C_PadActivateModeFunction = Ptr Pad -> Ptr Object -> CUInt -> CInt -> IO CInt

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

type PadActivateModeFunction

Arguments

 = Pad

pad: a Pad

-> Object

parent: the parent of pad

-> PadMode

mode: the requested activation mode of pad

-> Bool

active: activate or deactivate the pad.

-> IO Bool

Returns: True if the pad could be activated or deactivated.

The prototype of the push and pull activate functions.

dynamic_PadActivateModeFunction

Arguments

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

=> FunPtr C_PadActivateModeFunction

-> a

pad: a Pad

-> b

parent: the parent of pad

-> PadMode

mode: the requested activation mode of pad

-> Bool

active: activate or deactivate the pad.

-> m Bool

Returns: True if the pad could be activated or deactivated.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PadActivateModeFunction :: MonadIO m => PadActivateModeFunction -> m (GClosure C_PadActivateModeFunction)

Wrap the callback into a GClosure.

mk_PadActivateModeFunction :: C_PadActivateModeFunction -> IO (FunPtr C_PadActivateModeFunction)

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

noPadActivateModeFunction :: Maybe PadActivateModeFunction

A convenience synonym for Nothing :: Maybe PadActivateModeFunction.

wrap_PadActivateModeFunction :: Maybe (Ptr (FunPtr C_PadActivateModeFunction)) -> PadActivateModeFunction -> C_PadActivateModeFunction

Wrap a PadActivateModeFunction into a C_PadActivateModeFunction.

PadChainFunction

type C_PadChainFunction = Ptr Pad -> Ptr Object -> Ptr Buffer -> IO CInt

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

type PadChainFunction

Arguments

 = Pad

pad: the sink Pad that performed the chain.

-> Maybe Object

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> Buffer

buffer: the Buffer that is chained, not Nothing.

-> IO FlowReturn

Returns: GST_FLOW_OK for success

A function that will be called on sinkpads when chaining buffers. The function typically processes the data contained in the buffer and either consumes the data or passes it on to the internally linked pad(s).

The implementer of this function receives a refcount to buffer and should gst_buffer_unref() when the buffer is no longer needed.

When a chain function detects an error in the data stream, it must post an error on the bus and return an appropriate FlowReturn value.

dynamic_PadChainFunction

Arguments

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

=> FunPtr C_PadChainFunction

-> a

pad: the sink Pad that performed the chain.

-> Maybe b

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> Buffer

buffer: the Buffer that is chained, not Nothing.

-> m FlowReturn

Returns: GST_FLOW_OK for success

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PadChainFunction :: MonadIO m => PadChainFunction -> m (GClosure C_PadChainFunction)

Wrap the callback into a GClosure.

mk_PadChainFunction :: C_PadChainFunction -> IO (FunPtr C_PadChainFunction)

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

noPadChainFunction :: Maybe PadChainFunction

A convenience synonym for Nothing :: Maybe PadChainFunction.

wrap_PadChainFunction :: Maybe (Ptr (FunPtr C_PadChainFunction)) -> PadChainFunction -> C_PadChainFunction

Wrap a PadChainFunction into a C_PadChainFunction.

PadChainListFunction

type C_PadChainListFunction = Ptr Pad -> Ptr Object -> Ptr BufferList -> IO CInt

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

type PadChainListFunction

Arguments

 = Pad

pad: the sink Pad that performed the chain.

-> Maybe Object

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> BufferList

list: the BufferList that is chained, not Nothing.

-> IO FlowReturn

Returns: GST_FLOW_OK for success

A function that will be called on sinkpads when chaining buffer lists. The function typically processes the data contained in the buffer list and either consumes the data or passes it on to the internally linked pad(s).

The implementer of this function receives a refcount to list and should gst_buffer_list_unref() when the list is no longer needed.

When a chainlist function detects an error in the data stream, it must post an error on the bus and return an appropriate FlowReturn value.

dynamic_PadChainListFunction

Arguments

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

=> FunPtr C_PadChainListFunction

-> a

pad: the sink Pad that performed the chain.

-> Maybe b

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> BufferList

list: the BufferList that is chained, not Nothing.

-> m FlowReturn

Returns: GST_FLOW_OK for success

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PadChainListFunction :: MonadIO m => PadChainListFunction -> m (GClosure C_PadChainListFunction)

Wrap the callback into a GClosure.

mk_PadChainListFunction :: C_PadChainListFunction -> IO (FunPtr C_PadChainListFunction)

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

noPadChainListFunction :: Maybe PadChainListFunction

A convenience synonym for Nothing :: Maybe PadChainListFunction.

wrap_PadChainListFunction :: Maybe (Ptr (FunPtr C_PadChainListFunction)) -> PadChainListFunction -> C_PadChainListFunction

Wrap a PadChainListFunction into a C_PadChainListFunction.

PadEventFullFunction

type C_PadEventFullFunction = Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt

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

type PadEventFullFunction

Arguments

 = Pad

pad: the Pad to handle the event.

-> Maybe Object

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> Event

event: the Event to handle.

-> IO FlowReturn

Returns: FlowReturnOk if the event was handled properly, or any other FlowReturn dependent on downstream state.

Function signature to handle an event for the pad.

This variant is for specific elements that will take into account the last downstream flow return (from a pad push), in which case they can return it.

Since: 1.8

dynamic_PadEventFullFunction

Arguments

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

=> FunPtr C_PadEventFullFunction

-> a

pad: the Pad to handle the event.

-> Maybe b

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> Event

event: the Event to handle.

-> m FlowReturn

Returns: FlowReturnOk if the event was handled properly, or any other FlowReturn dependent on downstream state.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PadEventFullFunction :: MonadIO m => PadEventFullFunction -> m (GClosure C_PadEventFullFunction)

Wrap the callback into a GClosure.

mk_PadEventFullFunction :: C_PadEventFullFunction -> IO (FunPtr C_PadEventFullFunction)

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

noPadEventFullFunction :: Maybe PadEventFullFunction

A convenience synonym for Nothing :: Maybe PadEventFullFunction.

wrap_PadEventFullFunction :: Maybe (Ptr (FunPtr C_PadEventFullFunction)) -> PadEventFullFunction -> C_PadEventFullFunction

Wrap a PadEventFullFunction into a C_PadEventFullFunction.

PadEventFunction

type C_PadEventFunction = Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt

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

type PadEventFunction

Arguments

 = Pad

pad: the Pad to handle the event.

-> Maybe Object

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> Event

event: the Event to handle.

-> IO Bool

Returns: True if the pad could handle the event.

Function signature to handle an event for the pad.

dynamic_PadEventFunction

Arguments

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

=> FunPtr C_PadEventFunction

-> a

pad: the Pad to handle the event.

-> Maybe b

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> Event

event: the Event to handle.

-> 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_PadEventFunction :: MonadIO m => PadEventFunction -> m (GClosure C_PadEventFunction)

Wrap the callback into a GClosure.

mk_PadEventFunction :: C_PadEventFunction -> IO (FunPtr C_PadEventFunction)

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

noPadEventFunction :: Maybe PadEventFunction

A convenience synonym for Nothing :: Maybe PadEventFunction.

wrap_PadEventFunction :: Maybe (Ptr (FunPtr C_PadEventFunction)) -> PadEventFunction -> C_PadEventFunction

Wrap a PadEventFunction into a C_PadEventFunction.

PadForwardFunction

type C_PadForwardFunction = Ptr Pad -> Ptr () -> IO CInt

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

type PadForwardFunction

Arguments

 = Pad

pad: the Pad that is forwarded.

-> IO Bool

Returns: True if the dispatching procedure has to be stopped.

A forward function is called for all internally linked pads, see padForward.

type PadForwardFunction_WithClosures

Arguments

 = Pad

pad: the Pad that is forwarded.

-> Ptr ()

userData: the gpointer to optional user data.

-> IO Bool

Returns: True if the dispatching procedure has to be stopped.

A forward function is called for all internally linked pads, see padForward.

drop_closures_PadForwardFunction :: PadForwardFunction -> PadForwardFunction_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_PadForwardFunction

Arguments

:: (HasCallStack, MonadIO m, IsPad a)

=> FunPtr C_PadForwardFunction

-> a

pad: the Pad that is forwarded.

-> Ptr ()

userData: the gpointer to optional user data.

-> m Bool

Returns: True if the dispatching procedure has to be stopped.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PadForwardFunction :: MonadIO m => PadForwardFunction -> m (GClosure C_PadForwardFunction)

Wrap the callback into a GClosure.

mk_PadForwardFunction :: C_PadForwardFunction -> IO (FunPtr C_PadForwardFunction)

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

noPadForwardFunction :: Maybe PadForwardFunction

A convenience synonym for Nothing :: Maybe PadForwardFunction.

noPadForwardFunction_WithClosures :: Maybe PadForwardFunction_WithClosures

A convenience synonym for Nothing :: Maybe PadForwardFunction_WithClosures.

wrap_PadForwardFunction :: Maybe (Ptr (FunPtr C_PadForwardFunction)) -> PadForwardFunction_WithClosures -> C_PadForwardFunction

Wrap a PadForwardFunction into a C_PadForwardFunction.

PadGetRangeFunction

type C_PadGetRangeFunction = Ptr Pad -> Ptr Object -> Word64 -> Word32 -> Ptr Buffer -> IO CInt

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

type PadGetRangeFunction

Arguments

 = Pad

pad: the src Pad to perform the getrange on.

-> Maybe Object

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> Word64

offset: the offset of the range

-> Word32

length: the length of the range

-> Buffer

buffer: a memory location to hold the result buffer, cannot be Nothing.

-> IO FlowReturn

Returns: GST_FLOW_OK for success and a valid buffer in buffer. Any other return value leaves buffer undefined.

This function will be called on source pads when a peer element request a buffer at the specified offset and length. 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 installed on a source pad with gst_pad_set_getrange_function() and can only be called on source pads after they are successfully activated with padActivateMode with the GST_PAD_MODE_PULL.

offset and length are always given in byte units. offset must normally be a value between 0 and the length in bytes of the data available on pad. The length (duration in bytes) can be retrieved with a GST_QUERY_DURATION or with a GST_QUERY_SEEKING.

Any offset larger or equal than the length will make the function return GST_FLOW_EOS, which corresponds to EOS. In this case buffer does not contain a valid buffer.

The buffer size of buffer will only be smaller than length when offset is near the end of the stream. In all other cases, the size of buffer must be exactly the requested size.

It is allowed to call this function with a 0 length and valid offset, in which case buffer will contain a 0-sized buffer and the function returns GST_FLOW_OK.

When this function is called with a -1 offset, the sequentially next buffer of length length in the stream is returned.

When this function is called with a -1 length, a buffer with a default optimal length is returned in buffer. The length might depend on the value of offset.

dynamic_PadGetRangeFunction

Arguments

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

=> FunPtr C_PadGetRangeFunction

-> a

pad: the src Pad to perform the getrange on.

-> Maybe b

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> Word64

offset: the offset of the range

-> Word32

length: the length of the range

-> Buffer

buffer: a memory location to hold the result buffer, cannot be Nothing.

-> m FlowReturn

Returns: GST_FLOW_OK for success and a valid buffer in buffer. Any other return value leaves buffer undefined.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PadGetRangeFunction :: MonadIO m => PadGetRangeFunction -> m (GClosure C_PadGetRangeFunction)

Wrap the callback into a GClosure.

mk_PadGetRangeFunction :: C_PadGetRangeFunction -> IO (FunPtr C_PadGetRangeFunction)

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

noPadGetRangeFunction :: Maybe PadGetRangeFunction

A convenience synonym for Nothing :: Maybe PadGetRangeFunction.

wrap_PadGetRangeFunction :: Maybe (Ptr (FunPtr C_PadGetRangeFunction)) -> PadGetRangeFunction -> C_PadGetRangeFunction

Wrap a PadGetRangeFunction into a C_PadGetRangeFunction.

PadIterIntLinkFunction

type C_PadIterIntLinkFunction = Ptr Pad -> Ptr Object -> IO (Ptr Iterator)

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

type PadIterIntLinkFunction

Arguments

 = Pad

pad: The Pad to query.

-> Maybe Object

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> IO Iterator

Returns: a new Iterator that will iterate over all pads that are linked to the given pad on the inside of the parent element.

the caller must call iteratorFree after usage.

The signature of the internal pad link iterator function.

dynamic_PadIterIntLinkFunction

Arguments

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

=> FunPtr C_PadIterIntLinkFunction

-> a

pad: The Pad to query.

-> Maybe b

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> m Iterator

Returns: a new Iterator that will iterate over all pads that are linked to the given pad on the inside of the parent element.

the caller must call iteratorFree after usage.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PadIterIntLinkFunction :: MonadIO m => PadIterIntLinkFunction -> m (GClosure C_PadIterIntLinkFunction)

Wrap the callback into a GClosure.

mk_PadIterIntLinkFunction :: C_PadIterIntLinkFunction -> IO (FunPtr C_PadIterIntLinkFunction)

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

noPadIterIntLinkFunction :: Maybe PadIterIntLinkFunction

A convenience synonym for Nothing :: Maybe PadIterIntLinkFunction.

wrap_PadIterIntLinkFunction :: Maybe (Ptr (FunPtr C_PadIterIntLinkFunction)) -> PadIterIntLinkFunction -> C_PadIterIntLinkFunction

Wrap a PadIterIntLinkFunction into a C_PadIterIntLinkFunction.

PadLinkFunction

type C_PadLinkFunction = Ptr Pad -> Ptr Object -> Ptr Pad -> IO CInt

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

type PadLinkFunction

Arguments

 = Pad

pad: the Pad that is linked.

-> Maybe Object

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> Pad

peer: the peer Pad of the link

-> IO PadLinkReturn

Returns: the result of the link with the specified peer.

Function signature to handle a new link on the pad.

dynamic_PadLinkFunction

Arguments

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

=> FunPtr C_PadLinkFunction

-> a

pad: the Pad that is linked.

-> Maybe b

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> c

peer: the peer Pad of the link

-> m PadLinkReturn

Returns: the result of the link with the specified peer.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PadLinkFunction :: MonadIO m => PadLinkFunction -> m (GClosure C_PadLinkFunction)

Wrap the callback into a GClosure.

mk_PadLinkFunction :: C_PadLinkFunction -> IO (FunPtr C_PadLinkFunction)

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

noPadLinkFunction :: Maybe PadLinkFunction

A convenience synonym for Nothing :: Maybe PadLinkFunction.

wrap_PadLinkFunction :: Maybe (Ptr (FunPtr C_PadLinkFunction)) -> PadLinkFunction -> C_PadLinkFunction

Wrap a PadLinkFunction into a C_PadLinkFunction.

PadProbeCallback

type C_PadProbeCallback = Ptr Pad -> Ptr PadProbeInfo -> Ptr () -> IO CUInt

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

type PadProbeCallback

Arguments

 = Pad

pad: the Pad that is blocked

-> PadProbeInfo

info: PadProbeInfo

-> IO PadProbeReturn

Returns: a PadProbeReturn

Callback used by padAddProbe. Gets called to notify about the current blocking type.

The callback is allowed to modify the data pointer in info.

type PadProbeCallback_WithClosures

Arguments

 = Pad

pad: the Pad that is blocked

-> PadProbeInfo

info: PadProbeInfo

-> Ptr ()

userData: the gpointer to optional user data.

-> IO PadProbeReturn

Returns: a PadProbeReturn

Callback used by padAddProbe. Gets called to notify about the current blocking type.

The callback is allowed to modify the data pointer in info.

drop_closures_PadProbeCallback :: PadProbeCallback -> PadProbeCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_PadProbeCallback

Arguments

:: (HasCallStack, MonadIO m, IsPad a)

=> FunPtr C_PadProbeCallback

-> a

pad: the Pad that is blocked

-> PadProbeInfo

info: PadProbeInfo

-> Ptr ()

userData: the gpointer to optional user data.

-> m PadProbeReturn

Returns: a PadProbeReturn

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PadProbeCallback :: MonadIO m => PadProbeCallback -> m (GClosure C_PadProbeCallback)

Wrap the callback into a GClosure.

mk_PadProbeCallback :: C_PadProbeCallback -> IO (FunPtr C_PadProbeCallback)

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

noPadProbeCallback :: Maybe PadProbeCallback

A convenience synonym for Nothing :: Maybe PadProbeCallback.

noPadProbeCallback_WithClosures :: Maybe PadProbeCallback_WithClosures

A convenience synonym for Nothing :: Maybe PadProbeCallback_WithClosures.

wrap_PadProbeCallback :: Maybe (Ptr (FunPtr C_PadProbeCallback)) -> PadProbeCallback_WithClosures -> C_PadProbeCallback

Wrap a PadProbeCallback into a C_PadProbeCallback.

PadQueryFunction

type C_PadQueryFunction = Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt

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

type PadQueryFunction

Arguments

 = Pad

pad: the Pad to query.

-> Maybe Object

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> Query

query: the Query object to execute

-> IO Bool

Returns: True if the query could be performed.

The signature of the query function.

dynamic_PadQueryFunction

Arguments

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

=> FunPtr C_PadQueryFunction

-> a

pad: the Pad to query.

-> Maybe b

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> Query

query: the Query object to execute

-> m Bool

Returns: True if the query could be performed.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PadQueryFunction :: MonadIO m => PadQueryFunction -> m (GClosure C_PadQueryFunction)

Wrap the callback into a GClosure.

mk_PadQueryFunction :: C_PadQueryFunction -> IO (FunPtr C_PadQueryFunction)

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

noPadQueryFunction :: Maybe PadQueryFunction

A convenience synonym for Nothing :: Maybe PadQueryFunction.

wrap_PadQueryFunction :: Maybe (Ptr (FunPtr C_PadQueryFunction)) -> PadQueryFunction -> C_PadQueryFunction

Wrap a PadQueryFunction into a C_PadQueryFunction.

PadStickyEventsForeachFunction

type C_PadStickyEventsForeachFunction = Ptr Pad -> Ptr Event -> Ptr () -> IO CInt

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

type PadStickyEventsForeachFunction

Arguments

 = Pad

pad: the Pad.

-> Maybe Event

event: a sticky Event.

-> IO Bool

Returns: True if the iteration should continue

Callback used by padStickyEventsForeach.

When this function returns True, the next event will be returned. When False is returned, padStickyEventsForeach will return.

When event is set to Nothing, the item will be removed from the list of sticky events. event can be replaced by assigning a new reference to it. This function is responsible for unreffing the old event when removing or modifying.

type PadStickyEventsForeachFunction_WithClosures

Arguments

 = Pad

pad: the Pad.

-> Maybe Event

event: a sticky Event.

-> Ptr ()

userData: the gpointer to optional user data.

-> IO Bool

Returns: True if the iteration should continue

Callback used by padStickyEventsForeach.

When this function returns True, the next event will be returned. When False is returned, padStickyEventsForeach will return.

When event is set to Nothing, the item will be removed from the list of sticky events. event can be replaced by assigning a new reference to it. This function is responsible for unreffing the old event when removing or modifying.

drop_closures_PadStickyEventsForeachFunction :: PadStickyEventsForeachFunction -> PadStickyEventsForeachFunction_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_PadStickyEventsForeachFunction

Arguments

:: (HasCallStack, MonadIO m, IsPad a)

=> FunPtr C_PadStickyEventsForeachFunction

-> a

pad: the Pad.

-> Maybe Event

event: a sticky Event.

-> Ptr ()

userData: the gpointer to optional user data.

-> m Bool

Returns: True if the iteration should continue

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PadStickyEventsForeachFunction :: MonadIO m => PadStickyEventsForeachFunction -> m (GClosure C_PadStickyEventsForeachFunction)

Wrap the callback into a GClosure.

mk_PadStickyEventsForeachFunction :: C_PadStickyEventsForeachFunction -> IO (FunPtr C_PadStickyEventsForeachFunction)

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

noPadStickyEventsForeachFunction :: Maybe PadStickyEventsForeachFunction

A convenience synonym for Nothing :: Maybe PadStickyEventsForeachFunction.

noPadStickyEventsForeachFunction_WithClosures :: Maybe PadStickyEventsForeachFunction_WithClosures

A convenience synonym for Nothing :: Maybe PadStickyEventsForeachFunction_WithClosures.

wrap_PadStickyEventsForeachFunction :: Maybe (Ptr (FunPtr C_PadStickyEventsForeachFunction)) -> PadStickyEventsForeachFunction_WithClosures -> C_PadStickyEventsForeachFunction

Wrap a PadStickyEventsForeachFunction into a C_PadStickyEventsForeachFunction.

PadUnlinkFunction

type C_PadUnlinkFunction = Ptr Pad -> Ptr Object -> IO ()

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

type PadUnlinkFunction

Arguments

 = Pad

pad: the Pad that is linked.

-> Maybe Object

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> IO ()

Function signature to handle a unlinking the pad prom its peer.

The pad's lock is already held when the unlink function is called, so most pad functions cannot be called from within the callback.

dynamic_PadUnlinkFunction

Arguments

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

=> FunPtr C_PadUnlinkFunction

-> a

pad: the Pad that is linked.

-> Maybe b

parent: the parent of pad. If the GST_PAD_FLAG_NEED_PARENT flag is set, parent is guaranteed to be not-Nothing and remain valid during the execution of this function.

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PadUnlinkFunction :: MonadIO m => PadUnlinkFunction -> m (GClosure C_PadUnlinkFunction)

Wrap the callback into a GClosure.

mk_PadUnlinkFunction :: C_PadUnlinkFunction -> IO (FunPtr C_PadUnlinkFunction)

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

noPadUnlinkFunction :: Maybe PadUnlinkFunction

A convenience synonym for Nothing :: Maybe PadUnlinkFunction.

wrap_PadUnlinkFunction :: Maybe (Ptr (FunPtr C_PadUnlinkFunction)) -> PadUnlinkFunction -> C_PadUnlinkFunction

Wrap a PadUnlinkFunction into a C_PadUnlinkFunction.

PluginFeatureFilter

type C_PluginFeatureFilter = Ptr PluginFeature -> Ptr () -> IO CInt

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

type PluginFeatureFilter

Arguments

 = PluginFeature

feature: the pluginfeature to check

-> IO Bool

Returns: True for a positive match, False otherwise

A function that can be used with e.g. registryFeatureFilter to get a list of pluginfeature that match certain criteria.

type PluginFeatureFilter_WithClosures

Arguments

 = PluginFeature

feature: the pluginfeature to check

-> Ptr ()

userData: the user_data that has been passed on e.g. registryFeatureFilter

-> IO Bool

Returns: True for a positive match, False otherwise

A function that can be used with e.g. registryFeatureFilter to get a list of pluginfeature that match certain criteria.

drop_closures_PluginFeatureFilter :: PluginFeatureFilter -> PluginFeatureFilter_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_PluginFeatureFilter

Arguments

:: (HasCallStack, MonadIO m, IsPluginFeature a)

=> FunPtr C_PluginFeatureFilter

-> a

feature: the pluginfeature to check

-> Ptr ()

userData: the user_data that has been passed on e.g. registryFeatureFilter

-> m Bool

Returns: True for a positive match, False otherwise

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PluginFeatureFilter :: MonadIO m => PluginFeatureFilter -> m (GClosure C_PluginFeatureFilter)

Wrap the callback into a GClosure.

mk_PluginFeatureFilter :: C_PluginFeatureFilter -> IO (FunPtr C_PluginFeatureFilter)

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

noPluginFeatureFilter :: Maybe PluginFeatureFilter

A convenience synonym for Nothing :: Maybe PluginFeatureFilter.

noPluginFeatureFilter_WithClosures :: Maybe PluginFeatureFilter_WithClosures

A convenience synonym for Nothing :: Maybe PluginFeatureFilter_WithClosures.

wrap_PluginFeatureFilter :: Maybe (Ptr (FunPtr C_PluginFeatureFilter)) -> PluginFeatureFilter_WithClosures -> C_PluginFeatureFilter

Wrap a PluginFeatureFilter into a C_PluginFeatureFilter.

PluginFilter

type C_PluginFilter = Ptr Plugin -> Ptr () -> IO CInt

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

type PluginFilter

Arguments

 = Plugin

plugin: the plugin to check

-> IO Bool

Returns: True for a positive match, False otherwise

A function that can be used with e.g. registryPluginFilter to get a list of plugins that match certain criteria.

type PluginFilter_WithClosures

Arguments

 = Plugin

plugin: the plugin to check

-> Ptr ()

userData: the user_data that has been passed on e.g. registryPluginFilter

-> IO Bool

Returns: True for a positive match, False otherwise

A function that can be used with e.g. registryPluginFilter to get a list of plugins that match certain criteria.

drop_closures_PluginFilter :: PluginFilter -> PluginFilter_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_PluginFilter

Arguments

:: (HasCallStack, MonadIO m, IsPlugin a)

=> FunPtr C_PluginFilter

-> a

plugin: the plugin to check

-> Ptr ()

userData: the user_data that has been passed on e.g. registryPluginFilter

-> m Bool

Returns: True for a positive match, False otherwise

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PluginFilter :: MonadIO m => PluginFilter -> m (GClosure C_PluginFilter)

Wrap the callback into a GClosure.

mk_PluginFilter :: C_PluginFilter -> IO (FunPtr C_PluginFilter)

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

noPluginFilter :: Maybe PluginFilter

A convenience synonym for Nothing :: Maybe PluginFilter.

noPluginFilter_WithClosures :: Maybe PluginFilter_WithClosures

A convenience synonym for Nothing :: Maybe PluginFilter_WithClosures.

wrap_PluginFilter :: Maybe (Ptr (FunPtr C_PluginFilter)) -> PluginFilter_WithClosures -> C_PluginFilter

Wrap a PluginFilter into a C_PluginFilter.

PluginInitFullFunc

type C_PluginInitFullFunc = Ptr Plugin -> Ptr () -> IO CInt

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

type PluginInitFullFunc

Arguments

 = Plugin

plugin: The plugin object

-> IO Bool

Returns: True if plugin initialised successfully

A plugin should provide a pointer to a function of either PluginInitFunc or this type in the plugin_desc struct. The function will be called by the loader at startup. One would then register each PluginFeature. This version allows user data to be passed to init function (useful for bindings).

type PluginInitFullFunc_WithClosures

Arguments

 = Plugin

plugin: The plugin object

-> Ptr ()

userData: extra data

-> IO Bool

Returns: True if plugin initialised successfully

A plugin should provide a pointer to a function of either PluginInitFunc or this type in the plugin_desc struct. The function will be called by the loader at startup. One would then register each PluginFeature. This version allows user data to be passed to init function (useful for bindings).

drop_closures_PluginInitFullFunc :: PluginInitFullFunc -> PluginInitFullFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_PluginInitFullFunc

Arguments

:: (HasCallStack, MonadIO m, IsPlugin a)

=> FunPtr C_PluginInitFullFunc

-> a

plugin: The plugin object

-> Ptr ()

userData: extra data

-> m Bool

Returns: True if plugin initialised successfully

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PluginInitFullFunc :: MonadIO m => PluginInitFullFunc -> m (GClosure C_PluginInitFullFunc)

Wrap the callback into a GClosure.

mk_PluginInitFullFunc :: C_PluginInitFullFunc -> IO (FunPtr C_PluginInitFullFunc)

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

noPluginInitFullFunc :: Maybe PluginInitFullFunc

A convenience synonym for Nothing :: Maybe PluginInitFullFunc.

noPluginInitFullFunc_WithClosures :: Maybe PluginInitFullFunc_WithClosures

A convenience synonym for Nothing :: Maybe PluginInitFullFunc_WithClosures.

wrap_PluginInitFullFunc :: Maybe (Ptr (FunPtr C_PluginInitFullFunc)) -> PluginInitFullFunc_WithClosures -> C_PluginInitFullFunc

Wrap a PluginInitFullFunc into a C_PluginInitFullFunc.

PluginInitFunc

type C_PluginInitFunc = Ptr Plugin -> IO CInt

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

type PluginInitFunc

Arguments

 = Plugin

plugin: The plugin object

-> IO Bool

Returns: True if plugin initialised successfully

A plugin should provide a pointer to a function of this type in the plugin_desc struct. This function will be called by the loader at startup. One would then register each PluginFeature.

dynamic_PluginInitFunc

Arguments

:: (HasCallStack, MonadIO m, IsPlugin a)

=> FunPtr C_PluginInitFunc

-> a

plugin: The plugin object

-> m Bool

Returns: True if plugin initialised successfully

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PluginInitFunc :: MonadIO m => PluginInitFunc -> m (GClosure C_PluginInitFunc)

Wrap the callback into a GClosure.

mk_PluginInitFunc :: C_PluginInitFunc -> IO (FunPtr C_PluginInitFunc)

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

noPluginInitFunc :: Maybe PluginInitFunc

A convenience synonym for Nothing :: Maybe PluginInitFunc.

wrap_PluginInitFunc :: Maybe (Ptr (FunPtr C_PluginInitFunc)) -> PluginInitFunc -> C_PluginInitFunc

Wrap a PluginInitFunc into a C_PluginInitFunc.

PromiseChangeFunc

type C_PromiseChangeFunc = Ptr Promise -> Ptr () -> IO ()

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

type PromiseChangeFunc

Arguments

 = Promise

promise: a Promise

-> IO ()

No description available in the introspection data.

Since: 1.14

type PromiseChangeFunc_WithClosures

Arguments

 = Promise

promise: a Promise

-> Ptr ()

userData: user data

-> IO ()

No description available in the introspection data.

Since: 1.14

drop_closures_PromiseChangeFunc :: PromiseChangeFunc -> PromiseChangeFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_PromiseChangeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_PromiseChangeFunc

-> Promise

promise: a Promise

-> Ptr ()

userData: user data

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_PromiseChangeFunc :: MonadIO m => PromiseChangeFunc -> m (GClosure C_PromiseChangeFunc)

Wrap the callback into a GClosure.

mk_PromiseChangeFunc :: C_PromiseChangeFunc -> IO (FunPtr C_PromiseChangeFunc)

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

noPromiseChangeFunc :: Maybe PromiseChangeFunc

A convenience synonym for Nothing :: Maybe PromiseChangeFunc.

noPromiseChangeFunc_WithClosures :: Maybe PromiseChangeFunc_WithClosures

A convenience synonym for Nothing :: Maybe PromiseChangeFunc_WithClosures.

wrap_PromiseChangeFunc :: Maybe (Ptr (FunPtr C_PromiseChangeFunc)) -> PromiseChangeFunc_WithClosures -> C_PromiseChangeFunc

Wrap a PromiseChangeFunc into a C_PromiseChangeFunc.

StructureFilterMapFunc

type C_StructureFilterMapFunc = Word32 -> Ptr GValue -> Ptr () -> IO CInt

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

type StructureFilterMapFunc

Arguments

 = Word32

fieldId: the GQuark of the field name

-> GValue

value: the Value of the field

-> IO Bool

Returns: True if the field should be preserved, False if it should be removed.

A function that will be called in structureFilterAndMapInPlace. The function may modify value, and the value will be removed from the structure if False is returned.

type StructureFilterMapFunc_WithClosures

Arguments

 = Word32

fieldId: the GQuark of the field name

-> GValue

value: the Value of the field

-> Ptr ()

userData: user data

-> IO Bool

Returns: True if the field should be preserved, False if it should be removed.

A function that will be called in structureFilterAndMapInPlace. The function may modify value, and the value will be removed from the structure if False is returned.

drop_closures_StructureFilterMapFunc :: StructureFilterMapFunc -> StructureFilterMapFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_StructureFilterMapFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_StructureFilterMapFunc

-> Word32

fieldId: the GQuark of the field name

-> GValue

value: the Value of the field

-> Ptr ()

userData: user data

-> m Bool

Returns: True if the field should be preserved, False if it should be removed.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_StructureFilterMapFunc :: MonadIO m => StructureFilterMapFunc -> m (GClosure C_StructureFilterMapFunc)

Wrap the callback into a GClosure.

mk_StructureFilterMapFunc :: C_StructureFilterMapFunc -> IO (FunPtr C_StructureFilterMapFunc)

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

noStructureFilterMapFunc :: Maybe StructureFilterMapFunc

A convenience synonym for Nothing :: Maybe StructureFilterMapFunc.

noStructureFilterMapFunc_WithClosures :: Maybe StructureFilterMapFunc_WithClosures

A convenience synonym for Nothing :: Maybe StructureFilterMapFunc_WithClosures.

wrap_StructureFilterMapFunc :: Maybe (Ptr (FunPtr C_StructureFilterMapFunc)) -> StructureFilterMapFunc_WithClosures -> C_StructureFilterMapFunc

Wrap a StructureFilterMapFunc into a C_StructureFilterMapFunc.

StructureForeachFunc

type C_StructureForeachFunc = Word32 -> Ptr GValue -> Ptr () -> IO CInt

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

type StructureForeachFunc

Arguments

 = Word32

fieldId: the GQuark of the field name

-> GValue

value: the Value of the field

-> IO Bool

Returns: True if the foreach operation should continue, False if the foreach operation should stop with False.

A function that will be called in structureForeach. The function may not modify value.

type StructureForeachFunc_WithClosures

Arguments

 = Word32

fieldId: the GQuark of the field name

-> GValue

value: the Value of the field

-> Ptr ()

userData: user data

-> IO Bool

Returns: True if the foreach operation should continue, False if the foreach operation should stop with False.

A function that will be called in structureForeach. The function may not modify value.

drop_closures_StructureForeachFunc :: StructureForeachFunc -> StructureForeachFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_StructureForeachFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_StructureForeachFunc

-> Word32

fieldId: the GQuark of the field name

-> GValue

value: the Value of the field

-> Ptr ()

userData: user data

-> m Bool

Returns: True if the foreach operation should continue, False if the foreach operation should stop with False.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_StructureForeachFunc :: MonadIO m => StructureForeachFunc -> m (GClosure C_StructureForeachFunc)

Wrap the callback into a GClosure.

mk_StructureForeachFunc :: C_StructureForeachFunc -> IO (FunPtr C_StructureForeachFunc)

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

noStructureForeachFunc :: Maybe StructureForeachFunc

A convenience synonym for Nothing :: Maybe StructureForeachFunc.

noStructureForeachFunc_WithClosures :: Maybe StructureForeachFunc_WithClosures

A convenience synonym for Nothing :: Maybe StructureForeachFunc_WithClosures.

wrap_StructureForeachFunc :: Maybe (Ptr (FunPtr C_StructureForeachFunc)) -> StructureForeachFunc_WithClosures -> C_StructureForeachFunc

Wrap a StructureForeachFunc into a C_StructureForeachFunc.

StructureMapFunc

type C_StructureMapFunc = Word32 -> Ptr GValue -> Ptr () -> IO CInt

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

type StructureMapFunc

Arguments

 = Word32

fieldId: the GQuark of the field name

-> GValue

value: the Value of the field

-> IO Bool

Returns: True if the map operation should continue, False if the map operation should stop with False.

A function that will be called in structureMapInPlace. The function may modify value.

type StructureMapFunc_WithClosures

Arguments

 = Word32

fieldId: the GQuark of the field name

-> GValue

value: the Value of the field

-> Ptr ()

userData: user data

-> IO Bool

Returns: True if the map operation should continue, False if the map operation should stop with False.

A function that will be called in structureMapInPlace. The function may modify value.

drop_closures_StructureMapFunc :: StructureMapFunc -> StructureMapFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_StructureMapFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_StructureMapFunc

-> Word32

fieldId: the GQuark of the field name

-> GValue

value: the Value of the field

-> Ptr ()

userData: user data

-> m Bool

Returns: True if the map operation should continue, False if the map operation should stop with False.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_StructureMapFunc :: MonadIO m => StructureMapFunc -> m (GClosure C_StructureMapFunc)

Wrap the callback into a GClosure.

mk_StructureMapFunc :: C_StructureMapFunc -> IO (FunPtr C_StructureMapFunc)

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

noStructureMapFunc :: Maybe StructureMapFunc

A convenience synonym for Nothing :: Maybe StructureMapFunc.

noStructureMapFunc_WithClosures :: Maybe StructureMapFunc_WithClosures

A convenience synonym for Nothing :: Maybe StructureMapFunc_WithClosures.

wrap_StructureMapFunc :: Maybe (Ptr (FunPtr C_StructureMapFunc)) -> StructureMapFunc_WithClosures -> C_StructureMapFunc

Wrap a StructureMapFunc into a C_StructureMapFunc.

TagForeachFunc

type C_TagForeachFunc = Ptr TagList -> CString -> Ptr () -> IO ()

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

type TagForeachFunc

Arguments

 = TagList

list: the TagList

-> Text

tag: a name of a tag in list

-> IO ()

A function that will be called in tagListForeach. The function may not modify the tag list.

type TagForeachFunc_WithClosures

Arguments

 = TagList

list: the TagList

-> Text

tag: a name of a tag in list

-> Ptr ()

userData: user data

-> IO ()

A function that will be called in tagListForeach. The function may not modify the tag list.

drop_closures_TagForeachFunc :: TagForeachFunc -> TagForeachFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TagForeachFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TagForeachFunc

-> TagList

list: the TagList

-> Text

tag: a name of a tag in list

-> Ptr ()

userData: user data

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TagForeachFunc :: MonadIO m => TagForeachFunc -> m (GClosure C_TagForeachFunc)

Wrap the callback into a GClosure.

mk_TagForeachFunc :: C_TagForeachFunc -> IO (FunPtr C_TagForeachFunc)

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

noTagForeachFunc :: Maybe TagForeachFunc

A convenience synonym for Nothing :: Maybe TagForeachFunc.

noTagForeachFunc_WithClosures :: Maybe TagForeachFunc_WithClosures

A convenience synonym for Nothing :: Maybe TagForeachFunc_WithClosures.

wrap_TagForeachFunc :: Maybe (Ptr (FunPtr C_TagForeachFunc)) -> TagForeachFunc_WithClosures -> C_TagForeachFunc

Wrap a TagForeachFunc into a C_TagForeachFunc.

TagMergeFunc

type C_TagMergeFunc = Ptr GValue -> Ptr GValue -> IO ()

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

type TagMergeFunc

Arguments

 = GValue

dest: the destination Value

-> GValue

src: the source Value

-> IO ()

A function for merging multiple values of a tag used when registering tags.

dynamic_TagMergeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TagMergeFunc

-> GValue

dest: the destination Value

-> GValue

src: the source Value

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TagMergeFunc :: MonadIO m => TagMergeFunc -> m (GClosure C_TagMergeFunc)

Wrap the callback into a GClosure.

mk_TagMergeFunc :: C_TagMergeFunc -> IO (FunPtr C_TagMergeFunc)

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

noTagMergeFunc :: Maybe TagMergeFunc

A convenience synonym for Nothing :: Maybe TagMergeFunc.

wrap_TagMergeFunc :: Maybe (Ptr (FunPtr C_TagMergeFunc)) -> TagMergeFunc -> C_TagMergeFunc

Wrap a TagMergeFunc into a C_TagMergeFunc.

TaskFunction

type C_TaskFunction = Ptr () -> IO ()

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

type TaskFunction = IO ()

A function that will repeatedly be called in the thread created by a Task.

type TaskFunction_WithClosures

Arguments

 = Ptr ()

userData: user data passed to the function

-> IO ()

A function that will repeatedly be called in the thread created by a Task.

drop_closures_TaskFunction :: TaskFunction -> TaskFunction_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TaskFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TaskFunction

-> Ptr ()

userData: user data passed to the function

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TaskFunction :: MonadIO m => TaskFunction -> m (GClosure C_TaskFunction)

Wrap the callback into a GClosure.

mk_TaskFunction :: C_TaskFunction -> IO (FunPtr C_TaskFunction)

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

noTaskFunction :: Maybe TaskFunction

A convenience synonym for Nothing :: Maybe TaskFunction.

noTaskFunction_WithClosures :: Maybe TaskFunction_WithClosures

A convenience synonym for Nothing :: Maybe TaskFunction_WithClosures.

wrap_TaskFunction :: Maybe (Ptr (FunPtr C_TaskFunction)) -> TaskFunction_WithClosures -> C_TaskFunction

Wrap a TaskFunction into a C_TaskFunction.

TaskPoolFunction

type C_TaskPoolFunction = Ptr () -> IO ()

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

type TaskPoolFunction = IO ()

Task function, see taskPoolPush.

type TaskPoolFunction_WithClosures

Arguments

 = Ptr ()

userData: user data for the task function

-> IO ()

Task function, see taskPoolPush.

drop_closures_TaskPoolFunction :: TaskPoolFunction -> TaskPoolFunction_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TaskPoolFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TaskPoolFunction

-> Ptr ()

userData: user data for the task function

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TaskPoolFunction :: MonadIO m => TaskPoolFunction -> m (GClosure C_TaskPoolFunction)

Wrap the callback into a GClosure.

mk_TaskPoolFunction :: C_TaskPoolFunction -> IO (FunPtr C_TaskPoolFunction)

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

noTaskPoolFunction :: Maybe TaskPoolFunction

A convenience synonym for Nothing :: Maybe TaskPoolFunction.

noTaskPoolFunction_WithClosures :: Maybe TaskPoolFunction_WithClosures

A convenience synonym for Nothing :: Maybe TaskPoolFunction_WithClosures.

wrap_TaskPoolFunction :: Maybe (Ptr (FunPtr C_TaskPoolFunction)) -> TaskPoolFunction_WithClosures -> C_TaskPoolFunction

Wrap a TaskPoolFunction into a C_TaskPoolFunction.

TaskThreadFunc

type C_TaskThreadFunc = Ptr Task -> Ptr Thread -> Ptr () -> IO ()

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

type TaskThreadFunc

Arguments

 = Task

task: The Task

-> Thread

thread: The Thread

-> IO ()

Custom GstTask thread callback functions that can be installed.

type TaskThreadFunc_WithClosures

Arguments

 = Task

task: The Task

-> Thread

thread: The Thread

-> Ptr ()

userData: user data

-> IO ()

Custom GstTask thread callback functions that can be installed.

drop_closures_TaskThreadFunc :: TaskThreadFunc -> TaskThreadFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TaskThreadFunc

Arguments

:: (HasCallStack, MonadIO m, IsTask a)

=> FunPtr C_TaskThreadFunc

-> a

task: The Task

-> Thread

thread: The Thread

-> Ptr ()

userData: user data

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TaskThreadFunc :: MonadIO m => TaskThreadFunc -> m (GClosure C_TaskThreadFunc)

Wrap the callback into a GClosure.

mk_TaskThreadFunc :: C_TaskThreadFunc -> IO (FunPtr C_TaskThreadFunc)

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

noTaskThreadFunc :: Maybe TaskThreadFunc

A convenience synonym for Nothing :: Maybe TaskThreadFunc.

noTaskThreadFunc_WithClosures :: Maybe TaskThreadFunc_WithClosures

A convenience synonym for Nothing :: Maybe TaskThreadFunc_WithClosures.

wrap_TaskThreadFunc :: Maybe (Ptr (FunPtr C_TaskThreadFunc)) -> TaskThreadFunc_WithClosures -> C_TaskThreadFunc

Wrap a TaskThreadFunc into a C_TaskThreadFunc.

TypeFindFunction

type C_TypeFindFunction = Ptr TypeFind -> Ptr () -> IO ()

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

type TypeFindFunction

Arguments

 = TypeFind

find: A TypeFind structure

-> IO ()

A function that will be called by typefinding.

type TypeFindFunction_WithClosures

Arguments

 = TypeFind

find: A TypeFind structure

-> Ptr ()

userData: optional data to pass to the function

-> IO ()

A function that will be called by typefinding.

drop_closures_TypeFindFunction :: TypeFindFunction -> TypeFindFunction_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TypeFindFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TypeFindFunction

-> TypeFind

find: A TypeFind structure

-> Ptr ()

userData: optional data to pass to the function

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeFindFunction :: MonadIO m => TypeFindFunction -> m (GClosure C_TypeFindFunction)

Wrap the callback into a GClosure.

mk_TypeFindFunction :: C_TypeFindFunction -> IO (FunPtr C_TypeFindFunction)

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

noTypeFindFunction :: Maybe TypeFindFunction

A convenience synonym for Nothing :: Maybe TypeFindFunction.

noTypeFindFunction_WithClosures :: Maybe TypeFindFunction_WithClosures

A convenience synonym for Nothing :: Maybe TypeFindFunction_WithClosures.

wrap_TypeFindFunction :: Maybe (Ptr (FunPtr C_TypeFindFunction)) -> TypeFindFunction_WithClosures -> C_TypeFindFunction

Wrap a TypeFindFunction into a C_TypeFindFunction.

TypeFindGetLengthFieldCallback

type C_TypeFindGetLengthFieldCallback = Ptr () -> IO Word64

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

type TypeFindGetLengthFieldCallback = Ptr () -> IO Word64

No description available in the introspection data.

dynamic_TypeFindGetLengthFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeFindGetLengthFieldCallback -> Ptr () -> m Word64

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeFindGetLengthFieldCallback :: MonadIO m => TypeFindGetLengthFieldCallback -> m (GClosure C_TypeFindGetLengthFieldCallback)

Wrap the callback into a GClosure.

mk_TypeFindGetLengthFieldCallback :: C_TypeFindGetLengthFieldCallback -> IO (FunPtr C_TypeFindGetLengthFieldCallback)

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

noTypeFindGetLengthFieldCallback :: Maybe TypeFindGetLengthFieldCallback

A convenience synonym for Nothing :: Maybe TypeFindGetLengthFieldCallback.

wrap_TypeFindGetLengthFieldCallback :: Maybe (Ptr (FunPtr C_TypeFindGetLengthFieldCallback)) -> TypeFindGetLengthFieldCallback -> C_TypeFindGetLengthFieldCallback

Wrap a TypeFindGetLengthFieldCallback into a C_TypeFindGetLengthFieldCallback.

TypeFindPeekFieldCallback

type C_TypeFindPeekFieldCallback = Ptr () -> Int64 -> Word32 -> IO Word8

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

type TypeFindPeekFieldCallback = Ptr () -> Int64 -> Word32 -> IO Word8

No description available in the introspection data.

dynamic_TypeFindPeekFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeFindPeekFieldCallback -> Ptr () -> Int64 -> Word32 -> m Word8

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeFindPeekFieldCallback :: MonadIO m => TypeFindPeekFieldCallback -> m (GClosure C_TypeFindPeekFieldCallback)

Wrap the callback into a GClosure.

mk_TypeFindPeekFieldCallback :: C_TypeFindPeekFieldCallback -> IO (FunPtr C_TypeFindPeekFieldCallback)

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

noTypeFindPeekFieldCallback :: Maybe TypeFindPeekFieldCallback

A convenience synonym for Nothing :: Maybe TypeFindPeekFieldCallback.

wrap_TypeFindPeekFieldCallback :: Maybe (Ptr (FunPtr C_TypeFindPeekFieldCallback)) -> TypeFindPeekFieldCallback -> C_TypeFindPeekFieldCallback

Wrap a TypeFindPeekFieldCallback into a C_TypeFindPeekFieldCallback.

TypeFindSuggestFieldCallback

type C_TypeFindSuggestFieldCallback = Ptr () -> Word32 -> Ptr Caps -> IO ()

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

type TypeFindSuggestFieldCallback = Ptr () -> Word32 -> Caps -> IO ()

No description available in the introspection data.

dynamic_TypeFindSuggestFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeFindSuggestFieldCallback -> Ptr () -> Word32 -> Caps -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeFindSuggestFieldCallback :: MonadIO m => TypeFindSuggestFieldCallback -> m (GClosure C_TypeFindSuggestFieldCallback)

Wrap the callback into a GClosure.

mk_TypeFindSuggestFieldCallback :: C_TypeFindSuggestFieldCallback -> IO (FunPtr C_TypeFindSuggestFieldCallback)

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

noTypeFindSuggestFieldCallback :: Maybe TypeFindSuggestFieldCallback

A convenience synonym for Nothing :: Maybe TypeFindSuggestFieldCallback.

wrap_TypeFindSuggestFieldCallback :: Maybe (Ptr (FunPtr C_TypeFindSuggestFieldCallback)) -> TypeFindSuggestFieldCallback -> C_TypeFindSuggestFieldCallback

Wrap a TypeFindSuggestFieldCallback into a C_TypeFindSuggestFieldCallback.

ValueCompareFunc

type C_ValueCompareFunc = Ptr GValue -> Ptr GValue -> IO Int32

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

type ValueCompareFunc

Arguments

 = GValue

value1: first value for comparison

-> GValue

value2: second value for comparison

-> IO Int32

Returns: one of GST_VALUE_LESS_THAN, GST_VALUE_EQUAL, GST_VALUE_GREATER_THAN or GST_VALUE_UNORDERED

Used together with valueCompare to compare Value items.

dynamic_ValueCompareFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ValueCompareFunc

-> GValue

value1: first value for comparison

-> GValue

value2: second value for comparison

-> m Int32

Returns: one of GST_VALUE_LESS_THAN, GST_VALUE_EQUAL, GST_VALUE_GREATER_THAN or GST_VALUE_UNORDERED

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ValueCompareFunc :: MonadIO m => ValueCompareFunc -> m (GClosure C_ValueCompareFunc)

Wrap the callback into a GClosure.

mk_ValueCompareFunc :: C_ValueCompareFunc -> IO (FunPtr C_ValueCompareFunc)

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

noValueCompareFunc :: Maybe ValueCompareFunc

A convenience synonym for Nothing :: Maybe ValueCompareFunc.

wrap_ValueCompareFunc :: Maybe (Ptr (FunPtr C_ValueCompareFunc)) -> ValueCompareFunc -> C_ValueCompareFunc

Wrap a ValueCompareFunc into a C_ValueCompareFunc.

ValueDeserializeFunc

type C_ValueDeserializeFunc = Ptr GValue -> CString -> IO CInt

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

type ValueDeserializeFunc

Arguments

 = GValue

dest: a Value

-> Text

s: a string

-> IO Bool

Returns: True for success

Used by valueDeserialize to parse a non-binary form into the Value.

dynamic_ValueDeserializeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ValueDeserializeFunc

-> GValue

dest: a Value

-> Text

s: a string

-> m Bool

Returns: True for success

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ValueDeserializeFunc :: MonadIO m => ValueDeserializeFunc -> m (GClosure C_ValueDeserializeFunc)

Wrap the callback into a GClosure.

mk_ValueDeserializeFunc :: C_ValueDeserializeFunc -> IO (FunPtr C_ValueDeserializeFunc)

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

noValueDeserializeFunc :: Maybe ValueDeserializeFunc

A convenience synonym for Nothing :: Maybe ValueDeserializeFunc.

wrap_ValueDeserializeFunc :: Maybe (Ptr (FunPtr C_ValueDeserializeFunc)) -> ValueDeserializeFunc -> C_ValueDeserializeFunc

Wrap a ValueDeserializeFunc into a C_ValueDeserializeFunc.

ValueSerializeFunc

type C_ValueSerializeFunc = Ptr GValue -> IO CString

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

type ValueSerializeFunc

Arguments

 = GValue

value1: a Value

-> IO Text

Returns: the string representation of the value

Used by valueSerialize to obtain a non-binary form of the Value.

Free-function: g_free

dynamic_ValueSerializeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ValueSerializeFunc

-> GValue

value1: a Value

-> m Text

Returns: the string representation of the value

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ValueSerializeFunc :: MonadIO m => ValueSerializeFunc -> m (GClosure C_ValueSerializeFunc)

Wrap the callback into a GClosure.

mk_ValueSerializeFunc :: C_ValueSerializeFunc -> IO (FunPtr C_ValueSerializeFunc)

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

noValueSerializeFunc :: Maybe ValueSerializeFunc

A convenience synonym for Nothing :: Maybe ValueSerializeFunc.

wrap_ValueSerializeFunc :: Maybe (Ptr (FunPtr C_ValueSerializeFunc)) -> ValueSerializeFunc -> C_ValueSerializeFunc

Wrap a ValueSerializeFunc into a C_ValueSerializeFunc.