{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstBase.Structs.BitWriter
(
BitWriter(..) ,
newZeroBitWriter ,
noBitWriter ,
#if defined(ENABLE_OVERLOADING)
ResolveBitWriterMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
BitWriterAlignBytesMethodInfo ,
#endif
bitWriterAlignBytes ,
#if defined(ENABLE_OVERLOADING)
BitWriterFreeMethodInfo ,
#endif
bitWriterFree ,
#if defined(ENABLE_OVERLOADING)
BitWriterFreeAndGetBufferMethodInfo ,
#endif
bitWriterFreeAndGetBuffer ,
#if defined(ENABLE_OVERLOADING)
BitWriterGetDataMethodInfo ,
#endif
bitWriterGetData ,
#if defined(ENABLE_OVERLOADING)
BitWriterGetRemainingMethodInfo ,
#endif
bitWriterGetRemaining ,
#if defined(ENABLE_OVERLOADING)
BitWriterGetSizeMethodInfo ,
#endif
bitWriterGetSize ,
#if defined(ENABLE_OVERLOADING)
BitWriterPutBitsUint16MethodInfo ,
#endif
bitWriterPutBitsUint16 ,
#if defined(ENABLE_OVERLOADING)
BitWriterPutBitsUint32MethodInfo ,
#endif
bitWriterPutBitsUint32 ,
#if defined(ENABLE_OVERLOADING)
BitWriterPutBitsUint64MethodInfo ,
#endif
bitWriterPutBitsUint64 ,
#if defined(ENABLE_OVERLOADING)
BitWriterPutBitsUint8MethodInfo ,
#endif
bitWriterPutBitsUint8 ,
#if defined(ENABLE_OVERLOADING)
BitWriterPutBytesMethodInfo ,
#endif
bitWriterPutBytes ,
#if defined(ENABLE_OVERLOADING)
BitWriterResetMethodInfo ,
#endif
bitWriterReset ,
#if defined(ENABLE_OVERLOADING)
BitWriterResetAndGetBufferMethodInfo ,
#endif
bitWriterResetAndGetBuffer ,
#if defined(ENABLE_OVERLOADING)
BitWriterSetPosMethodInfo ,
#endif
bitWriterSetPos ,
#if defined(ENABLE_OVERLOADING)
bitWriter_bitSize ,
#endif
getBitWriterBitSize ,
setBitWriterBitSize ,
#if defined(ENABLE_OVERLOADING)
bitWriter_data ,
#endif
getBitWriterData ,
setBitWriterData ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.Gst.Structs.Buffer as Gst.Buffer
newtype BitWriter = BitWriter (ManagedPtr BitWriter)
deriving (BitWriter -> BitWriter -> Bool
(BitWriter -> BitWriter -> Bool)
-> (BitWriter -> BitWriter -> Bool) -> Eq BitWriter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BitWriter -> BitWriter -> Bool
$c/= :: BitWriter -> BitWriter -> Bool
== :: BitWriter -> BitWriter -> Bool
$c== :: BitWriter -> BitWriter -> Bool
Eq)
instance WrappedPtr BitWriter where
wrappedPtrCalloc :: IO (Ptr BitWriter)
wrappedPtrCalloc = Int -> IO (Ptr BitWriter)
forall a. Int -> IO (Ptr a)
callocBytes 56
wrappedPtrCopy :: BitWriter -> IO BitWriter
wrappedPtrCopy = \p :: BitWriter
p -> BitWriter -> (Ptr BitWriter -> IO BitWriter) -> IO BitWriter
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BitWriter
p (Int -> Ptr BitWriter -> IO (Ptr BitWriter)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 56 (Ptr BitWriter -> IO (Ptr BitWriter))
-> (Ptr BitWriter -> IO BitWriter) -> Ptr BitWriter -> IO BitWriter
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr BitWriter -> BitWriter)
-> Ptr BitWriter -> IO BitWriter
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr BitWriter -> BitWriter
BitWriter)
wrappedPtrFree :: Maybe (GDestroyNotify BitWriter)
wrappedPtrFree = GDestroyNotify BitWriter -> Maybe (GDestroyNotify BitWriter)
forall a. a -> Maybe a
Just GDestroyNotify BitWriter
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free
newZeroBitWriter :: MonadIO m => m BitWriter
newZeroBitWriter :: m BitWriter
newZeroBitWriter = IO BitWriter -> m BitWriter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BitWriter -> m BitWriter) -> IO BitWriter -> m BitWriter
forall a b. (a -> b) -> a -> b
$ IO (Ptr BitWriter)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr BitWriter)
-> (Ptr BitWriter -> IO BitWriter) -> IO BitWriter
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr BitWriter -> BitWriter)
-> Ptr BitWriter -> IO BitWriter
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr BitWriter -> BitWriter
BitWriter
instance tag ~ 'AttrSet => Constructible BitWriter tag where
new :: (ManagedPtr BitWriter -> BitWriter)
-> [AttrOp BitWriter tag] -> m BitWriter
new _ attrs :: [AttrOp BitWriter tag]
attrs = do
BitWriter
o <- m BitWriter
forall (m :: * -> *). MonadIO m => m BitWriter
newZeroBitWriter
BitWriter -> [AttrOp BitWriter 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set BitWriter
o [AttrOp BitWriter tag]
[AttrOp BitWriter 'AttrSet]
attrs
BitWriter -> m BitWriter
forall (m :: * -> *) a. Monad m => a -> m a
return BitWriter
o
noBitWriter :: Maybe BitWriter
noBitWriter :: Maybe BitWriter
noBitWriter = Maybe BitWriter
forall a. Maybe a
Nothing
getBitWriterData :: MonadIO m => BitWriter -> m Word8
getBitWriterData :: BitWriter -> m Word8
getBitWriterData s :: BitWriter
s = IO Word8 -> m Word8
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ BitWriter -> (Ptr BitWriter -> IO Word8) -> IO Word8
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BitWriter
s ((Ptr BitWriter -> IO Word8) -> IO Word8)
-> (Ptr BitWriter -> IO Word8) -> IO Word8
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr BitWriter
ptr -> do
Word8
val <- Ptr Word8 -> IO Word8
forall a. Storable a => Ptr a -> IO a
peek (Ptr BitWriter
ptr Ptr BitWriter -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO Word8
Word8 -> IO Word8
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
val
setBitWriterData :: MonadIO m => BitWriter -> Word8 -> m ()
setBitWriterData :: BitWriter -> Word8 -> m ()
setBitWriterData s :: BitWriter
s val :: Word8
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ BitWriter -> (Ptr BitWriter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BitWriter
s ((Ptr BitWriter -> IO ()) -> IO ())
-> (Ptr BitWriter -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr BitWriter
ptr -> do
Ptr Word8 -> Word8 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BitWriter
ptr Ptr BitWriter -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Word8
val :: Word8)
#if defined(ENABLE_OVERLOADING)
data BitWriterDataFieldInfo
instance AttrInfo BitWriterDataFieldInfo where
type AttrBaseTypeConstraint BitWriterDataFieldInfo = (~) BitWriter
type AttrAllowedOps BitWriterDataFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint BitWriterDataFieldInfo = (~) Word8
type AttrTransferTypeConstraint BitWriterDataFieldInfo = (~)Word8
type AttrTransferType BitWriterDataFieldInfo = Word8
type AttrGetType BitWriterDataFieldInfo = Word8
type AttrLabel BitWriterDataFieldInfo = "data"
type AttrOrigin BitWriterDataFieldInfo = BitWriter
attrGet = getBitWriterData
attrSet = setBitWriterData
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
bitWriter_data :: AttrLabelProxy "data"
bitWriter_data = AttrLabelProxy
#endif
getBitWriterBitSize :: MonadIO m => BitWriter -> m Word32
getBitWriterBitSize :: BitWriter -> m Word32
getBitWriterBitSize s :: BitWriter
s = 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
$ BitWriter -> (Ptr BitWriter -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BitWriter
s ((Ptr BitWriter -> IO Word32) -> IO Word32)
-> (Ptr BitWriter -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr BitWriter
ptr -> do
Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr BitWriter
ptr Ptr BitWriter -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) :: IO Word32
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setBitWriterBitSize :: MonadIO m => BitWriter -> Word32 -> m ()
setBitWriterBitSize :: BitWriter -> Word32 -> m ()
setBitWriterBitSize s :: BitWriter
s val :: Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ BitWriter -> (Ptr BitWriter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BitWriter
s ((Ptr BitWriter -> IO ()) -> IO ())
-> (Ptr BitWriter -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr BitWriter
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BitWriter
ptr Ptr BitWriter -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data BitWriterBitSizeFieldInfo
instance AttrInfo BitWriterBitSizeFieldInfo where
type AttrBaseTypeConstraint BitWriterBitSizeFieldInfo = (~) BitWriter
type AttrAllowedOps BitWriterBitSizeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint BitWriterBitSizeFieldInfo = (~) Word32
type AttrTransferTypeConstraint BitWriterBitSizeFieldInfo = (~)Word32
type AttrTransferType BitWriterBitSizeFieldInfo = Word32
type AttrGetType BitWriterBitSizeFieldInfo = Word32
type AttrLabel BitWriterBitSizeFieldInfo = "bit_size"
type AttrOrigin BitWriterBitSizeFieldInfo = BitWriter
attrGet = getBitWriterBitSize
attrSet = setBitWriterBitSize
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
bitWriter_bitSize :: AttrLabelProxy "bitSize"
bitWriter_bitSize = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList BitWriter
type instance O.AttributeList BitWriter = BitWriterAttributeList
type BitWriterAttributeList = ('[ '("data", BitWriterDataFieldInfo), '("bitSize", BitWriterBitSizeFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_bit_writer_align_bytes" gst_bit_writer_align_bytes ::
Ptr BitWriter ->
Word8 ->
IO CInt
bitWriterAlignBytes ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> Word8
-> m Bool
bitWriterAlignBytes :: BitWriter -> Word8 -> m Bool
bitWriterAlignBytes bitwriter :: BitWriter
bitwriter trailingBit :: Word8
trailingBit = 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 BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
CInt
result <- Ptr BitWriter -> Word8 -> IO CInt
gst_bit_writer_align_bytes Ptr BitWriter
bitwriter' Word8
trailingBit
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BitWriterAlignBytesMethodInfo
instance (signature ~ (Word8 -> m Bool), MonadIO m) => O.MethodInfo BitWriterAlignBytesMethodInfo BitWriter signature where
overloadedMethod = bitWriterAlignBytes
#endif
foreign import ccall "gst_bit_writer_free" gst_bit_writer_free ::
Ptr BitWriter ->
IO ()
bitWriterFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> m ()
bitWriterFree :: BitWriter -> m ()
bitWriterFree bitwriter :: BitWriter
bitwriter = 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 BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
Ptr BitWriter -> IO ()
gst_bit_writer_free Ptr BitWriter
bitwriter'
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BitWriterFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BitWriterFreeMethodInfo BitWriter signature where
overloadedMethod = bitWriterFree
#endif
foreign import ccall "gst_bit_writer_free_and_get_buffer" gst_bit_writer_free_and_get_buffer ::
Ptr BitWriter ->
IO (Ptr Gst.Buffer.Buffer)
bitWriterFreeAndGetBuffer ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> m Gst.Buffer.Buffer
bitWriterFreeAndGetBuffer :: BitWriter -> m Buffer
bitWriterFreeAndGetBuffer bitwriter :: BitWriter
bitwriter = 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 BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
Ptr Buffer
result <- Ptr BitWriter -> IO (Ptr Buffer)
gst_bit_writer_free_and_get_buffer Ptr BitWriter
bitwriter'
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "bitWriterFreeAndGetBuffer" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
result
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
#if defined(ENABLE_OVERLOADING)
data BitWriterFreeAndGetBufferMethodInfo
instance (signature ~ (m Gst.Buffer.Buffer), MonadIO m) => O.MethodInfo BitWriterFreeAndGetBufferMethodInfo BitWriter signature where
overloadedMethod = bitWriterFreeAndGetBuffer
#endif
foreign import ccall "gst_bit_writer_get_data" gst_bit_writer_get_data ::
Ptr BitWriter ->
IO Word8
bitWriterGetData ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> m Word8
bitWriterGetData :: BitWriter -> m Word8
bitWriterGetData bitwriter :: BitWriter
bitwriter = IO Word8 -> m Word8
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ do
Ptr BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
Word8
result <- Ptr BitWriter -> IO Word8
gst_bit_writer_get_data Ptr BitWriter
bitwriter'
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
Word8 -> IO Word8
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
result
#if defined(ENABLE_OVERLOADING)
data BitWriterGetDataMethodInfo
instance (signature ~ (m Word8), MonadIO m) => O.MethodInfo BitWriterGetDataMethodInfo BitWriter signature where
overloadedMethod = bitWriterGetData
#endif
foreign import ccall "gst_bit_writer_get_remaining" gst_bit_writer_get_remaining ::
Ptr BitWriter ->
IO Word32
bitWriterGetRemaining ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> m Word32
bitWriterGetRemaining :: BitWriter -> m Word32
bitWriterGetRemaining bitwriter :: BitWriter
bitwriter = 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 BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
Word32
result <- Ptr BitWriter -> IO Word32
gst_bit_writer_get_remaining Ptr BitWriter
bitwriter'
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data BitWriterGetRemainingMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo BitWriterGetRemainingMethodInfo BitWriter signature where
overloadedMethod = bitWriterGetRemaining
#endif
foreign import ccall "gst_bit_writer_get_size" gst_bit_writer_get_size ::
Ptr BitWriter ->
IO Word32
bitWriterGetSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> m Word32
bitWriterGetSize :: BitWriter -> m Word32
bitWriterGetSize bitwriter :: BitWriter
bitwriter = 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 BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
Word32
result <- Ptr BitWriter -> IO Word32
gst_bit_writer_get_size Ptr BitWriter
bitwriter'
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data BitWriterGetSizeMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo BitWriterGetSizeMethodInfo BitWriter signature where
overloadedMethod = bitWriterGetSize
#endif
foreign import ccall "gst_bit_writer_put_bits_uint16" gst_bit_writer_put_bits_uint16 ::
Ptr BitWriter ->
Word16 ->
Word32 ->
IO CInt
bitWriterPutBitsUint16 ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> Word16
-> Word32
-> m Bool
bitWriterPutBitsUint16 :: BitWriter -> Word16 -> Word32 -> m Bool
bitWriterPutBitsUint16 bitwriter :: BitWriter
bitwriter value :: Word16
value nbits :: Word32
nbits = 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 BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
CInt
result <- Ptr BitWriter -> Word16 -> Word32 -> IO CInt
gst_bit_writer_put_bits_uint16 Ptr BitWriter
bitwriter' Word16
value Word32
nbits
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BitWriterPutBitsUint16MethodInfo
instance (signature ~ (Word16 -> Word32 -> m Bool), MonadIO m) => O.MethodInfo BitWriterPutBitsUint16MethodInfo BitWriter signature where
overloadedMethod = bitWriterPutBitsUint16
#endif
foreign import ccall "gst_bit_writer_put_bits_uint32" gst_bit_writer_put_bits_uint32 ::
Ptr BitWriter ->
Word32 ->
Word32 ->
IO CInt
bitWriterPutBitsUint32 ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> Word32
-> Word32
-> m Bool
bitWriterPutBitsUint32 :: BitWriter -> Word32 -> Word32 -> m Bool
bitWriterPutBitsUint32 bitwriter :: BitWriter
bitwriter value :: Word32
value nbits :: Word32
nbits = 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 BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
CInt
result <- Ptr BitWriter -> Word32 -> Word32 -> IO CInt
gst_bit_writer_put_bits_uint32 Ptr BitWriter
bitwriter' Word32
value Word32
nbits
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BitWriterPutBitsUint32MethodInfo
instance (signature ~ (Word32 -> Word32 -> m Bool), MonadIO m) => O.MethodInfo BitWriterPutBitsUint32MethodInfo BitWriter signature where
overloadedMethod = bitWriterPutBitsUint32
#endif
foreign import ccall "gst_bit_writer_put_bits_uint64" gst_bit_writer_put_bits_uint64 ::
Ptr BitWriter ->
Word64 ->
Word32 ->
IO CInt
bitWriterPutBitsUint64 ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> Word64
-> Word32
-> m Bool
bitWriterPutBitsUint64 :: BitWriter -> Word64 -> Word32 -> m Bool
bitWriterPutBitsUint64 bitwriter :: BitWriter
bitwriter value :: Word64
value nbits :: Word32
nbits = 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 BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
CInt
result <- Ptr BitWriter -> Word64 -> Word32 -> IO CInt
gst_bit_writer_put_bits_uint64 Ptr BitWriter
bitwriter' Word64
value Word32
nbits
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BitWriterPutBitsUint64MethodInfo
instance (signature ~ (Word64 -> Word32 -> m Bool), MonadIO m) => O.MethodInfo BitWriterPutBitsUint64MethodInfo BitWriter signature where
overloadedMethod = bitWriterPutBitsUint64
#endif
foreign import ccall "gst_bit_writer_put_bits_uint8" gst_bit_writer_put_bits_uint8 ::
Ptr BitWriter ->
Word8 ->
Word32 ->
IO CInt
bitWriterPutBitsUint8 ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> Word8
-> Word32
-> m Bool
bitWriterPutBitsUint8 :: BitWriter -> Word8 -> Word32 -> m Bool
bitWriterPutBitsUint8 bitwriter :: BitWriter
bitwriter value :: Word8
value nbits :: Word32
nbits = 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 BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
CInt
result <- Ptr BitWriter -> Word8 -> Word32 -> IO CInt
gst_bit_writer_put_bits_uint8 Ptr BitWriter
bitwriter' Word8
value Word32
nbits
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BitWriterPutBitsUint8MethodInfo
instance (signature ~ (Word8 -> Word32 -> m Bool), MonadIO m) => O.MethodInfo BitWriterPutBitsUint8MethodInfo BitWriter signature where
overloadedMethod = bitWriterPutBitsUint8
#endif
foreign import ccall "gst_bit_writer_put_bytes" gst_bit_writer_put_bytes ::
Ptr BitWriter ->
Word8 ->
Word32 ->
IO CInt
bitWriterPutBytes ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> Word8
-> Word32
-> m Bool
bitWriterPutBytes :: BitWriter -> Word8 -> Word32 -> m Bool
bitWriterPutBytes bitwriter :: BitWriter
bitwriter data_ :: Word8
data_ nbytes :: Word32
nbytes = 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 BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
CInt
result <- Ptr BitWriter -> Word8 -> Word32 -> IO CInt
gst_bit_writer_put_bytes Ptr BitWriter
bitwriter' Word8
data_ Word32
nbytes
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BitWriterPutBytesMethodInfo
instance (signature ~ (Word8 -> Word32 -> m Bool), MonadIO m) => O.MethodInfo BitWriterPutBytesMethodInfo BitWriter signature where
overloadedMethod = bitWriterPutBytes
#endif
foreign import ccall "gst_bit_writer_reset" gst_bit_writer_reset ::
Ptr BitWriter ->
IO ()
bitWriterReset ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> m ()
bitWriterReset :: BitWriter -> m ()
bitWriterReset bitwriter :: BitWriter
bitwriter = 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 BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
Ptr BitWriter -> IO ()
gst_bit_writer_reset Ptr BitWriter
bitwriter'
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BitWriterResetMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo BitWriterResetMethodInfo BitWriter signature where
overloadedMethod = bitWriterReset
#endif
foreign import ccall "gst_bit_writer_reset_and_get_buffer" gst_bit_writer_reset_and_get_buffer ::
Ptr BitWriter ->
IO (Ptr Gst.Buffer.Buffer)
bitWriterResetAndGetBuffer ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> m Gst.Buffer.Buffer
bitWriterResetAndGetBuffer :: BitWriter -> m Buffer
bitWriterResetAndGetBuffer bitwriter :: BitWriter
bitwriter = 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 BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
Ptr Buffer
result <- Ptr BitWriter -> IO (Ptr Buffer)
gst_bit_writer_reset_and_get_buffer Ptr BitWriter
bitwriter'
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "bitWriterResetAndGetBuffer" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
result
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
#if defined(ENABLE_OVERLOADING)
data BitWriterResetAndGetBufferMethodInfo
instance (signature ~ (m Gst.Buffer.Buffer), MonadIO m) => O.MethodInfo BitWriterResetAndGetBufferMethodInfo BitWriter signature where
overloadedMethod = bitWriterResetAndGetBuffer
#endif
foreign import ccall "gst_bit_writer_set_pos" gst_bit_writer_set_pos ::
Ptr BitWriter ->
Word32 ->
IO CInt
bitWriterSetPos ::
(B.CallStack.HasCallStack, MonadIO m) =>
BitWriter
-> Word32
-> m Bool
bitWriterSetPos :: BitWriter -> Word32 -> m Bool
bitWriterSetPos bitwriter :: BitWriter
bitwriter pos :: Word32
pos = 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 BitWriter
bitwriter' <- BitWriter -> IO (Ptr BitWriter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BitWriter
bitwriter
CInt
result <- Ptr BitWriter -> Word32 -> IO CInt
gst_bit_writer_set_pos Ptr BitWriter
bitwriter' Word32
pos
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
BitWriter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BitWriter
bitwriter
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BitWriterSetPosMethodInfo
instance (signature ~ (Word32 -> m Bool), MonadIO m) => O.MethodInfo BitWriterSetPosMethodInfo BitWriter signature where
overloadedMethod = bitWriterSetPos
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveBitWriterMethod (t :: Symbol) (o :: *) :: * where
ResolveBitWriterMethod "alignBytes" o = BitWriterAlignBytesMethodInfo
ResolveBitWriterMethod "free" o = BitWriterFreeMethodInfo
ResolveBitWriterMethod "freeAndGetBuffer" o = BitWriterFreeAndGetBufferMethodInfo
ResolveBitWriterMethod "putBitsUint16" o = BitWriterPutBitsUint16MethodInfo
ResolveBitWriterMethod "putBitsUint32" o = BitWriterPutBitsUint32MethodInfo
ResolveBitWriterMethod "putBitsUint64" o = BitWriterPutBitsUint64MethodInfo
ResolveBitWriterMethod "putBitsUint8" o = BitWriterPutBitsUint8MethodInfo
ResolveBitWriterMethod "putBytes" o = BitWriterPutBytesMethodInfo
ResolveBitWriterMethod "reset" o = BitWriterResetMethodInfo
ResolveBitWriterMethod "resetAndGetBuffer" o = BitWriterResetAndGetBufferMethodInfo
ResolveBitWriterMethod "getData" o = BitWriterGetDataMethodInfo
ResolveBitWriterMethod "getRemaining" o = BitWriterGetRemainingMethodInfo
ResolveBitWriterMethod "getSize" o = BitWriterGetSizeMethodInfo
ResolveBitWriterMethod "setPos" o = BitWriterSetPosMethodInfo
ResolveBitWriterMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveBitWriterMethod t BitWriter, O.MethodInfo info BitWriter p) => OL.IsLabel t (BitWriter -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif