{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- 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.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.GstVideo.Structs.VideoCodecState
    ( 

-- * Exported types
    VideoCodecState(..)                     ,
    newZeroVideoCodecState                  ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [ref]("GI.GstVideo.Structs.VideoCodecState#g:method:ref"), [unref]("GI.GstVideo.Structs.VideoCodecState#g:method:unref").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveVideoCodecStateMethod            ,
#endif

-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    VideoCodecStateRefMethodInfo            ,
#endif
    videoCodecStateRef                      ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    VideoCodecStateUnrefMethodInfo          ,
#endif
    videoCodecStateUnref                    ,




 -- * Properties


-- ** allocationCaps #attr:allocationCaps#
-- | The t'GI.Gst.Structs.Caps.Caps' for allocation query and pool
--     negotiation. Since: 1.10

    clearVideoCodecStateAllocationCaps      ,
    getVideoCodecStateAllocationCaps        ,
    setVideoCodecStateAllocationCaps        ,
#if defined(ENABLE_OVERLOADING)
    videoCodecState_allocationCaps          ,
#endif


-- ** caps #attr:caps#
-- | The t'GI.Gst.Structs.Caps.Caps' used in the caps negotiation of the pad.

    clearVideoCodecStateCaps                ,
    getVideoCodecStateCaps                  ,
    setVideoCodecStateCaps                  ,
#if defined(ENABLE_OVERLOADING)
    videoCodecState_caps                    ,
#endif


-- ** codecData #attr:codecData#
-- | a t'GI.Gst.Structs.Buffer.Buffer' corresponding to the
--     \'codec_data\' field of a stream, or NULL.

    clearVideoCodecStateCodecData           ,
    getVideoCodecStateCodecData             ,
    setVideoCodecStateCodecData             ,
#if defined(ENABLE_OVERLOADING)
    videoCodecState_codecData               ,
#endif


-- ** info #attr:info#
-- | The t'GI.GstVideo.Structs.VideoInfo.VideoInfo' describing the stream

    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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
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 GHC.Records as R

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 (SP.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)

instance SP.ManagedPtrNewtype VideoCodecState where
    toManagedPtr :: VideoCodecState -> ManagedPtr VideoCodecState
toManagedPtr (VideoCodecState ManagedPtr VideoCodecState
p) = ManagedPtr VideoCodecState
p

foreign import ccall "gst_video_codec_state_get_type" c_gst_video_codec_state_get_type :: 
    IO GType

type instance O.ParentTypes VideoCodecState = '[]
instance O.HasParentTypes VideoCodecState

instance B.Types.TypedObject VideoCodecState where
    glibType :: IO GType
glibType = IO GType
c_gst_video_codec_state_get_type

instance B.Types.GBoxed VideoCodecState

-- | Convert 'VideoCodecState' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe VideoCodecState) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_video_codec_state_get_type
    gvalueSet_ :: Ptr GValue -> Maybe VideoCodecState -> IO ()
gvalueSet_ Ptr GValue
gv Maybe VideoCodecState
P.Nothing = Ptr GValue -> Ptr VideoCodecState -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr VideoCodecState
forall a. Ptr a
FP.nullPtr :: FP.Ptr VideoCodecState)
    gvalueSet_ Ptr GValue
gv (P.Just VideoCodecState
obj) = VideoCodecState -> (Ptr VideoCodecState -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VideoCodecState
obj (Ptr GValue -> Ptr VideoCodecState -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe VideoCodecState)
gvalueGet_ Ptr GValue
gv = do
        Ptr VideoCodecState
ptr <- Ptr GValue -> IO (Ptr VideoCodecState)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr VideoCodecState)
        if Ptr VideoCodecState
ptr Ptr VideoCodecState -> Ptr VideoCodecState -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr VideoCodecState
forall a. Ptr a
FP.nullPtr
        then VideoCodecState -> Maybe VideoCodecState
forall a. a -> Maybe a
P.Just (VideoCodecState -> Maybe VideoCodecState)
-> IO VideoCodecState -> IO (Maybe VideoCodecState)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr VideoCodecState -> VideoCodecState)
-> Ptr VideoCodecState -> IO VideoCodecState
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr VideoCodecState -> VideoCodecState
VideoCodecState Ptr VideoCodecState
ptr
        else Maybe VideoCodecState -> IO (Maybe VideoCodecState)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoCodecState
forall a. Maybe a
P.Nothing
        
    

-- | Construct a `VideoCodecState` struct initialized to zero.
newZeroVideoCodecState :: MonadIO m => m VideoCodecState
newZeroVideoCodecState :: forall (m :: * -> *). MonadIO m => 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. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
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, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoCodecState -> VideoCodecState
VideoCodecState

instance tag ~ 'AttrSet => Constructible VideoCodecState tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr VideoCodecState -> VideoCodecState)
-> [AttrOp VideoCodecState tag] -> m VideoCodecState
new ManagedPtr VideoCodecState -> VideoCodecState
_ [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


-- | Get the value of the “@info@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoCodecState #info
-- @
getVideoCodecStateInfo :: MonadIO m => VideoCodecState -> m GstVideo.VideoInfo.VideoInfo
getVideoCodecStateInfo :: forall (m :: * -> *). MonadIO m => VideoCodecState -> m VideoInfo
getVideoCodecStateInfo 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 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` Int
8 :: (Ptr GstVideo.VideoInfo.VideoInfo)
    VideoInfo
val' <- ((ManagedPtr VideoInfo -> VideoInfo)
-> Ptr VideoInfo -> IO VideoInfo
forall a.
(HasCallStack, GBoxed 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


-- | Get the value of the “@caps@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoCodecState #caps
-- @
getVideoCodecStateCaps :: MonadIO m => VideoCodecState -> m (Maybe Gst.Caps.Caps)
getVideoCodecStateCaps :: forall (m :: * -> *).
MonadIO m =>
VideoCodecState -> m (Maybe Caps)
getVideoCodecStateCaps 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 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` Int
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
$ \Ptr Caps
val' -> do
        Caps
val'' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed 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

-- | Set the value of the “@caps@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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 :: forall (m :: * -> *).
MonadIO m =>
VideoCodecState -> Ptr Caps -> m ()
setVideoCodecStateCaps VideoCodecState
s 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 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` Int
128) (Ptr Caps
val :: Ptr Gst.Caps.Caps)

-- | Set the value of the “@caps@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #caps
-- @
clearVideoCodecStateCaps :: MonadIO m => VideoCodecState -> m ()
clearVideoCodecStateCaps :: forall (m :: * -> *). MonadIO m => VideoCodecState -> m ()
clearVideoCodecStateCaps 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 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` Int
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


-- | Get the value of the “@codec_data@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoCodecState #codecData
-- @
getVideoCodecStateCodecData :: MonadIO m => VideoCodecState -> m (Maybe Gst.Buffer.Buffer)
getVideoCodecStateCodecData :: forall (m :: * -> *).
MonadIO m =>
VideoCodecState -> m (Maybe Buffer)
getVideoCodecStateCodecData 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 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` Int
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
$ \Ptr Buffer
val' -> do
        Buffer
val'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed 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

-- | Set the value of the “@codec_data@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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 :: forall (m :: * -> *).
MonadIO m =>
VideoCodecState -> Ptr Buffer -> m ()
setVideoCodecStateCodecData VideoCodecState
s 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 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` Int
136) (Ptr Buffer
val :: Ptr Gst.Buffer.Buffer)

-- | Set the value of the “@codec_data@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #codecData
-- @
clearVideoCodecStateCodecData :: MonadIO m => VideoCodecState -> m ()
clearVideoCodecStateCodecData :: forall (m :: * -> *). MonadIO m => VideoCodecState -> m ()
clearVideoCodecStateCodecData 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 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` Int
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


-- | Get the value of the “@allocation_caps@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoCodecState #allocationCaps
-- @
getVideoCodecStateAllocationCaps :: MonadIO m => VideoCodecState -> m (Maybe Gst.Caps.Caps)
getVideoCodecStateAllocationCaps :: forall (m :: * -> *).
MonadIO m =>
VideoCodecState -> m (Maybe Caps)
getVideoCodecStateAllocationCaps 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 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` Int
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
$ \Ptr Caps
val' -> do
        Caps
val'' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed 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

-- | Set the value of the “@allocation_caps@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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 :: forall (m :: * -> *).
MonadIO m =>
VideoCodecState -> Ptr Caps -> m ()
setVideoCodecStateAllocationCaps VideoCodecState
s 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 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` Int
144) (Ptr Caps
val :: Ptr Gst.Caps.Caps)

-- | Set the value of the “@allocation_caps@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #allocationCaps
-- @
clearVideoCodecStateAllocationCaps :: MonadIO m => VideoCodecState -> m ()
clearVideoCodecStateAllocationCaps :: forall (m :: * -> *). MonadIO m => VideoCodecState -> m ()
clearVideoCodecStateAllocationCaps 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 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` Int
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

-- 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 t'GI.GstVideo.Structs.VideoCodecState.VideoCodecState'
    -> m VideoCodecState
    -- ^ __Returns:__ /@buf@/
videoCodecStateRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoCodecState -> m VideoCodecState
videoCodecStateRef 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 Text
"videoCodecStateRef" Ptr VideoCodecState
result
    VideoCodecState
result' <- ((ManagedPtr VideoCodecState -> VideoCodecState)
-> Ptr VideoCodecState -> IO VideoCodecState
forall a.
(HasCallStack, GBoxed 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.OverloadedMethod VideoCodecStateRefMethodInfo VideoCodecState signature where
    overloadedMethod = videoCodecStateRef

instance O.OverloadedMethodInfo VideoCodecStateRefMethodInfo VideoCodecState where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GstVideo.Structs.VideoCodecState.videoCodecStateRef",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.24/docs/GI-GstVideo-Structs-VideoCodecState.html#v: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 t'GI.GstVideo.Structs.VideoCodecState.VideoCodecState'
    -> m ()
videoCodecStateUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoCodecState -> m ()
videoCodecStateUnref 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.OverloadedMethod VideoCodecStateUnrefMethodInfo VideoCodecState signature where
    overloadedMethod = videoCodecStateUnref

instance O.OverloadedMethodInfo VideoCodecStateUnrefMethodInfo VideoCodecState where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GstVideo.Structs.VideoCodecState.videoCodecStateUnref",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.24/docs/GI-GstVideo-Structs-VideoCodecState.html#v: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.OverloadedMethod 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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveVideoCodecStateMethod t VideoCodecState, O.OverloadedMethod info VideoCodecState p, R.HasField t VideoCodecState p) => R.HasField t VideoCodecState p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveVideoCodecStateMethod t VideoCodecState, O.OverloadedMethodInfo info VideoCodecState) => OL.IsLabel t (O.MethodProxy info VideoCodecState) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif