gi-gstvideo-0.1.6.13: 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 (garetxe@gmail.com)

A #GstVideoCodecFrame represents a video frame both in raw and
encoded form.
-}

module GI.GstVideo.Structs.VideoCodecFrame
    ( 

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


 -- * Methods
-- ** videoCodecFrameGetUserData
    VideoCodecFrameGetUserDataMethodInfo    ,
    videoCodecFrameGetUserData              ,


-- ** videoCodecFrameRef
    VideoCodecFrameRefMethodInfo            ,
    videoCodecFrameRef                      ,


-- ** videoCodecFrameSetUserData
    VideoCodecFrameSetUserDataMethodInfo    ,
    videoCodecFrameSetUserData              ,


-- ** videoCodecFrameUnref
    VideoCodecFrameUnrefMethodInfo          ,
    videoCodecFrameUnref                    ,




 -- * Properties
-- ** Deadline
    videoCodecFrameReadDeadline             ,


-- ** DecodeFrameNumber
    videoCodecFrameReadDecodeFrameNumber    ,


-- ** DistanceFromSync
    videoCodecFrameReadDistanceFromSync     ,


-- ** Dts
    videoCodecFrameReadDts                  ,


-- ** Duration
    videoCodecFrameReadDuration             ,


-- ** InputBuffer
    videoCodecFrameReadInputBuffer          ,


-- ** OutputBuffer
    videoCodecFrameReadOutputBuffer         ,


-- ** PresentationFrameNumber
    videoCodecFrameReadPresentationFrameNumber,


-- ** Pts
    videoCodecFrameReadPts                  ,


-- ** SystemFrameNumber
    videoCodecFrameReadSystemFrameNumber    ,




    ) where

import Prelude ()
import Data.GI.Base.ShortPrelude

import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map

import GI.GstVideo.Types
import GI.GstVideo.Callbacks
import qualified GI.GLib as GLib
import qualified GI.Gst as Gst

newtype VideoCodecFrame = VideoCodecFrame (ForeignPtr 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

noVideoCodecFrame :: Maybe VideoCodecFrame
noVideoCodecFrame = Nothing

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

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

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

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

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

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

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

videoCodecFrameReadInputBuffer :: VideoCodecFrame -> IO Gst.Buffer
videoCodecFrameReadInputBuffer s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 56) :: IO (Ptr Gst.Buffer)
    val' <- (newBoxed Gst.Buffer) val
    return val'

videoCodecFrameReadOutputBuffer :: VideoCodecFrame -> IO Gst.Buffer
videoCodecFrameReadOutputBuffer s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 64) :: IO (Ptr Gst.Buffer)
    val' <- (newBoxed Gst.Buffer) val
    return val'

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

-- method VideoCodecFrame::get_user_data
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_codec_frame_get_user_data" gst_video_codec_frame_get_user_data :: 
    Ptr VideoCodecFrame ->                  -- _obj : TInterface "GstVideo" "VideoCodecFrame"
    IO ()


videoCodecFrameGetUserData ::
    (MonadIO m) =>
    VideoCodecFrame                         -- _obj
    -> m ()                                 -- result
videoCodecFrameGetUserData _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    gst_video_codec_frame_get_user_data _obj'
    touchManagedPtr _obj
    return ()

data VideoCodecFrameGetUserDataMethodInfo
instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoCodecFrameGetUserDataMethodInfo VideoCodecFrame signature where
    overloadedMethod _ = videoCodecFrameGetUserData

-- method VideoCodecFrame::ref
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TInterface "GstVideo" "VideoCodecFrame"
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_codec_frame_ref" gst_video_codec_frame_ref :: 
    Ptr VideoCodecFrame ->                  -- _obj : TInterface "GstVideo" "VideoCodecFrame"
    IO (Ptr VideoCodecFrame)


videoCodecFrameRef ::
    (MonadIO m) =>
    VideoCodecFrame                         -- _obj
    -> m VideoCodecFrame                    -- result
videoCodecFrameRef _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    result <- gst_video_codec_frame_ref _obj'
    checkUnexpectedReturnNULL "gst_video_codec_frame_ref" result
    result' <- (wrapBoxed VideoCodecFrame) result
    touchManagedPtr _obj
    return result'

data VideoCodecFrameRefMethodInfo
instance (signature ~ (m VideoCodecFrame), MonadIO m) => MethodInfo VideoCodecFrameRefMethodInfo VideoCodecFrame signature where
    overloadedMethod _ = videoCodecFrameRef

-- method VideoCodecFrame::set_user_data
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_codec_frame_set_user_data" gst_video_codec_frame_set_user_data :: 
    Ptr VideoCodecFrame ->                  -- _obj : TInterface "GstVideo" "VideoCodecFrame"
    Ptr () ->                               -- user_data : TBasicType TVoid
    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
    IO ()


videoCodecFrameSetUserData ::
    (MonadIO m) =>
    VideoCodecFrame                         -- _obj
    -> GLib.DestroyNotify                   -- notify
    -> m ()                                 -- result
videoCodecFrameSetUserData _obj notify = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    ptrnotify <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))
    notify' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptrnotify) notify)
    poke ptrnotify notify'
    let userData = nullPtr
    gst_video_codec_frame_set_user_data _obj' userData notify'
    touchManagedPtr _obj
    return ()

data VideoCodecFrameSetUserDataMethodInfo
instance (signature ~ (GLib.DestroyNotify -> m ()), MonadIO m) => MethodInfo VideoCodecFrameSetUserDataMethodInfo VideoCodecFrame signature where
    overloadedMethod _ = videoCodecFrameSetUserData

-- method VideoCodecFrame::unref
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_codec_frame_unref" gst_video_codec_frame_unref :: 
    Ptr VideoCodecFrame ->                  -- _obj : TInterface "GstVideo" "VideoCodecFrame"
    IO ()


videoCodecFrameUnref ::
    (MonadIO m) =>
    VideoCodecFrame                         -- _obj
    -> m ()                                 -- result
videoCodecFrameUnref _obj = liftIO $ do
    let _obj' = unsafeManagedPtrGetPtr _obj
    gst_video_codec_frame_unref _obj'
    touchManagedPtr _obj
    return ()

data VideoCodecFrameUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoCodecFrameUnrefMethodInfo VideoCodecFrame signature where
    overloadedMethod _ = videoCodecFrameUnref

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 = MethodResolutionFailed l o

instance (info ~ ResolveVideoCodecFrameMethod t VideoCodecFrame, MethodInfo info VideoCodecFrame p) => IsLabelProxy t (VideoCodecFrame -> p) where
    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveVideoCodecFrameMethod t VideoCodecFrame, MethodInfo info VideoCodecFrame p) => IsLabel t (VideoCodecFrame -> p) where
    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
#endif