#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.GstVideo.Structs.VideoMeta
(
VideoMeta(..) ,
newZeroVideoMeta ,
noVideoMeta ,
videoMetaGetInfo ,
#if ENABLE_OVERLOADING
VideoMetaMapMethodInfo ,
#endif
videoMetaMap ,
#if ENABLE_OVERLOADING
VideoMetaUnmapMethodInfo ,
#endif
videoMetaUnmap ,
clearVideoMetaBuffer ,
getVideoMetaBuffer ,
setVideoMetaBuffer ,
#if ENABLE_OVERLOADING
videoMeta_buffer ,
#endif
getVideoMetaFlags ,
setVideoMetaFlags ,
#if ENABLE_OVERLOADING
videoMeta_flags ,
#endif
getVideoMetaFormat ,
setVideoMetaFormat ,
#if ENABLE_OVERLOADING
videoMeta_format ,
#endif
getVideoMetaHeight ,
setVideoMetaHeight ,
#if ENABLE_OVERLOADING
videoMeta_height ,
#endif
getVideoMetaId ,
setVideoMetaId ,
#if ENABLE_OVERLOADING
videoMeta_id ,
#endif
clearVideoMetaMap ,
getVideoMetaMap ,
setVideoMetaMap ,
#if ENABLE_OVERLOADING
videoMeta_map ,
#endif
getVideoMetaMeta ,
#if ENABLE_OVERLOADING
videoMeta_meta ,
#endif
getVideoMetaNPlanes ,
setVideoMetaNPlanes ,
#if ENABLE_OVERLOADING
videoMeta_nPlanes ,
#endif
clearVideoMetaUnmap ,
getVideoMetaUnmap ,
setVideoMetaUnmap ,
#if ENABLE_OVERLOADING
videoMeta_unmap ,
#endif
getVideoMetaWidth ,
setVideoMetaWidth ,
#if ENABLE_OVERLOADING
videoMeta_width ,
#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.Gst.Flags as Gst.Flags
import qualified GI.Gst.Structs.Buffer as Gst.Buffer
import qualified GI.Gst.Structs.MapInfo as Gst.MapInfo
import qualified GI.Gst.Structs.Meta as Gst.Meta
import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo
import qualified GI.GstVideo.Callbacks as GstVideo.Callbacks
import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums
import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags
newtype VideoMeta = VideoMeta (ManagedPtr VideoMeta)
instance WrappedPtr VideoMeta where
wrappedPtrCalloc = callocBytes 112
wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 112 >=> wrapPtr VideoMeta)
wrappedPtrFree = Just ptr_to_g_free
newZeroVideoMeta :: MonadIO m => m VideoMeta
newZeroVideoMeta = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoMeta
instance tag ~ 'AttrSet => Constructible VideoMeta tag where
new _ attrs = do
o <- newZeroVideoMeta
GI.Attributes.set o attrs
return o
noVideoMeta :: Maybe VideoMeta
noVideoMeta = Nothing
getVideoMetaMeta :: MonadIO m => VideoMeta -> m Gst.Meta.Meta
getVideoMetaMeta s = liftIO $ withManagedPtr s $ \ptr -> do
let val = ptr `plusPtr` 0 :: (Ptr Gst.Meta.Meta)
val' <- (newPtr Gst.Meta.Meta) val
return val'
#if ENABLE_OVERLOADING
data VideoMetaMetaFieldInfo
instance AttrInfo VideoMetaMetaFieldInfo where
type AttrAllowedOps VideoMetaMetaFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint VideoMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta)
type AttrBaseTypeConstraint VideoMetaMetaFieldInfo = (~) VideoMeta
type AttrGetType VideoMetaMetaFieldInfo = Gst.Meta.Meta
type AttrLabel VideoMetaMetaFieldInfo = "meta"
type AttrOrigin VideoMetaMetaFieldInfo = VideoMeta
attrGet _ = getVideoMetaMeta
attrSet _ = undefined
attrConstruct = undefined
attrClear _ = undefined
videoMeta_meta :: AttrLabelProxy "meta"
videoMeta_meta = AttrLabelProxy
#endif
getVideoMetaBuffer :: MonadIO m => VideoMeta -> m (Maybe Gst.Buffer.Buffer)
getVideoMetaBuffer s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 16) :: IO (Ptr Gst.Buffer.Buffer)
result <- SP.convertIfNonNull val $ \val' -> do
val'' <- (newBoxed Gst.Buffer.Buffer) val'
return val''
return result
setVideoMetaBuffer :: MonadIO m => VideoMeta -> Ptr Gst.Buffer.Buffer -> m ()
setVideoMetaBuffer s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 16) (val :: Ptr Gst.Buffer.Buffer)
clearVideoMetaBuffer :: MonadIO m => VideoMeta -> m ()
clearVideoMetaBuffer s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr Gst.Buffer.Buffer)
#if ENABLE_OVERLOADING
data VideoMetaBufferFieldInfo
instance AttrInfo VideoMetaBufferFieldInfo where
type AttrAllowedOps VideoMetaBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint VideoMetaBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer)
type AttrBaseTypeConstraint VideoMetaBufferFieldInfo = (~) VideoMeta
type AttrGetType VideoMetaBufferFieldInfo = Maybe Gst.Buffer.Buffer
type AttrLabel VideoMetaBufferFieldInfo = "buffer"
type AttrOrigin VideoMetaBufferFieldInfo = VideoMeta
attrGet _ = getVideoMetaBuffer
attrSet _ = setVideoMetaBuffer
attrConstruct = undefined
attrClear _ = clearVideoMetaBuffer
videoMeta_buffer :: AttrLabelProxy "buffer"
videoMeta_buffer = AttrLabelProxy
#endif
getVideoMetaFlags :: MonadIO m => VideoMeta -> m [GstVideo.Flags.VideoFrameFlags]
getVideoMetaFlags s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 24) :: IO CUInt
let val' = wordToGFlags val
return val'
setVideoMetaFlags :: MonadIO m => VideoMeta -> [GstVideo.Flags.VideoFrameFlags] -> m ()
setVideoMetaFlags s val = liftIO $ withManagedPtr s $ \ptr -> do
let val' = gflagsToWord val
poke (ptr `plusPtr` 24) (val' :: CUInt)
#if ENABLE_OVERLOADING
data VideoMetaFlagsFieldInfo
instance AttrInfo VideoMetaFlagsFieldInfo where
type AttrAllowedOps VideoMetaFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint VideoMetaFlagsFieldInfo = (~) [GstVideo.Flags.VideoFrameFlags]
type AttrBaseTypeConstraint VideoMetaFlagsFieldInfo = (~) VideoMeta
type AttrGetType VideoMetaFlagsFieldInfo = [GstVideo.Flags.VideoFrameFlags]
type AttrLabel VideoMetaFlagsFieldInfo = "flags"
type AttrOrigin VideoMetaFlagsFieldInfo = VideoMeta
attrGet _ = getVideoMetaFlags
attrSet _ = setVideoMetaFlags
attrConstruct = undefined
attrClear _ = undefined
videoMeta_flags :: AttrLabelProxy "flags"
videoMeta_flags = AttrLabelProxy
#endif
getVideoMetaFormat :: MonadIO m => VideoMeta -> m GstVideo.Enums.VideoFormat
getVideoMetaFormat s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 28) :: IO CUInt
let val' = (toEnum . fromIntegral) val
return val'
setVideoMetaFormat :: MonadIO m => VideoMeta -> GstVideo.Enums.VideoFormat -> m ()
setVideoMetaFormat s val = liftIO $ withManagedPtr s $ \ptr -> do
let val' = (fromIntegral . fromEnum) val
poke (ptr `plusPtr` 28) (val' :: CUInt)
#if ENABLE_OVERLOADING
data VideoMetaFormatFieldInfo
instance AttrInfo VideoMetaFormatFieldInfo where
type AttrAllowedOps VideoMetaFormatFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint VideoMetaFormatFieldInfo = (~) GstVideo.Enums.VideoFormat
type AttrBaseTypeConstraint VideoMetaFormatFieldInfo = (~) VideoMeta
type AttrGetType VideoMetaFormatFieldInfo = GstVideo.Enums.VideoFormat
type AttrLabel VideoMetaFormatFieldInfo = "format"
type AttrOrigin VideoMetaFormatFieldInfo = VideoMeta
attrGet _ = getVideoMetaFormat
attrSet _ = setVideoMetaFormat
attrConstruct = undefined
attrClear _ = undefined
videoMeta_format :: AttrLabelProxy "format"
videoMeta_format = AttrLabelProxy
#endif
getVideoMetaId :: MonadIO m => VideoMeta -> m Int32
getVideoMetaId s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 32) :: IO Int32
return val
setVideoMetaId :: MonadIO m => VideoMeta -> Int32 -> m ()
setVideoMetaId s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 32) (val :: Int32)
#if ENABLE_OVERLOADING
data VideoMetaIdFieldInfo
instance AttrInfo VideoMetaIdFieldInfo where
type AttrAllowedOps VideoMetaIdFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint VideoMetaIdFieldInfo = (~) Int32
type AttrBaseTypeConstraint VideoMetaIdFieldInfo = (~) VideoMeta
type AttrGetType VideoMetaIdFieldInfo = Int32
type AttrLabel VideoMetaIdFieldInfo = "id"
type AttrOrigin VideoMetaIdFieldInfo = VideoMeta
attrGet _ = getVideoMetaId
attrSet _ = setVideoMetaId
attrConstruct = undefined
attrClear _ = undefined
videoMeta_id :: AttrLabelProxy "id"
videoMeta_id = AttrLabelProxy
#endif
getVideoMetaWidth :: MonadIO m => VideoMeta -> m Word32
getVideoMetaWidth s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 36) :: IO Word32
return val
setVideoMetaWidth :: MonadIO m => VideoMeta -> Word32 -> m ()
setVideoMetaWidth s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 36) (val :: Word32)
#if ENABLE_OVERLOADING
data VideoMetaWidthFieldInfo
instance AttrInfo VideoMetaWidthFieldInfo where
type AttrAllowedOps VideoMetaWidthFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint VideoMetaWidthFieldInfo = (~) Word32
type AttrBaseTypeConstraint VideoMetaWidthFieldInfo = (~) VideoMeta
type AttrGetType VideoMetaWidthFieldInfo = Word32
type AttrLabel VideoMetaWidthFieldInfo = "width"
type AttrOrigin VideoMetaWidthFieldInfo = VideoMeta
attrGet _ = getVideoMetaWidth
attrSet _ = setVideoMetaWidth
attrConstruct = undefined
attrClear _ = undefined
videoMeta_width :: AttrLabelProxy "width"
videoMeta_width = AttrLabelProxy
#endif
getVideoMetaHeight :: MonadIO m => VideoMeta -> m Word32
getVideoMetaHeight s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 40) :: IO Word32
return val
setVideoMetaHeight :: MonadIO m => VideoMeta -> Word32 -> m ()
setVideoMetaHeight s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 40) (val :: Word32)
#if ENABLE_OVERLOADING
data VideoMetaHeightFieldInfo
instance AttrInfo VideoMetaHeightFieldInfo where
type AttrAllowedOps VideoMetaHeightFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint VideoMetaHeightFieldInfo = (~) Word32
type AttrBaseTypeConstraint VideoMetaHeightFieldInfo = (~) VideoMeta
type AttrGetType VideoMetaHeightFieldInfo = Word32
type AttrLabel VideoMetaHeightFieldInfo = "height"
type AttrOrigin VideoMetaHeightFieldInfo = VideoMeta
attrGet _ = getVideoMetaHeight
attrSet _ = setVideoMetaHeight
attrConstruct = undefined
attrClear _ = undefined
videoMeta_height :: AttrLabelProxy "height"
videoMeta_height = AttrLabelProxy
#endif
getVideoMetaNPlanes :: MonadIO m => VideoMeta -> m Word32
getVideoMetaNPlanes s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 44) :: IO Word32
return val
setVideoMetaNPlanes :: MonadIO m => VideoMeta -> Word32 -> m ()
setVideoMetaNPlanes s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 44) (val :: Word32)
#if ENABLE_OVERLOADING
data VideoMetaNPlanesFieldInfo
instance AttrInfo VideoMetaNPlanesFieldInfo where
type AttrAllowedOps VideoMetaNPlanesFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint VideoMetaNPlanesFieldInfo = (~) Word32
type AttrBaseTypeConstraint VideoMetaNPlanesFieldInfo = (~) VideoMeta
type AttrGetType VideoMetaNPlanesFieldInfo = Word32
type AttrLabel VideoMetaNPlanesFieldInfo = "n_planes"
type AttrOrigin VideoMetaNPlanesFieldInfo = VideoMeta
attrGet _ = getVideoMetaNPlanes
attrSet _ = setVideoMetaNPlanes
attrConstruct = undefined
attrClear _ = undefined
videoMeta_nPlanes :: AttrLabelProxy "nPlanes"
videoMeta_nPlanes = AttrLabelProxy
#endif
getVideoMetaMap :: MonadIO m => VideoMeta -> m (Maybe GstVideo.Callbacks.VideoMetaMapFieldCallback)
getVideoMetaMap s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 96) :: IO (FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = GstVideo.Callbacks.dynamic_VideoMetaMapFieldCallback val'
return val''
return result
setVideoMetaMap :: MonadIO m => VideoMeta -> FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback -> m ()
setVideoMetaMap s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 96) (val :: FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback)
clearVideoMetaMap :: MonadIO m => VideoMeta -> m ()
clearVideoMetaMap s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 96) (FP.nullFunPtr :: FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback)
#if ENABLE_OVERLOADING
data VideoMetaMapFieldInfo
instance AttrInfo VideoMetaMapFieldInfo where
type AttrAllowedOps VideoMetaMapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint VideoMetaMapFieldInfo = (~) (FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback)
type AttrBaseTypeConstraint VideoMetaMapFieldInfo = (~) VideoMeta
type AttrGetType VideoMetaMapFieldInfo = Maybe GstVideo.Callbacks.VideoMetaMapFieldCallback
type AttrLabel VideoMetaMapFieldInfo = "map"
type AttrOrigin VideoMetaMapFieldInfo = VideoMeta
attrGet _ = getVideoMetaMap
attrSet _ = setVideoMetaMap
attrConstruct = undefined
attrClear _ = clearVideoMetaMap
videoMeta_map :: AttrLabelProxy "map"
videoMeta_map = AttrLabelProxy
#endif
getVideoMetaUnmap :: MonadIO m => VideoMeta -> m (Maybe GstVideo.Callbacks.VideoMetaUnmapFieldCallback)
getVideoMetaUnmap s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 104) :: IO (FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = GstVideo.Callbacks.dynamic_VideoMetaUnmapFieldCallback val'
return val''
return result
setVideoMetaUnmap :: MonadIO m => VideoMeta -> FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback -> m ()
setVideoMetaUnmap s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 104) (val :: FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback)
clearVideoMetaUnmap :: MonadIO m => VideoMeta -> m ()
clearVideoMetaUnmap s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 104) (FP.nullFunPtr :: FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback)
#if ENABLE_OVERLOADING
data VideoMetaUnmapFieldInfo
instance AttrInfo VideoMetaUnmapFieldInfo where
type AttrAllowedOps VideoMetaUnmapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint VideoMetaUnmapFieldInfo = (~) (FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback)
type AttrBaseTypeConstraint VideoMetaUnmapFieldInfo = (~) VideoMeta
type AttrGetType VideoMetaUnmapFieldInfo = Maybe GstVideo.Callbacks.VideoMetaUnmapFieldCallback
type AttrLabel VideoMetaUnmapFieldInfo = "unmap"
type AttrOrigin VideoMetaUnmapFieldInfo = VideoMeta
attrGet _ = getVideoMetaUnmap
attrSet _ = setVideoMetaUnmap
attrConstruct = undefined
attrClear _ = clearVideoMetaUnmap
videoMeta_unmap :: AttrLabelProxy "unmap"
videoMeta_unmap = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList VideoMeta
type instance O.AttributeList VideoMeta = VideoMetaAttributeList
type VideoMetaAttributeList = ('[ '("meta", VideoMetaMetaFieldInfo), '("buffer", VideoMetaBufferFieldInfo), '("flags", VideoMetaFlagsFieldInfo), '("format", VideoMetaFormatFieldInfo), '("id", VideoMetaIdFieldInfo), '("width", VideoMetaWidthFieldInfo), '("height", VideoMetaHeightFieldInfo), '("nPlanes", VideoMetaNPlanesFieldInfo), '("map", VideoMetaMapFieldInfo), '("unmap", VideoMetaUnmapFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_video_meta_map" gst_video_meta_map ::
Ptr VideoMeta ->
Word32 ->
Ptr Gst.MapInfo.MapInfo ->
Ptr (Ptr ()) ->
Ptr Int32 ->
CUInt ->
IO CInt
videoMetaMap ::
(B.CallStack.HasCallStack, MonadIO m) =>
VideoMeta
-> Word32
-> Gst.MapInfo.MapInfo
-> [Gst.Flags.MapFlags]
-> m ((Bool, Ptr (), Int32))
videoMetaMap meta plane info flags = liftIO $ do
meta' <- unsafeManagedPtrGetPtr meta
info' <- unsafeManagedPtrGetPtr info
data_ <- allocMem :: IO (Ptr (Ptr ()))
stride <- allocMem :: IO (Ptr Int32)
let flags' = gflagsToWord flags
result <- gst_video_meta_map meta' plane info' data_ stride flags'
let result' = (/= 0) result
data_' <- peek data_
stride' <- peek stride
touchManagedPtr meta
touchManagedPtr info
freeMem data_
freeMem stride
return (result', data_', stride')
#if ENABLE_OVERLOADING
data VideoMetaMapMethodInfo
instance (signature ~ (Word32 -> Gst.MapInfo.MapInfo -> [Gst.Flags.MapFlags] -> m ((Bool, Ptr (), Int32))), MonadIO m) => O.MethodInfo VideoMetaMapMethodInfo VideoMeta signature where
overloadedMethod _ = videoMetaMap
#endif
foreign import ccall "gst_video_meta_unmap" gst_video_meta_unmap ::
Ptr VideoMeta ->
Word32 ->
Ptr Gst.MapInfo.MapInfo ->
IO CInt
videoMetaUnmap ::
(B.CallStack.HasCallStack, MonadIO m) =>
VideoMeta
-> Word32
-> Gst.MapInfo.MapInfo
-> m Bool
videoMetaUnmap meta plane info = liftIO $ do
meta' <- unsafeManagedPtrGetPtr meta
info' <- unsafeManagedPtrGetPtr info
result <- gst_video_meta_unmap meta' plane info'
let result' = (/= 0) result
touchManagedPtr meta
touchManagedPtr info
return result'
#if ENABLE_OVERLOADING
data VideoMetaUnmapMethodInfo
instance (signature ~ (Word32 -> Gst.MapInfo.MapInfo -> m Bool), MonadIO m) => O.MethodInfo VideoMetaUnmapMethodInfo VideoMeta signature where
overloadedMethod _ = videoMetaUnmap
#endif
foreign import ccall "gst_video_meta_get_info" gst_video_meta_get_info ::
IO (Ptr Gst.MetaInfo.MetaInfo)
videoMetaGetInfo ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Gst.MetaInfo.MetaInfo
videoMetaGetInfo = liftIO $ do
result <- gst_video_meta_get_info
checkUnexpectedReturnNULL "videoMetaGetInfo" result
result' <- (newPtr Gst.MetaInfo.MetaInfo) result
return result'
#if ENABLE_OVERLOADING
#endif
#if ENABLE_OVERLOADING
type family ResolveVideoMetaMethod (t :: Symbol) (o :: *) :: * where
ResolveVideoMetaMethod "map" o = VideoMetaMapMethodInfo
ResolveVideoMetaMethod "unmap" o = VideoMetaUnmapMethodInfo
ResolveVideoMetaMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveVideoMetaMethod t VideoMeta, O.MethodInfo info VideoMeta p) => OL.IsLabel t (VideoMeta -> 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