GI.Gst.Callbacks

Signals

BufferForeachMetaFunc

type BufferForeachMetaFunc = Buffer -> IO (Bool, Maybe Meta)

type BufferForeachMetaFunc_WithClosures = Buffer -> Ptr () -> IO (Bool, Maybe Meta)

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

drop_closures_BufferForeachMetaFunc :: BufferForeachMetaFunc -> BufferForeachMetaFunc_WithClosures

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

genClosure_BufferForeachMetaFunc :: BufferForeachMetaFunc -> IO Closure

mk_BufferForeachMetaFunc :: C_BufferForeachMetaFunc -> IO (FunPtr C_BufferForeachMetaFunc)

noBufferForeachMetaFunc :: Maybe BufferForeachMetaFunc

noBufferForeachMetaFunc_WithClosures :: Maybe BufferForeachMetaFunc_WithClosures

wrap_BufferForeachMetaFunc :: Maybe (Ptr (FunPtr C_BufferForeachMetaFunc)) -> BufferForeachMetaFunc_WithClosures -> Ptr Buffer -> Ptr (Ptr Meta) -> Ptr () -> IO CInt

BufferListFunc

type BufferListFunc = Word32 -> IO (Bool, Maybe Buffer)

type BufferListFunc_WithClosures = Word32 -> Ptr () -> IO (Bool, Maybe Buffer)

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

drop_closures_BufferListFunc :: BufferListFunc -> BufferListFunc_WithClosures

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

genClosure_BufferListFunc :: BufferListFunc -> IO Closure

mk_BufferListFunc :: C_BufferListFunc -> IO (FunPtr C_BufferListFunc)

noBufferListFunc :: Maybe BufferListFunc

noBufferListFunc_WithClosures :: Maybe BufferListFunc_WithClosures

wrap_BufferListFunc :: Maybe (Ptr (FunPtr C_BufferListFunc)) -> BufferListFunc_WithClosures -> Ptr (Ptr Buffer) -> Word32 -> Ptr () -> IO CInt

BusFunc

type BusFunc = Bus -> Message -> IO Bool

type BusFunc_WithClosures = Bus -> Message -> Ptr () -> IO Bool

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

drop_closures_BusFunc :: BusFunc -> BusFunc_WithClosures

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.

genClosure_BusFunc :: BusFunc -> IO Closure

mk_BusFunc :: C_BusFunc -> IO (FunPtr C_BusFunc)

noBusFunc :: Maybe BusFunc

noBusFunc_WithClosures :: Maybe BusFunc_WithClosures

wrap_BusFunc :: Maybe (Ptr (FunPtr C_BusFunc)) -> BusFunc_WithClosures -> Ptr Bus -> Ptr Message -> Ptr () -> IO CInt

BusSyncHandler

type BusSyncHandler = Bus -> Message -> IO BusSyncReply

type BusSyncHandler_WithClosures = Bus -> Message -> Ptr () -> IO BusSyncReply

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

drop_closures_BusSyncHandler :: BusSyncHandler -> BusSyncHandler_WithClosures

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

genClosure_BusSyncHandler :: BusSyncHandler -> IO Closure

mk_BusSyncHandler :: C_BusSyncHandler -> IO (FunPtr C_BusSyncHandler)

noBusSyncHandler :: Maybe BusSyncHandler

noBusSyncHandler_WithClosures :: Maybe BusSyncHandler_WithClosures

wrap_BusSyncHandler :: Maybe (Ptr (FunPtr C_BusSyncHandler)) -> BusSyncHandler_WithClosures -> Ptr Bus -> Ptr Message -> Ptr () -> IO CUInt

CapsFilterMapFunc

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

type CapsFilterMapFunc = CapsFeatures -> Structure -> IO Bool

type CapsFilterMapFunc_WithClosures = CapsFeatures -> Structure -> Ptr () -> IO Bool

drop_closures_CapsFilterMapFunc :: CapsFilterMapFunc -> CapsFilterMapFunc_WithClosures

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.

genClosure_CapsFilterMapFunc :: CapsFilterMapFunc -> IO Closure

mk_CapsFilterMapFunc :: C_CapsFilterMapFunc -> IO (FunPtr C_CapsFilterMapFunc)

noCapsFilterMapFunc :: Maybe CapsFilterMapFunc

noCapsFilterMapFunc_WithClosures :: Maybe CapsFilterMapFunc_WithClosures

wrap_CapsFilterMapFunc :: Maybe (Ptr (FunPtr C_CapsFilterMapFunc)) -> CapsFilterMapFunc_WithClosures -> Ptr CapsFeatures -> Ptr Structure -> Ptr () -> IO CInt

CapsForeachFunc

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

type CapsForeachFunc = CapsFeatures -> Structure -> IO Bool

type CapsForeachFunc_WithClosures = CapsFeatures -> Structure -> Ptr () -> IO Bool

drop_closures_CapsForeachFunc :: CapsForeachFunc -> CapsForeachFunc_WithClosures

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.

genClosure_CapsForeachFunc :: CapsForeachFunc -> IO Closure

mk_CapsForeachFunc :: C_CapsForeachFunc -> IO (FunPtr C_CapsForeachFunc)

noCapsForeachFunc :: Maybe CapsForeachFunc

noCapsForeachFunc_WithClosures :: Maybe CapsForeachFunc_WithClosures

wrap_CapsForeachFunc :: Maybe (Ptr (FunPtr C_CapsForeachFunc)) -> CapsForeachFunc_WithClosures -> Ptr CapsFeatures -> Ptr Structure -> Ptr () -> IO CInt

CapsMapFunc

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

type CapsMapFunc = CapsFeatures -> Structure -> IO Bool

type CapsMapFunc_WithClosures = CapsFeatures -> Structure -> Ptr () -> IO Bool

drop_closures_CapsMapFunc :: CapsMapFunc -> CapsMapFunc_WithClosures

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.

genClosure_CapsMapFunc :: CapsMapFunc -> IO Closure

mk_CapsMapFunc :: C_CapsMapFunc -> IO (FunPtr C_CapsMapFunc)

noCapsMapFunc :: Maybe CapsMapFunc

noCapsMapFunc_WithClosures :: Maybe CapsMapFunc_WithClosures

wrap_CapsMapFunc :: Maybe (Ptr (FunPtr C_CapsMapFunc)) -> CapsMapFunc_WithClosures -> Ptr CapsFeatures -> Ptr Structure -> Ptr () -> IO CInt

ClockCallback

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

type ClockCallback = Clock -> Word64 -> Ptr () -> IO Bool

type ClockCallback_WithClosures = Clock -> Word64 -> Ptr () -> Ptr () -> IO Bool

drop_closures_ClockCallback :: ClockCallback -> ClockCallback_WithClosures

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)

genClosure_ClockCallback :: ClockCallback -> IO Closure

mk_ClockCallback :: C_ClockCallback -> IO (FunPtr C_ClockCallback)

noClockCallback :: Maybe ClockCallback

noClockCallback_WithClosures :: Maybe ClockCallback_WithClosures

wrap_ClockCallback :: Maybe (Ptr (FunPtr C_ClockCallback)) -> ClockCallback_WithClosures -> Ptr Clock -> Word64 -> Ptr () -> Ptr () -> IO CInt

ControlBindingConvert

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

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

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

genClosure_ControlBindingConvert :: ControlBindingConvert -> IO Closure

mk_ControlBindingConvert :: C_ControlBindingConvert -> IO (FunPtr C_ControlBindingConvert)

noControlBindingConvert :: Maybe ControlBindingConvert

wrap_ControlBindingConvert :: Maybe (Ptr (FunPtr C_ControlBindingConvert)) -> ControlBindingConvert -> Ptr ControlBinding -> CDouble -> Ptr GValue -> IO ()

ControlSourceGetValue

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

type ControlSourceGetValue = ControlSource -> Word64 -> Double -> IO Bool

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.

genClosure_ControlSourceGetValue :: ControlSourceGetValue -> IO Closure

mk_ControlSourceGetValue :: C_ControlSourceGetValue -> IO (FunPtr C_ControlSourceGetValue)

noControlSourceGetValue :: Maybe ControlSourceGetValue

wrap_ControlSourceGetValue :: Maybe (Ptr (FunPtr C_ControlSourceGetValue)) -> ControlSourceGetValue -> Ptr ControlSource -> Word64 -> CDouble -> IO CInt

ControlSourceGetValueArray

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

type ControlSourceGetValueArray = ControlSource -> Word64 -> Word64 -> Word32 -> Double -> IO Bool

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.

genClosure_ControlSourceGetValueArray :: ControlSourceGetValueArray -> IO Closure

mk_ControlSourceGetValueArray :: C_ControlSourceGetValueArray -> IO (FunPtr C_ControlSourceGetValueArray)

noControlSourceGetValueArray :: Maybe ControlSourceGetValueArray

wrap_ControlSourceGetValueArray :: Maybe (Ptr (FunPtr C_ControlSourceGetValueArray)) -> ControlSourceGetValueArray -> Ptr ControlSource -> Word64 -> Word64 -> Word32 -> CDouble -> IO CInt

DebugFuncPtr

type C_DebugFuncPtr = IO ()

type DebugFuncPtr = IO ()

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

genClosure_DebugFuncPtr :: DebugFuncPtr -> IO Closure

mk_DebugFuncPtr :: C_DebugFuncPtr -> IO (FunPtr C_DebugFuncPtr)

noDebugFuncPtr :: Maybe DebugFuncPtr

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

ElementCallAsyncFunc

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

type ElementCallAsyncFunc = Element -> IO ()

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

drop_closures_ElementCallAsyncFunc :: ElementCallAsyncFunc -> ElementCallAsyncFunc_WithClosures

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

genClosure_ElementCallAsyncFunc :: ElementCallAsyncFunc -> IO Closure

mk_ElementCallAsyncFunc :: C_ElementCallAsyncFunc -> IO (FunPtr C_ElementCallAsyncFunc)

noElementCallAsyncFunc :: Maybe ElementCallAsyncFunc

noElementCallAsyncFunc_WithClosures :: Maybe ElementCallAsyncFunc_WithClosures

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

IteratorCopyFunction

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

type IteratorCopyFunction = Iterator -> Iterator -> IO ()

dynamic_IteratorCopyFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IteratorCopyFunction

-> Iterator

it: The original iterator

-> Iterator

copy: The copied iterator

-> m ()

genClosure_IteratorCopyFunction :: IteratorCopyFunction -> IO Closure

mk_IteratorCopyFunction :: C_IteratorCopyFunction -> IO (FunPtr C_IteratorCopyFunction)

noIteratorCopyFunction :: Maybe IteratorCopyFunction

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

IteratorFoldFunction

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

type IteratorFoldFunction = GValue -> GValue -> IO Bool

type IteratorFoldFunction_WithClosures = GValue -> GValue -> Ptr () -> IO Bool

drop_closures_IteratorFoldFunction :: IteratorFoldFunction -> IteratorFoldFunction_WithClosures

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.

genClosure_IteratorFoldFunction :: IteratorFoldFunction -> IO Closure

mk_IteratorFoldFunction :: C_IteratorFoldFunction -> IO (FunPtr C_IteratorFoldFunction)

noIteratorFoldFunction :: Maybe IteratorFoldFunction

noIteratorFoldFunction_WithClosures :: Maybe IteratorFoldFunction_WithClosures

wrap_IteratorFoldFunction :: Maybe (Ptr (FunPtr C_IteratorFoldFunction)) -> IteratorFoldFunction_WithClosures -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt

IteratorForeachFunction

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

type IteratorForeachFunction = GValue -> IO ()

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

drop_closures_IteratorForeachFunction :: IteratorForeachFunction -> IteratorForeachFunction_WithClosures

dynamic_IteratorForeachFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IteratorForeachFunction

-> GValue

item: The item

-> Ptr ()

userData: User data

-> m ()

genClosure_IteratorForeachFunction :: IteratorForeachFunction -> IO Closure

mk_IteratorForeachFunction :: C_IteratorForeachFunction -> IO (FunPtr C_IteratorForeachFunction)

noIteratorForeachFunction :: Maybe IteratorForeachFunction

noIteratorForeachFunction_WithClosures :: Maybe IteratorForeachFunction_WithClosures

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

IteratorFreeFunction

type C_IteratorFreeFunction = Ptr Iterator -> IO ()

type IteratorFreeFunction = Iterator -> IO ()

dynamic_IteratorFreeFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IteratorFreeFunction

-> Iterator

it: the iterator

-> m ()

genClosure_IteratorFreeFunction :: IteratorFreeFunction -> IO Closure

mk_IteratorFreeFunction :: C_IteratorFreeFunction -> IO (FunPtr C_IteratorFreeFunction)

noIteratorFreeFunction :: Maybe IteratorFreeFunction

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

IteratorItemFunction

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

type IteratorItemFunction = Iterator -> GValue -> IO IteratorItem

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.

genClosure_IteratorItemFunction :: IteratorItemFunction -> IO Closure

mk_IteratorItemFunction :: C_IteratorItemFunction -> IO (FunPtr C_IteratorItemFunction)

noIteratorItemFunction :: Maybe IteratorItemFunction

wrap_IteratorItemFunction :: Maybe (Ptr (FunPtr C_IteratorItemFunction)) -> IteratorItemFunction -> Ptr Iterator -> Ptr GValue -> IO CUInt

IteratorNextFunction

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

type IteratorNextFunction = Iterator -> GValue -> IO IteratorResult

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.

genClosure_IteratorNextFunction :: IteratorNextFunction -> IO Closure

mk_IteratorNextFunction :: C_IteratorNextFunction -> IO (FunPtr C_IteratorNextFunction)

noIteratorNextFunction :: Maybe IteratorNextFunction

wrap_IteratorNextFunction :: Maybe (Ptr (FunPtr C_IteratorNextFunction)) -> IteratorNextFunction -> Ptr Iterator -> Ptr GValue -> IO CUInt

IteratorResyncFunction

type C_IteratorResyncFunction = Ptr Iterator -> IO ()

type IteratorResyncFunction = Iterator -> IO ()

dynamic_IteratorResyncFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IteratorResyncFunction

-> Iterator

it: the iterator

-> m ()

genClosure_IteratorResyncFunction :: IteratorResyncFunction -> IO Closure

mk_IteratorResyncFunction :: C_IteratorResyncFunction -> IO (FunPtr C_IteratorResyncFunction)

noIteratorResyncFunction :: Maybe IteratorResyncFunction

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

LogFunction

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

type LogFunction = DebugCategory -> DebugLevel -> Text -> Text -> Int32 -> Object -> DebugMessage -> IO ()

type LogFunction_WithClosures = DebugCategory -> DebugLevel -> Text -> Text -> Int32 -> Object -> DebugMessage -> Ptr () -> IO ()

drop_closures_LogFunction :: LogFunction -> LogFunction_WithClosures

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

genClosure_LogFunction :: LogFunction -> IO Closure

mk_LogFunction :: C_LogFunction -> IO (FunPtr C_LogFunction)

noLogFunction :: Maybe LogFunction

noLogFunction_WithClosures :: Maybe LogFunction_WithClosures

wrap_LogFunction :: Maybe (Ptr (FunPtr C_LogFunction)) -> LogFunction_WithClosures -> Ptr DebugCategory -> CUInt -> CString -> CString -> Int32 -> Ptr Object -> Ptr DebugMessage -> Ptr () -> IO ()

MemoryCopyFunction

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

type MemoryCopyFunction = Memory -> Int64 -> Int64 -> IO Memory

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.

genClosure_MemoryCopyFunction :: MemoryCopyFunction -> IO Closure

mk_MemoryCopyFunction :: C_MemoryCopyFunction -> IO (FunPtr C_MemoryCopyFunction)

noMemoryCopyFunction :: Maybe MemoryCopyFunction

wrap_MemoryCopyFunction :: Maybe (Ptr (FunPtr C_MemoryCopyFunction)) -> MemoryCopyFunction -> Ptr Memory -> Int64 -> Int64 -> IO (Ptr Memory)

MemoryIsSpanFunction

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

type MemoryIsSpanFunction = Memory -> Memory -> Word64 -> IO Bool

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.

genClosure_MemoryIsSpanFunction :: MemoryIsSpanFunction -> IO Closure

mk_MemoryIsSpanFunction :: C_MemoryIsSpanFunction -> IO (FunPtr C_MemoryIsSpanFunction)

noMemoryIsSpanFunction :: Maybe MemoryIsSpanFunction

wrap_MemoryIsSpanFunction :: Maybe (Ptr (FunPtr C_MemoryIsSpanFunction)) -> MemoryIsSpanFunction -> Ptr Memory -> Ptr Memory -> Word64 -> IO CInt

MemoryMapFullFunction

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

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

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.

genClosure_MemoryMapFullFunction :: MemoryMapFullFunction -> IO Closure

mk_MemoryMapFullFunction :: C_MemoryMapFullFunction -> IO (FunPtr C_MemoryMapFullFunction)

noMemoryMapFullFunction :: Maybe MemoryMapFullFunction

wrap_MemoryMapFullFunction :: Maybe (Ptr (FunPtr C_MemoryMapFullFunction)) -> MemoryMapFullFunction -> Ptr Memory -> Ptr MapInfo -> Word64 -> IO (Ptr ())

MemoryMapFunction

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

type MemoryMapFunction = Memory -> Word64 -> [MapFlags] -> IO (Ptr ())

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.

genClosure_MemoryMapFunction :: MemoryMapFunction -> IO Closure

mk_MemoryMapFunction :: C_MemoryMapFunction -> IO (FunPtr C_MemoryMapFunction)

noMemoryMapFunction :: Maybe MemoryMapFunction

wrap_MemoryMapFunction :: Maybe (Ptr (FunPtr C_MemoryMapFunction)) -> MemoryMapFunction -> Ptr Memory -> Word64 -> CUInt -> IO (Ptr ())

