gi-gstvideo-1.0.18: GI/GstVideo/Structs/VideoCodecFrame.hs

{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

A 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' represents a video frame both in raw and
encoded form.
-}

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

module GI.GstVideo.Structs.VideoCodecFrame
    ( 

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


 -- * Methods
-- ** getUserData #method:getUserData#

#if ENABLE_OVERLOADING
    VideoCodecFrameGetUserDataMethodInfo    ,
#endif
    videoCodecFrameGetUserData              ,


-- ** ref #method:ref#

#if ENABLE_OVERLOADING
    VideoCodecFrameRefMethodInfo            ,
#endif
    videoCodecFrameRef                      ,


-- ** setUserData #method:setUserData#

#if ENABLE_OVERLOADING
    VideoCodecFrameSetUserDataMethodInfo    ,
#endif
    videoCodecFrameSetUserData              ,


-- ** unref #method:unref#

#if ENABLE_OVERLOADING
    VideoCodecFrameUnrefMethodInfo          ,
#endif
    videoCodecFrameUnref                    ,




 -- * Properties
-- ** deadline #attr:deadline#
{- | Running time when the frame will be used.
-}
    getVideoCodecFrameDeadline              ,
    setVideoCodecFrameDeadline              ,
#if ENABLE_OVERLOADING
    videoCodecFrame_deadline                ,
#endif


-- ** distanceFromSync #attr:distanceFromSync#
{- | Distance in frames from the last synchronization point.
-}
    getVideoCodecFrameDistanceFromSync      ,
    setVideoCodecFrameDistanceFromSync      ,
#if ENABLE_OVERLOADING
    videoCodecFrame_distanceFromSync        ,
#endif


-- ** dts #attr:dts#
{- | Decoding timestamp
-}
    getVideoCodecFrameDts                   ,
    setVideoCodecFrameDts                   ,
#if ENABLE_OVERLOADING
    videoCodecFrame_dts                     ,
#endif


-- ** duration #attr:duration#
{- | Duration of the frame
-}
    getVideoCodecFrameDuration              ,
    setVideoCodecFrameDuration              ,
#if ENABLE_OVERLOADING
    videoCodecFrame_duration                ,
#endif


-- ** inputBuffer #attr:inputBuffer#
{- | the input '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 ENABLE_OVERLOADING
    videoCodecFrame_inputBuffer             ,
#endif


-- ** outputBuffer #attr:outputBuffer#
{- | the output '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 ENABLE_OVERLOADING
    videoCodecFrame_outputBuffer            ,
#endif


-- ** pts #attr:pts#
{- | Presentation timestamp
-}
    getVideoCodecFramePts                   ,
    setVideoCodecFramePts                   ,
#if 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 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.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.GLib.Callbacks as GLib.Callbacks
import qualified GI.Gst.Structs.Buffer as Gst.Buffer

-- | Memory-managed wrapper type.
newtype VideoCodecFrame = VideoCodecFrame (ManagedPtr VideoCodecFrame)
foreign import ccall "gst_video_codec_frame_get_type" c_gst_video_codec_frame_get_type :: 
    IO GType

instance BoxedObject VideoCodecFrame where
    boxedType _ = c_gst_video_codec_frame_get_type

-- | Construct a `VideoCodecFrame` struct initialized to zero.
newZeroVideoCodecFrame :: MonadIO m => m VideoCodecFrame
newZeroVideoCodecFrame = liftIO $ callocBoxedBytes 104 >>= wrapBoxed VideoCodecFrame

instance tag ~ 'AttrSet => Constructible VideoCodecFrame tag where
    new _ attrs = do
        o <- newZeroVideoCodecFrame
        GI.Attributes.set o attrs
        return o


-- | A convenience alias for `Nothing` :: `Maybe` `VideoCodecFrame`.
noVideoCodecFrame :: Maybe VideoCodecFrame
noVideoCodecFrame = Nothing

{- |
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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO Word32
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Word32)

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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word64
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word64)

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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Word64
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Word64)

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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO Word64
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 40) (val :: Word64)

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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 48) :: IO Int32
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 48) (val :: Int32)

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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 56) :: 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 “@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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 56) (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 s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 56) (FP.nullPtr :: Ptr Gst.Buffer.Buffer)

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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 64) :: 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 “@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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 64) (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 s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 64) (FP.nullPtr :: Ptr Gst.Buffer.Buffer)

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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 72) :: IO Word64
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 72) (val :: Word64)

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

videoCodecFrame_deadline :: AttrLabelProxy "deadline"
videoCodecFrame_deadline = AttrLabelProxy

#endif



#if 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 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -}
    -> m (Ptr ())
    {- ^ __Returns:__ The previously set user_data -}
videoCodecFrameGetUserData frame = liftIO $ do
    frame' <- unsafeManagedPtrGetPtr frame
    result <- gst_video_codec_frame_get_user_data frame'
    touchManagedPtr frame
    return result

#if 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 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -}
    -> m VideoCodecFrame
    {- ^ __Returns:__ /@buf@/ -}
videoCodecFrameRef frame = liftIO $ do
    frame' <- unsafeManagedPtrGetPtr frame
    result <- gst_video_codec_frame_ref frame'
    checkUnexpectedReturnNULL "videoCodecFrameRef" result
    result' <- (wrapBoxed VideoCodecFrame) result
    touchManagedPtr frame
    return result'

#if 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 '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 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -}
    -> GLib.Callbacks.DestroyNotify
    {- ^ /@notify@/: a 'GI.GLib.Callbacks.DestroyNotify' -}
    -> m ()
videoCodecFrameSetUserData frame notify = liftIO $ do
    frame' <- unsafeManagedPtrGetPtr frame
    ptrnotify <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
    notify' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrnotify) notify)
    poke ptrnotify notify'
    let userData = nullPtr
    gst_video_codec_frame_set_user_data frame' userData notify'
    touchManagedPtr frame
    return ()

#if 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 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -}
    -> m ()
videoCodecFrameUnref frame = liftIO $ do
    frame' <- unsafeManagedPtrGetPtr frame
    gst_video_codec_frame_unref frame'
    touchManagedPtr frame
    return ()

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

#endif

#if 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 (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif