{- | 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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