MemoryShareFunction

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

type MemoryShareFunction = Memory -> Int64 -> Int64 -> IO Memory

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.

genClosure_MemoryShareFunction :: MemoryShareFunction -> IO Closure

mk_MemoryShareFunction :: C_MemoryShareFunction -> IO (FunPtr C_MemoryShareFunction)

noMemoryShareFunction :: Maybe MemoryShareFunction

wrap_MemoryShareFunction :: Maybe (Ptr (FunPtr C_MemoryShareFunction)) -> MemoryShareFunction -> Ptr Memory -> Int64 -> Int64 -> IO (Ptr Memory)

MemoryUnmapFullFunction

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

type MemoryUnmapFullFunction = Memory -> MapInfo -> IO ()

dynamic_MemoryUnmapFullFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MemoryUnmapFullFunction

-> Memory

mem: a Memory

-> MapInfo

info: a MapInfo

-> m ()

genClosure_MemoryUnmapFullFunction :: MemoryUnmapFullFunction -> IO Closure

mk_MemoryUnmapFullFunction :: C_MemoryUnmapFullFunction -> IO (FunPtr C_MemoryUnmapFullFunction)

noMemoryUnmapFullFunction :: Maybe MemoryUnmapFullFunction

wrap_MemoryUnmapFullFunction :: Maybe (Ptr (FunPtr C_MemoryUnmapFullFunction)) -> MemoryUnmapFullFunction -> Ptr Memory -> Ptr MapInfo -> IO ()

MemoryUnmapFunction

type C_MemoryUnmapFunction = Ptr Memory -> IO ()

type MemoryUnmapFunction = Memory -> IO ()

dynamic_MemoryUnmapFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MemoryUnmapFunction

-> Memory

mem: a Memory

-> m ()

genClosure_MemoryUnmapFunction :: MemoryUnmapFunction -> IO Closure

mk_MemoryUnmapFunction :: C_MemoryUnmapFunction -> IO (FunPtr C_MemoryUnmapFunction)

noMemoryUnmapFunction :: Maybe MemoryUnmapFunction

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

MetaFreeFunction

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

type MetaFreeFunction = Meta -> Buffer -> IO ()

dynamic_MetaFreeFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MetaFreeFunction

-> Meta

meta: a Meta

-> Buffer

buffer: a Buffer

-> m ()

genClosure_MetaFreeFunction :: MetaFreeFunction -> IO Closure

mk_MetaFreeFunction :: C_MetaFreeFunction -> IO (FunPtr C_MetaFreeFunction)

noMetaFreeFunction :: Maybe MetaFreeFunction

wrap_MetaFreeFunction :: Maybe (Ptr (FunPtr C_MetaFreeFunction)) -> MetaFreeFunction -> Ptr Meta -> Ptr Buffer -> IO ()

MetaInitFunction

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

type MetaInitFunction = Meta -> Ptr () -> Buffer -> IO Bool

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

genClosure_MetaInitFunction :: MetaInitFunction -> IO Closure

mk_MetaInitFunction :: C_MetaInitFunction -> IO (FunPtr C_MetaInitFunction)

noMetaInitFunction :: Maybe MetaInitFunction

wrap_MetaInitFunction :: Maybe (Ptr (FunPtr C_MetaInitFunction)) -> MetaInitFunction -> Ptr Meta -> Ptr () -> Ptr Buffer -> IO CInt

MetaTransformFunction

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

type MetaTransformFunction = Buffer -> Meta -> Buffer -> Word32 -> Ptr () -> IO Bool

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

genClosure_MetaTransformFunction :: MetaTransformFunction -> IO Closure

mk_MetaTransformFunction :: C_MetaTransformFunction -> IO (FunPtr C_MetaTransformFunction)

noMetaTransformFunction :: Maybe MetaTransformFunction

wrap_MetaTransformFunction :: Maybe (Ptr (FunPtr C_MetaTransformFunction)) -> MetaTransformFunction -> Ptr Buffer -> Ptr Meta -> Ptr Buffer -> Word32 -> Ptr () -> IO CInt

MiniObjectDisposeFunction

type C_MiniObjectDisposeFunction = Ptr MiniObject -> IO CInt

type MiniObjectDisposeFunction = MiniObject -> IO Bool

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.

genClosure_MiniObjectDisposeFunction :: MiniObjectDisposeFunction -> IO Closure

mk_MiniObjectDisposeFunction :: C_MiniObjectDisposeFunction -> IO (FunPtr C_MiniObjectDisposeFunction)

noMiniObjectDisposeFunction :: Maybe MiniObjectDisposeFunction

wrap_MiniObjectDisposeFunction :: Maybe (Ptr (FunPtr C_MiniObjectDisposeFunction)) -> MiniObjectDisposeFunction -> Ptr MiniObject -> IO CInt

MiniObjectFreeFunction

type C_MiniObjectFreeFunction = Ptr MiniObject -> IO ()

type MiniObjectFreeFunction = MiniObject -> IO ()

dynamic_MiniObjectFreeFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MiniObjectFreeFunction

-> MiniObject

obj: MiniObject to free

-> m ()

genClosure_MiniObjectFreeFunction :: MiniObjectFreeFunction -> IO Closure

mk_MiniObjectFreeFunction :: C_MiniObjectFreeFunction -> IO (FunPtr C_MiniObjectFreeFunction)

noMiniObjectFreeFunction :: Maybe MiniObjectFreeFunction

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

MiniObjectNotify

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

type MiniObjectNotify = MiniObject -> IO ()

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

drop_closures_MiniObjectNotify :: MiniObjectNotify -> MiniObjectNotify_WithClosures

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

genClosure_MiniObjectNotify :: MiniObjectNotify -> IO Closure

mk_MiniObjectNotify :: C_MiniObjectNotify -> IO (FunPtr C_MiniObjectNotify)

noMiniObjectNotify :: Maybe MiniObjectNotify

noMiniObjectNotify_WithClosures :: Maybe MiniObjectNotify_WithClosures

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

