{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.Buffer
(
Buffer(..) ,
newZeroBuffer ,
#if defined(ENABLE_OVERLOADING)
ResolveBufferMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
BufferAddMetaMethodInfo ,
#endif
bufferAddMeta ,
#if defined(ENABLE_OVERLOADING)
BufferAddParentBufferMetaMethodInfo ,
#endif
bufferAddParentBufferMeta ,
#if defined(ENABLE_OVERLOADING)
BufferAddProtectionMetaMethodInfo ,
#endif
bufferAddProtectionMeta ,
#if defined(ENABLE_OVERLOADING)
BufferAddReferenceTimestampMetaMethodInfo,
#endif
bufferAddReferenceTimestampMeta ,
#if defined(ENABLE_OVERLOADING)
BufferAppendMethodInfo ,
#endif
bufferAppend ,
#if defined(ENABLE_OVERLOADING)
BufferAppendMemoryMethodInfo ,
#endif
bufferAppendMemory ,
#if defined(ENABLE_OVERLOADING)
BufferAppendRegionMethodInfo ,
#endif
bufferAppendRegion ,
#if defined(ENABLE_OVERLOADING)
BufferCopyDeepMethodInfo ,
#endif
bufferCopyDeep ,
#if defined(ENABLE_OVERLOADING)
BufferCopyIntoMethodInfo ,
#endif
bufferCopyInto ,
#if defined(ENABLE_OVERLOADING)
BufferCopyRegionMethodInfo ,
#endif
bufferCopyRegion ,
#if defined(ENABLE_OVERLOADING)
BufferExtractMethodInfo ,
#endif
bufferExtract ,
#if defined(ENABLE_OVERLOADING)
BufferExtractDupMethodInfo ,
#endif
bufferExtractDup ,
#if defined(ENABLE_OVERLOADING)
BufferFillMethodInfo ,
#endif
bufferFill ,
#if defined(ENABLE_OVERLOADING)
BufferFindMemoryMethodInfo ,
#endif
bufferFindMemory ,
#if defined(ENABLE_OVERLOADING)
BufferForeachMetaMethodInfo ,
#endif
bufferForeachMeta ,
#if defined(ENABLE_OVERLOADING)
BufferGetAllMemoryMethodInfo ,
#endif
bufferGetAllMemory ,
#if defined(ENABLE_OVERLOADING)
BufferGetFlagsMethodInfo ,
#endif
bufferGetFlags ,
bufferGetMaxMemory ,
#if defined(ENABLE_OVERLOADING)
BufferGetMemoryMethodInfo ,
#endif
bufferGetMemory ,
#if defined(ENABLE_OVERLOADING)
BufferGetMemoryRangeMethodInfo ,
#endif
bufferGetMemoryRange ,
#if defined(ENABLE_OVERLOADING)
BufferGetMetaMethodInfo ,
#endif
bufferGetMeta ,
#if defined(ENABLE_OVERLOADING)
BufferGetNMetaMethodInfo ,
#endif
bufferGetNMeta ,
#if defined(ENABLE_OVERLOADING)
BufferGetReferenceTimestampMetaMethodInfo,
#endif
bufferGetReferenceTimestampMeta ,
#if defined(ENABLE_OVERLOADING)
BufferGetSizeMethodInfo ,
#endif
bufferGetSize ,
#if defined(ENABLE_OVERLOADING)
BufferGetSizesMethodInfo ,
#endif
bufferGetSizes ,
#if defined(ENABLE_OVERLOADING)
BufferGetSizesRangeMethodInfo ,
#endif
bufferGetSizesRange ,
#if defined(ENABLE_OVERLOADING)
BufferHasFlagsMethodInfo ,
#endif
bufferHasFlags ,
#if defined(ENABLE_OVERLOADING)
BufferInsertMemoryMethodInfo ,
#endif
bufferInsertMemory ,
#if defined(ENABLE_OVERLOADING)
BufferIsAllMemoryWritableMethodInfo ,
#endif
bufferIsAllMemoryWritable ,
#if defined(ENABLE_OVERLOADING)
BufferIsMemoryRangeWritableMethodInfo ,
#endif
bufferIsMemoryRangeWritable ,
#if defined(ENABLE_OVERLOADING)
BufferMapMethodInfo ,
#endif
bufferMap ,
#if defined(ENABLE_OVERLOADING)
BufferMapRangeMethodInfo ,
#endif
bufferMapRange ,
#if defined(ENABLE_OVERLOADING)
BufferMemcmpMethodInfo ,
#endif
bufferMemcmp ,
#if defined(ENABLE_OVERLOADING)
BufferMemsetMethodInfo ,
#endif
bufferMemset ,
#if defined(ENABLE_OVERLOADING)
BufferNMemoryMethodInfo ,
#endif
bufferNMemory ,
bufferNew ,
bufferNewAllocate ,
bufferNewWrapped ,
bufferNewWrappedBytes ,
bufferNewWrappedFull ,
#if defined(ENABLE_OVERLOADING)
BufferPeekMemoryMethodInfo ,
#endif
bufferPeekMemory ,
#if defined(ENABLE_OVERLOADING)
BufferPrependMemoryMethodInfo ,
#endif
bufferPrependMemory ,
#if defined(ENABLE_OVERLOADING)
BufferRemoveAllMemoryMethodInfo ,
#endif
bufferRemoveAllMemory ,
#if defined(ENABLE_OVERLOADING)
BufferRemoveMemoryMethodInfo ,
#endif
bufferRemoveMemory ,
#if defined(ENABLE_OVERLOADING)
BufferRemoveMemoryRangeMethodInfo ,
#endif
bufferRemoveMemoryRange ,
#if defined(ENABLE_OVERLOADING)
BufferRemoveMetaMethodInfo ,
#endif
bufferRemoveMeta ,
#if defined(ENABLE_OVERLOADING)
BufferReplaceAllMemoryMethodInfo ,
#endif
bufferReplaceAllMemory ,
#if defined(ENABLE_OVERLOADING)
BufferReplaceMemoryMethodInfo ,
#endif
bufferReplaceMemory ,
#if defined(ENABLE_OVERLOADING)
BufferReplaceMemoryRangeMethodInfo ,
#endif
bufferReplaceMemoryRange ,
#if defined(ENABLE_OVERLOADING)
BufferResizeMethodInfo ,
#endif
bufferResize ,
#if defined(ENABLE_OVERLOADING)
BufferResizeRangeMethodInfo ,
#endif
bufferResizeRange ,
#if defined(ENABLE_OVERLOADING)
BufferSetFlagsMethodInfo ,
#endif
bufferSetFlags ,
#if defined(ENABLE_OVERLOADING)
BufferSetSizeMethodInfo ,
#endif
bufferSetSize ,
#if defined(ENABLE_OVERLOADING)
BufferUnmapMethodInfo ,
#endif
bufferUnmap ,
#if defined(ENABLE_OVERLOADING)
BufferUnsetFlagsMethodInfo ,
#endif
bufferUnsetFlags ,
#if defined(ENABLE_OVERLOADING)
buffer_dts ,
#endif
getBufferDts ,
setBufferDts ,
#if defined(ENABLE_OVERLOADING)
buffer_duration ,
#endif
getBufferDuration ,
setBufferDuration ,
#if defined(ENABLE_OVERLOADING)
buffer_miniObject ,
#endif
getBufferMiniObject ,
#if defined(ENABLE_OVERLOADING)
buffer_offset ,
#endif
getBufferOffset ,
setBufferOffset ,
#if defined(ENABLE_OVERLOADING)
buffer_offsetEnd ,
#endif
getBufferOffsetEnd ,
setBufferOffsetEnd ,
#if defined(ENABLE_OVERLOADING)
buffer_pool ,
#endif
clearBufferPool ,
getBufferPool ,
setBufferPool ,
#if defined(ENABLE_OVERLOADING)
buffer_pts ,
#endif
getBufferPts ,
setBufferPts ,
) 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.BasicTypes as B.Types
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 Control.Monad.IO.Class as MIO
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.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
import {-# SOURCE #-} qualified GI.Gst.Objects.Allocator as Gst.Allocator
import {-# SOURCE #-} qualified GI.Gst.Objects.BufferPool as Gst.BufferPool
import {-# SOURCE #-} qualified GI.Gst.Structs.AllocationParams as Gst.AllocationParams
import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.Gst.Structs.MapInfo as Gst.MapInfo
import {-# SOURCE #-} qualified GI.Gst.Structs.Memory as Gst.Memory
import {-# SOURCE #-} qualified GI.Gst.Structs.Meta as Gst.Meta
import {-# SOURCE #-} qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo
import {-# SOURCE #-} qualified GI.Gst.Structs.MiniObject as Gst.MiniObject
import {-# SOURCE #-} qualified GI.Gst.Structs.ParentBufferMeta as Gst.ParentBufferMeta
import {-# SOURCE #-} qualified GI.Gst.Structs.ProtectionMeta as Gst.ProtectionMeta
import {-# SOURCE #-} qualified GI.Gst.Structs.ReferenceTimestampMeta as Gst.ReferenceTimestampMeta
import {-# SOURCE #-} qualified GI.Gst.Structs.Structure as Gst.Structure
newtype Buffer = Buffer (SP.ManagedPtr Buffer)
deriving (Buffer -> Buffer -> Bool
(Buffer -> Buffer -> Bool)
-> (Buffer -> Buffer -> Bool) -> Eq Buffer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Buffer -> Buffer -> Bool
$c/= :: Buffer -> Buffer -> Bool
== :: Buffer -> Buffer -> Bool
$c== :: Buffer -> Buffer -> Bool
Eq)
instance SP.ManagedPtrNewtype Buffer where
toManagedPtr :: Buffer -> ManagedPtr Buffer
toManagedPtr (Buffer ManagedPtr Buffer
p) = ManagedPtr Buffer
p
foreign import ccall "gst_buffer_get_type" c_gst_buffer_get_type ::
IO GType
type instance O.ParentTypes Buffer = '[]
instance O.HasParentTypes Buffer
instance B.Types.TypedObject Buffer where
glibType :: IO GType
glibType = IO GType
c_gst_buffer_get_type
instance B.Types.GBoxed Buffer
instance B.GValue.IsGValue Buffer where
toGValue :: Buffer -> IO GValue
toGValue Buffer
o = do
GType
gtype <- IO GType
c_gst_buffer_get_type
Buffer -> (Ptr Buffer -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Buffer
o (GType -> (GValue -> Ptr Buffer -> IO ()) -> Ptr Buffer -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Buffer -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO Buffer
fromGValue GValue
gv = do
Ptr Buffer
ptr <- GValue -> IO (Ptr Buffer)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr Buffer)
(ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Buffer -> Buffer
Buffer Ptr Buffer
ptr
newZeroBuffer :: MonadIO m => m Buffer
newZeroBuffer :: m Buffer
newZeroBuffer = IO Buffer -> m Buffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Buffer)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
112 IO (Ptr Buffer) -> (Ptr Buffer -> IO Buffer) -> IO Buffer
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Buffer
instance tag ~ 'AttrSet => Constructible Buffer tag where
new :: (ManagedPtr Buffer -> Buffer) -> [AttrOp Buffer tag] -> m Buffer
new ManagedPtr Buffer -> Buffer
_ [AttrOp Buffer tag]
attrs = do
Buffer
o <- m Buffer
forall (m :: * -> *). MonadIO m => m Buffer
newZeroBuffer
Buffer -> [AttrOp Buffer 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Buffer
o [AttrOp Buffer tag]
[AttrOp Buffer 'AttrSet]
attrs
Buffer -> m Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
o
getBufferMiniObject :: MonadIO m => Buffer -> m Gst.MiniObject.MiniObject
getBufferMiniObject :: Buffer -> m MiniObject
getBufferMiniObject Buffer
s = IO MiniObject -> m MiniObject
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MiniObject -> m MiniObject) -> IO MiniObject -> m MiniObject
forall a b. (a -> b) -> a -> b
$ Buffer -> (Ptr Buffer -> IO MiniObject) -> IO MiniObject
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO MiniObject) -> IO MiniObject)
-> (Ptr Buffer -> IO MiniObject) -> IO MiniObject
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
let val :: Ptr MiniObject
val = Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr MiniObject
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Gst.MiniObject.MiniObject)
MiniObject
val' <- ((ManagedPtr MiniObject -> MiniObject)
-> Ptr MiniObject -> IO MiniObject
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr MiniObject -> MiniObject
Gst.MiniObject.MiniObject) Ptr MiniObject
val
MiniObject -> IO MiniObject
forall (m :: * -> *) a. Monad m => a -> m a
return MiniObject
val'
#if defined(ENABLE_OVERLOADING)
data BufferMiniObjectFieldInfo
instance AttrInfo BufferMiniObjectFieldInfo where
type AttrBaseTypeConstraint BufferMiniObjectFieldInfo = (~) Buffer
type AttrAllowedOps BufferMiniObjectFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint BufferMiniObjectFieldInfo = (~) (Ptr Gst.MiniObject.MiniObject)
type AttrTransferTypeConstraint BufferMiniObjectFieldInfo = (~)(Ptr Gst.MiniObject.MiniObject)
type AttrTransferType BufferMiniObjectFieldInfo = (Ptr Gst.MiniObject.MiniObject)
type AttrGetType BufferMiniObjectFieldInfo = Gst.MiniObject.MiniObject
type AttrLabel BufferMiniObjectFieldInfo = "mini_object"
type AttrOrigin BufferMiniObjectFieldInfo = Buffer
attrGet = getBufferMiniObject
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
buffer_miniObject :: AttrLabelProxy "miniObject"
buffer_miniObject = AttrLabelProxy
#endif
getBufferPool :: MonadIO m => Buffer -> m (Maybe Gst.BufferPool.BufferPool)
getBufferPool :: Buffer -> m (Maybe BufferPool)
getBufferPool Buffer
s = IO (Maybe BufferPool) -> m (Maybe BufferPool)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BufferPool) -> m (Maybe BufferPool))
-> IO (Maybe BufferPool) -> m (Maybe BufferPool)
forall a b. (a -> b) -> a -> b
$ Buffer
-> (Ptr Buffer -> IO (Maybe BufferPool)) -> IO (Maybe BufferPool)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO (Maybe BufferPool)) -> IO (Maybe BufferPool))
-> (Ptr Buffer -> IO (Maybe BufferPool)) -> IO (Maybe BufferPool)
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
Ptr BufferPool
val <- Ptr (Ptr BufferPool) -> IO (Ptr BufferPool)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr (Ptr BufferPool)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) :: IO (Ptr Gst.BufferPool.BufferPool)
Maybe BufferPool
result <- Ptr BufferPool
-> (Ptr BufferPool -> IO BufferPool) -> IO (Maybe BufferPool)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr BufferPool
val ((Ptr BufferPool -> IO BufferPool) -> IO (Maybe BufferPool))
-> (Ptr BufferPool -> IO BufferPool) -> IO (Maybe BufferPool)
forall a b. (a -> b) -> a -> b
$ \Ptr BufferPool
val' -> do
BufferPool
val'' <- ((ManagedPtr BufferPool -> BufferPool)
-> Ptr BufferPool -> IO BufferPool
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr BufferPool -> BufferPool
Gst.BufferPool.BufferPool) Ptr BufferPool
val'
BufferPool -> IO BufferPool
forall (m :: * -> *) a. Monad m => a -> m a
return BufferPool
val''
Maybe BufferPool -> IO (Maybe BufferPool)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BufferPool
result
setBufferPool :: MonadIO m => Buffer -> Ptr Gst.BufferPool.BufferPool -> m ()
setBufferPool :: Buffer -> Ptr BufferPool -> m ()
setBufferPool Buffer
s Ptr BufferPool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Buffer -> (Ptr Buffer -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO ()) -> IO ()) -> (Ptr Buffer -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
Ptr (Ptr BufferPool) -> Ptr BufferPool -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr (Ptr BufferPool)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (Ptr BufferPool
val :: Ptr Gst.BufferPool.BufferPool)
clearBufferPool :: MonadIO m => Buffer -> m ()
clearBufferPool :: Buffer -> m ()
clearBufferPool Buffer
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Buffer -> (Ptr Buffer -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO ()) -> IO ()) -> (Ptr Buffer -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
Ptr (Ptr BufferPool) -> Ptr BufferPool -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr (Ptr BufferPool)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (Ptr BufferPool
forall a. Ptr a
FP.nullPtr :: Ptr Gst.BufferPool.BufferPool)
#if defined(ENABLE_OVERLOADING)
data BufferPoolFieldInfo
instance AttrInfo BufferPoolFieldInfo where
type AttrBaseTypeConstraint BufferPoolFieldInfo = (~) Buffer
type AttrAllowedOps BufferPoolFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint BufferPoolFieldInfo = (~) (Ptr Gst.BufferPool.BufferPool)
type AttrTransferTypeConstraint BufferPoolFieldInfo = (~)(Ptr Gst.BufferPool.BufferPool)
type AttrTransferType BufferPoolFieldInfo = (Ptr Gst.BufferPool.BufferPool)
type AttrGetType BufferPoolFieldInfo = Maybe Gst.BufferPool.BufferPool
type AttrLabel BufferPoolFieldInfo = "pool"
type AttrOrigin BufferPoolFieldInfo = Buffer
attrGet = getBufferPool
attrSet = setBufferPool
attrConstruct = undefined
attrClear = clearBufferPool
attrTransfer _ v = do
return v
buffer_pool :: AttrLabelProxy "pool"
buffer_pool = AttrLabelProxy
#endif
getBufferPts :: MonadIO m => Buffer -> m Word64
getBufferPts :: Buffer -> m Word64
getBufferPts Buffer
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Buffer -> (Ptr Buffer -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO Word64) -> IO Word64)
-> (Ptr Buffer -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setBufferPts :: MonadIO m => Buffer -> Word64 -> m ()
setBufferPts :: Buffer -> Word64 -> m ()
setBufferPts Buffer
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Buffer -> (Ptr Buffer -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO ()) -> IO ()) -> (Ptr Buffer -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data BufferPtsFieldInfo
instance AttrInfo BufferPtsFieldInfo where
type AttrBaseTypeConstraint BufferPtsFieldInfo = (~) Buffer
type AttrAllowedOps BufferPtsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint BufferPtsFieldInfo = (~) Word64
type AttrTransferTypeConstraint BufferPtsFieldInfo = (~)Word64
type AttrTransferType BufferPtsFieldInfo = Word64
type AttrGetType BufferPtsFieldInfo = Word64
type AttrLabel BufferPtsFieldInfo = "pts"
type AttrOrigin BufferPtsFieldInfo = Buffer
attrGet = getBufferPts
attrSet = setBufferPts
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
buffer_pts :: AttrLabelProxy "pts"
buffer_pts = AttrLabelProxy
#endif
getBufferDts :: MonadIO m => Buffer -> m Word64
getBufferDts :: Buffer -> m Word64
getBufferDts Buffer
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Buffer -> (Ptr Buffer -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO Word64) -> IO Word64)
-> (Ptr Buffer -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setBufferDts :: MonadIO m => Buffer -> Word64 -> m ()
setBufferDts :: Buffer -> Word64 -> m ()
setBufferDts Buffer
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Buffer -> (Ptr Buffer -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO ()) -> IO ()) -> (Ptr Buffer -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data BufferDtsFieldInfo
instance AttrInfo BufferDtsFieldInfo where
type AttrBaseTypeConstraint BufferDtsFieldInfo = (~) Buffer
type AttrAllowedOps BufferDtsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint BufferDtsFieldInfo = (~) Word64
type AttrTransferTypeConstraint BufferDtsFieldInfo = (~)Word64
type AttrTransferType BufferDtsFieldInfo = Word64
type AttrGetType BufferDtsFieldInfo = Word64
type AttrLabel BufferDtsFieldInfo = "dts"
type AttrOrigin BufferDtsFieldInfo = Buffer
attrGet = getBufferDts
attrSet = setBufferDts
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
buffer_dts :: AttrLabelProxy "dts"
buffer_dts = AttrLabelProxy
#endif
getBufferDuration :: MonadIO m => Buffer -> m Word64
getBufferDuration :: Buffer -> m Word64
getBufferDuration Buffer
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Buffer -> (Ptr Buffer -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO Word64) -> IO Word64)
-> (Ptr Buffer -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
88) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setBufferDuration :: MonadIO m => Buffer -> Word64 -> m ()
setBufferDuration :: Buffer -> Word64 -> m ()
setBufferDuration Buffer
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Buffer -> (Ptr Buffer -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO ()) -> IO ()) -> (Ptr Buffer -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
88) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data BufferDurationFieldInfo
instance AttrInfo BufferDurationFieldInfo where
type AttrBaseTypeConstraint BufferDurationFieldInfo = (~) Buffer
type AttrAllowedOps BufferDurationFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint BufferDurationFieldInfo = (~) Word64
type AttrTransferTypeConstraint BufferDurationFieldInfo = (~)Word64
type AttrTransferType BufferDurationFieldInfo = Word64
type AttrGetType BufferDurationFieldInfo = Word64
type AttrLabel BufferDurationFieldInfo = "duration"
type AttrOrigin BufferDurationFieldInfo = Buffer
attrGet = getBufferDuration
attrSet = setBufferDuration
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
buffer_duration :: AttrLabelProxy "duration"
buffer_duration = AttrLabelProxy
#endif
getBufferOffset :: MonadIO m => Buffer -> m Word64
getBufferOffset :: Buffer -> m Word64
getBufferOffset Buffer
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Buffer -> (Ptr Buffer -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO Word64) -> IO Word64)
-> (Ptr Buffer -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
96) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setBufferOffset :: MonadIO m => Buffer -> Word64 -> m ()
setBufferOffset :: Buffer -> Word64 -> m ()
setBufferOffset Buffer
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Buffer -> (Ptr Buffer -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO ()) -> IO ()) -> (Ptr Buffer -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
96) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data BufferOffsetFieldInfo
instance AttrInfo BufferOffsetFieldInfo where
type AttrBaseTypeConstraint BufferOffsetFieldInfo = (~) Buffer
type AttrAllowedOps BufferOffsetFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint BufferOffsetFieldInfo = (~) Word64
type AttrTransferTypeConstraint BufferOffsetFieldInfo = (~)Word64
type AttrTransferType BufferOffsetFieldInfo = Word64
type AttrGetType BufferOffsetFieldInfo = Word64
type AttrLabel BufferOffsetFieldInfo = "offset"
type AttrOrigin BufferOffsetFieldInfo = Buffer
attrGet = getBufferOffset
attrSet = setBufferOffset
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
buffer_offset :: AttrLabelProxy "offset"
buffer_offset = AttrLabelProxy
#endif
getBufferOffsetEnd :: MonadIO m => Buffer -> m Word64
getBufferOffsetEnd :: Buffer -> m Word64
getBufferOffsetEnd Buffer
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Buffer -> (Ptr Buffer -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO Word64) -> IO Word64)
-> (Ptr Buffer -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
104) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setBufferOffsetEnd :: MonadIO m => Buffer -> Word64 -> m ()
setBufferOffsetEnd :: Buffer -> Word64 -> m ()
setBufferOffsetEnd Buffer
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Buffer -> (Ptr Buffer -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Buffer
s ((Ptr Buffer -> IO ()) -> IO ()) -> (Ptr Buffer -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Buffer
ptr Ptr Buffer -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
104) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data BufferOffsetEndFieldInfo
instance AttrInfo BufferOffsetEndFieldInfo where
type AttrBaseTypeConstraint BufferOffsetEndFieldInfo = (~) Buffer
type AttrAllowedOps BufferOffsetEndFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint BufferOffsetEndFieldInfo = (~) Word64
type AttrTransferTypeConstraint BufferOffsetEndFieldInfo = (~)Word64
type AttrTransferType BufferOffsetEndFieldInfo = Word64
type AttrGetType BufferOffsetEndFieldInfo = Word64
type AttrLabel BufferOffsetEndFieldInfo = "offset_end"
type AttrOrigin BufferOffsetEndFieldInfo = Buffer
attrGet = getBufferOffsetEnd
attrSet = setBufferOffsetEnd
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
buffer_offsetEnd :: AttrLabelProxy "offsetEnd"
buffer_offsetEnd = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Buffer
type instance O.AttributeList Buffer = BufferAttributeList
type BufferAttributeList = ('[ '("miniObject", BufferMiniObjectFieldInfo), '("pool", BufferPoolFieldInfo), '("pts", BufferPtsFieldInfo), '("dts", BufferDtsFieldInfo), '("duration", BufferDurationFieldInfo), '("offset", BufferOffsetFieldInfo), '("offsetEnd", BufferOffsetEndFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_buffer_new" gst_buffer_new ::
IO (Ptr Buffer)
bufferNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Buffer
bufferNew :: m Buffer
bufferNew = IO Buffer -> m Buffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
result <- IO (Ptr Buffer)
gst_buffer_new
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bufferNew" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Buffer) Ptr Buffer
result
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_buffer_new_allocate" gst_buffer_new_allocate ::
Ptr Gst.Allocator.Allocator ->
Word64 ->
Ptr Gst.AllocationParams.AllocationParams ->
IO (Ptr Buffer)
bufferNewAllocate ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Allocator.IsAllocator a) =>
Maybe (a)
-> Word64
-> Maybe (Gst.AllocationParams.AllocationParams)
-> m (Maybe Buffer)
bufferNewAllocate :: Maybe a -> Word64 -> Maybe AllocationParams -> m (Maybe Buffer)
bufferNewAllocate Maybe a
allocator Word64
size Maybe AllocationParams
params = IO (Maybe Buffer) -> m (Maybe Buffer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Buffer) -> m (Maybe Buffer))
-> IO (Maybe Buffer) -> m (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ do
Ptr Allocator
maybeAllocator <- case Maybe a
allocator of
Maybe a
Nothing -> Ptr Allocator -> IO (Ptr Allocator)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Allocator
forall a. Ptr a
nullPtr
Just a
jAllocator -> do
Ptr Allocator
jAllocator' <- a -> IO (Ptr Allocator)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jAllocator
Ptr Allocator -> IO (Ptr Allocator)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Allocator
jAllocator'
Ptr AllocationParams
maybeParams <- case Maybe AllocationParams
params of
Maybe AllocationParams
Nothing -> Ptr AllocationParams -> IO (Ptr AllocationParams)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AllocationParams
forall a. Ptr a
nullPtr
Just AllocationParams
jParams -> do
Ptr AllocationParams
jParams' <- AllocationParams -> IO (Ptr AllocationParams)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AllocationParams
jParams
Ptr AllocationParams -> IO (Ptr AllocationParams)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AllocationParams
jParams'
Ptr Buffer
result <- Ptr Allocator -> Word64 -> Ptr AllocationParams -> IO (Ptr Buffer)
gst_buffer_new_allocate Ptr Allocator
maybeAllocator Word64
size Ptr AllocationParams
maybeParams
Maybe Buffer
maybeResult <- Ptr Buffer -> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Buffer
result ((Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer))
-> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
result' -> do
Buffer
result'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Buffer) Ptr Buffer
result'
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result''
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
allocator a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe AllocationParams -> (AllocationParams -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe AllocationParams
params AllocationParams -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Buffer -> IO (Maybe Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_buffer_new_wrapped" gst_buffer_new_wrapped ::
Ptr Word8 ->
Word64 ->
IO (Ptr Buffer)
bufferNewWrapped ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m Buffer
bufferNewWrapped :: ByteString -> m Buffer
bufferNewWrapped ByteString
data_ = IO Buffer -> m Buffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
let size :: Word64
size = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
data_
Ptr Word8
data_' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
data_
Ptr Buffer
result <- Ptr Word8 -> Word64 -> IO (Ptr Buffer)
gst_buffer_new_wrapped Ptr Word8
data_' Word64
size
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bufferNewWrapped" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Buffer) Ptr Buffer
result
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_buffer_new_wrapped_bytes" gst_buffer_new_wrapped_bytes ::
Ptr GLib.Bytes.Bytes ->
IO (Ptr Buffer)
bufferNewWrappedBytes ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.Bytes.Bytes
-> m Buffer
bufferNewWrappedBytes :: Bytes -> m Buffer
bufferNewWrappedBytes Bytes
bytes = IO Buffer -> m Buffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
Ptr Bytes
bytes' <- Bytes -> IO (Ptr Bytes)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
bytes
Ptr Buffer
result <- Ptr Bytes -> IO (Ptr Buffer)
gst_buffer_new_wrapped_bytes Ptr Bytes
bytes'
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bufferNewWrappedBytes" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Buffer) Ptr Buffer
result
Bytes -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
bytes
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_buffer_new_wrapped_full" gst_buffer_new_wrapped_full ::
CUInt ->
Ptr Word8 ->
Word64 ->
Word64 ->
Word64 ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO (Ptr Buffer)
bufferNewWrappedFull ::
(B.CallStack.HasCallStack, MonadIO m) =>
[Gst.Flags.MemoryFlags]
-> ByteString
-> Word64
-> Word64
-> Maybe (GLib.Callbacks.DestroyNotify)
-> m Buffer
bufferNewWrappedFull :: [MemoryFlags]
-> ByteString
-> Word64
-> Word64
-> Maybe DestroyNotify
-> m Buffer
bufferNewWrappedFull [MemoryFlags]
flags ByteString
data_ Word64
maxsize Word64
offset Maybe DestroyNotify
notify = IO Buffer -> m Buffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
let size :: Word64
size = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
data_
let flags' :: CUInt
flags' = [MemoryFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MemoryFlags]
flags
Ptr Word8
data_' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
data_
FunPtr DestroyNotify
maybeNotify <- case Maybe DestroyNotify
notify of
Maybe DestroyNotify
Nothing -> FunPtr DestroyNotify -> IO (FunPtr DestroyNotify)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr DestroyNotify
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just DestroyNotify
jNotify -> do
Ptr (FunPtr DestroyNotify)
ptrnotify <- IO (Ptr (FunPtr DestroyNotify))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
FunPtr DestroyNotify
jNotify' <- DestroyNotify -> IO (FunPtr DestroyNotify)
GLib.Callbacks.mk_DestroyNotify (Maybe (Ptr (FunPtr DestroyNotify))
-> DestroyNotify -> DestroyNotify
GLib.Callbacks.wrap_DestroyNotify (Ptr (FunPtr DestroyNotify) -> Maybe (Ptr (FunPtr DestroyNotify))
forall a. a -> Maybe a
Just Ptr (FunPtr DestroyNotify)
ptrnotify) DestroyNotify
jNotify)
Ptr (FunPtr DestroyNotify) -> FunPtr DestroyNotify -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr DestroyNotify)
ptrnotify FunPtr DestroyNotify
jNotify'
FunPtr DestroyNotify -> IO (FunPtr DestroyNotify)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr DestroyNotify
jNotify'
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
Ptr Buffer
result <- CUInt
-> Ptr Word8
-> Word64
-> Word64
-> Word64
-> Ptr ()
-> FunPtr DestroyNotify
-> IO (Ptr Buffer)
gst_buffer_new_wrapped_full CUInt
flags' Ptr Word8
data_' Word64
maxsize Word64
offset Word64
size Ptr ()
forall a. Ptr a
userData FunPtr DestroyNotify
maybeNotify
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bufferNewWrappedFull" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Buffer) Ptr Buffer
result
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
data_'
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_buffer_add_meta" gst_buffer_add_meta ::
Ptr Buffer ->
Ptr Gst.MetaInfo.MetaInfo ->
Ptr () ->
IO (Ptr Gst.Meta.Meta)
bufferAddMeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Gst.MetaInfo.MetaInfo
-> Ptr ()
-> m (Maybe Gst.Meta.Meta)
bufferAddMeta :: Buffer -> MetaInfo -> Ptr () -> m (Maybe Meta)
bufferAddMeta Buffer
buffer MetaInfo
info Ptr ()
params = IO (Maybe Meta) -> m (Maybe Meta)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Meta) -> m (Maybe Meta))
-> IO (Maybe Meta) -> m (Maybe Meta)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr MetaInfo
info' <- MetaInfo -> IO (Ptr MetaInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MetaInfo
info
Ptr Meta
result <- Ptr Buffer -> Ptr MetaInfo -> Ptr () -> IO (Ptr Meta)
gst_buffer_add_meta Ptr Buffer
buffer' Ptr MetaInfo
info' Ptr ()
params
Maybe Meta
maybeResult <- Ptr Meta -> (Ptr Meta -> IO Meta) -> IO (Maybe Meta)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Meta
result ((Ptr Meta -> IO Meta) -> IO (Maybe Meta))
-> (Ptr Meta -> IO Meta) -> IO (Maybe Meta)
forall a b. (a -> b) -> a -> b
$ \Ptr Meta
result' -> do
Meta
result'' <- ((ManagedPtr Meta -> Meta) -> Ptr Meta -> IO Meta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Meta -> Meta
Gst.Meta.Meta) Ptr Meta
result'
Meta -> IO Meta
forall (m :: * -> *) a. Monad m => a -> m a
return Meta
result''
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
MetaInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MetaInfo
info
Maybe Meta -> IO (Maybe Meta)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Meta
maybeResult
#if defined(ENABLE_OVERLOADING)
data BufferAddMetaMethodInfo
instance (signature ~ (Gst.MetaInfo.MetaInfo -> Ptr () -> m (Maybe Gst.Meta.Meta)), MonadIO m) => O.MethodInfo BufferAddMetaMethodInfo Buffer signature where
overloadedMethod = bufferAddMeta
#endif
foreign import ccall "gst_buffer_add_parent_buffer_meta" gst_buffer_add_parent_buffer_meta ::
Ptr Buffer ->
Ptr Buffer ->
IO (Ptr Gst.ParentBufferMeta.ParentBufferMeta)
bufferAddParentBufferMeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Buffer
-> m (Maybe Gst.ParentBufferMeta.ParentBufferMeta)
bufferAddParentBufferMeta :: Buffer -> Buffer -> m (Maybe ParentBufferMeta)
bufferAddParentBufferMeta Buffer
buffer Buffer
ref = IO (Maybe ParentBufferMeta) -> m (Maybe ParentBufferMeta)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ParentBufferMeta) -> m (Maybe ParentBufferMeta))
-> IO (Maybe ParentBufferMeta) -> m (Maybe ParentBufferMeta)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Buffer
ref' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
ref
Ptr ParentBufferMeta
result <- Ptr Buffer -> Ptr Buffer -> IO (Ptr ParentBufferMeta)
gst_buffer_add_parent_buffer_meta Ptr Buffer
buffer' Ptr Buffer
ref'
Maybe ParentBufferMeta
maybeResult <- Ptr ParentBufferMeta
-> (Ptr ParentBufferMeta -> IO ParentBufferMeta)
-> IO (Maybe ParentBufferMeta)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ParentBufferMeta
result ((Ptr ParentBufferMeta -> IO ParentBufferMeta)
-> IO (Maybe ParentBufferMeta))
-> (Ptr ParentBufferMeta -> IO ParentBufferMeta)
-> IO (Maybe ParentBufferMeta)
forall a b. (a -> b) -> a -> b
$ \Ptr ParentBufferMeta
result' -> do
ParentBufferMeta
result'' <- ((ManagedPtr ParentBufferMeta -> ParentBufferMeta)
-> Ptr ParentBufferMeta -> IO ParentBufferMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr ParentBufferMeta -> ParentBufferMeta
Gst.ParentBufferMeta.ParentBufferMeta) Ptr ParentBufferMeta
result'
ParentBufferMeta -> IO ParentBufferMeta
forall (m :: * -> *) a. Monad m => a -> m a
return ParentBufferMeta
result''
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
ref
Maybe ParentBufferMeta -> IO (Maybe ParentBufferMeta)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ParentBufferMeta
maybeResult
#if defined(ENABLE_OVERLOADING)
data BufferAddParentBufferMetaMethodInfo
instance (signature ~ (Buffer -> m (Maybe Gst.ParentBufferMeta.ParentBufferMeta)), MonadIO m) => O.MethodInfo BufferAddParentBufferMetaMethodInfo Buffer signature where
overloadedMethod = bufferAddParentBufferMeta
#endif
foreign import ccall "gst_buffer_add_protection_meta" gst_buffer_add_protection_meta ::
Ptr Buffer ->
Ptr Gst.Structure.Structure ->
IO (Ptr Gst.ProtectionMeta.ProtectionMeta)
bufferAddProtectionMeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Gst.Structure.Structure
-> m Gst.ProtectionMeta.ProtectionMeta
bufferAddProtectionMeta :: Buffer -> Structure -> m ProtectionMeta
bufferAddProtectionMeta Buffer
buffer Structure
info = IO ProtectionMeta -> m ProtectionMeta
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ProtectionMeta -> m ProtectionMeta)
-> IO ProtectionMeta -> m ProtectionMeta
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Structure
info' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
info
Ptr ProtectionMeta
result <- Ptr Buffer -> Ptr Structure -> IO (Ptr ProtectionMeta)
gst_buffer_add_protection_meta Ptr Buffer
buffer' Ptr Structure
info'
Text -> Ptr ProtectionMeta -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bufferAddProtectionMeta" Ptr ProtectionMeta
result
ProtectionMeta
result' <- ((ManagedPtr ProtectionMeta -> ProtectionMeta)
-> Ptr ProtectionMeta -> IO ProtectionMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr ProtectionMeta -> ProtectionMeta
Gst.ProtectionMeta.ProtectionMeta) Ptr ProtectionMeta
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Structure
info
ProtectionMeta -> IO ProtectionMeta
forall (m :: * -> *) a. Monad m => a -> m a
return ProtectionMeta
result'
#if defined(ENABLE_OVERLOADING)
data BufferAddProtectionMetaMethodInfo
instance (signature ~ (Gst.Structure.Structure -> m Gst.ProtectionMeta.ProtectionMeta), MonadIO m) => O.MethodInfo BufferAddProtectionMetaMethodInfo Buffer signature where
overloadedMethod = bufferAddProtectionMeta
#endif
foreign import ccall "gst_buffer_add_reference_timestamp_meta" gst_buffer_add_reference_timestamp_meta ::
Ptr Buffer ->
Ptr Gst.Caps.Caps ->
Word64 ->
Word64 ->
IO (Ptr Gst.ReferenceTimestampMeta.ReferenceTimestampMeta)
bufferAddReferenceTimestampMeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Gst.Caps.Caps
-> Word64
-> Word64
-> m (Maybe Gst.ReferenceTimestampMeta.ReferenceTimestampMeta)
bufferAddReferenceTimestampMeta :: Buffer
-> Caps -> Word64 -> Word64 -> m (Maybe ReferenceTimestampMeta)
bufferAddReferenceTimestampMeta Buffer
buffer Caps
reference Word64
timestamp Word64
duration = IO (Maybe ReferenceTimestampMeta)
-> m (Maybe ReferenceTimestampMeta)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ReferenceTimestampMeta)
-> m (Maybe ReferenceTimestampMeta))
-> IO (Maybe ReferenceTimestampMeta)
-> m (Maybe ReferenceTimestampMeta)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Caps
reference' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
reference
Ptr ReferenceTimestampMeta
result <- Ptr Buffer
-> Ptr Caps -> Word64 -> Word64 -> IO (Ptr ReferenceTimestampMeta)
gst_buffer_add_reference_timestamp_meta Ptr Buffer
buffer' Ptr Caps
reference' Word64
timestamp Word64
duration
Maybe ReferenceTimestampMeta
maybeResult <- Ptr ReferenceTimestampMeta
-> (Ptr ReferenceTimestampMeta -> IO ReferenceTimestampMeta)
-> IO (Maybe ReferenceTimestampMeta)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ReferenceTimestampMeta
result ((Ptr ReferenceTimestampMeta -> IO ReferenceTimestampMeta)
-> IO (Maybe ReferenceTimestampMeta))
-> (Ptr ReferenceTimestampMeta -> IO ReferenceTimestampMeta)
-> IO (Maybe ReferenceTimestampMeta)
forall a b. (a -> b) -> a -> b
$ \Ptr ReferenceTimestampMeta
result' -> do
ReferenceTimestampMeta
result'' <- ((ManagedPtr ReferenceTimestampMeta -> ReferenceTimestampMeta)
-> Ptr ReferenceTimestampMeta -> IO ReferenceTimestampMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr ReferenceTimestampMeta -> ReferenceTimestampMeta
Gst.ReferenceTimestampMeta.ReferenceTimestampMeta) Ptr ReferenceTimestampMeta
result'
ReferenceTimestampMeta -> IO ReferenceTimestampMeta
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceTimestampMeta
result''
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
reference
Maybe ReferenceTimestampMeta -> IO (Maybe ReferenceTimestampMeta)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ReferenceTimestampMeta
maybeResult
#if defined(ENABLE_OVERLOADING)
data BufferAddReferenceTimestampMetaMethodInfo
instance (signature ~ (Gst.Caps.Caps -> Word64 -> Word64 -> m (Maybe Gst.ReferenceTimestampMeta.ReferenceTimestampMeta)), MonadIO m) => O.MethodInfo BufferAddReferenceTimestampMetaMethodInfo Buffer signature where
overloadedMethod = bufferAddReferenceTimestampMeta
#endif
foreign import ccall "gst_buffer_append" gst_buffer_append ::
Ptr Buffer ->
Ptr Buffer ->
IO (Ptr Buffer)
bufferAppend ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Buffer
-> m Buffer
bufferAppend :: Buffer -> Buffer -> m Buffer
bufferAppend Buffer
buf1 Buffer
buf2 = IO Buffer -> m Buffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buf1' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
buf1
Ptr Buffer
buf2' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
buf2
Ptr Buffer
result <- Ptr Buffer -> Ptr Buffer -> IO (Ptr Buffer)
gst_buffer_append Ptr Buffer
buf1' Ptr Buffer
buf2'
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bufferAppend" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Buffer) Ptr Buffer
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buf1
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buf2
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
#if defined(ENABLE_OVERLOADING)
data BufferAppendMethodInfo
instance (signature ~ (Buffer -> m Buffer), MonadIO m) => O.MethodInfo BufferAppendMethodInfo Buffer signature where
overloadedMethod = bufferAppend
#endif
foreign import ccall "gst_buffer_append_memory" gst_buffer_append_memory ::
Ptr Buffer ->
Ptr Gst.Memory.Memory ->
IO ()
bufferAppendMemory ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Gst.Memory.Memory
-> m ()
bufferAppendMemory :: Buffer -> Memory -> m ()
bufferAppendMemory Buffer
buffer Memory
mem = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Memory
mem' <- Memory -> IO (Ptr Memory)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Memory
mem
Ptr Buffer -> Ptr Memory -> IO ()
gst_buffer_append_memory Ptr Buffer
buffer' Ptr Memory
mem'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Memory -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Memory
mem
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferAppendMemoryMethodInfo
instance (signature ~ (Gst.Memory.Memory -> m ()), MonadIO m) => O.MethodInfo BufferAppendMemoryMethodInfo Buffer signature where
overloadedMethod = bufferAppendMemory
#endif
foreign import ccall "gst_buffer_append_region" gst_buffer_append_region ::
Ptr Buffer ->
Ptr Buffer ->
Int64 ->
Int64 ->
IO (Ptr Buffer)
bufferAppendRegion ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Buffer
-> Int64
-> Int64
-> m Buffer
bufferAppendRegion :: Buffer -> Buffer -> Int64 -> Int64 -> m Buffer
bufferAppendRegion Buffer
buf1 Buffer
buf2 Int64
offset Int64
size = IO Buffer -> m Buffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buf1' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
buf1
Ptr Buffer
buf2' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
buf2
Ptr Buffer
result <- Ptr Buffer -> Ptr Buffer -> Int64 -> Int64 -> IO (Ptr Buffer)
gst_buffer_append_region Ptr Buffer
buf1' Ptr Buffer
buf2' Int64
offset Int64
size
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bufferAppendRegion" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Buffer) Ptr Buffer
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buf1
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buf2
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
#if defined(ENABLE_OVERLOADING)
data BufferAppendRegionMethodInfo
instance (signature ~ (Buffer -> Int64 -> Int64 -> m Buffer), MonadIO m) => O.MethodInfo BufferAppendRegionMethodInfo Buffer signature where
overloadedMethod = bufferAppendRegion
#endif
foreign import ccall "gst_buffer_copy_deep" gst_buffer_copy_deep ::
Ptr Buffer ->
IO (Ptr Buffer)
bufferCopyDeep ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> m Buffer
bufferCopyDeep :: Buffer -> m Buffer
bufferCopyDeep Buffer
buf = IO Buffer -> m Buffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buf' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buf
Ptr Buffer
result <- Ptr Buffer -> IO (Ptr Buffer)
gst_buffer_copy_deep Ptr Buffer
buf'
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bufferCopyDeep" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Buffer) Ptr Buffer
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buf
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
#if defined(ENABLE_OVERLOADING)
data BufferCopyDeepMethodInfo
instance (signature ~ (m Buffer), MonadIO m) => O.MethodInfo BufferCopyDeepMethodInfo Buffer signature where
overloadedMethod = bufferCopyDeep
#endif
foreign import ccall "gst_buffer_copy_into" gst_buffer_copy_into ::
Ptr Buffer ->
Ptr Buffer ->
CUInt ->
Word64 ->
Word64 ->
IO CInt
bufferCopyInto ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Buffer
-> [Gst.Flags.BufferCopyFlags]
-> Word64
-> Word64
-> m Bool
bufferCopyInto :: Buffer -> Buffer -> [BufferCopyFlags] -> Word64 -> Word64 -> m Bool
bufferCopyInto Buffer
dest Buffer
src [BufferCopyFlags]
flags Word64
offset Word64
size = 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 Buffer
dest' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
dest
Ptr Buffer
src' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
src
let flags' :: CUInt
flags' = [BufferCopyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [BufferCopyFlags]
flags
CInt
result <- Ptr Buffer -> Ptr Buffer -> CUInt -> Word64 -> Word64 -> IO CInt
gst_buffer_copy_into Ptr Buffer
dest' Ptr Buffer
src' CUInt
flags' Word64
offset Word64
size
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
dest
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
src
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BufferCopyIntoMethodInfo
instance (signature ~ (Buffer -> [Gst.Flags.BufferCopyFlags] -> Word64 -> Word64 -> m Bool), MonadIO m) => O.MethodInfo BufferCopyIntoMethodInfo Buffer signature where
overloadedMethod = bufferCopyInto
#endif
foreign import ccall "gst_buffer_copy_region" gst_buffer_copy_region ::
Ptr Buffer ->
CUInt ->
Word64 ->
Word64 ->
IO (Ptr Buffer)
bufferCopyRegion ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> [Gst.Flags.BufferCopyFlags]
-> Word64
-> Word64
-> m Buffer
bufferCopyRegion :: Buffer -> [BufferCopyFlags] -> Word64 -> Word64 -> m Buffer
bufferCopyRegion Buffer
parent [BufferCopyFlags]
flags Word64
offset Word64
size = IO Buffer -> m Buffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
parent' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
parent
let flags' :: CUInt
flags' = [BufferCopyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [BufferCopyFlags]
flags
Ptr Buffer
result <- Ptr Buffer -> CUInt -> Word64 -> Word64 -> IO (Ptr Buffer)
gst_buffer_copy_region Ptr Buffer
parent' CUInt
flags' Word64
offset Word64
size
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"bufferCopyRegion" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Buffer) Ptr Buffer
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
parent
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
#if defined(ENABLE_OVERLOADING)
data BufferCopyRegionMethodInfo
instance (signature ~ ([Gst.Flags.BufferCopyFlags] -> Word64 -> Word64 -> m Buffer), MonadIO m) => O.MethodInfo BufferCopyRegionMethodInfo Buffer signature where
overloadedMethod = bufferCopyRegion
#endif
foreign import ccall "gst_buffer_extract" ::
Ptr Buffer ->
Word64 ->
Ptr Word8 ->
Word64 ->
IO Word64
bufferExtract ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word64
-> Maybe (ByteString)
-> m ((Word64, Maybe ByteString))
Buffer
buffer Word64
offset Maybe ByteString
dest = IO (Word64, Maybe ByteString) -> m (Word64, Maybe ByteString)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Word64, Maybe ByteString) -> m (Word64, Maybe ByteString))
-> IO (Word64, Maybe ByteString) -> m (Word64, Maybe ByteString)
forall a b. (a -> b) -> a -> b
$ do
let size :: Word64
size = case Maybe ByteString
dest of
Maybe ByteString
Nothing -> Word64
0
Just ByteString
jDest -> Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
jDest
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Word8
maybeDest <- case Maybe ByteString
dest of
Maybe ByteString
Nothing -> Ptr Word8 -> IO (Ptr Word8)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
forall a. Ptr a
nullPtr
Just ByteString
jDest -> do
Ptr Word8
jDest' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
jDest
Ptr Word8 -> IO (Ptr Word8)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
jDest'
Word64
result <- Ptr Buffer -> Word64 -> Ptr Word8 -> Word64 -> IO Word64
gst_buffer_extract Ptr Buffer
buffer' Word64
offset Ptr Word8
maybeDest Word64
size
Maybe ByteString
maybeMaybeDest <- Ptr Word8 -> (Ptr Word8 -> IO ByteString) -> IO (Maybe ByteString)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Word8
maybeDest ((Ptr Word8 -> IO ByteString) -> IO (Maybe ByteString))
-> (Ptr Word8 -> IO ByteString) -> IO (Maybe ByteString)
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
maybeDest' -> do
ByteString
maybeDest'' <- (Word64 -> Ptr Word8 -> IO ByteString
forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Word64
size) Ptr Word8
maybeDest'
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
maybeDest'
ByteString -> IO ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
maybeDest''
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
(Word64, Maybe ByteString) -> IO (Word64, Maybe ByteString)
forall (m :: * -> *) a. Monad m => a -> m a
return (Word64
result, Maybe ByteString
maybeMaybeDest)
#if defined(ENABLE_OVERLOADING)
data BufferExtractMethodInfo
instance (signature ~ (Word64 -> Maybe (ByteString) -> m ((Word64, Maybe ByteString))), MonadIO m) => O.MethodInfo BufferExtractMethodInfo Buffer signature where
overloadedMethod = bufferExtract
#endif
foreign import ccall "gst_buffer_extract_dup" ::
Ptr Buffer ->
Word64 ->
Word64 ->
Ptr (Ptr Word8) ->
Ptr Word64 ->
IO ()
bufferExtractDup ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word64
-> Word64
-> m (ByteString)
Buffer
buffer Word64
offset Word64
size = IO ByteString -> m ByteString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr (Ptr Word8)
dest <- IO (Ptr (Ptr Word8))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Word8))
Ptr Word64
destSize <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Buffer
-> Word64 -> Word64 -> Ptr (Ptr Word8) -> Ptr Word64 -> IO ()
gst_buffer_extract_dup Ptr Buffer
buffer' Word64
offset Word64
size Ptr (Ptr Word8)
dest Ptr Word64
destSize
Word64
destSize' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
destSize
Ptr Word8
dest' <- Ptr (Ptr Word8) -> IO (Ptr Word8)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Word8)
dest
ByteString
dest'' <- (Word64 -> Ptr Word8 -> IO ByteString
forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Word64
destSize') Ptr Word8
dest'
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
dest'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Ptr (Ptr Word8) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
dest
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
destSize
ByteString -> IO ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
dest''
#if defined(ENABLE_OVERLOADING)
data BufferExtractDupMethodInfo
instance (signature ~ (Word64 -> Word64 -> m (ByteString)), MonadIO m) => O.MethodInfo BufferExtractDupMethodInfo Buffer signature where
overloadedMethod = bufferExtractDup
#endif
foreign import ccall "gst_buffer_fill" gst_buffer_fill ::
Ptr Buffer ->
Word64 ->
Ptr Word8 ->
Word64 ->
IO Word64
bufferFill ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word64
-> ByteString
-> m Word64
bufferFill :: Buffer -> Word64 -> ByteString -> m Word64
bufferFill Buffer
buffer Word64
offset ByteString
src = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
let size :: Word64
size = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
src
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Word8
src' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
src
Word64
result <- Ptr Buffer -> Word64 -> Ptr Word8 -> Word64 -> IO Word64
gst_buffer_fill Ptr Buffer
buffer' Word64
offset Ptr Word8
src' Word64
size
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
src'
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data BufferFillMethodInfo
instance (signature ~ (Word64 -> ByteString -> m Word64), MonadIO m) => O.MethodInfo BufferFillMethodInfo Buffer signature where
overloadedMethod = bufferFill
#endif
foreign import ccall "gst_buffer_find_memory" gst_buffer_find_memory ::
Ptr Buffer ->
Word64 ->
Word64 ->
Ptr Word32 ->
Ptr Word32 ->
Ptr Word64 ->
IO CInt
bufferFindMemory ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word64
-> Word64
-> m ((Bool, Word32, Word32, Word64))
bufferFindMemory :: Buffer -> Word64 -> Word64 -> m (Bool, Word32, Word32, Word64)
bufferFindMemory Buffer
buffer Word64
offset Word64
size = IO (Bool, Word32, Word32, Word64)
-> m (Bool, Word32, Word32, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word32, Word32, Word64)
-> m (Bool, Word32, Word32, Word64))
-> IO (Bool, Word32, Word32, Word64)
-> m (Bool, Word32, Word32, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Word32
idx <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
Ptr Word32
length_ <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
Ptr Word64
skip <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
CInt
result <- Ptr Buffer
-> Word64
-> Word64
-> Ptr Word32
-> Ptr Word32
-> Ptr Word64
-> IO CInt
gst_buffer_find_memory Ptr Buffer
buffer' Word64
offset Word64
size Ptr Word32
idx Ptr Word32
length_ Ptr Word64
skip
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Word32
idx' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
idx
Word32
length_' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
length_
Word64
skip' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
skip
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
idx
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
length_
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
skip
(Bool, Word32, Word32, Word64) -> IO (Bool, Word32, Word32, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word32
idx', Word32
length_', Word64
skip')
#if defined(ENABLE_OVERLOADING)
data BufferFindMemoryMethodInfo
instance (signature ~ (Word64 -> Word64 -> m ((Bool, Word32, Word32, Word64))), MonadIO m) => O.MethodInfo BufferFindMemoryMethodInfo Buffer signature where
overloadedMethod = bufferFindMemory
#endif
foreign import ccall "gst_buffer_foreach_meta" gst_buffer_foreach_meta ::
Ptr Buffer ->
FunPtr Gst.Callbacks.C_BufferForeachMetaFunc ->
Ptr () ->
IO CInt
bufferForeachMeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Gst.Callbacks.BufferForeachMetaFunc
-> m Bool
bufferForeachMeta :: Buffer -> BufferForeachMetaFunc -> m Bool
bufferForeachMeta Buffer
buffer BufferForeachMetaFunc
func = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
FunPtr C_BufferForeachMetaFunc
func' <- C_BufferForeachMetaFunc -> IO (FunPtr C_BufferForeachMetaFunc)
Gst.Callbacks.mk_BufferForeachMetaFunc (Maybe (Ptr (FunPtr C_BufferForeachMetaFunc))
-> BufferForeachMetaFunc_WithClosures -> C_BufferForeachMetaFunc
Gst.Callbacks.wrap_BufferForeachMetaFunc Maybe (Ptr (FunPtr C_BufferForeachMetaFunc))
forall a. Maybe a
Nothing (BufferForeachMetaFunc -> BufferForeachMetaFunc_WithClosures
Gst.Callbacks.drop_closures_BufferForeachMetaFunc BufferForeachMetaFunc
func))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
CInt
result <- Ptr Buffer -> FunPtr C_BufferForeachMetaFunc -> Ptr () -> IO CInt
gst_buffer_foreach_meta Ptr Buffer
buffer' FunPtr C_BufferForeachMetaFunc
func' Ptr ()
forall a. Ptr a
userData
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_BufferForeachMetaFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_BufferForeachMetaFunc
func'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BufferForeachMetaMethodInfo
instance (signature ~ (Gst.Callbacks.BufferForeachMetaFunc -> m Bool), MonadIO m) => O.MethodInfo BufferForeachMetaMethodInfo Buffer signature where
overloadedMethod = bufferForeachMeta
#endif
foreign import ccall "gst_buffer_get_all_memory" gst_buffer_get_all_memory ::
Ptr Buffer ->
IO (Ptr Gst.Memory.Memory)
bufferGetAllMemory ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> m (Maybe Gst.Memory.Memory)
bufferGetAllMemory :: Buffer -> m (Maybe Memory)
bufferGetAllMemory Buffer
buffer = IO (Maybe Memory) -> m (Maybe Memory)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Memory) -> m (Maybe Memory))
-> IO (Maybe Memory) -> m (Maybe Memory)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Memory
result <- Ptr Buffer -> IO (Ptr Memory)
gst_buffer_get_all_memory Ptr Buffer
buffer'
Maybe Memory
maybeResult <- Ptr Memory -> (Ptr Memory -> IO Memory) -> IO (Maybe Memory)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Memory
result ((Ptr Memory -> IO Memory) -> IO (Maybe Memory))
-> (Ptr Memory -> IO Memory) -> IO (Maybe Memory)
forall a b. (a -> b) -> a -> b
$ \Ptr Memory
result' -> do
Memory
result'' <- ((ManagedPtr Memory -> Memory) -> Ptr Memory -> IO Memory
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Memory -> Memory
Gst.Memory.Memory) Ptr Memory
result'
Memory -> IO Memory
forall (m :: * -> *) a. Monad m => a -> m a
return Memory
result''
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Maybe Memory -> IO (Maybe Memory)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Memory
maybeResult
#if defined(ENABLE_OVERLOADING)
data BufferGetAllMemoryMethodInfo
instance (signature ~ (m (Maybe Gst.Memory.Memory)), MonadIO m) => O.MethodInfo BufferGetAllMemoryMethodInfo Buffer signature where
overloadedMethod = bufferGetAllMemory
#endif
foreign import ccall "gst_buffer_get_flags" gst_buffer_get_flags ::
Ptr Buffer ->
IO CUInt
bufferGetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> m [Gst.Flags.BufferFlags]
bufferGetFlags :: Buffer -> m [BufferFlags]
bufferGetFlags Buffer
buffer = IO [BufferFlags] -> m [BufferFlags]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [BufferFlags] -> m [BufferFlags])
-> IO [BufferFlags] -> m [BufferFlags]
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
CUInt
result <- Ptr Buffer -> IO CUInt
gst_buffer_get_flags Ptr Buffer
buffer'
let result' :: [BufferFlags]
result' = CUInt -> [BufferFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
[BufferFlags] -> IO [BufferFlags]
forall (m :: * -> *) a. Monad m => a -> m a
return [BufferFlags]
result'
#if defined(ENABLE_OVERLOADING)
data BufferGetFlagsMethodInfo
instance (signature ~ (m [Gst.Flags.BufferFlags]), MonadIO m) => O.MethodInfo BufferGetFlagsMethodInfo Buffer signature where
overloadedMethod = bufferGetFlags
#endif
foreign import ccall "gst_buffer_get_memory" gst_buffer_get_memory ::
Ptr Buffer ->
Word32 ->
IO (Ptr Gst.Memory.Memory)
bufferGetMemory ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word32
-> m (Maybe Gst.Memory.Memory)
bufferGetMemory :: Buffer -> Word32 -> m (Maybe Memory)
bufferGetMemory Buffer
buffer Word32
idx = IO (Maybe Memory) -> m (Maybe Memory)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Memory) -> m (Maybe Memory))
-> IO (Maybe Memory) -> m (Maybe Memory)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Memory
result <- Ptr Buffer -> Word32 -> IO (Ptr Memory)
gst_buffer_get_memory Ptr Buffer
buffer' Word32
idx
Maybe Memory
maybeResult <- Ptr Memory -> (Ptr Memory -> IO Memory) -> IO (Maybe Memory)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Memory
result ((Ptr Memory -> IO Memory) -> IO (Maybe Memory))
-> (Ptr Memory -> IO Memory) -> IO (Maybe Memory)
forall a b. (a -> b) -> a -> b
$ \Ptr Memory
result' -> do
Memory
result'' <- ((ManagedPtr Memory -> Memory) -> Ptr Memory -> IO Memory
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Memory -> Memory
Gst.Memory.Memory) Ptr Memory
result'
Memory -> IO Memory
forall (m :: * -> *) a. Monad m => a -> m a
return Memory
result''
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Maybe Memory -> IO (Maybe Memory)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Memory
maybeResult
#if defined(ENABLE_OVERLOADING)
data BufferGetMemoryMethodInfo
instance (signature ~ (Word32 -> m (Maybe Gst.Memory.Memory)), MonadIO m) => O.MethodInfo BufferGetMemoryMethodInfo Buffer signature where
overloadedMethod = bufferGetMemory
#endif
foreign import ccall "gst_buffer_get_memory_range" gst_buffer_get_memory_range ::
Ptr Buffer ->
Word32 ->
Int32 ->
IO (Ptr Gst.Memory.Memory)
bufferGetMemoryRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word32
-> Int32
-> m (Maybe Gst.Memory.Memory)
bufferGetMemoryRange :: Buffer -> Word32 -> Int32 -> m (Maybe Memory)
bufferGetMemoryRange Buffer
buffer Word32
idx Int32
length_ = IO (Maybe Memory) -> m (Maybe Memory)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Memory) -> m (Maybe Memory))
-> IO (Maybe Memory) -> m (Maybe Memory)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Memory
result <- Ptr Buffer -> Word32 -> Int32 -> IO (Ptr Memory)
gst_buffer_get_memory_range Ptr Buffer
buffer' Word32
idx Int32
length_
Maybe Memory
maybeResult <- Ptr Memory -> (Ptr Memory -> IO Memory) -> IO (Maybe Memory)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Memory
result ((Ptr Memory -> IO Memory) -> IO (Maybe Memory))
-> (Ptr Memory -> IO Memory) -> IO (Maybe Memory)
forall a b. (a -> b) -> a -> b
$ \Ptr Memory
result' -> do
Memory
result'' <- ((ManagedPtr Memory -> Memory) -> Ptr Memory -> IO Memory
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Memory -> Memory
Gst.Memory.Memory) Ptr Memory
result'
Memory -> IO Memory
forall (m :: * -> *) a. Monad m => a -> m a
return Memory
result''
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Maybe Memory -> IO (Maybe Memory)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Memory
maybeResult
#if defined(ENABLE_OVERLOADING)
data BufferGetMemoryRangeMethodInfo
instance (signature ~ (Word32 -> Int32 -> m (Maybe Gst.Memory.Memory)), MonadIO m) => O.MethodInfo BufferGetMemoryRangeMethodInfo Buffer signature where
overloadedMethod = bufferGetMemoryRange
#endif
foreign import ccall "gst_buffer_get_meta" gst_buffer_get_meta ::
Ptr Buffer ->
CGType ->
IO (Ptr Gst.Meta.Meta)
bufferGetMeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> GType
-> m (Maybe Gst.Meta.Meta)
bufferGetMeta :: Buffer -> GType -> m (Maybe Meta)
bufferGetMeta Buffer
buffer GType
api = IO (Maybe Meta) -> m (Maybe Meta)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Meta) -> m (Maybe Meta))
-> IO (Maybe Meta) -> m (Maybe Meta)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
let api' :: Word64
api' = GType -> Word64
gtypeToCGType GType
api
Ptr Meta
result <- Ptr Buffer -> Word64 -> IO (Ptr Meta)
gst_buffer_get_meta Ptr Buffer
buffer' Word64
api'
Maybe Meta
maybeResult <- Ptr Meta -> (Ptr Meta -> IO Meta) -> IO (Maybe Meta)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Meta
result ((Ptr Meta -> IO Meta) -> IO (Maybe Meta))
-> (Ptr Meta -> IO Meta) -> IO (Maybe Meta)
forall a b. (a -> b) -> a -> b
$ \Ptr Meta
result' -> do
Meta
result'' <- ((ManagedPtr Meta -> Meta) -> Ptr Meta -> IO Meta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Meta -> Meta
Gst.Meta.Meta) Ptr Meta
result'
Meta -> IO Meta
forall (m :: * -> *) a. Monad m => a -> m a
return Meta
result''
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Maybe Meta -> IO (Maybe Meta)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Meta
maybeResult
#if defined(ENABLE_OVERLOADING)
data BufferGetMetaMethodInfo
instance (signature ~ (GType -> m (Maybe Gst.Meta.Meta)), MonadIO m) => O.MethodInfo BufferGetMetaMethodInfo Buffer signature where
overloadedMethod = bufferGetMeta
#endif
foreign import ccall "gst_buffer_get_n_meta" gst_buffer_get_n_meta ::
Ptr Buffer ->
CGType ->
IO Word32
bufferGetNMeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> GType
-> m Word32
bufferGetNMeta :: Buffer -> GType -> m Word32
bufferGetNMeta Buffer
buffer GType
apiType = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
let apiType' :: Word64
apiType' = GType -> Word64
gtypeToCGType GType
apiType
Word32
result <- Ptr Buffer -> Word64 -> IO Word32
gst_buffer_get_n_meta Ptr Buffer
buffer' Word64
apiType'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data BufferGetNMetaMethodInfo
instance (signature ~ (GType -> m Word32), MonadIO m) => O.MethodInfo BufferGetNMetaMethodInfo Buffer signature where
overloadedMethod = bufferGetNMeta
#endif
foreign import ccall "gst_buffer_get_reference_timestamp_meta" gst_buffer_get_reference_timestamp_meta ::
Ptr Buffer ->
Ptr Gst.Caps.Caps ->
IO (Ptr Gst.ReferenceTimestampMeta.ReferenceTimestampMeta)
bufferGetReferenceTimestampMeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Maybe (Gst.Caps.Caps)
-> m (Maybe Gst.ReferenceTimestampMeta.ReferenceTimestampMeta)
bufferGetReferenceTimestampMeta :: Buffer -> Maybe Caps -> m (Maybe ReferenceTimestampMeta)
bufferGetReferenceTimestampMeta Buffer
buffer Maybe Caps
reference = IO (Maybe ReferenceTimestampMeta)
-> m (Maybe ReferenceTimestampMeta)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ReferenceTimestampMeta)
-> m (Maybe ReferenceTimestampMeta))
-> IO (Maybe ReferenceTimestampMeta)
-> m (Maybe ReferenceTimestampMeta)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Caps
maybeReference <- case Maybe Caps
reference of
Maybe Caps
Nothing -> Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
forall a. Ptr a
nullPtr
Just Caps
jReference -> do
Ptr Caps
jReference' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
jReference
Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
jReference'
Ptr ReferenceTimestampMeta
result <- Ptr Buffer -> Ptr Caps -> IO (Ptr ReferenceTimestampMeta)
gst_buffer_get_reference_timestamp_meta Ptr Buffer
buffer' Ptr Caps
maybeReference
Maybe ReferenceTimestampMeta
maybeResult <- Ptr ReferenceTimestampMeta
-> (Ptr ReferenceTimestampMeta -> IO ReferenceTimestampMeta)
-> IO (Maybe ReferenceTimestampMeta)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ReferenceTimestampMeta
result ((Ptr ReferenceTimestampMeta -> IO ReferenceTimestampMeta)
-> IO (Maybe ReferenceTimestampMeta))
-> (Ptr ReferenceTimestampMeta -> IO ReferenceTimestampMeta)
-> IO (Maybe ReferenceTimestampMeta)
forall a b. (a -> b) -> a -> b
$ \Ptr ReferenceTimestampMeta
result' -> do
ReferenceTimestampMeta
result'' <- ((ManagedPtr ReferenceTimestampMeta -> ReferenceTimestampMeta)
-> Ptr ReferenceTimestampMeta -> IO ReferenceTimestampMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr ReferenceTimestampMeta -> ReferenceTimestampMeta
Gst.ReferenceTimestampMeta.ReferenceTimestampMeta) Ptr ReferenceTimestampMeta
result'
ReferenceTimestampMeta -> IO ReferenceTimestampMeta
forall (m :: * -> *) a. Monad m => a -> m a
return ReferenceTimestampMeta
result''
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Maybe Caps -> (Caps -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Caps
reference Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe ReferenceTimestampMeta -> IO (Maybe ReferenceTimestampMeta)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ReferenceTimestampMeta
maybeResult
#if defined(ENABLE_OVERLOADING)
data BufferGetReferenceTimestampMetaMethodInfo
instance (signature ~ (Maybe (Gst.Caps.Caps) -> m (Maybe Gst.ReferenceTimestampMeta.ReferenceTimestampMeta)), MonadIO m) => O.MethodInfo BufferGetReferenceTimestampMetaMethodInfo Buffer signature where
overloadedMethod = bufferGetReferenceTimestampMeta
#endif
foreign import ccall "gst_buffer_get_size" gst_buffer_get_size ::
Ptr Buffer ->
IO Word64
bufferGetSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> m Word64
bufferGetSize :: Buffer -> m Word64
bufferGetSize Buffer
buffer = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Word64
result <- Ptr Buffer -> IO Word64
gst_buffer_get_size Ptr Buffer
buffer'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data BufferGetSizeMethodInfo
instance (signature ~ (m Word64), MonadIO m) => O.MethodInfo BufferGetSizeMethodInfo Buffer signature where
overloadedMethod = bufferGetSize
#endif
foreign import ccall "gst_buffer_get_sizes" gst_buffer_get_sizes ::
Ptr Buffer ->
Ptr Word64 ->
Ptr Word64 ->
IO Word64
bufferGetSizes ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> m ((Word64, Word64, Word64))
bufferGetSizes :: Buffer -> m (Word64, Word64, Word64)
bufferGetSizes Buffer
buffer = IO (Word64, Word64, Word64) -> m (Word64, Word64, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Word64, Word64, Word64) -> m (Word64, Word64, Word64))
-> IO (Word64, Word64, Word64) -> m (Word64, Word64, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Word64
offset <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Word64
maxsize <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Word64
result <- Ptr Buffer -> Ptr Word64 -> Ptr Word64 -> IO Word64
gst_buffer_get_sizes Ptr Buffer
buffer' Ptr Word64
offset Ptr Word64
maxsize
Word64
offset' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
offset
Word64
maxsize' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
maxsize
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
offset
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
maxsize
(Word64, Word64, Word64) -> IO (Word64, Word64, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Word64
result, Word64
offset', Word64
maxsize')
#if defined(ENABLE_OVERLOADING)
data BufferGetSizesMethodInfo
instance (signature ~ (m ((Word64, Word64, Word64))), MonadIO m) => O.MethodInfo BufferGetSizesMethodInfo Buffer signature where
overloadedMethod = bufferGetSizes
#endif
foreign import ccall "gst_buffer_get_sizes_range" gst_buffer_get_sizes_range ::
Ptr Buffer ->
Word32 ->
Int32 ->
Ptr Word64 ->
Ptr Word64 ->
IO Word64
bufferGetSizesRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word32
-> Int32
-> m ((Word64, Word64, Word64))
bufferGetSizesRange :: Buffer -> Word32 -> Int32 -> m (Word64, Word64, Word64)
bufferGetSizesRange Buffer
buffer Word32
idx Int32
length_ = IO (Word64, Word64, Word64) -> m (Word64, Word64, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Word64, Word64, Word64) -> m (Word64, Word64, Word64))
-> IO (Word64, Word64, Word64) -> m (Word64, Word64, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Word64
offset <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Word64
maxsize <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Word64
result <- Ptr Buffer
-> Word32 -> Int32 -> Ptr Word64 -> Ptr Word64 -> IO Word64
gst_buffer_get_sizes_range Ptr Buffer
buffer' Word32
idx Int32
length_ Ptr Word64
offset Ptr Word64
maxsize
Word64
offset' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
offset
Word64
maxsize' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
maxsize
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
offset
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
maxsize
(Word64, Word64, Word64) -> IO (Word64, Word64, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Word64
result, Word64
offset', Word64
maxsize')
#if defined(ENABLE_OVERLOADING)
data BufferGetSizesRangeMethodInfo
instance (signature ~ (Word32 -> Int32 -> m ((Word64, Word64, Word64))), MonadIO m) => O.MethodInfo BufferGetSizesRangeMethodInfo Buffer signature where
overloadedMethod = bufferGetSizesRange
#endif
foreign import ccall "gst_buffer_has_flags" gst_buffer_has_flags ::
Ptr Buffer ->
CUInt ->
IO CInt
bufferHasFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> [Gst.Flags.BufferFlags]
-> m Bool
bufferHasFlags :: Buffer -> [BufferFlags] -> m Bool
bufferHasFlags Buffer
buffer [BufferFlags]
flags = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
let flags' :: CUInt
flags' = [BufferFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [BufferFlags]
flags
CInt
result <- Ptr Buffer -> CUInt -> IO CInt
gst_buffer_has_flags Ptr Buffer
buffer' CUInt
flags'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BufferHasFlagsMethodInfo
instance (signature ~ ([Gst.Flags.BufferFlags] -> m Bool), MonadIO m) => O.MethodInfo BufferHasFlagsMethodInfo Buffer signature where
overloadedMethod = bufferHasFlags
#endif
foreign import ccall "gst_buffer_insert_memory" gst_buffer_insert_memory ::
Ptr Buffer ->
Int32 ->
Ptr Gst.Memory.Memory ->
IO ()
bufferInsertMemory ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Int32
-> Gst.Memory.Memory
-> m ()
bufferInsertMemory :: Buffer -> Int32 -> Memory -> m ()
bufferInsertMemory Buffer
buffer Int32
idx Memory
mem = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Memory
mem' <- Memory -> IO (Ptr Memory)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Memory
mem
Ptr Buffer -> Int32 -> Ptr Memory -> IO ()
gst_buffer_insert_memory Ptr Buffer
buffer' Int32
idx Ptr Memory
mem'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Memory -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Memory
mem
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferInsertMemoryMethodInfo
instance (signature ~ (Int32 -> Gst.Memory.Memory -> m ()), MonadIO m) => O.MethodInfo BufferInsertMemoryMethodInfo Buffer signature where
overloadedMethod = bufferInsertMemory
#endif
foreign import ccall "gst_buffer_is_all_memory_writable" gst_buffer_is_all_memory_writable ::
Ptr Buffer ->
IO CInt
bufferIsAllMemoryWritable ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> m Bool
bufferIsAllMemoryWritable :: Buffer -> m Bool
bufferIsAllMemoryWritable Buffer
buffer = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
CInt
result <- Ptr Buffer -> IO CInt
gst_buffer_is_all_memory_writable Ptr Buffer
buffer'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BufferIsAllMemoryWritableMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo BufferIsAllMemoryWritableMethodInfo Buffer signature where
overloadedMethod = bufferIsAllMemoryWritable
#endif
foreign import ccall "gst_buffer_is_memory_range_writable" gst_buffer_is_memory_range_writable ::
Ptr Buffer ->
Word32 ->
Int32 ->
IO CInt
bufferIsMemoryRangeWritable ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word32
-> Int32
-> m Bool
bufferIsMemoryRangeWritable :: Buffer -> Word32 -> Int32 -> m Bool
bufferIsMemoryRangeWritable Buffer
buffer Word32
idx Int32
length_ = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
CInt
result <- Ptr Buffer -> Word32 -> Int32 -> IO CInt
gst_buffer_is_memory_range_writable Ptr Buffer
buffer' Word32
idx Int32
length_
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BufferIsMemoryRangeWritableMethodInfo
instance (signature ~ (Word32 -> Int32 -> m Bool), MonadIO m) => O.MethodInfo BufferIsMemoryRangeWritableMethodInfo Buffer signature where
overloadedMethod = bufferIsMemoryRangeWritable
#endif
foreign import ccall "gst_buffer_map" gst_buffer_map ::
Ptr Buffer ->
Ptr Gst.MapInfo.MapInfo ->
CUInt ->
IO CInt
bufferMap ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> [Gst.Flags.MapFlags]
-> m ((Bool, Gst.MapInfo.MapInfo))
bufferMap :: Buffer -> [MapFlags] -> m (Bool, MapInfo)
bufferMap Buffer
buffer [MapFlags]
flags = IO (Bool, MapInfo) -> m (Bool, MapInfo)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, MapInfo) -> m (Bool, MapInfo))
-> IO (Bool, MapInfo) -> m (Bool, MapInfo)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr MapInfo
info <- Int -> IO (Ptr MapInfo)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
104 :: IO (Ptr Gst.MapInfo.MapInfo)
let flags' :: CUInt
flags' = [MapFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MapFlags]
flags
CInt
result <- Ptr Buffer -> Ptr MapInfo -> CUInt -> IO CInt
gst_buffer_map Ptr Buffer
buffer' Ptr MapInfo
info CUInt
flags'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
MapInfo
info' <- ((ManagedPtr MapInfo -> MapInfo) -> Ptr MapInfo -> IO MapInfo
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr MapInfo -> MapInfo
Gst.MapInfo.MapInfo) Ptr MapInfo
info
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
(Bool, MapInfo) -> IO (Bool, MapInfo)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', MapInfo
info')
#if defined(ENABLE_OVERLOADING)
data BufferMapMethodInfo
instance (signature ~ ([Gst.Flags.MapFlags] -> m ((Bool, Gst.MapInfo.MapInfo))), MonadIO m) => O.MethodInfo BufferMapMethodInfo Buffer signature where
overloadedMethod = bufferMap
#endif
foreign import ccall "gst_buffer_map_range" gst_buffer_map_range ::
Ptr Buffer ->
Word32 ->
Int32 ->
Ptr Gst.MapInfo.MapInfo ->
CUInt ->
IO CInt
bufferMapRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word32
-> Int32
-> [Gst.Flags.MapFlags]
-> m ((Bool, Gst.MapInfo.MapInfo))
bufferMapRange :: Buffer -> Word32 -> Int32 -> [MapFlags] -> m (Bool, MapInfo)
bufferMapRange Buffer
buffer Word32
idx Int32
length_ [MapFlags]
flags = IO (Bool, MapInfo) -> m (Bool, MapInfo)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, MapInfo) -> m (Bool, MapInfo))
-> IO (Bool, MapInfo) -> m (Bool, MapInfo)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr MapInfo
info <- Int -> IO (Ptr MapInfo)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
104 :: IO (Ptr Gst.MapInfo.MapInfo)
let flags' :: CUInt
flags' = [MapFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MapFlags]
flags
CInt
result <- Ptr Buffer -> Word32 -> Int32 -> Ptr MapInfo -> CUInt -> IO CInt
gst_buffer_map_range Ptr Buffer
buffer' Word32
idx Int32
length_ Ptr MapInfo
info CUInt
flags'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
MapInfo
info' <- ((ManagedPtr MapInfo -> MapInfo) -> Ptr MapInfo -> IO MapInfo
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr MapInfo -> MapInfo
Gst.MapInfo.MapInfo) Ptr MapInfo
info
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
(Bool, MapInfo) -> IO (Bool, MapInfo)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', MapInfo
info')
#if defined(ENABLE_OVERLOADING)
data BufferMapRangeMethodInfo
instance (signature ~ (Word32 -> Int32 -> [Gst.Flags.MapFlags] -> m ((Bool, Gst.MapInfo.MapInfo))), MonadIO m) => O.MethodInfo BufferMapRangeMethodInfo Buffer signature where
overloadedMethod = bufferMapRange
#endif
foreign import ccall "gst_buffer_memcmp" gst_buffer_memcmp ::
Ptr Buffer ->
Word64 ->
Ptr Word8 ->
Word64 ->
IO Int32
bufferMemcmp ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word64
-> ByteString
-> m Int32
bufferMemcmp :: Buffer -> Word64 -> ByteString -> m Int32
bufferMemcmp Buffer
buffer Word64
offset ByteString
mem = 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
let size :: Word64
size = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
mem
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Word8
mem' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
mem
Int32
result <- Ptr Buffer -> Word64 -> Ptr Word8 -> Word64 -> IO Int32
gst_buffer_memcmp Ptr Buffer
buffer' Word64
offset Ptr Word8
mem' Word64
size
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
mem'
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data BufferMemcmpMethodInfo
instance (signature ~ (Word64 -> ByteString -> m Int32), MonadIO m) => O.MethodInfo BufferMemcmpMethodInfo Buffer signature where
overloadedMethod = bufferMemcmp
#endif
foreign import ccall "gst_buffer_memset" gst_buffer_memset ::
Ptr Buffer ->
Word64 ->
Word8 ->
Word64 ->
IO Word64
bufferMemset ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word64
-> Word8
-> Word64
-> m Word64
bufferMemset :: Buffer -> Word64 -> Word8 -> Word64 -> m Word64
bufferMemset Buffer
buffer Word64
offset Word8
val Word64
size = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Word64
result <- Ptr Buffer -> Word64 -> Word8 -> Word64 -> IO Word64
gst_buffer_memset Ptr Buffer
buffer' Word64
offset Word8
val Word64
size
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data BufferMemsetMethodInfo
instance (signature ~ (Word64 -> Word8 -> Word64 -> m Word64), MonadIO m) => O.MethodInfo BufferMemsetMethodInfo Buffer signature where
overloadedMethod = bufferMemset
#endif
foreign import ccall "gst_buffer_n_memory" gst_buffer_n_memory ::
Ptr Buffer ->
IO Word32
bufferNMemory ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> m Word32
bufferNMemory :: Buffer -> m Word32
bufferNMemory Buffer
buffer = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Word32
result <- Ptr Buffer -> IO Word32
gst_buffer_n_memory Ptr Buffer
buffer'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data BufferNMemoryMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo BufferNMemoryMethodInfo Buffer signature where
overloadedMethod = bufferNMemory
#endif
foreign import ccall "gst_buffer_peek_memory" gst_buffer_peek_memory ::
Ptr Buffer ->
Word32 ->
IO (Ptr Gst.Memory.Memory)
bufferPeekMemory ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word32
-> m (Maybe Gst.Memory.Memory)
bufferPeekMemory :: Buffer -> Word32 -> m (Maybe Memory)
bufferPeekMemory Buffer
buffer Word32
idx = IO (Maybe Memory) -> m (Maybe Memory)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Memory) -> m (Maybe Memory))
-> IO (Maybe Memory) -> m (Maybe Memory)
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Memory
result <- Ptr Buffer -> Word32 -> IO (Ptr Memory)
gst_buffer_peek_memory Ptr Buffer
buffer' Word32
idx
Maybe Memory
maybeResult <- Ptr Memory -> (Ptr Memory -> IO Memory) -> IO (Maybe Memory)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Memory
result ((Ptr Memory -> IO Memory) -> IO (Maybe Memory))
-> (Ptr Memory -> IO Memory) -> IO (Maybe Memory)
forall a b. (a -> b) -> a -> b
$ \Ptr Memory
result' -> do
Memory
result'' <- ((ManagedPtr Memory -> Memory) -> Ptr Memory -> IO Memory
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Memory -> Memory
Gst.Memory.Memory) Ptr Memory
result'
Memory -> IO Memory
forall (m :: * -> *) a. Monad m => a -> m a
return Memory
result''
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Maybe Memory -> IO (Maybe Memory)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Memory
maybeResult
#if defined(ENABLE_OVERLOADING)
data BufferPeekMemoryMethodInfo
instance (signature ~ (Word32 -> m (Maybe Gst.Memory.Memory)), MonadIO m) => O.MethodInfo BufferPeekMemoryMethodInfo Buffer signature where
overloadedMethod = bufferPeekMemory
#endif
foreign import ccall "gst_buffer_prepend_memory" gst_buffer_prepend_memory ::
Ptr Buffer ->
Ptr Gst.Memory.Memory ->
IO ()
bufferPrependMemory ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Gst.Memory.Memory
-> m ()
bufferPrependMemory :: Buffer -> Memory -> m ()
bufferPrependMemory Buffer
buffer Memory
mem = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Memory
mem' <- Memory -> IO (Ptr Memory)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Memory
mem
Ptr Buffer -> Ptr Memory -> IO ()
gst_buffer_prepend_memory Ptr Buffer
buffer' Ptr Memory
mem'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Memory -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Memory
mem
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferPrependMemoryMethodInfo
instance (signature ~ (Gst.Memory.Memory -> m ()), MonadIO m) => O.MethodInfo BufferPrependMemoryMethodInfo Buffer signature where
overloadedMethod = bufferPrependMemory
#endif
foreign import ccall "gst_buffer_remove_all_memory" gst_buffer_remove_all_memory ::
Ptr Buffer ->
IO ()
bufferRemoveAllMemory ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> m ()
bufferRemoveAllMemory :: Buffer -> m ()
bufferRemoveAllMemory Buffer
buffer = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Buffer -> IO ()
gst_buffer_remove_all_memory Ptr Buffer
buffer'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferRemoveAllMemoryMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BufferRemoveAllMemoryMethodInfo Buffer signature where
overloadedMethod = bufferRemoveAllMemory
#endif
foreign import ccall "gst_buffer_remove_memory" gst_buffer_remove_memory ::
Ptr Buffer ->
Word32 ->
IO ()
bufferRemoveMemory ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word32
-> m ()
bufferRemoveMemory :: Buffer -> Word32 -> m ()
bufferRemoveMemory Buffer
buffer Word32
idx = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Buffer -> Word32 -> IO ()
gst_buffer_remove_memory Ptr Buffer
buffer' Word32
idx
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferRemoveMemoryMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo BufferRemoveMemoryMethodInfo Buffer signature where
overloadedMethod = bufferRemoveMemory
#endif
foreign import ccall "gst_buffer_remove_memory_range" gst_buffer_remove_memory_range ::
Ptr Buffer ->
Word32 ->
Int32 ->
IO ()
bufferRemoveMemoryRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word32
-> Int32
-> m ()
bufferRemoveMemoryRange :: Buffer -> Word32 -> Int32 -> m ()
bufferRemoveMemoryRange Buffer
buffer Word32
idx Int32
length_ = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Buffer -> Word32 -> Int32 -> IO ()
gst_buffer_remove_memory_range Ptr Buffer
buffer' Word32
idx Int32
length_
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferRemoveMemoryRangeMethodInfo
instance (signature ~ (Word32 -> Int32 -> m ()), MonadIO m) => O.MethodInfo BufferRemoveMemoryRangeMethodInfo Buffer signature where
overloadedMethod = bufferRemoveMemoryRange
#endif
foreign import ccall "gst_buffer_remove_meta" gst_buffer_remove_meta ::
Ptr Buffer ->
Ptr Gst.Meta.Meta ->
IO CInt
bufferRemoveMeta ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Gst.Meta.Meta
-> m Bool
bufferRemoveMeta :: Buffer -> Meta -> m Bool
bufferRemoveMeta Buffer
buffer Meta
meta = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Meta
meta' <- Meta -> IO (Ptr Meta)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Meta
meta
CInt
result <- Ptr Buffer -> Ptr Meta -> IO CInt
gst_buffer_remove_meta Ptr Buffer
buffer' Ptr Meta
meta'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Meta -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Meta
meta
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BufferRemoveMetaMethodInfo
instance (signature ~ (Gst.Meta.Meta -> m Bool), MonadIO m) => O.MethodInfo BufferRemoveMetaMethodInfo Buffer signature where
overloadedMethod = bufferRemoveMeta
#endif
foreign import ccall "gst_buffer_replace_all_memory" gst_buffer_replace_all_memory ::
Ptr Buffer ->
Ptr Gst.Memory.Memory ->
IO ()
bufferReplaceAllMemory ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Gst.Memory.Memory
-> m ()
bufferReplaceAllMemory :: Buffer -> Memory -> m ()
bufferReplaceAllMemory Buffer
buffer Memory
mem = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Memory
mem' <- Memory -> IO (Ptr Memory)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Memory
mem
Ptr Buffer -> Ptr Memory -> IO ()
gst_buffer_replace_all_memory Ptr Buffer
buffer' Ptr Memory
mem'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Memory -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Memory
mem
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferReplaceAllMemoryMethodInfo
instance (signature ~ (Gst.Memory.Memory -> m ()), MonadIO m) => O.MethodInfo BufferReplaceAllMemoryMethodInfo Buffer signature where
overloadedMethod = bufferReplaceAllMemory
#endif
foreign import ccall "gst_buffer_replace_memory" gst_buffer_replace_memory ::
Ptr Buffer ->
Word32 ->
Ptr Gst.Memory.Memory ->
IO ()
bufferReplaceMemory ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word32
-> Gst.Memory.Memory
-> m ()
bufferReplaceMemory :: Buffer -> Word32 -> Memory -> m ()
bufferReplaceMemory Buffer
buffer Word32
idx Memory
mem = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Memory
mem' <- Memory -> IO (Ptr Memory)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Memory
mem
Ptr Buffer -> Word32 -> Ptr Memory -> IO ()
gst_buffer_replace_memory Ptr Buffer
buffer' Word32
idx Ptr Memory
mem'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Memory -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Memory
mem
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferReplaceMemoryMethodInfo
instance (signature ~ (Word32 -> Gst.Memory.Memory -> m ()), MonadIO m) => O.MethodInfo BufferReplaceMemoryMethodInfo Buffer signature where
overloadedMethod = bufferReplaceMemory
#endif
foreign import ccall "gst_buffer_replace_memory_range" gst_buffer_replace_memory_range ::
Ptr Buffer ->
Word32 ->
Int32 ->
Ptr Gst.Memory.Memory ->
IO ()
bufferReplaceMemoryRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word32
-> Int32
-> Gst.Memory.Memory
-> m ()
bufferReplaceMemoryRange :: Buffer -> Word32 -> Int32 -> Memory -> m ()
bufferReplaceMemoryRange Buffer
buffer Word32
idx Int32
length_ Memory
mem = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Memory
mem' <- Memory -> IO (Ptr Memory)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Memory
mem
Ptr Buffer -> Word32 -> Int32 -> Ptr Memory -> IO ()
gst_buffer_replace_memory_range Ptr Buffer
buffer' Word32
idx Int32
length_ Ptr Memory
mem'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Memory -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Memory
mem
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferReplaceMemoryRangeMethodInfo
instance (signature ~ (Word32 -> Int32 -> Gst.Memory.Memory -> m ()), MonadIO m) => O.MethodInfo BufferReplaceMemoryRangeMethodInfo Buffer signature where
overloadedMethod = bufferReplaceMemoryRange
#endif
foreign import ccall "gst_buffer_resize" gst_buffer_resize ::
Ptr Buffer ->
Int64 ->
Int64 ->
IO ()
bufferResize ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Int64
-> Int64
-> m ()
bufferResize :: Buffer -> Int64 -> Int64 -> m ()
bufferResize Buffer
buffer Int64
offset Int64
size = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Buffer -> Int64 -> Int64 -> IO ()
gst_buffer_resize Ptr Buffer
buffer' Int64
offset Int64
size
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferResizeMethodInfo
instance (signature ~ (Int64 -> Int64 -> m ()), MonadIO m) => O.MethodInfo BufferResizeMethodInfo Buffer signature where
overloadedMethod = bufferResize
#endif
foreign import ccall "gst_buffer_resize_range" gst_buffer_resize_range ::
Ptr Buffer ->
Word32 ->
Int32 ->
Int64 ->
Int64 ->
IO CInt
bufferResizeRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Word32
-> Int32
-> Int64
-> Int64
-> m Bool
bufferResizeRange :: Buffer -> Word32 -> Int32 -> Int64 -> Int64 -> m Bool
bufferResizeRange Buffer
buffer Word32
idx Int32
length_ Int64
offset Int64
size = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
CInt
result <- Ptr Buffer -> Word32 -> Int32 -> Int64 -> Int64 -> IO CInt
gst_buffer_resize_range Ptr Buffer
buffer' Word32
idx Int32
length_ Int64
offset Int64
size
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BufferResizeRangeMethodInfo
instance (signature ~ (Word32 -> Int32 -> Int64 -> Int64 -> m Bool), MonadIO m) => O.MethodInfo BufferResizeRangeMethodInfo Buffer signature where
overloadedMethod = bufferResizeRange
#endif
foreign import ccall "gst_buffer_set_flags" gst_buffer_set_flags ::
Ptr Buffer ->
CUInt ->
IO CInt
bufferSetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> [Gst.Flags.BufferFlags]
-> m Bool
bufferSetFlags :: Buffer -> [BufferFlags] -> m Bool
bufferSetFlags Buffer
buffer [BufferFlags]
flags = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
let flags' :: CUInt
flags' = [BufferFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [BufferFlags]
flags
CInt
result <- Ptr Buffer -> CUInt -> IO CInt
gst_buffer_set_flags Ptr Buffer
buffer' CUInt
flags'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BufferSetFlagsMethodInfo
instance (signature ~ ([Gst.Flags.BufferFlags] -> m Bool), MonadIO m) => O.MethodInfo BufferSetFlagsMethodInfo Buffer signature where
overloadedMethod = bufferSetFlags
#endif
foreign import ccall "gst_buffer_set_size" gst_buffer_set_size ::
Ptr Buffer ->
Int64 ->
IO ()
bufferSetSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Int64
-> m ()
bufferSetSize :: Buffer -> Int64 -> m ()
bufferSetSize Buffer
buffer Int64
size = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Buffer -> Int64 -> IO ()
gst_buffer_set_size Ptr Buffer
buffer' Int64
size
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferSetSizeMethodInfo
instance (signature ~ (Int64 -> m ()), MonadIO m) => O.MethodInfo BufferSetSizeMethodInfo Buffer signature where
overloadedMethod = bufferSetSize
#endif
foreign import ccall "gst_buffer_unmap" gst_buffer_unmap ::
Ptr Buffer ->
Ptr Gst.MapInfo.MapInfo ->
IO ()
bufferUnmap ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> Gst.MapInfo.MapInfo
-> m ()
bufferUnmap :: Buffer -> MapInfo -> m ()
bufferUnmap Buffer
buffer MapInfo
info = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr MapInfo
info' <- MapInfo -> IO (Ptr MapInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MapInfo
info
Ptr Buffer -> Ptr MapInfo -> IO ()
gst_buffer_unmap Ptr Buffer
buffer' Ptr MapInfo
info'
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
MapInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MapInfo
info
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BufferUnmapMethodInfo
instance (signature ~ (Gst.MapInfo.MapInfo -> m ()), MonadIO m) => O.MethodInfo BufferUnmapMethodInfo Buffer signature where
overloadedMethod = bufferUnmap
#endif
foreign import ccall "gst_buffer_unset_flags" gst_buffer_unset_flags ::
Ptr Buffer ->
CUInt ->
IO CInt
bufferUnsetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Buffer
-> [Gst.Flags.BufferFlags]
-> m Bool
bufferUnsetFlags :: Buffer -> [BufferFlags] -> m Bool
bufferUnsetFlags Buffer
buffer [BufferFlags]
flags = 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 Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
let flags' :: CUInt
flags' = [BufferFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [BufferFlags]
flags
CInt
result <- Ptr Buffer -> CUInt -> IO CInt
gst_buffer_unset_flags Ptr Buffer
buffer' CUInt
flags'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BufferUnsetFlagsMethodInfo
instance (signature ~ ([Gst.Flags.BufferFlags] -> m Bool), MonadIO m) => O.MethodInfo BufferUnsetFlagsMethodInfo Buffer signature where
overloadedMethod = bufferUnsetFlags
#endif
foreign import ccall "gst_buffer_get_max_memory" gst_buffer_get_max_memory ::
IO Word32
bufferGetMaxMemory ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
bufferGetMaxMemory :: m Word32
bufferGetMaxMemory = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- IO Word32
gst_buffer_get_max_memory
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveBufferMethod (t :: Symbol) (o :: *) :: * where
ResolveBufferMethod "addMeta" o = BufferAddMetaMethodInfo
ResolveBufferMethod "addParentBufferMeta" o = BufferAddParentBufferMetaMethodInfo
ResolveBufferMethod "addProtectionMeta" o = BufferAddProtectionMetaMethodInfo
ResolveBufferMethod "addReferenceTimestampMeta" o = BufferAddReferenceTimestampMetaMethodInfo
ResolveBufferMethod "append" o = BufferAppendMethodInfo
ResolveBufferMethod "appendMemory" o = BufferAppendMemoryMethodInfo
ResolveBufferMethod "appendRegion" o = BufferAppendRegionMethodInfo
ResolveBufferMethod "copyDeep" o = BufferCopyDeepMethodInfo
ResolveBufferMethod "copyInto" o = BufferCopyIntoMethodInfo
ResolveBufferMethod "copyRegion" o = BufferCopyRegionMethodInfo
ResolveBufferMethod "extract" o = BufferExtractMethodInfo
ResolveBufferMethod "extractDup" o = BufferExtractDupMethodInfo
ResolveBufferMethod "fill" o = BufferFillMethodInfo
ResolveBufferMethod "findMemory" o = BufferFindMemoryMethodInfo
ResolveBufferMethod "foreachMeta" o = BufferForeachMetaMethodInfo
ResolveBufferMethod "hasFlags" o = BufferHasFlagsMethodInfo
ResolveBufferMethod "insertMemory" o = BufferInsertMemoryMethodInfo
ResolveBufferMethod "isAllMemoryWritable" o = BufferIsAllMemoryWritableMethodInfo
ResolveBufferMethod "isMemoryRangeWritable" o = BufferIsMemoryRangeWritableMethodInfo
ResolveBufferMethod "map" o = BufferMapMethodInfo
ResolveBufferMethod "mapRange" o = BufferMapRangeMethodInfo
ResolveBufferMethod "memcmp" o = BufferMemcmpMethodInfo
ResolveBufferMethod "memset" o = BufferMemsetMethodInfo
ResolveBufferMethod "nMemory" o = BufferNMemoryMethodInfo
ResolveBufferMethod "peekMemory" o = BufferPeekMemoryMethodInfo
ResolveBufferMethod "prependMemory" o = BufferPrependMemoryMethodInfo
ResolveBufferMethod "removeAllMemory" o = BufferRemoveAllMemoryMethodInfo
ResolveBufferMethod "removeMemory" o = BufferRemoveMemoryMethodInfo
ResolveBufferMethod "removeMemoryRange" o = BufferRemoveMemoryRangeMethodInfo
ResolveBufferMethod "removeMeta" o = BufferRemoveMetaMethodInfo
ResolveBufferMethod "replaceAllMemory" o = BufferReplaceAllMemoryMethodInfo
ResolveBufferMethod "replaceMemory" o = BufferReplaceMemoryMethodInfo
ResolveBufferMethod "replaceMemoryRange" o = BufferReplaceMemoryRangeMethodInfo
ResolveBufferMethod "resize" o = BufferResizeMethodInfo
ResolveBufferMethod "resizeRange" o = BufferResizeRangeMethodInfo
ResolveBufferMethod "unmap" o = BufferUnmapMethodInfo
ResolveBufferMethod "unsetFlags" o = BufferUnsetFlagsMethodInfo
ResolveBufferMethod "getAllMemory" o = BufferGetAllMemoryMethodInfo
ResolveBufferMethod "getFlags" o = BufferGetFlagsMethodInfo
ResolveBufferMethod "getMemory" o = BufferGetMemoryMethodInfo
ResolveBufferMethod "getMemoryRange" o = BufferGetMemoryRangeMethodInfo
ResolveBufferMethod "getMeta" o = BufferGetMetaMethodInfo
ResolveBufferMethod "getNMeta" o = BufferGetNMetaMethodInfo
ResolveBufferMethod "getReferenceTimestampMeta" o = BufferGetReferenceTimestampMetaMethodInfo
ResolveBufferMethod "getSize" o = BufferGetSizeMethodInfo
ResolveBufferMethod "getSizes" o = BufferGetSizesMethodInfo
ResolveBufferMethod "getSizesRange" o = BufferGetSizesRangeMethodInfo
ResolveBufferMethod "setFlags" o = BufferSetFlagsMethodInfo
ResolveBufferMethod "setSize" o = BufferSetSizeMethodInfo
ResolveBufferMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveBufferMethod t Buffer, O.MethodInfo info Buffer p) => OL.IsLabel t (Buffer -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif