{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A t'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' represents a video frame both in raw and
-- encoded form.

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

module GI.GstVideo.Structs.VideoCodecFrame
    ( 

-- * Exported types
    VideoCodecFrame(..)                     ,
    newZeroVideoCodecFrame                  ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveVideoCodecFrameMethod            ,
#endif


-- ** getUserData #method:getUserData#

#if defined(ENABLE_OVERLOADING)
    VideoCodecFrameGetUserDataMethodInfo    ,
#endif
    videoCodecFrameGetUserData              ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    VideoCodecFrameRefMethodInfo            ,
#endif
    videoCodecFrameRef                      ,


-- ** setUserData #method:setUserData#

#if defined(ENABLE_OVERLOADING)
    VideoCodecFrameSetUserDataMethodInfo    ,
#endif
    videoCodecFrameSetUserData              ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    VideoCodecFrameUnrefMethodInfo          ,
#endif
    videoCodecFrameUnref                    ,




 -- * Properties
-- ** deadline #attr:deadline#
-- | Running time when the frame will be used.

    getVideoCodecFrameDeadline              ,
    setVideoCodecFrameDeadline              ,
#if defined(ENABLE_OVERLOADING)
    videoCodecFrame_deadline                ,
#endif


-- ** distanceFromSync #attr:distanceFromSync#
-- | Distance in frames from the last synchronization point.

    getVideoCodecFrameDistanceFromSync      ,
    setVideoCodecFrameDistanceFromSync      ,
#if defined(ENABLE_OVERLOADING)
    videoCodecFrame_distanceFromSync        ,
#endif


-- ** dts #attr:dts#
-- | Decoding timestamp

    getVideoCodecFrameDts                   ,
    setVideoCodecFrameDts                   ,
#if defined(ENABLE_OVERLOADING)
    videoCodecFrame_dts                     ,
#endif


-- ** duration #attr:duration#
-- | Duration of the frame

    getVideoCodecFrameDuration              ,
    setVideoCodecFrameDuration              ,
#if defined(ENABLE_OVERLOADING)
    videoCodecFrame_duration                ,
#endif


-- ** inputBuffer #attr:inputBuffer#
-- | the input t'GI.Gst.Structs.Buffer.Buffer' that created this frame. The buffer is owned
--           by the frame and references to the frame instead of the buffer should
--           be kept.

    clearVideoCodecFrameInputBuffer         ,
    getVideoCodecFrameInputBuffer           ,
    setVideoCodecFrameInputBuffer           ,
#if defined(ENABLE_OVERLOADING)
    videoCodecFrame_inputBuffer             ,
#endif


-- ** outputBuffer #attr:outputBuffer#
-- | the output t'GI.Gst.Structs.Buffer.Buffer'. Implementations should set this either
--           directly, or by using the
--           /@gstVideoDecoderAllocateOutputFrame@/() or
--           /@gstVideoDecoderAllocateOutputBuffer@/() methods. The buffer is
--           owned by the frame and references to the frame instead of the
--           buffer should be kept.

    clearVideoCodecFrameOutputBuffer        ,
    getVideoCodecFrameOutputBuffer          ,
    setVideoCodecFrameOutputBuffer          ,
#if defined(ENABLE_OVERLOADING)
    videoCodecFrame_outputBuffer            ,
#endif


-- ** pts #attr:pts#
-- | Presentation timestamp

    getVideoCodecFramePts                   ,
    setVideoCodecFramePts                   ,
#if defined(ENABLE_OVERLOADING)
    videoCodecFrame_pts                     ,
#endif


-- ** systemFrameNumber #attr:systemFrameNumber#
-- | Unique identifier for the frame. Use this if you need
--       to get hold of the frame later (like when data is being decoded).
--       Typical usage in decoders is to set this on the opaque value provided
--       to the library and get back the frame using 'GI.GstVideo.Objects.VideoDecoder.videoDecoderGetFrame'

    getVideoCodecFrameSystemFrameNumber     ,
    setVideoCodecFrameSystemFrameNumber     ,
#if defined(ENABLE_OVERLOADING)
    videoCodecFrame_systemFrameNumber       ,
#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.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 GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.Gst.Structs.Buffer as Gst.Buffer

-- | Memory-managed wrapper type.
newtype VideoCodecFrame = VideoCodecFrame (SP.ManagedPtr VideoCodecFrame)
    deriving (VideoCodecFrame -> VideoCodecFrame -> Bool
(VideoCodecFrame -> VideoCodecFrame -> Bool)
-> (VideoCodecFrame -> VideoCodecFrame -> Bool)
-> Eq VideoCodecFrame
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoCodecFrame -> VideoCodecFrame -> Bool
$c/= :: VideoCodecFrame -> VideoCodecFrame -> Bool
== :: VideoCodecFrame -> VideoCodecFrame -> Bool
$c== :: VideoCodecFrame -> VideoCodecFrame -> Bool
Eq)

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

foreign import ccall "gst_video_codec_frame_get_type" c_gst_video_codec_frame_get_type :: 
    IO GType

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

instance B.Types.TypedObject VideoCodecFrame where
    glibType :: IO GType
glibType = IO GType
c_gst_video_codec_frame_get_type

instance B.Types.GBoxed VideoCodecFrame

-- | Convert 'VideoCodecFrame' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue VideoCodecFrame where
    toGValue :: VideoCodecFrame -> IO GValue
toGValue VideoCodecFrame
o = do
        GType
gtype <- IO GType
c_gst_video_codec_frame_get_type
        VideoCodecFrame -> (Ptr VideoCodecFrame -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VideoCodecFrame
o (GType
-> (GValue -> Ptr VideoCodecFrame -> IO ())
-> Ptr VideoCodecFrame
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr VideoCodecFrame -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
        
    fromGValue :: GValue -> IO VideoCodecFrame
fromGValue GValue
gv = do
        Ptr VideoCodecFrame
ptr <- GValue -> IO (Ptr VideoCodecFrame)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr VideoCodecFrame)
        (ManagedPtr VideoCodecFrame -> VideoCodecFrame)
-> Ptr VideoCodecFrame -> IO VideoCodecFrame
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr VideoCodecFrame -> VideoCodecFrame
VideoCodecFrame Ptr VideoCodecFrame
ptr
        
    

-- | Construct a `VideoCodecFrame` struct initialized to zero.
newZeroVideoCodecFrame :: MonadIO m => m VideoCodecFrame
newZeroVideoCodecFrame :: m VideoCodecFrame
newZeroVideoCodecFrame = IO VideoCodecFrame -> m VideoCodecFrame
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoCodecFrame -> m VideoCodecFrame)
-> IO VideoCodecFrame -> m VideoCodecFrame
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr VideoCodecFrame)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
104 IO (Ptr VideoCodecFrame)
-> (Ptr VideoCodecFrame -> IO VideoCodecFrame)
-> IO VideoCodecFrame
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr VideoCodecFrame -> VideoCodecFrame)
-> Ptr VideoCodecFrame -> IO VideoCodecFrame
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoCodecFrame -> VideoCodecFrame
VideoCodecFrame