PadActivateFunction

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

type PadActivateFunction = Pad -> Object -> IO Bool

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.

genClosure_PadActivateFunction :: PadActivateFunction -> IO Closure

mk_PadActivateFunction :: C_PadActivateFunction -> IO (FunPtr C_PadActivateFunction)

noPadActivateFunction :: Maybe PadActivateFunction

wrap_PadActivateFunction :: Maybe (Ptr (FunPtr C_PadActivateFunction)) -> PadActivateFunction -> Ptr Pad -> Ptr Object -> IO CInt

PadActivateModeFunction

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

type PadActivateModeFunction = Pad -> Object -> PadMode -> Bool -> IO Bool

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.

genClosure_PadActivateModeFunction :: PadActivateModeFunction -> IO Closure

mk_PadActivateModeFunction :: C_PadActivateModeFunction -> IO (FunPtr C_PadActivateModeFunction)

noPadActivateModeFunction :: Maybe PadActivateModeFunction

wrap_PadActivateModeFunction :: Maybe (Ptr (FunPtr C_PadActivateModeFunction)) -> PadActivateModeFunction -> Ptr Pad -> Ptr Object -> CUInt -> CInt -> IO CInt

PadChainFunction

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

type PadChainFunction = Pad -> Maybe Object -> Buffer -> IO FlowReturn

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

genClosure_PadChainFunction :: PadChainFunction -> IO Closure

mk_PadChainFunction :: C_PadChainFunction -> IO (FunPtr C_PadChainFunction)

noPadChainFunction :: Maybe PadChainFunction

wrap_PadChainFunction :: Maybe (Ptr (FunPtr C_PadChainFunction)) -> PadChainFunction -> Ptr Pad -> Ptr Object -> Ptr Buffer -> IO CUInt

PadChainListFunction

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

type PadChainListFunction = Pad -> Maybe Object -> BufferList -> IO FlowReturn

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

genClosure_PadChainListFunction :: PadChainListFunction -> IO Closure

mk_PadChainListFunction :: C_PadChainListFunction -> IO (FunPtr C_PadChainListFunction)

noPadChainListFunction :: Maybe PadChainListFunction

wrap_PadChainListFunction :: Maybe (Ptr (FunPtr C_PadChainListFunction)) -> PadChainListFunction -> Ptr Pad -> Ptr Object -> Ptr BufferList -> IO CUInt

PadEventFullFunction

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

type PadEventFullFunction = Pad -> Maybe Object -> Event -> IO FlowReturn

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.

genClosure_PadEventFullFunction :: PadEventFullFunction -> IO Closure

mk_PadEventFullFunction :: C_PadEventFullFunction -> IO (FunPtr C_PadEventFullFunction)

noPadEventFullFunction :: Maybe PadEventFullFunction

wrap_PadEventFullFunction :: Maybe (Ptr (FunPtr C_PadEventFullFunction)) -> PadEventFullFunction -> Ptr Pad -> Ptr Object -> Ptr Event -> IO CUInt

PadEventFunction

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

type PadEventFunction = Pad -> Maybe Object -> Event -> IO Bool

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.

genClosure_PadEventFunction :: PadEventFunction -> IO Closure

mk_PadEventFunction :: C_PadEventFunction -> IO (FunPtr C_PadEventFunction)

noPadEventFunction :: Maybe PadEventFunction

wrap_PadEventFunction :: Maybe (Ptr (FunPtr C_PadEventFunction)) -> PadEventFunction -> Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt

PadForwardFunction

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

type PadForwardFunction = Pad -> IO Bool

type PadForwardFunction_WithClosures = Pad -> Ptr () -> IO Bool

drop_closures_PadForwardFunction :: PadForwardFunction -> PadForwardFunction_WithClosures

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.

genClosure_PadForwardFunction :: PadForwardFunction -> IO Closure

mk_PadForwardFunction :: C_PadForwardFunction -> IO (FunPtr C_PadForwardFunction)

noPadForwardFunction :: Maybe PadForwardFunction

noPadForwardFunction_WithClosures :: Maybe PadForwardFunction_WithClosures

wrap_PadForwardFunction :: Maybe (Ptr (FunPtr C_PadForwardFunction)) -> PadForwardFunction_WithClosures -> Ptr Pad -> Ptr () -> IO CInt

PadGetRangeFunction

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

type PadGetRangeFunction = Pad -> Maybe Object -> Word64 -> Word32 -> Buffer -> IO FlowReturn

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.

genClosure_PadGetRangeFunction :: PadGetRangeFunction -> IO Closure

mk_PadGetRangeFunction :: C_PadGetRangeFunction -> IO (FunPtr C_PadGetRangeFunction)

noPadGetRangeFunction :: Maybe PadGetRangeFunction

wrap_PadGetRangeFunction :: Maybe (Ptr (FunPtr C_PadGetRangeFunction)) -> PadGetRangeFunction -> Ptr Pad -> Ptr Object -> Word64 -> Word32 -> Ptr Buffer -> IO CUInt

PadIterIntLinkFunction

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

type PadIterIntLinkFunction = Pad -> Maybe Object -> IO Iterator

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.

genClosure_PadIterIntLinkFunction :: PadIterIntLinkFunction -> IO Closure

mk_PadIterIntLinkFunction :: C_PadIterIntLinkFunction -> IO (FunPtr C_PadIterIntLinkFunction)

noPadIterIntLinkFunction :: Maybe PadIterIntLinkFunction

wrap_PadIterIntLinkFunction :: Maybe (Ptr (FunPtr C_PadIterIntLinkFunction)) -> PadIterIntLinkFunction -> Ptr Pad -> Ptr Object -> IO (Ptr Iterator)

PadLinkFunction

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

type PadLinkFunction = Pad -> Maybe Object -> Pad -> IO PadLinkReturn

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.

genClosure_PadLinkFunction :: PadLinkFunction -> IO Closure

mk_PadLinkFunction :: C_PadLinkFunction -> IO (FunPtr C_PadLinkFunction)

noPadLinkFunction :: Maybe PadLinkFunction

wrap_PadLinkFunction :: Maybe (Ptr (FunPtr C_PadLinkFunction)) -> PadLinkFunction -> Ptr Pad -> Ptr Object -> Ptr Pad -> IO CUInt

PadProbeCallback

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

type PadProbeCallback = Pad -> PadProbeInfo -> IO PadProbeReturn

type PadProbeCallback_WithClosures = Pad -> PadProbeInfo -> Ptr () -> IO PadProbeReturn

drop_closures_PadProbeCallback :: PadProbeCallback -> PadProbeCallback_WithClosures

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

genClosure_PadProbeCallback :: PadProbeCallback -> IO Closure

mk_PadProbeCallback :: C_PadProbeCallback -> IO (FunPtr C_PadProbeCallback)

noPadProbeCallback :: Maybe PadProbeCallback

noPadProbeCallback_WithClosures :: Maybe PadProbeCallback_WithClosures

wrap_PadProbeCallback :: Maybe (Ptr (FunPtr C_PadProbeCallback)) -> PadProbeCallback_WithClosures -> Ptr Pad -> Ptr PadProbeInfo -> Ptr () -> IO CUInt

PadQueryFunction

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

type PadQueryFunction = Pad -> Maybe Object -> Query -> IO Bool

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.

genClosure_PadQueryFunction :: PadQueryFunction -> IO Closure

mk_PadQueryFunction :: C_PadQueryFunction -> IO (FunPtr C_PadQueryFunction)

noPadQueryFunction :: Maybe PadQueryFunction

wrap_PadQueryFunction :: Maybe (Ptr (FunPtr C_PadQueryFunction)) -> PadQueryFunction -> Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt

PadStickyEventsForeachFunction

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

type PadStickyEventsForeachFunction = Pad -> Maybe Event -> IO Bool

type PadStickyEventsForeachFunction_WithClosures = Pad -> Maybe Event -> Ptr () -> IO Bool

drop_closures_PadStickyEventsForeachFunction :: PadStickyEventsForeachFunction -> PadStickyEventsForeachFunction_WithClosures

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

genClosure_PadStickyEventsForeachFunction :: PadStickyEventsForeachFunction -> IO Closure

mk_PadStickyEventsForeachFunction :: C_PadStickyEventsForeachFunction -> IO (FunPtr C_PadStickyEventsForeachFunction)

noPadStickyEventsForeachFunction :: Maybe PadStickyEventsForeachFunction

noPadStickyEventsForeachFunction_WithClosures :: Maybe PadStickyEventsForeachFunction_WithClosures

wrap_PadStickyEventsForeachFunction :: Maybe (Ptr (FunPtr C_PadStickyEventsForeachFunction)) -> PadStickyEventsForeachFunction_WithClosures -> Ptr Pad -> Ptr Event -> Ptr () -> IO CInt

PadUnlinkFunction

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

type PadUnlinkFunction = Pad -> Maybe Object -> IO ()

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

genClosure_PadUnlinkFunction :: PadUnlinkFunction -> IO Closure

mk_PadUnlinkFunction :: C_PadUnlinkFunction -> IO (FunPtr C_PadUnlinkFunction)

noPadUnlinkFunction :: Maybe PadUnlinkFunction

wrap_PadUnlinkFunction :: Maybe (Ptr (FunPtr C_PadUnlinkFunction)) -> PadUnlinkFunction -> Ptr Pad -> Ptr Object -> IO ()

PluginFeatureFilter

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

type PluginFeatureFilter = PluginFeature -> IO Bool

type PluginFeatureFilter_WithClosures = PluginFeature -> Ptr () -> IO Bool

drop_closures_PluginFeatureFilter :: PluginFeatureFilter -> PluginFeatureFilter_WithClosures

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

genClosure_PluginFeatureFilter :: PluginFeatureFilter -> IO Closure

mk_PluginFeatureFilter :: C_PluginFeatureFilter -> IO (FunPtr C_PluginFeatureFilter)

noPluginFeatureFilter :: Maybe PluginFeatureFilter

noPluginFeatureFilter_WithClosures :: Maybe PluginFeatureFilter_WithClosures

wrap_PluginFeatureFilter :: Maybe (Ptr (FunPtr C_PluginFeatureFilter)) -> PluginFeatureFilter_WithClosures -> Ptr PluginFeature -> Ptr () -> IO CInt

PluginFilter

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

type PluginFilter = Plugin -> IO Bool

type PluginFilter_WithClosures = Plugin -> Ptr () -> IO Bool

drop_closures_PluginFilter :: PluginFilter -> PluginFilter_WithClosures

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

genClosure_PluginFilter :: PluginFilter -> IO Closure

mk_PluginFilter :: C_PluginFilter -> IO (FunPtr C_PluginFilter)

noPluginFilter :: Maybe PluginFilter

noPluginFilter_WithClosures :: Maybe PluginFilter_WithClosures

wrap_PluginFilter :: Maybe (Ptr (FunPtr C_PluginFilter)) -> PluginFilter_WithClosures -> Ptr Plugin -> Ptr () -> IO CInt

PluginInitFullFunc

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

type PluginInitFullFunc = Plugin -> IO Bool

type PluginInitFullFunc_WithClosures = Plugin -> Ptr () -> IO Bool

drop_closures_PluginInitFullFunc :: PluginInitFullFunc -> PluginInitFullFunc_WithClosures

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

genClosure_PluginInitFullFunc :: PluginInitFullFunc -> IO Closure

mk_PluginInitFullFunc :: C_PluginInitFullFunc -> IO (FunPtr C_PluginInitFullFunc)

noPluginInitFullFunc :: Maybe PluginInitFullFunc

noPluginInitFullFunc_WithClosures :: Maybe PluginInitFullFunc_WithClosures

wrap_PluginInitFullFunc :: Maybe (Ptr (FunPtr C_PluginInitFullFunc)) -> PluginInitFullFunc_WithClosures -> Ptr Plugin -> Ptr () -> IO CInt

PluginInitFunc

type C_PluginInitFunc = Ptr Plugin -> IO CInt

