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

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

module GI.GstVideo.Structs.VideoCodecFrame
    ( 

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


 -- * Methods
-- ** getUserData #method:getUserData#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    VideoCodecFrameGetUserDataMethodInfo    ,
#endif
    videoCodecFrameGetUserData              ,


-- ** ref #method:ref#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    VideoCodecFrameRefMethodInfo            ,
#endif
    videoCodecFrameRef                      ,


-- ** setUserData #method:setUserData#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    VideoCodecFrameSetUserDataMethodInfo    ,
#endif
    videoCodecFrameSetUserData              ,


-- ** unref #method:unref#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    VideoCodecFrameUnrefMethodInfo          ,
#endif
    videoCodecFrameUnref                    ,




 -- * Properties
-- ** deadline #attr:deadline#
    getVideoCodecFrameDeadline              ,
    setVideoCodecFrameDeadline              ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoCodecFrame_deadline                ,
#endif


-- ** decodeFrameNumber #attr:decodeFrameNumber#
    getVideoCodecFrameDecodeFrameNumber     ,
    setVideoCodecFrameDecodeFrameNumber     ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoCodecFrame_decodeFrameNumber       ,
#endif


-- ** distanceFromSync #attr:distanceFromSync#
    getVideoCodecFrameDistanceFromSync      ,
    setVideoCodecFrameDistanceFromSync      ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoCodecFrame_distanceFromSync        ,
#endif


-- ** dts #attr:dts#
    getVideoCodecFrameDts                   ,
    setVideoCodecFrameDts                   ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoCodecFrame_dts                     ,
#endif


-- ** duration #attr:duration#
    getVideoCodecFrameDuration              ,
    setVideoCodecFrameDuration              ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoCodecFrame_duration                ,
#endif


-- ** inputBuffer #attr:inputBuffer#
    clearVideoCodecFrameInputBuffer         ,
    getVideoCodecFrameInputBuffer           ,
    setVideoCodecFrameInputBuffer           ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoCodecFrame_inputBuffer             ,
#endif


-- ** outputBuffer #attr:outputBuffer#
    clearVideoCodecFrameOutputBuffer        ,
    getVideoCodecFrameOutputBuffer          ,
    setVideoCodecFrameOutputBuffer          ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoCodecFrame_outputBuffer            ,
#endif


-- ** presentationFrameNumber #attr:presentationFrameNumber#
    getVideoCodecFramePresentationFrameNumber,
    setVideoCodecFramePresentationFrameNumber,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoCodecFrame_presentationFrameNumber ,
#endif


-- ** pts #attr:pts#
    getVideoCodecFramePts                   ,
    setVideoCodecFramePts                   ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoCodecFrame_pts                     ,
#endif


-- ** systemFrameNumber #attr:systemFrameNumber#
    getVideoCodecFrameSystemFrameNumber     ,
    setVideoCodecFrameSystemFrameNumber     ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.Gst.Structs.Buffer as Gst.Buffer

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


noVideoCodecFrame :: Maybe VideoCodecFrame
noVideoCodecFrame = Nothing

getVideoCodecFrameSystemFrameNumber :: MonadIO m => VideoCodecFrame -> m Word32
getVideoCodecFrameSystemFrameNumber s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO Word32
    return val

setVideoCodecFrameSystemFrameNumber :: MonadIO m => VideoCodecFrame -> Word32 -> m ()
setVideoCodecFrameSystemFrameNumber s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Word32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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


getVideoCodecFrameDecodeFrameNumber :: MonadIO m => VideoCodecFrame -> m Word32
getVideoCodecFrameDecodeFrameNumber s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 12) :: IO Word32
    return val