instance tag ~ 'AttrSet => Constructible VideoCodecFrame tag where
    new :: (ManagedPtr VideoCodecFrame -> VideoCodecFrame)
-> [AttrOp VideoCodecFrame tag] -> m VideoCodecFrame
new ManagedPtr VideoCodecFrame -> VideoCodecFrame
_ [AttrOp VideoCodecFrame tag]
attrs = do
        VideoCodecFrame
o <- m VideoCodecFrame
forall (m :: * -> *). MonadIO m => m VideoCodecFrame
newZeroVideoCodecFrame
        VideoCodecFrame -> [AttrOp VideoCodecFrame 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set VideoCodecFrame
o [AttrOp VideoCodecFrame tag]
[AttrOp VideoCodecFrame 'AttrSet]
attrs
        VideoCodecFrame -> m VideoCodecFrame
forall (m :: * -> *) a. Monad m => a -> m a
return VideoCodecFrame
o


-- | Get the value of the “@system_frame_number@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoCodecFrame #systemFrameNumber
-- @
getVideoCodecFrameSystemFrameNumber :: MonadIO m => VideoCodecFrame -> m Word32
getVideoCodecFrameSystemFrameNumber :: VideoCodecFrame -> m Word32
getVideoCodecFrameSystemFrameNumber VideoCodecFrame
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
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO Word32) -> IO Word32)
-> (Ptr VideoCodecFrame -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word32
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@system_frame_number@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoCodecFrame [ #systemFrameNumber 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoCodecFrameSystemFrameNumber :: MonadIO m => VideoCodecFrame -> Word32 -> m ()
setVideoCodecFrameSystemFrameNumber :: VideoCodecFrame -> Word32 -> m ()
setVideoCodecFrameSystemFrameNumber VideoCodecFrame
s 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
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO ()) -> IO ())
-> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data VideoCodecFrameSystemFrameNumberFieldInfo
instance AttrInfo VideoCodecFrameSystemFrameNumberFieldInfo where
    type AttrBaseTypeConstraint VideoCodecFrameSystemFrameNumberFieldInfo = (~) VideoCodecFrame
    type AttrAllowedOps VideoCodecFrameSystemFrameNumberFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoCodecFrameSystemFrameNumberFieldInfo = (~) Word32
    type AttrTransferTypeConstraint VideoCodecFrameSystemFrameNumberFieldInfo = (~)Word32
    type AttrTransferType VideoCodecFrameSystemFrameNumberFieldInfo = Word32
    type AttrGetType VideoCodecFrameSystemFrameNumberFieldInfo = Word32
    type AttrLabel VideoCodecFrameSystemFrameNumberFieldInfo = "system_frame_number"
    type AttrOrigin VideoCodecFrameSystemFrameNumberFieldInfo = VideoCodecFrame
    attrGet = getVideoCodecFrameSystemFrameNumber
    attrSet = setVideoCodecFrameSystemFrameNumber
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoCodecFrame_systemFrameNumber :: AttrLabelProxy "systemFrameNumber"
videoCodecFrame_systemFrameNumber = AttrLabelProxy

