{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstVideo.Structs.VideoCodecState
(
VideoCodecState(..) ,
newZeroVideoCodecState ,
noVideoCodecState ,
#if defined(ENABLE_OVERLOADING)
ResolveVideoCodecStateMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
VideoCodecStateRefMethodInfo ,
#endif
videoCodecStateRef ,
#if defined(ENABLE_OVERLOADING)
VideoCodecStateUnrefMethodInfo ,
#endif
videoCodecStateUnref ,
clearVideoCodecStateAllocationCaps ,
getVideoCodecStateAllocationCaps ,
setVideoCodecStateAllocationCaps ,
#if defined(ENABLE_OVERLOADING)
videoCodecState_allocationCaps ,
#endif
clearVideoCodecStateCaps ,
getVideoCodecStateCaps ,
setVideoCodecStateCaps ,
#if defined(ENABLE_OVERLOADING)
videoCodecState_caps ,
#endif
clearVideoCodecStateCodecData ,
getVideoCodecStateCodecData ,
setVideoCodecStateCodecData ,
#if defined(ENABLE_OVERLOADING)
videoCodecState_codecData ,
#endif
getVideoCodecStateInfo ,
#if defined(ENABLE_OVERLOADING)
videoCodecState_info ,
#endif
) 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
import qualified GI.Gst.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoInfo as GstVideo.VideoInfo
newtype VideoCodecState = VideoCodecState (ManagedPtr VideoCodecState)
deriving (VideoCodecState -> VideoCodecState -> Bool
(VideoCodecState -> VideoCodecState -> Bool)
-> (VideoCodecState -> VideoCodecState -> Bool)
-> Eq VideoCodecState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoCodecState -> VideoCodecState -> Bool
$c/= :: VideoCodecState -> VideoCodecState -> Bool
== :: VideoCodecState -> VideoCodecState -> Bool
$c== :: VideoCodecState -> VideoCodecState -> Bool
Eq)
foreign import ccall "gst_video_codec_state_get_type" c_gst_video_codec_state_get_type ::
IO GType
instance BoxedObject VideoCodecState where
boxedType :: VideoCodecState -> IO GType
boxedType _ = IO GType
c_gst_video_codec_state_get_type
instance B.GValue.IsGValue VideoCodecState where
toGValue :: VideoCodecState -> IO GValue
toGValue o :: VideoCodecState
o = do
GType
gtype <- IO GType
c_gst_video_codec_state_get_type
VideoCodecState -> (Ptr VideoCodecState -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VideoCodecState
o (GType
-> (GValue -> Ptr VideoCodecState -> IO ())
-> Ptr VideoCodecState
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr VideoCodecState -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO VideoCodecState
fromGValue gv :: GValue
gv = do
Ptr VideoCodecState
ptr <- GValue -> IO (Ptr VideoCodecState)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr VideoCodecState)
(ManagedPtr VideoCodecState -> VideoCodecState)
-> Ptr VideoCodecState -> IO VideoCodecState
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr VideoCodecState -> VideoCodecState
VideoCodecState Ptr VideoCodecState
ptr
newZeroVideoCodecState :: MonadIO m => m VideoCodecState
newZeroVideoCodecState :: m VideoCodecState
newZeroVideoCodecState = IO VideoCodecState -> m VideoCodecState
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoCodecState -> m VideoCodecState)
-> IO VideoCodecState -> m VideoCodecState
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr VideoCodecState)
forall a. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 304 IO (Ptr VideoCodecState)
-> (Ptr VideoCodecState -> IO VideoCodecState)
-> IO VideoCodecState
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr VideoCodecState -> VideoCodecState)
-> Ptr VideoCodecState -> IO VideoCodecState
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoCodecState -> VideoCodecState
VideoCodecState
instance tag ~ 'AttrSet => Constructible VideoCodecState tag where
new :: (ManagedPtr VideoCodecState -> VideoCodecState)
-> [AttrOp VideoCodecState tag] -> m VideoCodecState
new _ attrs :: [AttrOp VideoCodecState tag]
attrs = do
VideoCodecState
o <- m VideoCodecState
forall (m :: * -> *). MonadIO m => m VideoCodecState
newZeroVideoCodecState
VideoCodecState -> [AttrOp VideoCodecState 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set VideoCodecState
o [AttrOp VideoCodecState tag]
[AttrOp VideoCodecState 'AttrSet]
attrs
VideoCodecState -> m VideoCodecState
forall (m :: * -> *) a. Monad m => a -> m a
return VideoCodecState
o
noVideoCodecState :: Maybe VideoCodecState
noVideoCodecState :: Maybe VideoCodecState
noVideoCodecState = Maybe VideoCodecState
forall a. Maybe a
Nothing
getVideoCodecStateInfo :: MonadIO m => VideoCodecState -> m GstVideo.VideoInfo.VideoInfo
getVideoCodecStateInfo :: VideoCodecState -> m VideoInfo
getVideoCodecStateInfo s :: VideoCodecState
s = IO VideoInfo -> m VideoInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoInfo -> m VideoInfo) -> IO VideoInfo -> m VideoInfo
forall a b. (a -> b) -> a -> b
$ VideoCodecState
-> (Ptr VideoCodecState -> IO VideoInfo) -> IO VideoInfo
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecState
s ((Ptr VideoCodecState -> IO VideoInfo) -> IO VideoInfo)
-> (Ptr VideoCodecState -> IO VideoInfo) -> IO VideoInfo
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoCodecState
ptr -> do
let val :: Ptr VideoInfo
val = Ptr VideoCodecState
ptr Ptr VideoCodecState -> Int -> Ptr VideoInfo
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8 :: (Ptr GstVideo.VideoInfo.VideoInfo)
VideoInfo
val' <- ((ManagedPtr VideoInfo -> VideoInfo)
-> Ptr VideoInfo -> IO VideoInfo
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr VideoInfo -> VideoInfo
GstVideo.VideoInfo.VideoInfo) Ptr VideoInfo
val
VideoInfo -> IO VideoInfo
forall (m :: * -> *) a. Monad m => a -> m a
return VideoInfo
val'
#if defined(ENABLE_OVERLOADING)
data VideoCodecStateInfoFieldInfo
instance AttrInfo VideoCodecStateInfoFieldInfo where
type AttrBaseTypeConstraint VideoCodecStateInfoFieldInfo = (~) VideoCodecState
type AttrAllowedOps VideoCodecStateInfoFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint VideoCodecStateInfoFieldInfo = (~) (Ptr GstVideo.VideoInfo.VideoInfo)
type AttrTransferTypeConstraint VideoCodecStateInfoFieldInfo = (~)(Ptr GstVideo.VideoInfo.VideoInfo)
type AttrTransferType VideoCodecStateInfoFieldInfo = (Ptr GstVideo.VideoInfo.VideoInfo)
type AttrGetType VideoCodecStateInfoFieldInfo = GstVideo.VideoInfo.VideoInfo
type AttrLabel VideoCodecStateInfoFieldInfo = "info"
type AttrOrigin VideoCodecStateInfoFieldInfo = VideoCodecState
attrGet = getVideoCodecStateInfo
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
videoCodecState_info :: AttrLabelProxy "info"
videoCodecState_info = AttrLabelProxy
#endif
getVideoCodecStateCaps :: MonadIO m => VideoCodecState -> m (Maybe Gst.Caps.Caps)
getVideoCodecStateCaps :: VideoCodecState -> m (Maybe Caps)
getVideoCodecStateCaps s :: VideoCodecState
s = IO (Maybe Caps) -> m (Maybe Caps)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Caps) -> m (Maybe Caps))
-> IO (Maybe Caps) -> m (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ VideoCodecState
-> (Ptr VideoCodecState -> IO (Maybe Caps)) -> IO (Maybe Caps)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecState
s ((Ptr VideoCodecState -> IO (Maybe Caps)) -> IO (Maybe Caps))
-> (Ptr VideoCodecState -> IO (Maybe Caps)) -> IO (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoCodecState
ptr -> do
Ptr Caps
val <- Ptr (Ptr Caps) -> IO (Ptr Caps)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoCodecState
ptr Ptr VideoCodecState -> Int -> Ptr (Ptr Caps)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 128) :: IO (Ptr Gst.Caps.Caps)
Maybe Caps
result <- Ptr Caps -> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Caps
val ((Ptr Caps -> IO Caps) -> IO (Maybe Caps))
-> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ \val' :: Ptr Caps
val' -> do
Caps
val'' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
val'
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
val''
Maybe Caps -> IO (Maybe Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Caps
result
setVideoCodecStateCaps :: MonadIO m => VideoCodecState -> Ptr Gst.Caps.Caps -> m ()
setVideoCodecStateCaps :: VideoCodecState -> Ptr Caps -> m ()
setVideoCodecStateCaps s :: VideoCodecState
s val :: Ptr Caps
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoCodecState -> (Ptr VideoCodecState -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecState
s ((Ptr VideoCodecState -> IO ()) -> IO ())
-> (Ptr VideoCodecState -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoCodecState
ptr -> do
Ptr (Ptr Caps) -> Ptr Caps -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecState
ptr Ptr VideoCodecState -> Int -> Ptr (Ptr Caps)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 128) (Ptr Caps
val :: Ptr Gst.Caps.Caps)
clearVideoCodecStateCaps :: MonadIO m => VideoCodecState -> m ()
clearVideoCodecStateCaps :: VideoCodecState -> m ()
clearVideoCodecStateCaps s :: VideoCodecState
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoCodecState -> (Ptr VideoCodecState -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecState
s ((Ptr VideoCodecState -> IO ()) -> IO ())
-> (Ptr VideoCodecState -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoCodecState
ptr -> do
Ptr (Ptr Caps) -> Ptr Caps -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecState
ptr Ptr VideoCodecState -> Int -> Ptr (Ptr Caps)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 128) (Ptr Caps
forall a. Ptr a
FP.nullPtr :: Ptr Gst.Caps.Caps)
#if defined(ENABLE_OVERLOADING)
data VideoCodecStateCapsFieldInfo
instance AttrInfo VideoCodecStateCapsFieldInfo where
type AttrBaseTypeConstraint VideoCodecStateCapsFieldInfo = (~) VideoCodecState
type AttrAllowedOps VideoCodecStateCapsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint VideoCodecStateCapsFieldInfo = (~) (Ptr Gst.Caps.Caps)
type AttrTransferTypeConstraint VideoCodecStateCapsFieldInfo = (~)(Ptr Gst.Caps.Caps)
type AttrTransferType VideoCodecStateCapsFieldInfo = (Ptr Gst.Caps.Caps)
type AttrGetType VideoCodecStateCapsFieldInfo = Maybe Gst.Caps.Caps
type AttrLabel VideoCodecStateCapsFieldInfo = "caps"
type AttrOrigin VideoCodecStateCapsFieldInfo = VideoCodecState
attrGet = getVideoCodecStateCaps
attrSet = setVideoCodecStateCaps
attrConstruct = undefined
attrClear = clearVideoCodecStateCaps
attrTransfer _ v = do
return v
videoCodecState_caps :: AttrLabelProxy "caps"
videoCodecState_caps = AttrLabelProxy
#endif
getVideoCodecStateCodecData :: MonadIO m => VideoCodecState -> m (Maybe Gst.Buffer.Buffer)
getVideoCodecStateCodecData :: VideoCodecState -> m (Maybe Buffer)
getVideoCodecStateCodecData s :: VideoCodecState
s = 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
$ VideoCodecState
-> (Ptr VideoCodecState -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecState
s ((Ptr VideoCodecState -> IO (Maybe Buffer)) -> IO (Maybe Buffer))
-> (Ptr VideoCodecState -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoCodecState
ptr -> do
Ptr Buffer
val <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoCodecState
ptr Ptr VideoCodecState -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 136) :: IO (Ptr Gst.Buffer.Buffer)
Maybe Buffer
result <- Ptr Buffer -> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Buffer
val ((Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer))
-> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \val' :: Ptr Buffer
val' -> do
Buffer
val'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
val'
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
val''
Maybe Buffer -> IO (Maybe Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
result
setVideoCodecStateCodecData :: MonadIO m => VideoCodecState -> Ptr Gst.Buffer.Buffer -> m ()
setVideoCodecStateCodecData :: VideoCodecState -> Ptr Buffer -> m ()
setVideoCodecStateCodecData s :: VideoCodecState
s val :: Ptr Buffer
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoCodecState -> (Ptr VideoCodecState -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecState
s ((Ptr VideoCodecState -> IO ()) -> IO ())
-> (Ptr VideoCodecState -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoCodecState
ptr -> do
Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecState
ptr Ptr VideoCodecState -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 136) (Ptr Buffer
val :: Ptr Gst.Buffer.Buffer)
clearVideoCodecStateCodecData :: MonadIO m => VideoCodecState -> m ()
clearVideoCodecStateCodecData :: VideoCodecState -> m ()
clearVideoCodecStateCodecData s :: VideoCodecState
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoCodecState -> (Ptr VideoCodecState -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecState
s ((Ptr VideoCodecState -> IO ()) -> IO ())
-> (Ptr VideoCodecState -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoCodecState
ptr -> do
Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecState
ptr Ptr VideoCodecState -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 136) (Ptr Buffer
forall a. Ptr a
FP.nullPtr :: Ptr Gst.Buffer.Buffer)
#if defined(ENABLE_OVERLOADING)
data VideoCodecStateCodecDataFieldInfo
instance AttrInfo VideoCodecStateCodecDataFieldInfo where
type AttrBaseTypeConstraint VideoCodecStateCodecDataFieldInfo = (~) VideoCodecState
type AttrAllowedOps VideoCodecStateCodecDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint VideoCodecStateCodecDataFieldInfo = (~) (Ptr Gst.Buffer.Buffer)
type AttrTransferTypeConstraint VideoCodecStateCodecDataFieldInfo = (~)(Ptr Gst.Buffer.Buffer)
type AttrTransferType VideoCodecStateCodecDataFieldInfo = (Ptr Gst.Buffer.Buffer)
type AttrGetType VideoCodecStateCodecDataFieldInfo = Maybe Gst.Buffer.Buffer
type AttrLabel VideoCodecStateCodecDataFieldInfo = "codec_data"
type AttrOrigin VideoCodecStateCodecDataFieldInfo = VideoCodecState
attrGet = getVideoCodecStateCodecData
attrSet = setVideoCodecStateCodecData
attrConstruct = undefined
attrClear = clearVideoCodecStateCodecData
attrTransfer _ v = do
return v
videoCodecState_codecData :: AttrLabelProxy "codecData"
videoCodecState_codecData = AttrLabelProxy
#endif
getVideoCodecStateAllocationCaps :: MonadIO m => VideoCodecState -> m (Maybe Gst.Caps.Caps)
getVideoCodecStateAllocationCaps :: VideoCodecState -> m (Maybe Caps)
getVideoCodecStateAllocationCaps s :: VideoCodecState
s = IO (Maybe Caps) -> m (Maybe Caps)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Caps) -> m (Maybe Caps))
-> IO (Maybe Caps) -> m (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ VideoCodecState
-> (Ptr VideoCodecState -> IO (Maybe Caps)) -> IO (Maybe Caps)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecState
s ((Ptr VideoCodecState -> IO (Maybe Caps)) -> IO (Maybe Caps))
-> (Ptr VideoCodecState -> IO (Maybe Caps)) -> IO (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoCodecState
ptr -> do
Ptr Caps
val <- Ptr (Ptr Caps) -> IO (Ptr Caps)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoCodecState
ptr Ptr VideoCodecState -> Int -> Ptr (Ptr Caps)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 144) :: IO (Ptr Gst.Caps.Caps)
Maybe Caps
result <- Ptr Caps -> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Caps
val ((Ptr Caps -> IO Caps) -> IO (Maybe Caps))
-> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ \val' :: Ptr Caps
val' -> do
Caps
val'' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
val'
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
val''
Maybe Caps -> IO (Maybe Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Caps
result
setVideoCodecStateAllocationCaps :: MonadIO m => VideoCodecState -> Ptr Gst.Caps.Caps -> m ()
setVideoCodecStateAllocationCaps :: VideoCodecState -> Ptr Caps -> m ()
setVideoCodecStateAllocationCaps s :: VideoCodecState
s val :: Ptr Caps
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoCodecState -> (Ptr VideoCodecState -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecState
s ((Ptr VideoCodecState -> IO ()) -> IO ())
-> (Ptr VideoCodecState -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoCodecState
ptr -> do
Ptr (Ptr Caps) -> Ptr Caps -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecState
ptr Ptr VideoCodecState -> Int -> Ptr (Ptr Caps)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 144) (Ptr Caps
val :: Ptr Gst.Caps.Caps)
clearVideoCodecStateAllocationCaps :: MonadIO m => VideoCodecState -> m ()
clearVideoCodecStateAllocationCaps :: VideoCodecState -> m ()
clearVideoCodecStateAllocationCaps s :: VideoCodecState
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoCodecState -> (Ptr VideoCodecState -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecState
s ((Ptr VideoCodecState -> IO ()) -> IO ())
-> (Ptr VideoCodecState -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoCodecState
ptr -> do
Ptr (Ptr Caps) -> Ptr Caps -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecState
ptr Ptr VideoCodecState -> Int -> Ptr (Ptr Caps)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 144) (Ptr Caps
forall a. Ptr a
FP.nullPtr :: Ptr Gst.Caps.Caps)
#if defined(ENABLE_OVERLOADING)
data VideoCodecStateAllocationCapsFieldInfo
instance AttrInfo VideoCodecStateAllocationCapsFieldInfo where
type AttrBaseTypeConstraint VideoCodecStateAllocationCapsFieldInfo = (~) VideoCodecState
type AttrAllowedOps VideoCodecStateAllocationCapsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint VideoCodecStateAllocationCapsFieldInfo = (~) (Ptr Gst.Caps.Caps)
type AttrTransferTypeConstraint VideoCodecStateAllocationCapsFieldInfo = (~)(Ptr Gst.Caps.Caps)
type AttrTransferType VideoCodecStateAllocationCapsFieldInfo = (Ptr Gst.Caps.Caps)
type AttrGetType VideoCodecStateAllocationCapsFieldInfo = Maybe Gst.Caps.Caps
type AttrLabel VideoCodecStateAllocationCapsFieldInfo = "allocation_caps"
type AttrOrigin VideoCodecStateAllocationCapsFieldInfo = VideoCodecState
attrGet = getVideoCodecStateAllocationCaps
attrSet = setVideoCodecStateAllocationCaps
attrConstruct = undefined
attrClear = clearVideoCodecStateAllocationCaps
attrTransfer _ v = do
return v
videoCodecState_allocationCaps :: AttrLabelProxy "allocationCaps"
videoCodecState_allocationCaps = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoCodecState
type instance O.AttributeList VideoCodecState = VideoCodecStateAttributeList
type VideoCodecStateAttributeList = ('[ '("info", VideoCodecStateInfoFieldInfo), '("caps", VideoCodecStateCapsFieldInfo), '("codecData", VideoCodecStateCodecDataFieldInfo), '("allocationCaps", VideoCodecStateAllocationCapsFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_video_codec_state_ref" gst_video_codec_state_ref ::
Ptr VideoCodecState ->
IO (Ptr VideoCodecState)
videoCodecStateRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
VideoCodecState
-> m VideoCodecState
videoCodecStateRef :: VideoCodecState -> m VideoCodecState
videoCodecStateRef state :: VideoCodecState
state = IO VideoCodecState -> m VideoCodecState
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoCodecState -> m VideoCodecState)
-> IO VideoCodecState -> m VideoCodecState
forall a b. (a -> b) -> a -> b
$ do
Ptr VideoCodecState
state' <- VideoCodecState -> IO (Ptr VideoCodecState)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoCodecState
state
Ptr VideoCodecState
result <- Ptr VideoCodecState -> IO (Ptr VideoCodecState)
gst_video_codec_state_ref Ptr VideoCodecState
state'
Text -> Ptr VideoCodecState -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "videoCodecStateRef" Ptr VideoCodecState
result
VideoCodecState
result' <- ((ManagedPtr VideoCodecState -> VideoCodecState)
-> Ptr VideoCodecState -> IO VideoCodecState
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoCodecState -> VideoCodecState
VideoCodecState) Ptr VideoCodecState
result
VideoCodecState -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoCodecState
state
VideoCodecState -> IO VideoCodecState
forall (m :: * -> *) a. Monad m => a -> m a
return VideoCodecState
result'
#if defined(ENABLE_OVERLOADING)
data VideoCodecStateRefMethodInfo
instance (signature ~ (m VideoCodecState), MonadIO m) => O.MethodInfo VideoCodecStateRefMethodInfo VideoCodecState signature where
overloadedMethod = videoCodecStateRef
#endif
foreign import ccall "gst_video_codec_state_unref" gst_video_codec_state_unref ::
Ptr VideoCodecState ->
IO ()
videoCodecStateUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
VideoCodecState
-> m ()
videoCodecStateUnref :: VideoCodecState -> m ()
videoCodecStateUnref state :: VideoCodecState
state = 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 VideoCodecState
state' <- VideoCodecState -> IO (Ptr VideoCodecState)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoCodecState
state
Ptr VideoCodecState -> IO ()
gst_video_codec_state_unref Ptr VideoCodecState
state'
VideoCodecState -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoCodecState
state
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data VideoCodecStateUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoCodecStateUnrefMethodInfo VideoCodecState signature where
overloadedMethod = videoCodecStateUnref
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveVideoCodecStateMethod (t :: Symbol) (o :: *) :: * where
ResolveVideoCodecStateMethod "ref" o = VideoCodecStateRefMethodInfo
ResolveVideoCodecStateMethod "unref" o = VideoCodecStateUnrefMethodInfo
ResolveVideoCodecStateMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveVideoCodecStateMethod t VideoCodecState, O.MethodInfo info VideoCodecState p) => OL.IsLabel t (VideoCodecState -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif