#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstBase.Callbacks
(
C_CollectDataDestroyNotify ,
CollectDataDestroyNotify ,
dynamic_CollectDataDestroyNotify ,
genClosure_CollectDataDestroyNotify ,
mk_CollectDataDestroyNotify ,
noCollectDataDestroyNotify ,
wrap_CollectDataDestroyNotify ,
C_CollectPadsBufferFunction ,
CollectPadsBufferFunction ,
CollectPadsBufferFunction_WithClosures ,
drop_closures_CollectPadsBufferFunction ,
dynamic_CollectPadsBufferFunction ,
genClosure_CollectPadsBufferFunction ,
mk_CollectPadsBufferFunction ,
noCollectPadsBufferFunction ,
noCollectPadsBufferFunction_WithClosures,
wrap_CollectPadsBufferFunction ,
C_CollectPadsClipFunction ,
CollectPadsClipFunction ,
CollectPadsClipFunction_WithClosures ,
drop_closures_CollectPadsClipFunction ,
dynamic_CollectPadsClipFunction ,
genClosure_CollectPadsClipFunction ,
mk_CollectPadsClipFunction ,
noCollectPadsClipFunction ,
noCollectPadsClipFunction_WithClosures ,
wrap_CollectPadsClipFunction ,
C_CollectPadsCompareFunction ,
CollectPadsCompareFunction ,
CollectPadsCompareFunction_WithClosures ,
drop_closures_CollectPadsCompareFunction,
dynamic_CollectPadsCompareFunction ,
genClosure_CollectPadsCompareFunction ,
mk_CollectPadsCompareFunction ,
noCollectPadsCompareFunction ,
noCollectPadsCompareFunction_WithClosures,
wrap_CollectPadsCompareFunction ,
C_CollectPadsEventFunction ,
CollectPadsEventFunction ,
CollectPadsEventFunction_WithClosures ,
drop_closures_CollectPadsEventFunction ,
dynamic_CollectPadsEventFunction ,
genClosure_CollectPadsEventFunction ,
mk_CollectPadsEventFunction ,
noCollectPadsEventFunction ,
noCollectPadsEventFunction_WithClosures ,
wrap_CollectPadsEventFunction ,
C_CollectPadsFlushFunction ,
CollectPadsFlushFunction ,
CollectPadsFlushFunction_WithClosures ,
drop_closures_CollectPadsFlushFunction ,
dynamic_CollectPadsFlushFunction ,
genClosure_CollectPadsFlushFunction ,
mk_CollectPadsFlushFunction ,
noCollectPadsFlushFunction ,
noCollectPadsFlushFunction_WithClosures ,
wrap_CollectPadsFlushFunction ,
C_CollectPadsFunction ,
CollectPadsFunction ,
CollectPadsFunction_WithClosures ,
drop_closures_CollectPadsFunction ,
dynamic_CollectPadsFunction ,
genClosure_CollectPadsFunction ,
mk_CollectPadsFunction ,
noCollectPadsFunction ,
noCollectPadsFunction_WithClosures ,
wrap_CollectPadsFunction ,
C_CollectPadsQueryFunction ,
CollectPadsQueryFunction ,
CollectPadsQueryFunction_WithClosures ,
drop_closures_CollectPadsQueryFunction ,
dynamic_CollectPadsQueryFunction ,
genClosure_CollectPadsQueryFunction ,
mk_CollectPadsQueryFunction ,
noCollectPadsQueryFunction ,
noCollectPadsQueryFunction_WithClosures ,
wrap_CollectPadsQueryFunction ,
C_DataQueueEmptyCallback ,
DataQueueEmptyCallback ,
dynamic_DataQueueEmptyCallback ,
genClosure_DataQueueEmptyCallback ,
mk_DataQueueEmptyCallback ,
noDataQueueEmptyCallback ,
wrap_DataQueueEmptyCallback ,
C_DataQueueFullCallback ,
DataQueueFullCallback ,
dynamic_DataQueueFullCallback ,
genClosure_DataQueueFullCallback ,
mk_DataQueueFullCallback ,
noDataQueueFullCallback ,
wrap_DataQueueFullCallback ,
C_TypeFindHelperGetRangeFunction ,
TypeFindHelperGetRangeFunction ,
dynamic_TypeFindHelperGetRangeFunction ,
genClosure_TypeFindHelperGetRangeFunction,
mk_TypeFindHelperGetRangeFunction ,
noTypeFindHelperGetRangeFunction ,
wrap_TypeFindHelperGetRangeFunction ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.Gst.Enums as Gst.Enums
import qualified GI.Gst.Objects.Object as Gst.Object
import qualified GI.Gst.Structs.Buffer as Gst.Buffer
import qualified GI.Gst.Structs.Event as Gst.Event
import qualified GI.Gst.Structs.Query as Gst.Query
import {-# SOURCE #-} qualified GI.GstBase.Objects.CollectPads as GstBase.CollectPads
import {-# SOURCE #-} qualified GI.GstBase.Objects.DataQueue as GstBase.DataQueue
import {-# SOURCE #-} qualified GI.GstBase.Structs.CollectData as GstBase.CollectData
type C_TypeFindHelperGetRangeFunction =
Ptr Gst.Object.Object ->
Ptr Gst.Object.Object ->
Word64 ->
Word32 ->
Ptr (Ptr Gst.Buffer.Buffer) ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_TypeFindHelperGetRangeFunction :: FunPtr C_TypeFindHelperGetRangeFunction -> C_TypeFindHelperGetRangeFunction
dynamic_TypeFindHelperGetRangeFunction ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a, Gst.Object.IsObject b) =>
FunPtr C_TypeFindHelperGetRangeFunction
-> a
-> Maybe (b)
-> Word64
-> Word32
-> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))
dynamic_TypeFindHelperGetRangeFunction :: FunPtr C_TypeFindHelperGetRangeFunction
-> a -> Maybe b -> Word64 -> Word32 -> m (FlowReturn, Buffer)
dynamic_TypeFindHelperGetRangeFunction __funPtr :: FunPtr C_TypeFindHelperGetRangeFunction
__funPtr obj :: a
obj parent :: Maybe b
parent offset :: Word64
offset length_ :: Word32
length_ = IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer))
-> IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer)
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
obj' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
obj
Ptr Object
maybeParent <- case Maybe b
parent of
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just jParent :: b
jParent -> do
Ptr Object
jParent' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jParent
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jParent'
Ptr (Ptr Buffer)
buffer <- IO (Ptr (Ptr Buffer))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr Gst.Buffer.Buffer))
CInt
result <- (FunPtr C_TypeFindHelperGetRangeFunction
-> C_TypeFindHelperGetRangeFunction
__dynamic_C_TypeFindHelperGetRangeFunction FunPtr C_TypeFindHelperGetRangeFunction
__funPtr) Ptr Object
obj' Ptr Object
maybeParent Word64
offset Word32
length_ Ptr (Ptr Buffer)
buffer
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
Ptr Buffer
buffer' <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Buffer)
buffer
Buffer
buffer'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
buffer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
obj
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
parent b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Ptr (Ptr Buffer) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Buffer)
buffer
(FlowReturn, Buffer) -> IO (FlowReturn, Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return (FlowReturn
result', Buffer
buffer'')
foreign import ccall "wrapper"
mk_TypeFindHelperGetRangeFunction :: C_TypeFindHelperGetRangeFunction -> IO (FunPtr C_TypeFindHelperGetRangeFunction)
type TypeFindHelperGetRangeFunction =
Gst.Object.Object
-> Maybe Gst.Object.Object
-> Word64
-> Word32
-> IO ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))
noTypeFindHelperGetRangeFunction :: Maybe TypeFindHelperGetRangeFunction
noTypeFindHelperGetRangeFunction :: Maybe TypeFindHelperGetRangeFunction
noTypeFindHelperGetRangeFunction = Maybe TypeFindHelperGetRangeFunction
forall a. Maybe a
Nothing
genClosure_TypeFindHelperGetRangeFunction :: MonadIO m => TypeFindHelperGetRangeFunction -> m (GClosure C_TypeFindHelperGetRangeFunction)
genClosure_TypeFindHelperGetRangeFunction :: TypeFindHelperGetRangeFunction
-> m (GClosure C_TypeFindHelperGetRangeFunction)
genClosure_TypeFindHelperGetRangeFunction cb :: TypeFindHelperGetRangeFunction
cb = IO (GClosure C_TypeFindHelperGetRangeFunction)
-> m (GClosure C_TypeFindHelperGetRangeFunction)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TypeFindHelperGetRangeFunction)
-> m (GClosure C_TypeFindHelperGetRangeFunction))
-> IO (GClosure C_TypeFindHelperGetRangeFunction)
-> m (GClosure C_TypeFindHelperGetRangeFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_TypeFindHelperGetRangeFunction
cb' = Maybe (Ptr (FunPtr C_TypeFindHelperGetRangeFunction))
-> TypeFindHelperGetRangeFunction
-> C_TypeFindHelperGetRangeFunction
wrap_TypeFindHelperGetRangeFunction Maybe (Ptr (FunPtr C_TypeFindHelperGetRangeFunction))
forall a. Maybe a
Nothing TypeFindHelperGetRangeFunction
cb
C_TypeFindHelperGetRangeFunction
-> IO (FunPtr C_TypeFindHelperGetRangeFunction)
mk_TypeFindHelperGetRangeFunction C_TypeFindHelperGetRangeFunction
cb' IO (FunPtr C_TypeFindHelperGetRangeFunction)
-> (FunPtr C_TypeFindHelperGetRangeFunction
-> IO (GClosure C_TypeFindHelperGetRangeFunction))
-> IO (GClosure C_TypeFindHelperGetRangeFunction)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TypeFindHelperGetRangeFunction
-> IO (GClosure C_TypeFindHelperGetRangeFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_TypeFindHelperGetRangeFunction ::
Maybe (Ptr (FunPtr C_TypeFindHelperGetRangeFunction)) ->
TypeFindHelperGetRangeFunction ->
C_TypeFindHelperGetRangeFunction
wrap_TypeFindHelperGetRangeFunction :: Maybe (Ptr (FunPtr C_TypeFindHelperGetRangeFunction))
-> TypeFindHelperGetRangeFunction
-> C_TypeFindHelperGetRangeFunction
wrap_TypeFindHelperGetRangeFunction funptrptr :: Maybe (Ptr (FunPtr C_TypeFindHelperGetRangeFunction))
funptrptr _cb :: TypeFindHelperGetRangeFunction
_cb obj :: Ptr Object
obj parent :: Ptr Object
parent offset :: Word64
offset length_ :: Word32
length_ buffer :: Ptr (Ptr Buffer)
buffer = do
Object
obj' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Gst.Object.Object) Ptr Object
obj
Maybe Object
maybeParent <-
if Ptr Object
parent Ptr Object -> Ptr Object -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr Object
forall a. Ptr a
nullPtr
then Maybe Object -> IO (Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
forall a. Maybe a
Nothing
else do
Object
parent' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Gst.Object.Object) Ptr Object
parent
Maybe Object -> IO (Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Object -> IO (Maybe Object))
-> Maybe Object -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ Object -> Maybe Object
forall a. a -> Maybe a
Just Object
parent'
(result :: FlowReturn
result, outbuffer :: Buffer
outbuffer) <- TypeFindHelperGetRangeFunction
_cb Object
obj' Maybe Object
maybeParent Word64
offset Word32
length_
Ptr Buffer
outbuffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, BoxedObject a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
outbuffer
Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (Ptr Buffer)
buffer Ptr Buffer
outbuffer'
Maybe (Ptr (FunPtr C_TypeFindHelperGetRangeFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_TypeFindHelperGetRangeFunction))
funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (FlowReturn -> Int) -> FlowReturn -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FlowReturn -> Int
forall a. Enum a => a -> Int
fromEnum) FlowReturn
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_DataQueueFullCallback =
Ptr GstBase.DataQueue.DataQueue ->
Ptr () ->
IO ()
foreign import ccall "dynamic" __dynamic_C_DataQueueFullCallback :: FunPtr C_DataQueueFullCallback -> C_DataQueueFullCallback
dynamic_DataQueueFullCallback ::
(B.CallStack.HasCallStack, MonadIO m, GstBase.DataQueue.IsDataQueue a) =>
FunPtr C_DataQueueFullCallback
-> a
-> Ptr ()
-> m ()
dynamic_DataQueueFullCallback :: FunPtr C_DataQueueFullCallback -> a -> Ptr () -> m ()
dynamic_DataQueueFullCallback __funPtr :: FunPtr C_DataQueueFullCallback
__funPtr queue :: a
queue checkdata :: Ptr ()
checkdata = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DataQueue
queue' <- a -> IO (Ptr DataQueue)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
queue
(FunPtr C_DataQueueFullCallback -> C_DataQueueFullCallback
__dynamic_C_DataQueueFullCallback FunPtr C_DataQueueFullCallback
__funPtr) Ptr DataQueue
queue' Ptr ()
checkdata
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
queue
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_DataQueueFullCallback :: C_DataQueueFullCallback -> IO (FunPtr C_DataQueueFullCallback)
type DataQueueFullCallback =
GstBase.DataQueue.DataQueue
-> Ptr ()
-> IO ()
noDataQueueFullCallback :: Maybe DataQueueFullCallback
noDataQueueFullCallback :: Maybe DataQueueFullCallback
noDataQueueFullCallback = Maybe DataQueueFullCallback
forall a. Maybe a
Nothing
genClosure_DataQueueFullCallback :: MonadIO m => DataQueueFullCallback -> m (GClosure C_DataQueueFullCallback)
genClosure_DataQueueFullCallback :: DataQueueFullCallback -> m (GClosure C_DataQueueFullCallback)
genClosure_DataQueueFullCallback cb :: DataQueueFullCallback
cb = IO (GClosure C_DataQueueFullCallback)
-> m (GClosure C_DataQueueFullCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DataQueueFullCallback)
-> m (GClosure C_DataQueueFullCallback))
-> IO (GClosure C_DataQueueFullCallback)
-> m (GClosure C_DataQueueFullCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DataQueueFullCallback
cb' = Maybe (Ptr (FunPtr C_DataQueueFullCallback))
-> DataQueueFullCallback -> C_DataQueueFullCallback
wrap_DataQueueFullCallback Maybe (Ptr (FunPtr C_DataQueueFullCallback))
forall a. Maybe a
Nothing DataQueueFullCallback
cb
C_DataQueueFullCallback -> IO (FunPtr C_DataQueueFullCallback)
mk_DataQueueFullCallback C_DataQueueFullCallback
cb' IO (FunPtr C_DataQueueFullCallback)
-> (FunPtr C_DataQueueFullCallback
-> IO (GClosure C_DataQueueFullCallback))
-> IO (GClosure C_DataQueueFullCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DataQueueFullCallback
-> IO (GClosure C_DataQueueFullCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DataQueueFullCallback ::
Maybe (Ptr (FunPtr C_DataQueueFullCallback)) ->
DataQueueFullCallback ->
C_DataQueueFullCallback
wrap_DataQueueFullCallback :: Maybe (Ptr (FunPtr C_DataQueueFullCallback))
-> DataQueueFullCallback -> C_DataQueueFullCallback
wrap_DataQueueFullCallback funptrptr :: Maybe (Ptr (FunPtr C_DataQueueFullCallback))
funptrptr _cb :: DataQueueFullCallback
_cb queue :: Ptr DataQueue
queue checkdata :: Ptr ()
checkdata = do
DataQueue
queue' <- ((ManagedPtr DataQueue -> DataQueue)
-> Ptr DataQueue -> IO DataQueue
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DataQueue -> DataQueue
GstBase.DataQueue.DataQueue) Ptr DataQueue
queue
DataQueueFullCallback
_cb DataQueue
queue' Ptr ()
checkdata
Maybe (Ptr (FunPtr C_DataQueueFullCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_DataQueueFullCallback))
funptrptr
type C_DataQueueEmptyCallback =
Ptr GstBase.DataQueue.DataQueue ->
Ptr () ->
IO ()
foreign import ccall "dynamic" __dynamic_C_DataQueueEmptyCallback :: FunPtr C_DataQueueEmptyCallback -> C_DataQueueEmptyCallback
dynamic_DataQueueEmptyCallback ::
(B.CallStack.HasCallStack, MonadIO m, GstBase.DataQueue.IsDataQueue a) =>
FunPtr C_DataQueueEmptyCallback
-> a
-> Ptr ()
-> m ()
dynamic_DataQueueEmptyCallback :: FunPtr C_DataQueueFullCallback -> a -> Ptr () -> m ()
dynamic_DataQueueEmptyCallback __funPtr :: FunPtr C_DataQueueFullCallback
__funPtr queue :: a
queue checkdata :: Ptr ()
checkdata = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr DataQueue
queue' <- a -> IO (Ptr DataQueue)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
queue
(FunPtr C_DataQueueFullCallback -> C_DataQueueFullCallback
__dynamic_C_DataQueueEmptyCallback FunPtr C_DataQueueFullCallback
__funPtr) Ptr DataQueue
queue' Ptr ()
checkdata
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
queue
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_DataQueueEmptyCallback :: C_DataQueueEmptyCallback -> IO (FunPtr C_DataQueueEmptyCallback)
type DataQueueEmptyCallback =
GstBase.DataQueue.DataQueue
-> Ptr ()
-> IO ()
noDataQueueEmptyCallback :: Maybe DataQueueEmptyCallback
noDataQueueEmptyCallback :: Maybe DataQueueFullCallback
noDataQueueEmptyCallback = Maybe DataQueueFullCallback
forall a. Maybe a
Nothing
genClosure_DataQueueEmptyCallback :: MonadIO m => DataQueueEmptyCallback -> m (GClosure C_DataQueueEmptyCallback)
genClosure_DataQueueEmptyCallback :: DataQueueFullCallback -> m (GClosure C_DataQueueFullCallback)
genClosure_DataQueueEmptyCallback cb :: DataQueueFullCallback
cb = IO (GClosure C_DataQueueFullCallback)
-> m (GClosure C_DataQueueFullCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DataQueueFullCallback)
-> m (GClosure C_DataQueueFullCallback))
-> IO (GClosure C_DataQueueFullCallback)
-> m (GClosure C_DataQueueFullCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DataQueueFullCallback
cb' = Maybe (Ptr (FunPtr C_DataQueueFullCallback))
-> DataQueueFullCallback -> C_DataQueueFullCallback
wrap_DataQueueEmptyCallback Maybe (Ptr (FunPtr C_DataQueueFullCallback))
forall a. Maybe a
Nothing DataQueueFullCallback
cb
C_DataQueueFullCallback -> IO (FunPtr C_DataQueueFullCallback)
mk_DataQueueEmptyCallback C_DataQueueFullCallback
cb' IO (FunPtr C_DataQueueFullCallback)
-> (FunPtr C_DataQueueFullCallback
-> IO (GClosure C_DataQueueFullCallback))
-> IO (GClosure C_DataQueueFullCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DataQueueFullCallback
-> IO (GClosure C_DataQueueFullCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DataQueueEmptyCallback ::
Maybe (Ptr (FunPtr C_DataQueueEmptyCallback)) ->
DataQueueEmptyCallback ->
C_DataQueueEmptyCallback
wrap_DataQueueEmptyCallback :: Maybe (Ptr (FunPtr C_DataQueueFullCallback))
-> DataQueueFullCallback -> C_DataQueueFullCallback
wrap_DataQueueEmptyCallback funptrptr :: Maybe (Ptr (FunPtr C_DataQueueFullCallback))
funptrptr _cb :: DataQueueFullCallback
_cb queue :: Ptr DataQueue
queue checkdata :: Ptr ()
checkdata = do
DataQueue
queue' <- ((ManagedPtr DataQueue -> DataQueue)
-> Ptr DataQueue -> IO DataQueue
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DataQueue -> DataQueue
GstBase.DataQueue.DataQueue) Ptr DataQueue
queue
DataQueueFullCallback
_cb DataQueue
queue' Ptr ()
checkdata
Maybe (Ptr (FunPtr C_DataQueueFullCallback)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_DataQueueFullCallback))
funptrptr
type C_CollectPadsQueryFunction =
Ptr GstBase.CollectPads.CollectPads ->
Ptr GstBase.CollectData.CollectData ->
Ptr Gst.Query.Query ->
Ptr () ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_CollectPadsQueryFunction :: FunPtr C_CollectPadsQueryFunction -> C_CollectPadsQueryFunction
dynamic_CollectPadsQueryFunction ::
(B.CallStack.HasCallStack, MonadIO m, GstBase.CollectPads.IsCollectPads a) =>
FunPtr C_CollectPadsQueryFunction
-> a
-> GstBase.CollectData.CollectData
-> Gst.Query.Query
-> Ptr ()
-> m Bool
dynamic_CollectPadsQueryFunction :: FunPtr C_CollectPadsQueryFunction
-> a -> CollectData -> Query -> Ptr () -> m Bool
dynamic_CollectPadsQueryFunction __funPtr :: FunPtr C_CollectPadsQueryFunction
__funPtr pads :: a
pads pad :: CollectData
pad query :: Query
query userData :: Ptr ()
userData = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr CollectPads
pads' <- a -> IO (Ptr CollectPads)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pads
Ptr CollectData
pad' <- CollectData -> IO (Ptr CollectData)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CollectData
pad
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
CInt
result <- (FunPtr C_CollectPadsQueryFunction -> C_CollectPadsQueryFunction
__dynamic_C_CollectPadsQueryFunction FunPtr C_CollectPadsQueryFunction
__funPtr) Ptr CollectPads
pads' Ptr CollectData
pad' Ptr Query
query' Ptr ()
userData
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pads
CollectData -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CollectData
pad
Query -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Query
query
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_CollectPadsQueryFunction :: C_CollectPadsQueryFunction -> IO (FunPtr C_CollectPadsQueryFunction)
type CollectPadsQueryFunction =
GstBase.CollectPads.CollectPads
-> GstBase.CollectData.CollectData
-> Gst.Query.Query
-> IO Bool
noCollectPadsQueryFunction :: Maybe CollectPadsQueryFunction
noCollectPadsQueryFunction :: Maybe CollectPadsQueryFunction
noCollectPadsQueryFunction = Maybe CollectPadsQueryFunction
forall a. Maybe a
Nothing
type CollectPadsQueryFunction_WithClosures =
GstBase.CollectPads.CollectPads
-> GstBase.CollectData.CollectData
-> Gst.Query.Query
-> Ptr ()
-> IO Bool
noCollectPadsQueryFunction_WithClosures :: Maybe CollectPadsQueryFunction_WithClosures
noCollectPadsQueryFunction_WithClosures :: Maybe CollectPadsQueryFunction_WithClosures
noCollectPadsQueryFunction_WithClosures = Maybe CollectPadsQueryFunction_WithClosures
forall a. Maybe a
Nothing
drop_closures_CollectPadsQueryFunction :: CollectPadsQueryFunction -> CollectPadsQueryFunction_WithClosures
drop_closures_CollectPadsQueryFunction :: CollectPadsQueryFunction -> CollectPadsQueryFunction_WithClosures
drop_closures_CollectPadsQueryFunction _f :: CollectPadsQueryFunction
_f pads :: CollectPads
pads pad :: CollectData
pad query :: Query
query _ = CollectPadsQueryFunction
_f CollectPads
pads CollectData
pad Query
query
genClosure_CollectPadsQueryFunction :: MonadIO m => CollectPadsQueryFunction -> m (GClosure C_CollectPadsQueryFunction)
genClosure_CollectPadsQueryFunction :: CollectPadsQueryFunction -> m (GClosure C_CollectPadsQueryFunction)
genClosure_CollectPadsQueryFunction cb :: CollectPadsQueryFunction
cb = IO (GClosure C_CollectPadsQueryFunction)
-> m (GClosure C_CollectPadsQueryFunction)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CollectPadsQueryFunction)
-> m (GClosure C_CollectPadsQueryFunction))
-> IO (GClosure C_CollectPadsQueryFunction)
-> m (GClosure C_CollectPadsQueryFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: CollectPadsQueryFunction_WithClosures
cb' = CollectPadsQueryFunction -> CollectPadsQueryFunction_WithClosures
drop_closures_CollectPadsQueryFunction CollectPadsQueryFunction
cb
let cb'' :: C_CollectPadsQueryFunction
cb'' = Maybe (Ptr (FunPtr C_CollectPadsQueryFunction))
-> CollectPadsQueryFunction_WithClosures
-> C_CollectPadsQueryFunction
wrap_CollectPadsQueryFunction Maybe (Ptr (FunPtr C_CollectPadsQueryFunction))
forall a. Maybe a
Nothing CollectPadsQueryFunction_WithClosures
cb'
C_CollectPadsQueryFunction
-> IO (FunPtr C_CollectPadsQueryFunction)
mk_CollectPadsQueryFunction C_CollectPadsQueryFunction
cb'' IO (FunPtr C_CollectPadsQueryFunction)
-> (FunPtr C_CollectPadsQueryFunction
-> IO (GClosure C_CollectPadsQueryFunction))
-> IO (GClosure C_CollectPadsQueryFunction)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CollectPadsQueryFunction
-> IO (GClosure C_CollectPadsQueryFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_CollectPadsQueryFunction ::
Maybe (Ptr (FunPtr C_CollectPadsQueryFunction)) ->
CollectPadsQueryFunction_WithClosures ->
C_CollectPadsQueryFunction
wrap_CollectPadsQueryFunction :: Maybe (Ptr (FunPtr C_CollectPadsQueryFunction))
-> CollectPadsQueryFunction_WithClosures
-> C_CollectPadsQueryFunction
wrap_CollectPadsQueryFunction funptrptr :: Maybe (Ptr (FunPtr C_CollectPadsQueryFunction))
funptrptr _cb :: CollectPadsQueryFunction_WithClosures
_cb pads :: Ptr CollectPads
pads pad :: Ptr CollectData
pad query :: Ptr Query
query userData :: Ptr ()
userData = do
CollectPads
pads' <- ((ManagedPtr CollectPads -> CollectPads)
-> Ptr CollectPads -> IO CollectPads
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CollectPads -> CollectPads
GstBase.CollectPads.CollectPads) Ptr CollectPads
pads
CollectData
pad' <- ((ManagedPtr CollectData -> CollectData)
-> Ptr CollectData -> IO CollectData
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr CollectData -> CollectData
GstBase.CollectData.CollectData) Ptr CollectData
pad
(ManagedPtr Query -> Query)
-> Ptr Query -> (Query -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr Query -> Query
Gst.Query.Query Ptr Query
query ((Query -> IO CInt) -> IO CInt) -> (Query -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \query' :: Query
query' -> do
Bool
result <- CollectPadsQueryFunction_WithClosures
_cb CollectPads
pads' CollectData
pad' Query
query' Ptr ()
userData
Maybe (Ptr (FunPtr C_CollectPadsQueryFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_CollectPadsQueryFunction))
funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_CollectPadsFunction =
Ptr GstBase.CollectPads.CollectPads ->
Ptr () ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_CollectPadsFunction :: FunPtr C_CollectPadsFunction -> C_CollectPadsFunction
dynamic_CollectPadsFunction ::
(B.CallStack.HasCallStack, MonadIO m, GstBase.CollectPads.IsCollectPads a) =>
FunPtr C_CollectPadsFunction
-> a
-> Ptr ()
-> m Gst.Enums.FlowReturn
dynamic_CollectPadsFunction :: FunPtr C_CollectPadsFunction -> a -> Ptr () -> m FlowReturn
dynamic_CollectPadsFunction __funPtr :: FunPtr C_CollectPadsFunction
__funPtr pads :: a
pads userData :: Ptr ()
userData = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr CollectPads
pads' <- a -> IO (Ptr CollectPads)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pads
CInt
result <- (FunPtr C_CollectPadsFunction -> C_CollectPadsFunction
__dynamic_C_CollectPadsFunction FunPtr C_CollectPadsFunction
__funPtr) Ptr CollectPads
pads' Ptr ()
userData
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pads
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
foreign import ccall "wrapper"
mk_CollectPadsFunction :: C_CollectPadsFunction -> IO (FunPtr C_CollectPadsFunction)
type CollectPadsFunction =
GstBase.CollectPads.CollectPads
-> IO Gst.Enums.FlowReturn
noCollectPadsFunction :: Maybe CollectPadsFunction
noCollectPadsFunction :: Maybe CollectPadsFunction
noCollectPadsFunction = Maybe CollectPadsFunction
forall a. Maybe a
Nothing
type CollectPadsFunction_WithClosures =
GstBase.CollectPads.CollectPads
-> Ptr ()
-> IO Gst.Enums.FlowReturn
noCollectPadsFunction_WithClosures :: Maybe CollectPadsFunction_WithClosures
noCollectPadsFunction_WithClosures :: Maybe CollectPadsFunction_WithClosures
noCollectPadsFunction_WithClosures = Maybe CollectPadsFunction_WithClosures
forall a. Maybe a
Nothing
drop_closures_CollectPadsFunction :: CollectPadsFunction -> CollectPadsFunction_WithClosures
drop_closures_CollectPadsFunction :: CollectPadsFunction -> CollectPadsFunction_WithClosures
drop_closures_CollectPadsFunction _f :: CollectPadsFunction
_f pads :: CollectPads
pads _ = CollectPadsFunction
_f CollectPads
pads
genClosure_CollectPadsFunction :: MonadIO m => CollectPadsFunction -> m (GClosure C_CollectPadsFunction)
genClosure_CollectPadsFunction :: CollectPadsFunction -> m (GClosure C_CollectPadsFunction)
genClosure_CollectPadsFunction cb :: CollectPadsFunction
cb = IO (GClosure C_CollectPadsFunction)
-> m (GClosure C_CollectPadsFunction)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CollectPadsFunction)
-> m (GClosure C_CollectPadsFunction))
-> IO (GClosure C_CollectPadsFunction)
-> m (GClosure C_CollectPadsFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: CollectPadsFunction_WithClosures
cb' = CollectPadsFunction -> CollectPadsFunction_WithClosures
drop_closures_CollectPadsFunction CollectPadsFunction
cb
let cb'' :: C_CollectPadsFunction
cb'' = Maybe (Ptr (FunPtr C_CollectPadsFunction))
-> CollectPadsFunction_WithClosures -> C_CollectPadsFunction
wrap_CollectPadsFunction Maybe (Ptr (FunPtr C_CollectPadsFunction))
forall a. Maybe a
Nothing CollectPadsFunction_WithClosures
cb'
C_CollectPadsFunction -> IO (FunPtr C_CollectPadsFunction)
mk_CollectPadsFunction C_CollectPadsFunction
cb'' IO (FunPtr C_CollectPadsFunction)
-> (FunPtr C_CollectPadsFunction
-> IO (GClosure C_CollectPadsFunction))
-> IO (GClosure C_CollectPadsFunction)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CollectPadsFunction -> IO (GClosure C_CollectPadsFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_CollectPadsFunction ::
Maybe (Ptr (FunPtr C_CollectPadsFunction)) ->
CollectPadsFunction_WithClosures ->
C_CollectPadsFunction
wrap_CollectPadsFunction :: Maybe (Ptr (FunPtr C_CollectPadsFunction))
-> CollectPadsFunction_WithClosures -> C_CollectPadsFunction
wrap_CollectPadsFunction funptrptr :: Maybe (Ptr (FunPtr C_CollectPadsFunction))
funptrptr _cb :: CollectPadsFunction_WithClosures
_cb pads :: Ptr CollectPads
pads userData :: Ptr ()
userData = do
CollectPads
pads' <- ((ManagedPtr CollectPads -> CollectPads)
-> Ptr CollectPads -> IO CollectPads
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CollectPads -> CollectPads
GstBase.CollectPads.CollectPads) Ptr CollectPads
pads
FlowReturn
result <- CollectPadsFunction_WithClosures
_cb CollectPads
pads' Ptr ()
userData
Maybe (Ptr (FunPtr C_CollectPadsFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_CollectPadsFunction))
funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (FlowReturn -> Int) -> FlowReturn -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FlowReturn -> Int
forall a. Enum a => a -> Int
fromEnum) FlowReturn
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_CollectPadsFlushFunction =
Ptr GstBase.CollectPads.CollectPads ->
Ptr () ->
IO ()
foreign import ccall "dynamic" __dynamic_C_CollectPadsFlushFunction :: FunPtr C_CollectPadsFlushFunction -> C_CollectPadsFlushFunction
dynamic_CollectPadsFlushFunction ::
(B.CallStack.HasCallStack, MonadIO m, GstBase.CollectPads.IsCollectPads a) =>
FunPtr C_CollectPadsFlushFunction
-> a
-> Ptr ()
-> m ()
dynamic_CollectPadsFlushFunction :: FunPtr C_CollectPadsFlushFunction -> a -> Ptr () -> m ()
dynamic_CollectPadsFlushFunction __funPtr :: FunPtr C_CollectPadsFlushFunction
__funPtr pads :: a
pads userData :: Ptr ()
userData = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr CollectPads
pads' <- a -> IO (Ptr CollectPads)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pads
(FunPtr C_CollectPadsFlushFunction -> C_CollectPadsFlushFunction
__dynamic_C_CollectPadsFlushFunction FunPtr C_CollectPadsFlushFunction
__funPtr) Ptr CollectPads
pads' Ptr ()
userData
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pads
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_CollectPadsFlushFunction :: C_CollectPadsFlushFunction -> IO (FunPtr C_CollectPadsFlushFunction)
type CollectPadsFlushFunction =
GstBase.CollectPads.CollectPads
-> IO ()
noCollectPadsFlushFunction :: Maybe CollectPadsFlushFunction
noCollectPadsFlushFunction :: Maybe CollectPadsFlushFunction
noCollectPadsFlushFunction = Maybe CollectPadsFlushFunction
forall a. Maybe a
Nothing
type CollectPadsFlushFunction_WithClosures =
GstBase.CollectPads.CollectPads
-> Ptr ()
-> IO ()
noCollectPadsFlushFunction_WithClosures :: Maybe CollectPadsFlushFunction_WithClosures
noCollectPadsFlushFunction_WithClosures :: Maybe CollectPadsFlushFunction_WithClosures
noCollectPadsFlushFunction_WithClosures = Maybe CollectPadsFlushFunction_WithClosures
forall a. Maybe a
Nothing
drop_closures_CollectPadsFlushFunction :: CollectPadsFlushFunction -> CollectPadsFlushFunction_WithClosures
drop_closures_CollectPadsFlushFunction :: CollectPadsFlushFunction -> CollectPadsFlushFunction_WithClosures
drop_closures_CollectPadsFlushFunction _f :: CollectPadsFlushFunction
_f pads :: CollectPads
pads _ = CollectPadsFlushFunction
_f CollectPads
pads
genClosure_CollectPadsFlushFunction :: MonadIO m => CollectPadsFlushFunction -> m (GClosure C_CollectPadsFlushFunction)
genClosure_CollectPadsFlushFunction :: CollectPadsFlushFunction -> m (GClosure C_CollectPadsFlushFunction)
genClosure_CollectPadsFlushFunction cb :: CollectPadsFlushFunction
cb = IO (GClosure C_CollectPadsFlushFunction)
-> m (GClosure C_CollectPadsFlushFunction)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CollectPadsFlushFunction)
-> m (GClosure C_CollectPadsFlushFunction))
-> IO (GClosure C_CollectPadsFlushFunction)
-> m (GClosure C_CollectPadsFlushFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: CollectPadsFlushFunction_WithClosures
cb' = CollectPadsFlushFunction -> CollectPadsFlushFunction_WithClosures
drop_closures_CollectPadsFlushFunction CollectPadsFlushFunction
cb
let cb'' :: C_CollectPadsFlushFunction
cb'' = Maybe (Ptr (FunPtr C_CollectPadsFlushFunction))
-> CollectPadsFlushFunction_WithClosures
-> C_CollectPadsFlushFunction
wrap_CollectPadsFlushFunction Maybe (Ptr (FunPtr C_CollectPadsFlushFunction))
forall a. Maybe a
Nothing CollectPadsFlushFunction_WithClosures
cb'
C_CollectPadsFlushFunction
-> IO (FunPtr C_CollectPadsFlushFunction)
mk_CollectPadsFlushFunction C_CollectPadsFlushFunction
cb'' IO (FunPtr C_CollectPadsFlushFunction)
-> (FunPtr C_CollectPadsFlushFunction
-> IO (GClosure C_CollectPadsFlushFunction))
-> IO (GClosure C_CollectPadsFlushFunction)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CollectPadsFlushFunction
-> IO (GClosure C_CollectPadsFlushFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_CollectPadsFlushFunction ::
Maybe (Ptr (FunPtr C_CollectPadsFlushFunction)) ->
CollectPadsFlushFunction_WithClosures ->
C_CollectPadsFlushFunction
wrap_CollectPadsFlushFunction :: Maybe (Ptr (FunPtr C_CollectPadsFlushFunction))
-> CollectPadsFlushFunction_WithClosures
-> C_CollectPadsFlushFunction
wrap_CollectPadsFlushFunction funptrptr :: Maybe (Ptr (FunPtr C_CollectPadsFlushFunction))
funptrptr _cb :: CollectPadsFlushFunction_WithClosures
_cb pads :: Ptr CollectPads
pads userData :: Ptr ()
userData = do
CollectPads
pads' <- ((ManagedPtr CollectPads -> CollectPads)
-> Ptr CollectPads -> IO CollectPads
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CollectPads -> CollectPads
GstBase.CollectPads.CollectPads) Ptr CollectPads
pads
CollectPadsFlushFunction_WithClosures
_cb CollectPads
pads' Ptr ()
userData
Maybe (Ptr (FunPtr C_CollectPadsFlushFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_CollectPadsFlushFunction))
funptrptr
type C_CollectPadsEventFunction =
Ptr GstBase.CollectPads.CollectPads ->
Ptr GstBase.CollectData.CollectData ->
Ptr Gst.Event.Event ->
Ptr () ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_CollectPadsEventFunction :: FunPtr C_CollectPadsEventFunction -> C_CollectPadsEventFunction
dynamic_CollectPadsEventFunction ::
(B.CallStack.HasCallStack, MonadIO m, GstBase.CollectPads.IsCollectPads a) =>
FunPtr C_CollectPadsEventFunction
-> a
-> GstBase.CollectData.CollectData
-> Gst.Event.Event
-> Ptr ()
-> m Bool
dynamic_CollectPadsEventFunction :: FunPtr C_CollectPadsEventFunction
-> a -> CollectData -> Event -> Ptr () -> m Bool
dynamic_CollectPadsEventFunction __funPtr :: FunPtr C_CollectPadsEventFunction
__funPtr pads :: a
pads pad :: CollectData
pad event :: Event
event userData :: Ptr ()
userData = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr CollectPads
pads' <- a -> IO (Ptr CollectPads)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pads
Ptr CollectData
pad' <- CollectData -> IO (Ptr CollectData)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CollectData
pad
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CInt
result <- (FunPtr C_CollectPadsEventFunction -> C_CollectPadsEventFunction
__dynamic_C_CollectPadsEventFunction FunPtr C_CollectPadsEventFunction
__funPtr) Ptr CollectPads
pads' Ptr CollectData
pad' Ptr Event
event' Ptr ()
userData
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pads
CollectData -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CollectData
pad
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_CollectPadsEventFunction :: C_CollectPadsEventFunction -> IO (FunPtr C_CollectPadsEventFunction)
type CollectPadsEventFunction =
GstBase.CollectPads.CollectPads
-> GstBase.CollectData.CollectData
-> Gst.Event.Event
-> IO Bool
noCollectPadsEventFunction :: Maybe CollectPadsEventFunction
noCollectPadsEventFunction :: Maybe CollectPadsEventFunction
noCollectPadsEventFunction = Maybe CollectPadsEventFunction
forall a. Maybe a
Nothing
type CollectPadsEventFunction_WithClosures =
GstBase.CollectPads.CollectPads
-> GstBase.CollectData.CollectData
-> Gst.Event.Event
-> Ptr ()
-> IO Bool
noCollectPadsEventFunction_WithClosures :: Maybe CollectPadsEventFunction_WithClosures
noCollectPadsEventFunction_WithClosures :: Maybe CollectPadsEventFunction_WithClosures
noCollectPadsEventFunction_WithClosures = Maybe CollectPadsEventFunction_WithClosures
forall a. Maybe a
Nothing
drop_closures_CollectPadsEventFunction :: CollectPadsEventFunction -> CollectPadsEventFunction_WithClosures
drop_closures_CollectPadsEventFunction :: CollectPadsEventFunction -> CollectPadsEventFunction_WithClosures
drop_closures_CollectPadsEventFunction _f :: CollectPadsEventFunction
_f pads :: CollectPads
pads pad :: CollectData
pad event :: Event
event _ = CollectPadsEventFunction
_f CollectPads
pads CollectData
pad Event
event
genClosure_CollectPadsEventFunction :: MonadIO m => CollectPadsEventFunction -> m (GClosure C_CollectPadsEventFunction)
genClosure_CollectPadsEventFunction :: CollectPadsEventFunction -> m (GClosure C_CollectPadsEventFunction)
genClosure_CollectPadsEventFunction cb :: CollectPadsEventFunction
cb = IO (GClosure C_CollectPadsEventFunction)
-> m (GClosure C_CollectPadsEventFunction)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CollectPadsEventFunction)
-> m (GClosure C_CollectPadsEventFunction))
-> IO (GClosure C_CollectPadsEventFunction)
-> m (GClosure C_CollectPadsEventFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: CollectPadsEventFunction_WithClosures
cb' = CollectPadsEventFunction -> CollectPadsEventFunction_WithClosures
drop_closures_CollectPadsEventFunction CollectPadsEventFunction
cb
let cb'' :: C_CollectPadsEventFunction
cb'' = Maybe (Ptr (FunPtr C_CollectPadsEventFunction))
-> CollectPadsEventFunction_WithClosures
-> C_CollectPadsEventFunction
wrap_CollectPadsEventFunction Maybe (Ptr (FunPtr C_CollectPadsEventFunction))
forall a. Maybe a
Nothing CollectPadsEventFunction_WithClosures
cb'
C_CollectPadsEventFunction
-> IO (FunPtr C_CollectPadsEventFunction)
mk_CollectPadsEventFunction C_CollectPadsEventFunction
cb'' IO (FunPtr C_CollectPadsEventFunction)
-> (FunPtr C_CollectPadsEventFunction
-> IO (GClosure C_CollectPadsEventFunction))
-> IO (GClosure C_CollectPadsEventFunction)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CollectPadsEventFunction
-> IO (GClosure C_CollectPadsEventFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_CollectPadsEventFunction ::
Maybe (Ptr (FunPtr C_CollectPadsEventFunction)) ->
CollectPadsEventFunction_WithClosures ->
C_CollectPadsEventFunction
wrap_CollectPadsEventFunction :: Maybe (Ptr (FunPtr C_CollectPadsEventFunction))
-> CollectPadsEventFunction_WithClosures
-> C_CollectPadsEventFunction
wrap_CollectPadsEventFunction funptrptr :: Maybe (Ptr (FunPtr C_CollectPadsEventFunction))
funptrptr _cb :: CollectPadsEventFunction_WithClosures
_cb pads :: Ptr CollectPads
pads pad :: Ptr CollectData
pad event :: Ptr Event
event userData :: Ptr ()
userData = do
CollectPads
pads' <- ((ManagedPtr CollectPads -> CollectPads)
-> Ptr CollectPads -> IO CollectPads
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CollectPads -> CollectPads
GstBase.CollectPads.CollectPads) Ptr CollectPads
pads
CollectData
pad' <- ((ManagedPtr CollectData -> CollectData)
-> Ptr CollectData -> IO CollectData
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr CollectData -> CollectData
GstBase.CollectData.CollectData) Ptr CollectData
pad
(ManagedPtr Event -> Event)
-> Ptr Event -> (Event -> IO CInt) -> IO CInt
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr Event -> Event
Gst.Event.Event Ptr Event
event ((Event -> IO CInt) -> IO CInt) -> (Event -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ \event' :: Event
event' -> do
Bool
result <- CollectPadsEventFunction_WithClosures
_cb CollectPads
pads' CollectData
pad' Event
event' Ptr ()
userData
Maybe (Ptr (FunPtr C_CollectPadsEventFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_CollectPadsEventFunction))
funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_CollectPadsCompareFunction =
Ptr GstBase.CollectPads.CollectPads ->
Ptr GstBase.CollectData.CollectData ->
Word64 ->
Ptr GstBase.CollectData.CollectData ->
Word64 ->
Ptr () ->
IO Int32
foreign import ccall "dynamic" __dynamic_C_CollectPadsCompareFunction :: FunPtr C_CollectPadsCompareFunction -> C_CollectPadsCompareFunction
dynamic_CollectPadsCompareFunction ::
(B.CallStack.HasCallStack, MonadIO m, GstBase.CollectPads.IsCollectPads a) =>
FunPtr C_CollectPadsCompareFunction
-> a
-> GstBase.CollectData.CollectData
-> Word64
-> GstBase.CollectData.CollectData
-> Word64
-> Ptr ()
-> m Int32
dynamic_CollectPadsCompareFunction :: FunPtr C_CollectPadsCompareFunction
-> a
-> CollectData
-> Word64
-> CollectData
-> Word64
-> Ptr ()
-> m Int32
dynamic_CollectPadsCompareFunction __funPtr :: FunPtr C_CollectPadsCompareFunction
__funPtr pads :: a
pads data1 :: CollectData
data1 timestamp1 :: Word64
timestamp1 data2 :: CollectData
data2 timestamp2 :: Word64
timestamp2 userData :: Ptr ()
userData = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr CollectPads
pads' <- a -> IO (Ptr CollectPads)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pads
Ptr CollectData
data1' <- CollectData -> IO (Ptr CollectData)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CollectData
data1
Ptr CollectData
data2' <- CollectData -> IO (Ptr CollectData)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CollectData
data2
Int32
result <- (FunPtr C_CollectPadsCompareFunction -> C_CollectPadsCompareFunction
__dynamic_C_CollectPadsCompareFunction FunPtr C_CollectPadsCompareFunction
__funPtr) Ptr CollectPads
pads' Ptr CollectData
data1' Word64
timestamp1 Ptr CollectData
data2' Word64
timestamp2 Ptr ()
userData
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pads
CollectData -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CollectData
data1
CollectData -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CollectData
data2
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "wrapper"
mk_CollectPadsCompareFunction :: C_CollectPadsCompareFunction -> IO (FunPtr C_CollectPadsCompareFunction)
type CollectPadsCompareFunction =
GstBase.CollectPads.CollectPads
-> GstBase.CollectData.CollectData
-> Word64
-> GstBase.CollectData.CollectData
-> Word64
-> IO Int32
noCollectPadsCompareFunction :: Maybe CollectPadsCompareFunction
noCollectPadsCompareFunction :: Maybe CollectPadsCompareFunction
noCollectPadsCompareFunction = Maybe CollectPadsCompareFunction
forall a. Maybe a
Nothing
type CollectPadsCompareFunction_WithClosures =
GstBase.CollectPads.CollectPads
-> GstBase.CollectData.CollectData
-> Word64
-> GstBase.CollectData.CollectData
-> Word64
-> Ptr ()
-> IO Int32
noCollectPadsCompareFunction_WithClosures :: Maybe CollectPadsCompareFunction_WithClosures
noCollectPadsCompareFunction_WithClosures :: Maybe CollectPadsCompareFunction_WithClosures
noCollectPadsCompareFunction_WithClosures = Maybe CollectPadsCompareFunction_WithClosures
forall a. Maybe a
Nothing
drop_closures_CollectPadsCompareFunction :: CollectPadsCompareFunction -> CollectPadsCompareFunction_WithClosures
drop_closures_CollectPadsCompareFunction :: CollectPadsCompareFunction
-> CollectPadsCompareFunction_WithClosures
drop_closures_CollectPadsCompareFunction _f :: CollectPadsCompareFunction
_f pads :: CollectPads
pads data1 :: CollectData
data1 timestamp1 :: Word64
timestamp1 data2 :: CollectData
data2 timestamp2 :: Word64
timestamp2 _ = CollectPadsCompareFunction
_f CollectPads
pads CollectData
data1 Word64
timestamp1 CollectData
data2 Word64
timestamp2
genClosure_CollectPadsCompareFunction :: MonadIO m => CollectPadsCompareFunction -> m (GClosure C_CollectPadsCompareFunction)
genClosure_CollectPadsCompareFunction :: CollectPadsCompareFunction
-> m (GClosure C_CollectPadsCompareFunction)
genClosure_CollectPadsCompareFunction cb :: CollectPadsCompareFunction
cb = IO (GClosure C_CollectPadsCompareFunction)
-> m (GClosure C_CollectPadsCompareFunction)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CollectPadsCompareFunction)
-> m (GClosure C_CollectPadsCompareFunction))
-> IO (GClosure C_CollectPadsCompareFunction)
-> m (GClosure C_CollectPadsCompareFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: CollectPadsCompareFunction_WithClosures
cb' = CollectPadsCompareFunction
-> CollectPadsCompareFunction_WithClosures
drop_closures_CollectPadsCompareFunction CollectPadsCompareFunction
cb
let cb'' :: C_CollectPadsCompareFunction
cb'' = Maybe (Ptr (FunPtr C_CollectPadsCompareFunction))
-> CollectPadsCompareFunction_WithClosures
-> C_CollectPadsCompareFunction
wrap_CollectPadsCompareFunction Maybe (Ptr (FunPtr C_CollectPadsCompareFunction))
forall a. Maybe a
Nothing CollectPadsCompareFunction_WithClosures
cb'
C_CollectPadsCompareFunction
-> IO (FunPtr C_CollectPadsCompareFunction)
mk_CollectPadsCompareFunction C_CollectPadsCompareFunction
cb'' IO (FunPtr C_CollectPadsCompareFunction)
-> (FunPtr C_CollectPadsCompareFunction
-> IO (GClosure C_CollectPadsCompareFunction))
-> IO (GClosure C_CollectPadsCompareFunction)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CollectPadsCompareFunction
-> IO (GClosure C_CollectPadsCompareFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_CollectPadsCompareFunction ::
Maybe (Ptr (FunPtr C_CollectPadsCompareFunction)) ->
CollectPadsCompareFunction_WithClosures ->
C_CollectPadsCompareFunction
wrap_CollectPadsCompareFunction :: Maybe (Ptr (FunPtr C_CollectPadsCompareFunction))
-> CollectPadsCompareFunction_WithClosures
-> C_CollectPadsCompareFunction
wrap_CollectPadsCompareFunction funptrptr :: Maybe (Ptr (FunPtr C_CollectPadsCompareFunction))
funptrptr _cb :: CollectPadsCompareFunction_WithClosures
_cb pads :: Ptr CollectPads
pads data1 :: Ptr CollectData
data1 timestamp1 :: Word64
timestamp1 data2 :: Ptr CollectData
data2 timestamp2 :: Word64
timestamp2 userData :: Ptr ()
userData = do
CollectPads
pads' <- ((ManagedPtr CollectPads -> CollectPads)
-> Ptr CollectPads -> IO CollectPads
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CollectPads -> CollectPads
GstBase.CollectPads.CollectPads) Ptr CollectPads
pads
CollectData
data1' <- ((ManagedPtr CollectData -> CollectData)
-> Ptr CollectData -> IO CollectData
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr CollectData -> CollectData
GstBase.CollectData.CollectData) Ptr CollectData
data1
CollectData
data2' <- ((ManagedPtr CollectData -> CollectData)
-> Ptr CollectData -> IO CollectData
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr CollectData -> CollectData
GstBase.CollectData.CollectData) Ptr CollectData
data2
Int32
result <- CollectPadsCompareFunction_WithClosures
_cb CollectPads
pads' CollectData
data1' Word64
timestamp1 CollectData
data2' Word64
timestamp2 Ptr ()
userData
Maybe (Ptr (FunPtr C_CollectPadsCompareFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_CollectPadsCompareFunction))
funptrptr
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
type C_CollectPadsClipFunction =
Ptr GstBase.CollectPads.CollectPads ->
Ptr GstBase.CollectData.CollectData ->
Ptr Gst.Buffer.Buffer ->
Ptr (Ptr Gst.Buffer.Buffer) ->
Ptr () ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_CollectPadsClipFunction :: FunPtr C_CollectPadsClipFunction -> C_CollectPadsClipFunction
dynamic_CollectPadsClipFunction ::
(B.CallStack.HasCallStack, MonadIO m, GstBase.CollectPads.IsCollectPads a) =>
FunPtr C_CollectPadsClipFunction
-> a
-> GstBase.CollectData.CollectData
-> Gst.Buffer.Buffer
-> Ptr ()
-> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))
dynamic_CollectPadsClipFunction :: FunPtr C_CollectPadsClipFunction
-> a -> CollectData -> Buffer -> Ptr () -> m (FlowReturn, Buffer)
dynamic_CollectPadsClipFunction __funPtr :: FunPtr C_CollectPadsClipFunction
__funPtr pads :: a
pads data_ :: CollectData
data_ inbuffer :: Buffer
inbuffer userData :: Ptr ()
userData = IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer))
-> IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer)
forall a b. (a -> b) -> a -> b
$ do
Ptr CollectPads
pads' <- a -> IO (Ptr CollectPads)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pads
Ptr CollectData
data_' <- CollectData -> IO (Ptr CollectData)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CollectData
data_
Ptr Buffer
inbuffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, BoxedObject a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
inbuffer
Ptr (Ptr Buffer)
outbuffer <- IO (Ptr (Ptr Buffer))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr Gst.Buffer.Buffer))
CInt
result <- (FunPtr C_CollectPadsClipFunction -> C_CollectPadsClipFunction
__dynamic_C_CollectPadsClipFunction FunPtr C_CollectPadsClipFunction
__funPtr) Ptr CollectPads
pads' Ptr CollectData
data_' Ptr Buffer
inbuffer' Ptr (Ptr Buffer)
outbuffer Ptr ()
userData
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
Ptr Buffer
outbuffer' <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Buffer)
outbuffer
Buffer
outbuffer'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
outbuffer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pads
CollectData -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CollectData
data_
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
inbuffer
Ptr (Ptr Buffer) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Buffer)
outbuffer
(FlowReturn, Buffer) -> IO (FlowReturn, Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return (FlowReturn
result', Buffer
outbuffer'')
foreign import ccall "wrapper"
mk_CollectPadsClipFunction :: C_CollectPadsClipFunction -> IO (FunPtr C_CollectPadsClipFunction)
type CollectPadsClipFunction =
GstBase.CollectPads.CollectPads
-> GstBase.CollectData.CollectData
-> Gst.Buffer.Buffer
-> IO ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))
noCollectPadsClipFunction :: Maybe CollectPadsClipFunction
noCollectPadsClipFunction :: Maybe CollectPadsClipFunction
noCollectPadsClipFunction = Maybe CollectPadsClipFunction
forall a. Maybe a
Nothing
type CollectPadsClipFunction_WithClosures =
GstBase.CollectPads.CollectPads
-> GstBase.CollectData.CollectData
-> Gst.Buffer.Buffer
-> Ptr ()
-> IO ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))
noCollectPadsClipFunction_WithClosures :: Maybe CollectPadsClipFunction_WithClosures
noCollectPadsClipFunction_WithClosures :: Maybe CollectPadsClipFunction_WithClosures
noCollectPadsClipFunction_WithClosures = Maybe CollectPadsClipFunction_WithClosures
forall a. Maybe a
Nothing
drop_closures_CollectPadsClipFunction :: CollectPadsClipFunction -> CollectPadsClipFunction_WithClosures
drop_closures_CollectPadsClipFunction :: CollectPadsClipFunction -> CollectPadsClipFunction_WithClosures
drop_closures_CollectPadsClipFunction _f :: CollectPadsClipFunction
_f pads :: CollectPads
pads data_ :: CollectData
data_ inbuffer :: Buffer
inbuffer _ = CollectPadsClipFunction
_f CollectPads
pads CollectData
data_ Buffer
inbuffer
genClosure_CollectPadsClipFunction :: MonadIO m => CollectPadsClipFunction -> m (GClosure C_CollectPadsClipFunction)
genClosure_CollectPadsClipFunction :: CollectPadsClipFunction -> m (GClosure C_CollectPadsClipFunction)
genClosure_CollectPadsClipFunction cb :: CollectPadsClipFunction
cb = IO (GClosure C_CollectPadsClipFunction)
-> m (GClosure C_CollectPadsClipFunction)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CollectPadsClipFunction)
-> m (GClosure C_CollectPadsClipFunction))
-> IO (GClosure C_CollectPadsClipFunction)
-> m (GClosure C_CollectPadsClipFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: CollectPadsClipFunction_WithClosures
cb' = CollectPadsClipFunction -> CollectPadsClipFunction_WithClosures
drop_closures_CollectPadsClipFunction CollectPadsClipFunction
cb
let cb'' :: C_CollectPadsClipFunction
cb'' = Maybe (Ptr (FunPtr C_CollectPadsClipFunction))
-> CollectPadsClipFunction_WithClosures
-> C_CollectPadsClipFunction
wrap_CollectPadsClipFunction Maybe (Ptr (FunPtr C_CollectPadsClipFunction))
forall a. Maybe a
Nothing CollectPadsClipFunction_WithClosures
cb'
C_CollectPadsClipFunction -> IO (FunPtr C_CollectPadsClipFunction)
mk_CollectPadsClipFunction C_CollectPadsClipFunction
cb'' IO (FunPtr C_CollectPadsClipFunction)
-> (FunPtr C_CollectPadsClipFunction
-> IO (GClosure C_CollectPadsClipFunction))
-> IO (GClosure C_CollectPadsClipFunction)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CollectPadsClipFunction
-> IO (GClosure C_CollectPadsClipFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_CollectPadsClipFunction ::
Maybe (Ptr (FunPtr C_CollectPadsClipFunction)) ->
CollectPadsClipFunction_WithClosures ->
C_CollectPadsClipFunction
wrap_CollectPadsClipFunction :: Maybe (Ptr (FunPtr C_CollectPadsClipFunction))
-> CollectPadsClipFunction_WithClosures
-> C_CollectPadsClipFunction
wrap_CollectPadsClipFunction funptrptr :: Maybe (Ptr (FunPtr C_CollectPadsClipFunction))
funptrptr _cb :: CollectPadsClipFunction_WithClosures
_cb pads :: Ptr CollectPads
pads data_ :: Ptr CollectData
data_ inbuffer :: Ptr Buffer
inbuffer outbuffer :: Ptr (Ptr Buffer)
outbuffer userData :: Ptr ()
userData = do
CollectPads
pads' <- ((ManagedPtr CollectPads -> CollectPads)
-> Ptr CollectPads -> IO CollectPads
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CollectPads -> CollectPads
GstBase.CollectPads.CollectPads) Ptr CollectPads
pads
CollectData
data_' <- ((ManagedPtr CollectData -> CollectData)
-> Ptr CollectData -> IO CollectData
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr CollectData -> CollectData
GstBase.CollectData.CollectData) Ptr CollectData
data_
Buffer
inbuffer' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
inbuffer
(result :: FlowReturn
result, outoutbuffer :: Buffer
outoutbuffer) <- CollectPadsClipFunction_WithClosures
_cb CollectPads
pads' CollectData
data_' Buffer
inbuffer' Ptr ()
userData
Ptr Buffer
outoutbuffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, BoxedObject a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
outoutbuffer
Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (Ptr Buffer)
outbuffer Ptr Buffer
outoutbuffer'
Maybe (Ptr (FunPtr C_CollectPadsClipFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_CollectPadsClipFunction))
funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (FlowReturn -> Int) -> FlowReturn -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FlowReturn -> Int
forall a. Enum a => a -> Int
fromEnum) FlowReturn
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_CollectPadsBufferFunction =
Ptr GstBase.CollectPads.CollectPads ->
Ptr GstBase.CollectData.CollectData ->
Ptr Gst.Buffer.Buffer ->
Ptr () ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_CollectPadsBufferFunction :: FunPtr C_CollectPadsBufferFunction -> C_CollectPadsBufferFunction
dynamic_CollectPadsBufferFunction ::
(B.CallStack.HasCallStack, MonadIO m, GstBase.CollectPads.IsCollectPads a) =>
FunPtr C_CollectPadsBufferFunction
-> a
-> GstBase.CollectData.CollectData
-> Gst.Buffer.Buffer
-> Ptr ()
-> m Gst.Enums.FlowReturn
dynamic_CollectPadsBufferFunction :: FunPtr C_CollectPadsBufferFunction
-> a -> CollectData -> Buffer -> Ptr () -> m FlowReturn
dynamic_CollectPadsBufferFunction __funPtr :: FunPtr C_CollectPadsBufferFunction
__funPtr pads :: a
pads data_ :: CollectData
data_ buffer :: Buffer
buffer userData :: Ptr ()
userData = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr CollectPads
pads' <- a -> IO (Ptr CollectPads)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pads
Ptr CollectData
data_' <- CollectData -> IO (Ptr CollectData)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CollectData
data_
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, BoxedObject a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
buffer
CInt
result <- (FunPtr C_CollectPadsBufferFunction -> C_CollectPadsBufferFunction
__dynamic_C_CollectPadsBufferFunction FunPtr C_CollectPadsBufferFunction
__funPtr) Ptr CollectPads
pads' Ptr CollectData
data_' Ptr Buffer
buffer' Ptr ()
userData
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pads
CollectData -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CollectData
data_
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
foreign import ccall "wrapper"
mk_CollectPadsBufferFunction :: C_CollectPadsBufferFunction -> IO (FunPtr C_CollectPadsBufferFunction)
type CollectPadsBufferFunction =
GstBase.CollectPads.CollectPads
-> GstBase.CollectData.CollectData
-> Gst.Buffer.Buffer
-> IO Gst.Enums.FlowReturn
noCollectPadsBufferFunction :: Maybe CollectPadsBufferFunction
noCollectPadsBufferFunction :: Maybe CollectPadsBufferFunction
noCollectPadsBufferFunction = Maybe CollectPadsBufferFunction
forall a. Maybe a
Nothing
type CollectPadsBufferFunction_WithClosures =
GstBase.CollectPads.CollectPads
-> GstBase.CollectData.CollectData
-> Gst.Buffer.Buffer
-> Ptr ()
-> IO Gst.Enums.FlowReturn
noCollectPadsBufferFunction_WithClosures :: Maybe CollectPadsBufferFunction_WithClosures
noCollectPadsBufferFunction_WithClosures :: Maybe CollectPadsBufferFunction_WithClosures
noCollectPadsBufferFunction_WithClosures = Maybe CollectPadsBufferFunction_WithClosures
forall a. Maybe a
Nothing
drop_closures_CollectPadsBufferFunction :: CollectPadsBufferFunction -> CollectPadsBufferFunction_WithClosures
drop_closures_CollectPadsBufferFunction :: CollectPadsBufferFunction -> CollectPadsBufferFunction_WithClosures
drop_closures_CollectPadsBufferFunction _f :: CollectPadsBufferFunction
_f pads :: CollectPads
pads data_ :: CollectData
data_ buffer :: Buffer
buffer _ = CollectPadsBufferFunction
_f CollectPads
pads CollectData
data_ Buffer
buffer
genClosure_CollectPadsBufferFunction :: MonadIO m => CollectPadsBufferFunction -> m (GClosure C_CollectPadsBufferFunction)
genClosure_CollectPadsBufferFunction :: CollectPadsBufferFunction
-> m (GClosure C_CollectPadsBufferFunction)
genClosure_CollectPadsBufferFunction cb :: CollectPadsBufferFunction
cb = IO (GClosure C_CollectPadsBufferFunction)
-> m (GClosure C_CollectPadsBufferFunction)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CollectPadsBufferFunction)
-> m (GClosure C_CollectPadsBufferFunction))
-> IO (GClosure C_CollectPadsBufferFunction)
-> m (GClosure C_CollectPadsBufferFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: CollectPadsBufferFunction_WithClosures
cb' = CollectPadsBufferFunction -> CollectPadsBufferFunction_WithClosures
drop_closures_CollectPadsBufferFunction CollectPadsBufferFunction
cb
let cb'' :: C_CollectPadsBufferFunction
cb'' = Maybe (Ptr (FunPtr C_CollectPadsBufferFunction))
-> CollectPadsBufferFunction_WithClosures
-> C_CollectPadsBufferFunction
wrap_CollectPadsBufferFunction Maybe (Ptr (FunPtr C_CollectPadsBufferFunction))
forall a. Maybe a
Nothing CollectPadsBufferFunction_WithClosures
cb'
C_CollectPadsBufferFunction
-> IO (FunPtr C_CollectPadsBufferFunction)
mk_CollectPadsBufferFunction C_CollectPadsBufferFunction
cb'' IO (FunPtr C_CollectPadsBufferFunction)
-> (FunPtr C_CollectPadsBufferFunction
-> IO (GClosure C_CollectPadsBufferFunction))
-> IO (GClosure C_CollectPadsBufferFunction)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CollectPadsBufferFunction
-> IO (GClosure C_CollectPadsBufferFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_CollectPadsBufferFunction ::
Maybe (Ptr (FunPtr C_CollectPadsBufferFunction)) ->
CollectPadsBufferFunction_WithClosures ->
C_CollectPadsBufferFunction
wrap_CollectPadsBufferFunction :: Maybe (Ptr (FunPtr C_CollectPadsBufferFunction))
-> CollectPadsBufferFunction_WithClosures
-> C_CollectPadsBufferFunction
wrap_CollectPadsBufferFunction funptrptr :: Maybe (Ptr (FunPtr C_CollectPadsBufferFunction))
funptrptr _cb :: CollectPadsBufferFunction_WithClosures
_cb pads :: Ptr CollectPads
pads data_ :: Ptr CollectData
data_ buffer :: Ptr Buffer
buffer userData :: Ptr ()
userData = do
CollectPads
pads' <- ((ManagedPtr CollectPads -> CollectPads)
-> Ptr CollectPads -> IO CollectPads
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CollectPads -> CollectPads
GstBase.CollectPads.CollectPads) Ptr CollectPads
pads
CollectData
data_' <- ((ManagedPtr CollectData -> CollectData)
-> Ptr CollectData -> IO CollectData
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr CollectData -> CollectData
GstBase.CollectData.CollectData) Ptr CollectData
data_
Buffer
buffer' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
buffer
FlowReturn
result <- CollectPadsBufferFunction_WithClosures
_cb CollectPads
pads' CollectData
data_' Buffer
buffer' Ptr ()
userData
Maybe (Ptr (FunPtr C_CollectPadsBufferFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_CollectPadsBufferFunction))
funptrptr
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (FlowReturn -> Int) -> FlowReturn -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FlowReturn -> Int
forall a. Enum a => a -> Int
fromEnum) FlowReturn
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_CollectDataDestroyNotify =
Ptr GstBase.CollectData.CollectData ->
IO ()
foreign import ccall "dynamic" __dynamic_C_CollectDataDestroyNotify :: FunPtr C_CollectDataDestroyNotify -> C_CollectDataDestroyNotify
dynamic_CollectDataDestroyNotify ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_CollectDataDestroyNotify
-> GstBase.CollectData.CollectData
-> m ()
dynamic_CollectDataDestroyNotify :: FunPtr C_CollectDataDestroyNotify -> CollectData -> m ()
dynamic_CollectDataDestroyNotify __funPtr :: FunPtr C_CollectDataDestroyNotify
__funPtr data_ :: CollectData
data_ = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr CollectData
data_' <- CollectData -> IO (Ptr CollectData)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CollectData
data_
(FunPtr C_CollectDataDestroyNotify -> C_CollectDataDestroyNotify
__dynamic_C_CollectDataDestroyNotify FunPtr C_CollectDataDestroyNotify
__funPtr) Ptr CollectData
data_'
CollectData -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CollectData
data_
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_CollectDataDestroyNotify :: C_CollectDataDestroyNotify -> IO (FunPtr C_CollectDataDestroyNotify)
type CollectDataDestroyNotify =
GstBase.CollectData.CollectData
-> IO ()
noCollectDataDestroyNotify :: Maybe CollectDataDestroyNotify
noCollectDataDestroyNotify :: Maybe (CollectData -> IO ())
noCollectDataDestroyNotify = Maybe (CollectData -> IO ())
forall a. Maybe a
Nothing
genClosure_CollectDataDestroyNotify :: MonadIO m => CollectDataDestroyNotify -> m (GClosure C_CollectDataDestroyNotify)
genClosure_CollectDataDestroyNotify :: (CollectData -> IO ()) -> m (GClosure C_CollectDataDestroyNotify)
genClosure_CollectDataDestroyNotify cb :: CollectData -> IO ()
cb = IO (GClosure C_CollectDataDestroyNotify)
-> m (GClosure C_CollectDataDestroyNotify)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CollectDataDestroyNotify)
-> m (GClosure C_CollectDataDestroyNotify))
-> IO (GClosure C_CollectDataDestroyNotify)
-> m (GClosure C_CollectDataDestroyNotify)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_CollectDataDestroyNotify
cb' = Maybe (Ptr (FunPtr C_CollectDataDestroyNotify))
-> (CollectData -> IO ()) -> C_CollectDataDestroyNotify
wrap_CollectDataDestroyNotify Maybe (Ptr (FunPtr C_CollectDataDestroyNotify))
forall a. Maybe a
Nothing CollectData -> IO ()
cb
C_CollectDataDestroyNotify
-> IO (FunPtr C_CollectDataDestroyNotify)
mk_CollectDataDestroyNotify C_CollectDataDestroyNotify
cb' IO (FunPtr C_CollectDataDestroyNotify)
-> (FunPtr C_CollectDataDestroyNotify
-> IO (GClosure C_CollectDataDestroyNotify))
-> IO (GClosure C_CollectDataDestroyNotify)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CollectDataDestroyNotify
-> IO (GClosure C_CollectDataDestroyNotify)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_CollectDataDestroyNotify ::
Maybe (Ptr (FunPtr C_CollectDataDestroyNotify)) ->
CollectDataDestroyNotify ->
C_CollectDataDestroyNotify
wrap_CollectDataDestroyNotify :: Maybe (Ptr (FunPtr C_CollectDataDestroyNotify))
-> (CollectData -> IO ()) -> C_CollectDataDestroyNotify
wrap_CollectDataDestroyNotify funptrptr :: Maybe (Ptr (FunPtr C_CollectDataDestroyNotify))
funptrptr _cb :: CollectData -> IO ()
_cb data_ :: Ptr CollectData
data_ = do
CollectData
data_' <- ((ManagedPtr CollectData -> CollectData)
-> Ptr CollectData -> IO CollectData
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr CollectData -> CollectData
GstBase.CollectData.CollectData) Ptr CollectData
data_
CollectData -> IO ()
_cb CollectData
data_'
Maybe (Ptr (FunPtr C_CollectDataDestroyNotify)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_CollectDataDestroyNotify))
funptrptr