#endif


-- | Get the value of the “@dts@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoCodecFrame #dts
-- @
getVideoCodecFrameDts :: MonadIO m => VideoCodecFrame -> m Word64
getVideoCodecFrameDts :: VideoCodecFrame -> m Word64
getVideoCodecFrameDts VideoCodecFrame
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO Word64) -> IO Word64)
-> (Ptr VideoCodecFrame -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO Word64
    Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val

-- | Set the value of the “@dts@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoCodecFrame [ #dts 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoCodecFrameDts :: MonadIO m => VideoCodecFrame -> Word64 -> m ()
setVideoCodecFrameDts :: VideoCodecFrame -> Word64 -> m ()
setVideoCodecFrameDts VideoCodecFrame
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO ()) -> IO ())
-> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Word64
val :: Word64)

#if defined(ENABLE_OVERLOADING)
data VideoCodecFrameDtsFieldInfo
instance AttrInfo VideoCodecFrameDtsFieldInfo where
    type AttrBaseTypeConstraint VideoCodecFrameDtsFieldInfo = (~) VideoCodecFrame
    type AttrAllowedOps VideoCodecFrameDtsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoCodecFrameDtsFieldInfo = (~) Word64
    type AttrTransferTypeConstraint VideoCodecFrameDtsFieldInfo = (~)Word64
    type AttrTransferType VideoCodecFrameDtsFieldInfo = Word64
    type AttrGetType VideoCodecFrameDtsFieldInfo = Word64
    type AttrLabel VideoCodecFrameDtsFieldInfo = "dts"
    type AttrOrigin VideoCodecFrameDtsFieldInfo = VideoCodecFrame
    attrGet = getVideoCodecFrameDts
    attrSet = setVideoCodecFrameDts
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoCodecFrame_dts :: AttrLabelProxy "dts"
videoCodecFrame_dts = AttrLabelProxy

#endif


-- | Get the value of the “@pts@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoCodecFrame #pts
-- @
getVideoCodecFramePts :: MonadIO m => VideoCodecFrame -> m Word64
getVideoCodecFramePts :: VideoCodecFrame -> m Word64
getVideoCodecFramePts VideoCodecFrame
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO Word64) -> IO Word64)
-> (Ptr VideoCodecFrame -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO Word64
    Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val

-- | Set the value of the “@pts@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoCodecFrame [ #pts 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoCodecFramePts :: MonadIO m => VideoCodecFrame -> Word64 -> m ()
setVideoCodecFramePts :: VideoCodecFrame -> Word64 -> m ()
setVideoCodecFramePts VideoCodecFrame
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO ()) -> IO ())
-> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Word64
val :: Word64)

