#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.GstVideo.Structs.VideoCodecState
(
VideoCodecState(..) ,
newZeroVideoCodecState ,
noVideoCodecState ,
#if ENABLE_OVERLOADING
VideoCodecStateRefMethodInfo ,
#endif
videoCodecStateRef ,
#if ENABLE_OVERLOADING
VideoCodecStateUnrefMethodInfo ,
#endif
videoCodecStateUnref ,
clearVideoCodecStateAllocationCaps ,
getVideoCodecStateAllocationCaps ,
setVideoCodecStateAllocationCaps ,
#if ENABLE_OVERLOADING
videoCodecState_allocationCaps ,
#endif
clearVideoCodecStateCaps ,
getVideoCodecStateCaps ,
setVideoCodecStateCaps ,
#if ENABLE_OVERLOADING
videoCodecState_caps ,
#endif
clearVideoCodecStateCodecData ,
getVideoCodecStateCodecData ,
setVideoCodecStateCodecData ,
#if ENABLE_OVERLOADING
videoCodecState_codecData ,
#endif
getVideoCodecStateInfo ,
#if 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.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)
foreign import ccall "gst_video_codec_state_get_type" c_gst_video_codec_state_get_type ::
IO GType
instance BoxedObject VideoCodecState where
boxedType _ = c_gst_video_codec_state_get_type
newZeroVideoCodecState :: MonadIO m => m VideoCodecState
newZeroVideoCodecState = liftIO $ callocBoxedBytes 304 >>= wrapBoxed VideoCodecState
instance tag ~ 'AttrSet => Constructible VideoCodecState tag where
new _ attrs = do
o <- newZeroVideoCodecState
GI.Attributes.set o attrs
return o
noVideoCodecState :: Maybe VideoCodecState
noVideoCodecState = Nothing
getVideoCodecStateInfo :: MonadIO m => VideoCodecState -> m GstVideo.VideoInfo.VideoInfo
getVideoCodecStateInfo s = liftIO $ withManagedPtr s $ \ptr -> do
let val = ptr `plusPtr` 8 :: (Ptr GstVideo.VideoInfo.VideoInfo)
val' <- (newBoxed GstVideo.VideoInfo.VideoInfo) val
return val'
#if ENABLE_OVERLOADING
data VideoCodecStateInfoFieldInfo
instance AttrInfo VideoCodecStateInfoFieldInfo where
type AttrAllowedOps VideoCodecStateInfoFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint VideoCodecStateInfoFieldInfo = (~) (Ptr GstVideo.VideoInfo.VideoInfo)
type AttrBaseTypeConstraint VideoCodecStateInfoFieldInfo = (~) VideoCodecState
type AttrGetType VideoCodecStateInfoFieldInfo = GstVideo.VideoInfo.VideoInfo
type AttrLabel VideoCodecStateInfoFieldInfo = "info"
type AttrOrigin VideoCodecStateInfoFieldInfo = VideoCodecState
attrGet _ = getVideoCodecStateInfo
attrSet _ = undefined
attrConstruct = undefined
attrClear _ = undefined
videoCodecState_info :: AttrLabelProxy "info"
videoCodecState_info = AttrLabelProxy
#endif
getVideoCodecStateCaps :: MonadIO m => VideoCodecState -> m (Maybe Gst.Caps.Caps)
getVideoCodecStateCaps s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 128) :: IO (Ptr Gst.Caps.Caps)
result <- SP.convertIfNonNull val $ \val' -> do
val'' <- (newBoxed Gst.Caps.Caps) val'
return val''
return result
setVideoCodecStateCaps :: MonadIO m => VideoCodecState -> Ptr Gst.Caps.Caps -> m ()
setVideoCodecStateCaps s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 128) (val :: Ptr Gst.Caps.Caps)
clearVideoCodecStateCaps :: MonadIO m => VideoCodecState -> m ()
clearVideoCodecStateCaps s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 128) (FP.nullPtr :: Ptr Gst.Caps.Caps)
#if ENABLE_OVERLOADING
data VideoCodecStateCapsFieldInfo
instance AttrInfo VideoCodecStateCapsFieldInfo where
type AttrAllowedOps VideoCodecStateCapsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint VideoCodecStateCapsFieldInfo = (~) (Ptr Gst.Caps.Caps)
type AttrBaseTypeConstraint VideoCodecStateCapsFieldInfo = (~) VideoCodecState
type AttrGetType VideoCodecStateCapsFieldInfo = Maybe Gst.Caps.Caps
type AttrLabel VideoCodecStateCapsFieldInfo = "caps"
type AttrOrigin VideoCodecStateCapsFieldInfo = VideoCodecState
attrGet _ = getVideoCodecStateCaps
attrSet _ = setVideoCodecStateCaps
attrConstruct = undefined
attrClear _ = clearVideoCodecStateCaps
videoCodecState_caps :: AttrLabelProxy "caps"
videoCodecState_caps = AttrLabelProxy
#endif
getVideoCodecStateCodecData :: MonadIO m => VideoCodecState -> m (Maybe Gst.Buffer.Buffer)
getVideoCodecStateCodecData s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 136) :: IO (Ptr Gst.Buffer.Buffer)
result <- SP.convertIfNonNull val $ \val' -> do
val'' <- (newBoxed Gst.Buffer.Buffer) val'
return val''
return result
setVideoCodecStateCodecData :: MonadIO m => VideoCodecState -> Ptr Gst.Buffer.Buffer -> m ()
setVideoCodecStateCodecData s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 136) (val :: Ptr Gst.Buffer.Buffer)
clearVideoCodecStateCodecData :: MonadIO m => VideoCodecState -> m ()
clearVideoCodecStateCodecData s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 136) (FP.nullPtr :: Ptr Gst.Buffer.Buffer)
#if ENABLE_OVERLOADING
data VideoCodecStateCodecDataFieldInfo
instance AttrInfo VideoCodecStateCodecDataFieldInfo where
type AttrAllowedOps VideoCodecStateCodecDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint VideoCodecStateCodecDataFieldInfo = (~) (Ptr Gst.Buffer.Buffer)
type AttrBaseTypeConstraint VideoCodecStateCodecDataFieldInfo = (~) VideoCodecState
type AttrGetType VideoCodecStateCodecDataFieldInfo = Maybe Gst.Buffer.Buffer
type AttrLabel VideoCodecStateCodecDataFieldInfo = "codec_data"
type AttrOrigin VideoCodecStateCodecDataFieldInfo = VideoCodecState
attrGet _ = getVideoCodecStateCodecData
attrSet _ = setVideoCodecStateCodecData
attrConstruct = undefined
attrClear _ = clearVideoCodecStateCodecData
videoCodecState_codecData :: AttrLabelProxy "codecData"
videoCodecState_codecData = AttrLabelProxy
#endif
getVideoCodecStateAllocationCaps :: MonadIO m => VideoCodecState -> m (Maybe Gst.Caps.Caps)
getVideoCodecStateAllocationCaps s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 144) :: IO (Ptr Gst.Caps.Caps)
result <- SP.convertIfNonNull val $ \val' -> do
val'' <- (newBoxed Gst.Caps.Caps) val'
return val''
return result
setVideoCodecStateAllocationCaps :: MonadIO m => VideoCodecState -> Ptr Gst.Caps.Caps -> m ()
setVideoCodecStateAllocationCaps s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 144) (val :: Ptr Gst.Caps.Caps)
clearVideoCodecStateAllocationCaps :: MonadIO m => VideoCodecState -> m ()
clearVideoCodecStateAllocationCaps s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 144) (FP.nullPtr :: Ptr Gst.Caps.Caps)
#if ENABLE_OVERLOADING
data VideoCodecStateAllocationCapsFieldInfo
instance AttrInfo VideoCodecStateAllocationCapsFieldInfo where
type AttrAllowedOps VideoCodecStateAllocationCapsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint VideoCodecStateAllocationCapsFieldInfo = (~) (Ptr Gst.Caps.Caps)
type AttrBaseTypeConstraint VideoCodecStateAllocationCapsFieldInfo = (~) VideoCodecState
type AttrGetType VideoCodecStateAllocationCapsFieldInfo = Maybe Gst.Caps.Caps
type AttrLabel VideoCodecStateAllocationCapsFieldInfo = "allocation_caps"
type AttrOrigin VideoCodecStateAllocationCapsFieldInfo = VideoCodecState
attrGet _ = getVideoCodecStateAllocationCaps
attrSet _ = setVideoCodecStateAllocationCaps
attrConstruct = undefined
attrClear _ = clearVideoCodecStateAllocationCaps
videoCodecState_allocationCaps :: AttrLabelProxy "allocationCaps"
videoCodecState_allocationCaps = AttrLabelProxy
#endif
#if 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 state = liftIO $ do
state' <- unsafeManagedPtrGetPtr state
result <- gst_video_codec_state_ref state'
checkUnexpectedReturnNULL "videoCodecStateRef" result
result' <- (wrapBoxed VideoCodecState) result
touchManagedPtr state
return result'
#if 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 state = liftIO $ do
state' <- unsafeManagedPtrGetPtr state
gst_video_codec_state_unref state'
touchManagedPtr state
return ()
#if ENABLE_OVERLOADING
data VideoCodecStateUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoCodecStateUnrefMethodInfo VideoCodecState signature where
overloadedMethod _ = videoCodecStateUnref
#endif
#if 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 (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif