{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) Structure representing the state of an incoming or outgoing video stream for encoders and decoders. Decoders and encoders will receive such a state through their respective /@setFormat@/ vmethods. Decoders and encoders can set the downstream state, by using the /@gstVideoDecoderSetOutputState@/() or /@gstVideoEncoderSetOutputState@/() methods. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.GstVideo.Structs.VideoCodecState ( -- * Exported types VideoCodecState(..) , newZeroVideoCodecState , noVideoCodecState , -- * Methods -- ** ref #method:ref# #if ENABLE_OVERLOADING VideoCodecStateRefMethodInfo , #endif videoCodecStateRef , -- ** unref #method:unref# #if ENABLE_OVERLOADING VideoCodecStateUnrefMethodInfo , #endif videoCodecStateUnref , -- * Properties -- ** allocationCaps #attr:allocationCaps# {- | The 'GI.Gst.Structs.Caps.Caps' for allocation query and pool negotiation. Since: 1.10 -} clearVideoCodecStateAllocationCaps , getVideoCodecStateAllocationCaps , setVideoCodecStateAllocationCaps , #if ENABLE_OVERLOADING videoCodecState_allocationCaps , #endif -- ** caps #attr:caps# {- | The 'GI.Gst.Structs.Caps.Caps' used in the caps negotiation of the pad. -} clearVideoCodecStateCaps , getVideoCodecStateCaps , setVideoCodecStateCaps , #if ENABLE_OVERLOADING videoCodecState_caps , #endif -- ** codecData #attr:codecData# {- | a 'GI.Gst.Structs.Buffer.Buffer' corresponding to the \'codec_data\' field of a stream, or NULL. -} clearVideoCodecStateCodecData , getVideoCodecStateCodecData , setVideoCodecStateCodecData , #if ENABLE_OVERLOADING videoCodecState_codecData , #endif -- ** info #attr:info# {- | The 'GI.GstVideo.Structs.VideoInfo.VideoInfo' describing the stream -} 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 -- | Memory-managed wrapper type. 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 -- | Construct a `VideoCodecState` struct initialized to zero. 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 -- | A convenience alias for `Nothing` :: `Maybe` `VideoCodecState`. noVideoCodecState :: Maybe VideoCodecState noVideoCodecState = Nothing {- | Get the value of the “@info@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' videoCodecState #info @ -} 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 {- | Get the value of the “@caps@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' videoCodecState #caps @ -} 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 {- | Set the value of the “@caps@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' videoCodecState [ #caps 'Data.GI.Base.Attributes.:=' value ] @ -} 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) {- | Set the value of the “@caps@” field to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #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 {- | Get the value of the “@codec_data@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' videoCodecState #codecData @ -} 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 {- | Set the value of the “@codec_data@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' videoCodecState [ #codecData 'Data.GI.Base.Attributes.:=' value ] @ -} 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) {- | Set the value of the “@codec_data@” field to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #codecData @ -} 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 {- | Get the value of the “@allocation_caps@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' videoCodecState #allocationCaps @ -} 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 {- | Set the value of the “@allocation_caps@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' videoCodecState [ #allocationCaps 'Data.GI.Base.Attributes.:=' value ] @ -} 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) {- | Set the value of the “@allocation_caps@” field to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #allocationCaps @ -} 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 -- method VideoCodecState::ref -- method type : OrdinaryMethod -- Args : [Arg {argCName = "state", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoCodecState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"})) -- throws : False -- Skip return : False foreign import ccall "gst_video_codec_state_ref" gst_video_codec_state_ref :: Ptr VideoCodecState -> -- state : TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}) IO (Ptr VideoCodecState) {- | Increases the refcount of the given state by one. -} videoCodecStateRef :: (B.CallStack.HasCallStack, MonadIO m) => VideoCodecState {- ^ /@state@/: a 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState' -} -> m VideoCodecState {- ^ __Returns:__ /@buf@/ -} 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 -- method VideoCodecState::unref -- method type : OrdinaryMethod -- Args : [Arg {argCName = "state", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoCodecState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_video_codec_state_unref" gst_video_codec_state_unref :: Ptr VideoCodecState -> -- state : TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}) IO () {- | Decreases the refcount of the state. If the refcount reaches 0, the state will be freed. -} videoCodecStateUnref :: (B.CallStack.HasCallStack, MonadIO m) => VideoCodecState {- ^ /@state@/: a 'GI.GstVideo.Structs.VideoCodecState.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