#if defined(ENABLE_OVERLOADING)
data VideoCodecFramePtsFieldInfo
instance AttrInfo VideoCodecFramePtsFieldInfo where
    type AttrBaseTypeConstraint VideoCodecFramePtsFieldInfo = (~) VideoCodecFrame
    type AttrAllowedOps VideoCodecFramePtsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoCodecFramePtsFieldInfo = (~) Word64
    type AttrTransferTypeConstraint VideoCodecFramePtsFieldInfo = (~)Word64
    type AttrTransferType VideoCodecFramePtsFieldInfo = Word64
    type AttrGetType VideoCodecFramePtsFieldInfo = Word64
    type AttrLabel VideoCodecFramePtsFieldInfo = "pts"
    type AttrOrigin VideoCodecFramePtsFieldInfo = VideoCodecFrame
    attrGet = getVideoCodecFramePts
    attrSet = setVideoCodecFramePts
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoCodecFrame_pts :: AttrLabelProxy "pts"
videoCodecFrame_pts = AttrLabelProxy

#endif


-- | Get the value of the “@duration@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoCodecFrame #duration
-- @
getVideoCodecFrameDuration :: MonadIO m => VideoCodecFrame -> m Word64
getVideoCodecFrameDuration :: VideoCodecFrame -> m Word64
getVideoCodecFrameDuration VideoCodecFrame
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO Word64) -> IO Word64)
-> (Ptr VideoCodecFrame -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO Word64
    Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val

-- | Set the value of the “@duration@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoCodecFrame [ #duration 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoCodecFrameDuration :: MonadIO m => VideoCodecFrame -> Word64 -> m ()
setVideoCodecFrameDuration :: VideoCodecFrame -> Word64 -> m ()
setVideoCodecFrameDuration VideoCodecFrame
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO ()) -> IO ())
-> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (Word64
val :: Word64)

#if defined(ENABLE_OVERLOADING)
data VideoCodecFrameDurationFieldInfo
instance AttrInfo VideoCodecFrameDurationFieldInfo where
    type AttrBaseTypeConstraint VideoCodecFrameDurationFieldInfo = (~) VideoCodecFrame
    type AttrAllowedOps VideoCodecFrameDurationFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoCodecFrameDurationFieldInfo = (~) Word64
    type AttrTransferTypeConstraint VideoCodecFrameDurationFieldInfo = (~)Word64
    type AttrTransferType VideoCodecFrameDurationFieldInfo = Word64
    type AttrGetType VideoCodecFrameDurationFieldInfo = Word64
    type AttrLabel VideoCodecFrameDurationFieldInfo = "duration"
    type AttrOrigin VideoCodecFrameDurationFieldInfo = VideoCodecFrame
    attrGet = getVideoCodecFrameDuration
    attrSet = setVideoCodecFrameDuration
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoCodecFrame_duration :: AttrLabelProxy "duration"
videoCodecFrame_duration = AttrLabelProxy

#endif


-- | Get the value of the “@distance_from_sync@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoCodecFrame #distanceFromSync
-- @
getVideoCodecFrameDistanceFromSync :: MonadIO m => VideoCodecFrame -> m Int32
getVideoCodecFrameDistanceFromSync :: VideoCodecFrame -> m Int32
getVideoCodecFrameDistanceFromSync VideoCodecFrame
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO Int32) -> IO Int32)
-> (Ptr VideoCodecFrame -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@distance_from_sync@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoCodecFrame [ #distanceFromSync 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoCodecFrameDistanceFromSync :: MonadIO m => VideoCodecFrame -> Int32 -> m ()
setVideoCodecFrameDistanceFromSync :: VideoCodecFrame -> Int32 -> m ()
setVideoCodecFrameDistanceFromSync VideoCodecFrame
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO ()) -> IO ())
-> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data VideoCodecFrameDistanceFromSyncFieldInfo
instance AttrInfo VideoCodecFrameDistanceFromSyncFieldInfo where
    type AttrBaseTypeConstraint VideoCodecFrameDistanceFromSyncFieldInfo = (~) VideoCodecFrame
    type AttrAllowedOps VideoCodecFrameDistanceFromSyncFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoCodecFrameDistanceFromSyncFieldInfo = (~) Int32
    type AttrTransferTypeConstraint VideoCodecFrameDistanceFromSyncFieldInfo = (~)Int32
    type AttrTransferType VideoCodecFrameDistanceFromSyncFieldInfo = Int32
    type AttrGetType VideoCodecFrameDistanceFromSyncFieldInfo = Int32
    type AttrLabel VideoCodecFrameDistanceFromSyncFieldInfo = "distance_from_sync"
    type AttrOrigin VideoCodecFrameDistanceFromSyncFieldInfo = VideoCodecFrame
    attrGet = getVideoCodecFrameDistanceFromSync
    attrSet = setVideoCodecFrameDistanceFromSync
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoCodecFrame_distanceFromSync :: AttrLabelProxy "distanceFromSync"
videoCodecFrame_distanceFromSync = AttrLabelProxy