type PluginInitFunc = Plugin -> IO Bool

dynamic_PluginInitFunc

Arguments

:: (HasCallStack, MonadIO m, IsPlugin a)

=> FunPtr C_PluginInitFunc

-> a

plugin: The plugin object

-> m Bool

Returns: True if plugin initialised successfully

genClosure_PluginInitFunc :: PluginInitFunc -> IO Closure

mk_PluginInitFunc :: C_PluginInitFunc -> IO (FunPtr C_PluginInitFunc)

noPluginInitFunc :: Maybe PluginInitFunc

wrap_PluginInitFunc :: Maybe (Ptr (FunPtr C_PluginInitFunc)) -> PluginInitFunc -> Ptr Plugin -> IO CInt

StructureFilterMapFunc

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

type StructureFilterMapFunc = Word32 -> GValue -> IO Bool

type StructureFilterMapFunc_WithClosures = Word32 -> GValue -> Ptr () -> IO Bool

drop_closures_StructureFilterMapFunc :: StructureFilterMapFunc -> StructureFilterMapFunc_WithClosures

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.

genClosure_StructureFilterMapFunc :: StructureFilterMapFunc -> IO Closure

mk_StructureFilterMapFunc :: C_StructureFilterMapFunc -> IO (FunPtr C_StructureFilterMapFunc)

noStructureFilterMapFunc :: Maybe StructureFilterMapFunc

noStructureFilterMapFunc_WithClosures :: Maybe StructureFilterMapFunc_WithClosures

wrap_StructureFilterMapFunc :: Maybe (Ptr (FunPtr C_StructureFilterMapFunc)) -> StructureFilterMapFunc_WithClosures -> Word32 -> Ptr GValue -> Ptr () -> IO CInt

StructureForeachFunc

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

type StructureForeachFunc = Word32 -> GValue -> IO Bool

type StructureForeachFunc_WithClosures = Word32 -> GValue -> Ptr () -> IO Bool

drop_closures_StructureForeachFunc :: StructureForeachFunc -> StructureForeachFunc_WithClosures

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.

genClosure_StructureForeachFunc :: StructureForeachFunc -> IO Closure

mk_StructureForeachFunc :: C_StructureForeachFunc -> IO (FunPtr C_StructureForeachFunc)

noStructureForeachFunc :: Maybe StructureForeachFunc

noStructureForeachFunc_WithClosures :: Maybe StructureForeachFunc_WithClosures

wrap_StructureForeachFunc :: Maybe (Ptr (FunPtr C_StructureForeachFunc)) -> StructureForeachFunc_WithClosures -> Word32 -> Ptr GValue -> Ptr () -> IO CInt

StructureMapFunc

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

type StructureMapFunc = Word32 -> GValue -> IO Bool

type StructureMapFunc_WithClosures = Word32 -> GValue -> Ptr () -> IO Bool

drop_closures_StructureMapFunc :: StructureMapFunc -> StructureMapFunc_WithClosures

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.

genClosure_StructureMapFunc :: StructureMapFunc -> IO Closure

mk_StructureMapFunc :: C_StructureMapFunc -> IO (FunPtr C_StructureMapFunc)

noStructureMapFunc :: Maybe StructureMapFunc

noStructureMapFunc_WithClosures :: Maybe StructureMapFunc_WithClosures

wrap_StructureMapFunc :: Maybe (Ptr (FunPtr C_StructureMapFunc)) -> StructureMapFunc_WithClosures -> Word32 -> Ptr GValue -> Ptr () -> IO CInt

TagForeachFunc

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

type TagForeachFunc = TagList -> Text -> IO ()

type TagForeachFunc_WithClosures = TagList -> Text -> Ptr () -> IO ()

drop_closures_TagForeachFunc :: TagForeachFunc -> TagForeachFunc_WithClosures

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

genClosure_TagForeachFunc :: TagForeachFunc -> IO Closure

mk_TagForeachFunc :: C_TagForeachFunc -> IO (FunPtr C_TagForeachFunc)

noTagForeachFunc :: Maybe TagForeachFunc

noTagForeachFunc_WithClosures :: Maybe TagForeachFunc_WithClosures

wrap_TagForeachFunc :: Maybe (Ptr (FunPtr C_TagForeachFunc)) -> TagForeachFunc_WithClosures -> Ptr TagList -> CString -> Ptr () -> IO ()

TagMergeFunc

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

type TagMergeFunc = GValue -> GValue -> IO ()

dynamic_TagMergeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TagMergeFunc

-> GValue

dest: the destination Value

-> GValue

src: the source Value

-> m ()

genClosure_TagMergeFunc :: TagMergeFunc -> IO Closure

mk_TagMergeFunc :: C_TagMergeFunc -> IO (FunPtr C_TagMergeFunc)

noTagMergeFunc :: Maybe TagMergeFunc

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

TaskFunction

type C_TaskFunction = Ptr () -> IO ()

type TaskFunction = IO ()

type TaskFunction_WithClosures = Ptr () -> IO ()

drop_closures_TaskFunction :: TaskFunction -> TaskFunction_WithClosures

dynamic_TaskFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TaskFunction

-> Ptr ()

userData: user data passed to the function

-> m ()

genClosure_TaskFunction :: TaskFunction -> IO Closure

mk_TaskFunction :: C_TaskFunction -> IO (FunPtr C_TaskFunction)

noTaskFunction :: Maybe TaskFunction

noTaskFunction_WithClosures :: Maybe TaskFunction_WithClosures

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

TaskPoolFunction

type C_TaskPoolFunction = Ptr () -> IO ()

type TaskPoolFunction = IO ()

type TaskPoolFunction_WithClosures = Ptr () -> IO ()

drop_closures_TaskPoolFunction :: TaskPoolFunction -> TaskPoolFunction_WithClosures

dynamic_TaskPoolFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TaskPoolFunction

-> Ptr ()

userData: user data for the task function

-> m ()

genClosure_TaskPoolFunction :: TaskPoolFunction -> IO Closure

mk_TaskPoolFunction :: C_TaskPoolFunction -> IO (FunPtr C_TaskPoolFunction)

noTaskPoolFunction :: Maybe TaskPoolFunction

noTaskPoolFunction_WithClosures :: Maybe TaskPoolFunction_WithClosures

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

TaskThreadFunc

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

type TaskThreadFunc = Task -> Thread -> IO ()

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

drop_closures_TaskThreadFunc :: TaskThreadFunc -> TaskThreadFunc_WithClosures

dynamic_TaskThreadFunc

Arguments

:: (HasCallStack, MonadIO m, IsTask a)

=> FunPtr C_TaskThreadFunc

-> a

task: The Task

-> Thread

thread: The Thread

-> Ptr ()

userData: user data

-> m ()

genClosure_TaskThreadFunc :: TaskThreadFunc -> IO Closure

mk_TaskThreadFunc :: C_TaskThreadFunc -> IO (FunPtr C_TaskThreadFunc)

noTaskThreadFunc :: Maybe TaskThreadFunc

noTaskThreadFunc_WithClosures :: Maybe TaskThreadFunc_WithClosures

wrap_TaskThreadFunc :: Maybe (Ptr (FunPtr C_TaskThreadFunc)) -> TaskThreadFunc_WithClosures -> Ptr Task -> Ptr Thread -> Ptr () -> IO ()

TypeFindFunction

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

type TypeFindFunction = TypeFind -> IO ()

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

drop_closures_TypeFindFunction :: TypeFindFunction -> TypeFindFunction_WithClosures

dynamic_TypeFindFunction

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TypeFindFunction

-> TypeFind

find: A TypeFind structure

-> Ptr ()

userData: optional data to pass to the function

-> m ()

genClosure_TypeFindFunction :: TypeFindFunction -> IO Closure

mk_TypeFindFunction :: C_TypeFindFunction -> IO (FunPtr C_TypeFindFunction)

noTypeFindFunction :: Maybe TypeFindFunction

noTypeFindFunction_WithClosures :: Maybe TypeFindFunction_WithClosures

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

TypeFindGetLengthFieldCallback

type C_TypeFindGetLengthFieldCallback = Ptr () -> IO Word64

type TypeFindGetLengthFieldCallback = Ptr () -> IO Word64

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

genClosure_TypeFindGetLengthFieldCallback :: TypeFindGetLengthFieldCallback -> IO Closure

mk_TypeFindGetLengthFieldCallback :: C_TypeFindGetLengthFieldCallback -> IO (FunPtr C_TypeFindGetLengthFieldCallback)

noTypeFindGetLengthFieldCallback :: Maybe TypeFindGetLengthFieldCallback

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

TypeFindPeekFieldCallback

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

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

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

genClosure_TypeFindPeekFieldCallback :: TypeFindPeekFieldCallback -> IO Closure

mk_TypeFindPeekFieldCallback :: C_TypeFindPeekFieldCallback -> IO (FunPtr C_TypeFindPeekFieldCallback)

noTypeFindPeekFieldCallback :: Maybe TypeFindPeekFieldCallback

wrap_TypeFindPeekFieldCallback :: Maybe (Ptr (FunPtr C_TypeFindPeekFieldCallback)) -> TypeFindPeekFieldCallback -> Ptr () -> Int64 -> Word32 -> IO Word8

TypeFindSuggestFieldCallback

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

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

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

genClosure_TypeFindSuggestFieldCallback :: TypeFindSuggestFieldCallback -> IO Closure

mk_TypeFindSuggestFieldCallback :: C_TypeFindSuggestFieldCallback -> IO (FunPtr C_TypeFindSuggestFieldCallback)

noTypeFindSuggestFieldCallback :: Maybe TypeFindSuggestFieldCallback

wrap_TypeFindSuggestFieldCallback :: Maybe (Ptr (FunPtr C_TypeFindSuggestFieldCallback)) -> TypeFindSuggestFieldCallback -> Ptr () -> Word32 -> Ptr Caps -> IO ()

ValueCompareFunc

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

type ValueCompareFunc = GValue -> GValue -> IO Int32

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

genClosure_ValueCompareFunc :: ValueCompareFunc -> IO Closure

mk_ValueCompareFunc :: C_ValueCompareFunc -> IO (FunPtr C_ValueCompareFunc)

noValueCompareFunc :: Maybe ValueCompareFunc

wrap_ValueCompareFunc :: Maybe (Ptr (FunPtr C_ValueCompareFunc)) -> ValueCompareFunc -> Ptr GValue -> Ptr GValue -> IO Int32

ValueDeserializeFunc

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

type ValueDeserializeFunc = GValue -> Text -> IO Bool

dynamic_ValueDeserializeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ValueDeserializeFunc

-> GValue

dest: a Value

-> Text

s: a string

-> m Bool

Returns: True for success

genClosure_ValueDeserializeFunc :: ValueDeserializeFunc -> IO Closure

mk_ValueDeserializeFunc :: C_ValueDeserializeFunc -> IO (FunPtr C_ValueDeserializeFunc)

noValueDeserializeFunc :: Maybe ValueDeserializeFunc

wrap_ValueDeserializeFunc :: Maybe (Ptr (FunPtr C_ValueDeserializeFunc)) -> ValueDeserializeFunc -> Ptr GValue -> CString -> IO CInt

ValueSerializeFunc

type C_ValueSerializeFunc = Ptr GValue -> IO CString

type ValueSerializeFunc = GValue -> IO Text

dynamic_ValueSerializeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ValueSerializeFunc

-> GValue

value1: a Value

-> m Text

Returns: the string representation of the value

genClosure_ValueSerializeFunc :: ValueSerializeFunc -> IO Closure

mk_ValueSerializeFunc :: C_ValueSerializeFunc -> IO (FunPtr C_ValueSerializeFunc)

noValueSerializeFunc :: Maybe ValueSerializeFunc

wrap_ValueSerializeFunc :: Maybe (Ptr (FunPtr C_ValueSerializeFunc)) -> ValueSerializeFunc -> Ptr GValue -> IO CString