setVideoCodecFrameDecodeFrameNumber :: MonadIO m => VideoCodecFrame -> Word32 -> m ()
setVideoCodecFrameDecodeFrameNumber s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 12) (val :: Word32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoCodecFrameDecodeFrameNumberFieldInfo
instance AttrInfo VideoCodecFrameDecodeFrameNumberFieldInfo where
    type AttrAllowedOps VideoCodecFrameDecodeFrameNumberFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoCodecFrameDecodeFrameNumberFieldInfo = (~) Word32
    type AttrBaseTypeConstraint VideoCodecFrameDecodeFrameNumberFieldInfo = (~) VideoCodecFrame
    type AttrGetType VideoCodecFrameDecodeFrameNumberFieldInfo = Word32
    type AttrLabel VideoCodecFrameDecodeFrameNumberFieldInfo = "decode_frame_number"
    type AttrOrigin VideoCodecFrameDecodeFrameNumberFieldInfo = VideoCodecFrame
    attrGet _ = getVideoCodecFrameDecodeFrameNumber
    attrSet _ = setVideoCodecFrameDecodeFrameNumber
    attrConstruct = undefined
    attrClear _ = undefined

videoCodecFrame_decodeFrameNumber :: AttrLabelProxy "decodeFrameNumber"
videoCodecFrame_decodeFrameNumber = AttrLabelProxy

#endif


getVideoCodecFramePresentationFrameNumber :: MonadIO m => VideoCodecFrame -> m Word32
getVideoCodecFramePresentationFrameNumber s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO Word32
    return val

setVideoCodecFramePresentationFrameNumber :: MonadIO m => VideoCodecFrame -> Word32 -> m ()
setVideoCodecFramePresentationFrameNumber s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Word32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoCodecFramePresentationFrameNumberFieldInfo
instance AttrInfo VideoCodecFramePresentationFrameNumberFieldInfo where
    type AttrAllowedOps VideoCodecFramePresentationFrameNumberFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoCodecFramePresentationFrameNumberFieldInfo = (~) Word32
    type AttrBaseTypeConstraint VideoCodecFramePresentationFrameNumberFieldInfo = (~) VideoCodecFrame
    type AttrGetType VideoCodecFramePresentationFrameNumberFieldInfo = Word32
    type AttrLabel VideoCodecFramePresentationFrameNumberFieldInfo = "presentation_frame_number"
    type AttrOrigin VideoCodecFramePresentationFrameNumberFieldInfo = VideoCodecFrame
    attrGet _ = getVideoCodecFramePresentationFrameNumber
    attrSet _ = setVideoCodecFramePresentationFrameNumber
    attrConstruct = undefined
    attrClear _ = undefined

videoCodecFrame_presentationFrameNumber :: AttrLabelProxy "presentationFrameNumber"
videoCodecFrame_presentationFrameNumber = AttrLabelProxy

#endif


getVideoCodecFrameDts :: MonadIO m => VideoCodecFrame -> m Word64
getVideoCodecFrameDts s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word64
    return val

setVideoCodecFrameDts :: MonadIO m => VideoCodecFrame -> Word64 -> m ()
setVideoCodecFrameDts s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word64)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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


getVideoCodecFramePts :: MonadIO m => VideoCodecFrame -> m Word64
getVideoCodecFramePts s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Word64
    return val

setVideoCodecFramePts :: MonadIO m => VideoCodecFrame -> Word64 -> m ()
setVideoCodecFramePts s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Word64)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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


getVideoCodecFrameDuration :: MonadIO m => VideoCodecFrame -> m Word64
getVideoCodecFrameDuration s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO Word64
    return val

setVideoCodecFrameDuration :: MonadIO m => VideoCodecFrame -> Word64 -> m ()
setVideoCodecFrameDuration s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 40) (val :: Word64)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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


getVideoCodecFrameDistanceFromSync :: MonadIO m => VideoCodecFrame -> m Int32
getVideoCodecFrameDistanceFromSync s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 48) :: IO Int32
    return val

setVideoCodecFrameDistanceFromSync :: MonadIO m => VideoCodecFrame -> Int32 -> m ()
setVideoCodecFrameDistanceFromSync s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 48) (val :: Int32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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


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

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)

clearVideoCodecFrameInputBuffer :: MonadIO m => VideoCodecFrame -> m ()
clearVideoCodecFrameInputBuffer s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 56) (FP.nullPtr :: Ptr Gst.Buffer.Buffer)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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


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

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)

clearVideoCodecFrameOutputBuffer :: MonadIO m => VideoCodecFrame -> m ()
clearVideoCodecFrameOutputBuffer s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 64) (FP.nullPtr :: Ptr Gst.Buffer.Buffer)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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


getVideoCodecFrameDeadline :: MonadIO m => VideoCodecFrame -> m Word64
getVideoCodecFrameDeadline s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 72) :: IO Word64
    return val

setVideoCodecFrameDeadline :: MonadIO m => VideoCodecFrame -> Word64 -> m ()
setVideoCodecFrameDeadline s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 72) (val :: Word64)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList VideoCodecFrame
type instance O.AttributeList VideoCodecFrame = VideoCodecFrameAttributeList
type VideoCodecFrameAttributeList = ('[ '("systemFrameNumber", VideoCodecFrameSystemFrameNumberFieldInfo), '("decodeFrameNumber", VideoCodecFrameDecodeFrameNumberFieldInfo), '("presentationFrameNumber", VideoCodecFramePresentationFrameNumberFieldInfo), '("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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoCodecFrameUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoCodecFrameUnrefMethodInfo VideoCodecFrame signature where
    overloadedMethod _ = videoCodecFrameUnref

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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) => O.IsLabelProxy t (VideoCodecFrame -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveVideoCodecFrameMethod t VideoCodecFrame, O.MethodInfo info VideoCodecFrame p) => O.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

#endif