#endif


-- | Get the value of the “@input_buffer@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoCodecFrame #inputBuffer
-- @
getVideoCodecFrameInputBuffer :: MonadIO m => VideoCodecFrame -> m (Maybe Gst.Buffer.Buffer)
getVideoCodecFrameInputBuffer :: VideoCodecFrame -> m (Maybe Buffer)
getVideoCodecFrameInputBuffer VideoCodecFrame
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
$ VideoCodecFrame
-> (Ptr VideoCodecFrame -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO (Maybe Buffer)) -> IO (Maybe Buffer))
-> (Ptr VideoCodecFrame -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Ptr Buffer
val <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) :: 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 “@input_buffer@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoCodecFrame [ #inputBuffer 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoCodecFrameInputBuffer :: MonadIO m => VideoCodecFrame -> Ptr Gst.Buffer.Buffer -> m ()
setVideoCodecFrameInputBuffer :: VideoCodecFrame -> Ptr Buffer -> m ()
setVideoCodecFrameInputBuffer VideoCodecFrame
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
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO ()) -> IO ())
-> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (Ptr Buffer
val :: Ptr Gst.Buffer.Buffer)

-- | Set the value of the “@input_buffer@” 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' #inputBuffer
-- @
clearVideoCodecFrameInputBuffer :: MonadIO m => VideoCodecFrame -> m ()
clearVideoCodecFrameInputBuffer :: VideoCodecFrame -> m ()
clearVideoCodecFrameInputBuffer VideoCodecFrame
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO ()) -> IO ())
-> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (Ptr Buffer
forall a. Ptr a
FP.nullPtr :: Ptr Gst.Buffer.Buffer)

#if defined(ENABLE_OVERLOADING)
data VideoCodecFrameInputBufferFieldInfo
instance AttrInfo VideoCodecFrameInputBufferFieldInfo where
    type AttrBaseTypeConstraint VideoCodecFrameInputBufferFieldInfo = (~) VideoCodecFrame
    type AttrAllowedOps VideoCodecFrameInputBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint VideoCodecFrameInputBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer)
    type AttrTransferTypeConstraint VideoCodecFrameInputBufferFieldInfo = (~)(Ptr Gst.Buffer.Buffer)
    type AttrTransferType VideoCodecFrameInputBufferFieldInfo = (Ptr Gst.Buffer.Buffer)
    type AttrGetType VideoCodecFrameInputBufferFieldInfo = Maybe Gst.Buffer.Buffer
    type AttrLabel VideoCodecFrameInputBufferFieldInfo = "input_buffer"
    type AttrOrigin VideoCodecFrameInputBufferFieldInfo = VideoCodecFrame
    attrGet = getVideoCodecFrameInputBuffer
    attrSet = setVideoCodecFrameInputBuffer
    attrConstruct = undefined
    attrClear = clearVideoCodecFrameInputBuffer
    attrTransfer _ v = do
        return v

videoCodecFrame_inputBuffer :: AttrLabelProxy "inputBuffer"
videoCodecFrame_inputBuffer = AttrLabelProxy

#endif


-- | Get the value of the “@output_buffer@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoCodecFrame #outputBuffer
-- @
getVideoCodecFrameOutputBuffer :: MonadIO m => VideoCodecFrame -> m (Maybe Gst.Buffer.Buffer)
getVideoCodecFrameOutputBuffer :: VideoCodecFrame -> m (Maybe Buffer)
getVideoCodecFrameOutputBuffer VideoCodecFrame
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
$ VideoCodecFrame
-> (Ptr VideoCodecFrame -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO (Maybe Buffer)) -> IO (Maybe Buffer))
-> (Ptr VideoCodecFrame -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Ptr Buffer
val <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) :: 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 “@output_buffer@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoCodecFrame [ #outputBuffer 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoCodecFrameOutputBuffer :: MonadIO m => VideoCodecFrame -> Ptr Gst.Buffer.Buffer -> m ()
setVideoCodecFrameOutputBuffer :: VideoCodecFrame -> Ptr Buffer -> m ()
setVideoCodecFrameOutputBuffer VideoCodecFrame
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
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO ()) -> IO ())
-> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (Ptr Buffer
val :: Ptr Gst.Buffer.Buffer)

-- | Set the value of the “@output_buffer@” 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' #outputBuffer
-- @
clearVideoCodecFrameOutputBuffer :: MonadIO m => VideoCodecFrame -> m ()
clearVideoCodecFrameOutputBuffer :: VideoCodecFrame -> m ()
clearVideoCodecFrameOutputBuffer VideoCodecFrame
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO ()) -> IO ())
-> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (Ptr Buffer
forall a. Ptr a
FP.nullPtr :: Ptr Gst.Buffer.Buffer)

#if defined(ENABLE_OVERLOADING)
data VideoCodecFrameOutputBufferFieldInfo
instance AttrInfo VideoCodecFrameOutputBufferFieldInfo where
    type AttrBaseTypeConstraint VideoCodecFrameOutputBufferFieldInfo = (~) VideoCodecFrame
    type AttrAllowedOps VideoCodecFrameOutputBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint VideoCodecFrameOutputBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer)
    type AttrTransferTypeConstraint VideoCodecFrameOutputBufferFieldInfo = (~)(Ptr Gst.Buffer.Buffer)
    type AttrTransferType VideoCodecFrameOutputBufferFieldInfo = (Ptr Gst.Buffer.Buffer)
    type AttrGetType VideoCodecFrameOutputBufferFieldInfo = Maybe Gst.Buffer.Buffer
    type AttrLabel VideoCodecFrameOutputBufferFieldInfo = "output_buffer"
    type AttrOrigin VideoCodecFrameOutputBufferFieldInfo = VideoCodecFrame
    attrGet = getVideoCodecFrameOutputBuffer
    attrSet = setVideoCodecFrameOutputBuffer
    attrConstruct = undefined
    attrClear = clearVideoCodecFrameOutputBuffer
    attrTransfer _ v = do
        return v

videoCodecFrame_outputBuffer :: AttrLabelProxy "outputBuffer"
videoCodecFrame_outputBuffer = AttrLabelProxy

#endif


-- | Get the value of the “@deadline@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoCodecFrame #deadline
-- @
getVideoCodecFrameDeadline :: MonadIO m => VideoCodecFrame -> m Word64
getVideoCodecFrameDeadline :: VideoCodecFrame -> m Word64
getVideoCodecFrameDeadline VideoCodecFrame
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO Word64) -> IO Word64)
-> (Ptr VideoCodecFrame -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) :: IO Word64
    Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val

-- | Set the value of the “@deadline@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoCodecFrame [ #deadline 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoCodecFrameDeadline :: MonadIO m => VideoCodecFrame -> Word64 -> m ()
setVideoCodecFrameDeadline :: VideoCodecFrame -> Word64 -> m ()
setVideoCodecFrameDeadline VideoCodecFrame
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoCodecFrame -> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecFrame
s ((Ptr VideoCodecFrame -> IO ()) -> IO ())
-> (Ptr VideoCodecFrame -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecFrame
ptr -> do
    Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecFrame
ptr Ptr VideoCodecFrame -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) (Word64
val :: Word64)

#if defined(ENABLE_OVERLOADING)
data VideoCodecFrameDeadlineFieldInfo
instance AttrInfo VideoCodecFrameDeadlineFieldInfo where
    type AttrBaseTypeConstraint VideoCodecFrameDeadlineFieldInfo = (~) VideoCodecFrame
    type AttrAllowedOps VideoCodecFrameDeadlineFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoCodecFrameDeadlineFieldInfo = (~) Word64
    type AttrTransferTypeConstraint VideoCodecFrameDeadlineFieldInfo = (~)Word64
    type AttrTransferType VideoCodecFrameDeadlineFieldInfo = Word64
    type AttrGetType VideoCodecFrameDeadlineFieldInfo = Word64
    type AttrLabel VideoCodecFrameDeadlineFieldInfo = "deadline"
    type AttrOrigin VideoCodecFrameDeadlineFieldInfo = VideoCodecFrame
    attrGet = getVideoCodecFrameDeadline
    attrSet = setVideoCodecFrameDeadline
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoCodecFrame_deadline :: AttrLabelProxy "deadline"
videoCodecFrame_deadline = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoCodecFrame
type instance O.AttributeList VideoCodecFrame = VideoCodecFrameAttributeList
type VideoCodecFrameAttributeList = ('[ '("systemFrameNumber", VideoCodecFrameSystemFrameNumberFieldInfo), '("dts", VideoCodecFrameDtsFieldInfo), '("pts", VideoCodecFramePtsFieldInfo), '("duration", VideoCodecFrameDurationFieldInfo), '("distanceFromSync", VideoCodecFrameDistanceFromSyncFieldInfo), '("inputBuffer", VideoCodecFrameInputBufferFieldInfo), '("outputBuffer", VideoCodecFrameOutputBufferFieldInfo), '("deadline", VideoCodecFrameDeadlineFieldInfo)] :: [(Symbol, *)])
#endif

-- method VideoCodecFrame::get_user_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "frame"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoCodecFrame" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoCodecFrame"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_codec_frame_get_user_data" gst_video_codec_frame_get_user_data :: 
    Ptr VideoCodecFrame ->                  -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"})
    IO (Ptr ())

-- | Gets private data set on the frame by the subclass via
-- 'GI.GstVideo.Structs.VideoCodecFrame.videoCodecFrameSetUserData' previously.
videoCodecFrameGetUserData ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoCodecFrame
    -- ^ /@frame@/: a t'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame'
    -> m (Ptr ())
    -- ^ __Returns:__ The previously set user_data
videoCodecFrameGetUserData :: VideoCodecFrame -> m (Ptr ())
videoCodecFrameGetUserData VideoCodecFrame
frame = IO (Ptr ()) -> m (Ptr ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoCodecFrame
frame' <- VideoCodecFrame -> IO (Ptr VideoCodecFrame)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoCodecFrame
frame
    Ptr ()
result <- Ptr VideoCodecFrame -> IO (Ptr ())
gst_video_codec_frame_get_user_data Ptr VideoCodecFrame
frame'
    VideoCodecFrame -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoCodecFrame
frame
    Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result

#if defined(ENABLE_OVERLOADING)
data VideoCodecFrameGetUserDataMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m) => O.MethodInfo VideoCodecFrameGetUserDataMethodInfo VideoCodecFrame signature where
    overloadedMethod = videoCodecFrameGetUserData

#endif

-- method VideoCodecFrame::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "frame"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoCodecFrame" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoCodecFrame"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GstVideo" , name = "VideoCodecFrame" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_codec_frame_ref" gst_video_codec_frame_ref :: 
    Ptr VideoCodecFrame ->                  -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"})
    IO (Ptr VideoCodecFrame)

-- | Increases the refcount of the given frame by one.
videoCodecFrameRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoCodecFrame
    -- ^ /@frame@/: a t'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame'
    -> m VideoCodecFrame
    -- ^ __Returns:__ /@buf@/
videoCodecFrameRef :: VideoCodecFrame -> m VideoCodecFrame
videoCodecFrameRef VideoCodecFrame
frame = IO VideoCodecFrame -> m VideoCodecFrame
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoCodecFrame -> m VideoCodecFrame)
-> IO VideoCodecFrame -> m VideoCodecFrame
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoCodecFrame
frame' <- VideoCodecFrame -> IO (Ptr VideoCodecFrame)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoCodecFrame
frame
    Ptr VideoCodecFrame
result <- Ptr VideoCodecFrame -> IO (Ptr VideoCodecFrame)
gst_video_codec_frame_ref Ptr VideoCodecFrame
frame'
    Text -> Ptr VideoCodecFrame -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoCodecFrameRef" Ptr VideoCodecFrame
result
    VideoCodecFrame
result' <- ((ManagedPtr VideoCodecFrame -> VideoCodecFrame)
-> Ptr VideoCodecFrame -> IO VideoCodecFrame
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoCodecFrame -> VideoCodecFrame
VideoCodecFrame) Ptr VideoCodecFrame
result
    VideoCodecFrame -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoCodecFrame
frame
    VideoCodecFrame -> IO VideoCodecFrame
forall (m :: * -> *) a. Monad m => a -> m a
return VideoCodecFrame
result'

#if defined(ENABLE_OVERLOADING)
data VideoCodecFrameRefMethodInfo
instance (signature ~ (m VideoCodecFrame), MonadIO m) => O.MethodInfo VideoCodecFrameRefMethodInfo VideoCodecFrame signature where
    overloadedMethod = videoCodecFrameRef

#endif

-- method VideoCodecFrame::set_user_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "frame"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoCodecFrame" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoCodecFrame"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "private data" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "notify"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GDestroyNotify" , sinceVersion = Nothing }
--           , argScope = ScopeTypeAsync
--           , argClosure = 1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_codec_frame_set_user_data" gst_video_codec_frame_set_user_data :: 
    Ptr VideoCodecFrame ->                  -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

-- | Sets /@userData@/ on the frame and the t'GI.GLib.Callbacks.DestroyNotify' that will be called when
-- the frame is freed. Allows to attach private data by the subclass to frames.
-- 
-- If a /@userData@/ was previously set, then the previous set /@notify@/ will be called
-- before the /@userData@/ is replaced.
videoCodecFrameSetUserData ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoCodecFrame
    -- ^ /@frame@/: a t'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame'
    -> GLib.Callbacks.DestroyNotify
    -- ^ /@notify@/: a t'GI.GLib.Callbacks.DestroyNotify'
    -> m ()
videoCodecFrameSetUserData :: VideoCodecFrame -> DestroyNotify -> m ()
videoCodecFrameSetUserData VideoCodecFrame
frame DestroyNotify
notify = 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 VideoCodecFrame
frame' <- VideoCodecFrame -> IO (Ptr VideoCodecFrame)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoCodecFrame
frame
    Ptr (FunPtr DestroyNotify)
ptrnotify <- IO (Ptr (FunPtr DestroyNotify))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
    FunPtr DestroyNotify
notify' <- DestroyNotify -> IO (FunPtr DestroyNotify)
GLib.Callbacks.mk_DestroyNotify (Maybe (Ptr (FunPtr DestroyNotify))
-> DestroyNotify -> DestroyNotify
GLib.Callbacks.wrap_DestroyNotify (Ptr (FunPtr DestroyNotify) -> Maybe (Ptr (FunPtr DestroyNotify))
forall a. a -> Maybe a
Just Ptr (FunPtr DestroyNotify)
ptrnotify) DestroyNotify
notify)
    Ptr (FunPtr DestroyNotify) -> FunPtr DestroyNotify -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr DestroyNotify)
ptrnotify FunPtr DestroyNotify
notify'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr VideoCodecFrame -> Ptr () -> FunPtr DestroyNotify -> IO ()
gst_video_codec_frame_set_user_data Ptr VideoCodecFrame
frame' Ptr ()
forall a. Ptr a
userData FunPtr DestroyNotify
notify'
    VideoCodecFrame -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoCodecFrame
frame
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VideoCodecFrameSetUserDataMethodInfo
instance (signature ~ (GLib.Callbacks.DestroyNotify -> m ()), MonadIO m) => O.MethodInfo VideoCodecFrameSetUserDataMethodInfo VideoCodecFrame signature where
    overloadedMethod = videoCodecFrameSetUserData

#endif

-- method VideoCodecFrame::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "frame"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoCodecFrame" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoCodecFrame"
--                 , 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_frame_unref" gst_video_codec_frame_unref :: 
    Ptr VideoCodecFrame ->                  -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"})
    IO ()

-- | Decreases the refcount of the frame. If the refcount reaches 0, the frame
-- will be freed.
videoCodecFrameUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoCodecFrame
    -- ^ /@frame@/: a t'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame'
    -> m ()
videoCodecFrameUnref :: VideoCodecFrame -> m ()
videoCodecFrameUnref VideoCodecFrame
frame = 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 VideoCodecFrame
frame' <- VideoCodecFrame -> IO (Ptr VideoCodecFrame)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoCodecFrame
frame
    Ptr VideoCodecFrame -> IO ()
gst_video_codec_frame_unref Ptr VideoCodecFrame
frame'
    VideoCodecFrame -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoCodecFrame
frame
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VideoCodecFrameUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoCodecFrameUnrefMethodInfo VideoCodecFrame signature where
    overloadedMethod = videoCodecFrameUnref

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveVideoCodecFrameMethod (t :: Symbol) (o :: *) :: * where
    ResolveVideoCodecFrameMethod "ref" o = VideoCodecFrameRefMethodInfo
    ResolveVideoCodecFrameMethod "unref" o = VideoCodecFrameUnrefMethodInfo
    ResolveVideoCodecFrameMethod "getUserData" o = VideoCodecFrameGetUserDataMethodInfo
    ResolveVideoCodecFrameMethod "setUserData" o = VideoCodecFrameSetUserDataMethodInfo
    ResolveVideoCodecFrameMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveVideoCodecFrameMethod t VideoCodecFrame, O.MethodInfo info VideoCodecFrame p) => OL.IsLabel t (VideoCodecFrame -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif