{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) The 'GI.Gst.Structs.Meta.Meta' structure should be included as the first member of a 'GI.Gst.Structs.Buffer.Buffer' metadata structure. The structure defines the API of the metadata and should be accessible to all elements using the metadata. A metadata API is registered with 'GI.Gst.Functions.metaApiTypeRegister' which takes a name for the metadata API and some tags associated with the metadata. With 'GI.Gst.Functions.metaApiTypeHasTag' one can check if a certain metadata API contains a given tag. Multiple implementations of a metadata API can be registered. To implement a metadata API, 'GI.Gst.Functions.metaRegister' should be used. This function takes all parameters needed to create, free and transform metadata along with the size of the metadata. The function returns a 'GI.Gst.Structs.MetaInfo.MetaInfo' structure that contains the information for the implementation of the API. A specific implementation can be retrieved by name with 'GI.Gst.Functions.metaGetInfo'. See 'GI.Gst.Structs.Buffer.Buffer' for how the metadata can be added, retrieved and removed from buffers. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gst.Structs.Meta ( -- * Exported types Meta(..) , newZeroMeta , noMeta , -- * Methods -- ** apiTypeGetTags #method:apiTypeGetTags# metaApiTypeGetTags , -- ** apiTypeHasTag #method:apiTypeHasTag# metaApiTypeHasTag , -- ** apiTypeRegister #method:apiTypeRegister# metaApiTypeRegister , -- ** compareSeqnum #method:compareSeqnum# #if ENABLE_OVERLOADING MetaCompareSeqnumMethodInfo , #endif metaCompareSeqnum , -- ** getInfo #method:getInfo# metaGetInfo , -- ** getSeqnum #method:getSeqnum# #if ENABLE_OVERLOADING MetaGetSeqnumMethodInfo , #endif metaGetSeqnum , -- ** register #method:register# metaRegister , -- * Properties -- ** flags #attr:flags# {- | extra flags for the metadata -} getMetaFlags , #if ENABLE_OVERLOADING meta_flags , #endif setMetaFlags , -- ** info #attr:info# {- | pointer to the 'GI.Gst.Structs.MetaInfo.MetaInfo' -} clearMetaInfo , getMetaInfo , #if ENABLE_OVERLOADING meta_info , #endif setMetaInfo , ) 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.Callbacks as Gst.Callbacks import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags import {-# SOURCE #-} qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo -- | Memory-managed wrapper type. newtype Meta = Meta (ManagedPtr Meta) instance WrappedPtr Meta where wrappedPtrCalloc = callocBytes 16 wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 16 >=> wrapPtr Meta) wrappedPtrFree = Just ptr_to_g_free -- | Construct a `Meta` struct initialized to zero. newZeroMeta :: MonadIO m => m Meta newZeroMeta = liftIO $ wrappedPtrCalloc >>= wrapPtr Meta instance tag ~ 'AttrSet => Constructible Meta tag where new _ attrs = do o <- newZeroMeta GI.Attributes.set o attrs return o -- | A convenience alias for `Nothing` :: `Maybe` `Meta`. noMeta :: Maybe Meta noMeta = Nothing {- | Get the value of the “@flags@” field. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' meta #flags @ -} getMetaFlags :: MonadIO m => Meta -> m [Gst.Flags.MetaFlags] getMetaFlags s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO CUInt let val' = wordToGFlags val return val' {- | Set the value of the “@flags@” field. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' meta [ #flags 'Data.GI.Base.Attributes.:=' value ] @ -} setMetaFlags :: MonadIO m => Meta -> [Gst.Flags.MetaFlags] -> m () setMetaFlags s val = liftIO $ withManagedPtr s $ \ptr -> do let val' = gflagsToWord val poke (ptr `plusPtr` 0) (val' :: CUInt) #if ENABLE_OVERLOADING data MetaFlagsFieldInfo instance AttrInfo MetaFlagsFieldInfo where type AttrAllowedOps MetaFlagsFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint MetaFlagsFieldInfo = (~) [Gst.Flags.MetaFlags] type AttrBaseTypeConstraint MetaFlagsFieldInfo = (~) Meta type AttrGetType MetaFlagsFieldInfo = [Gst.Flags.MetaFlags] type AttrLabel MetaFlagsFieldInfo = "flags" type AttrOrigin MetaFlagsFieldInfo = Meta attrGet _ = getMetaFlags attrSet _ = setMetaFlags attrConstruct = undefined attrClear _ = undefined meta_flags :: AttrLabelProxy "flags" meta_flags = AttrLabelProxy #endif {- | Get the value of the “@info@” field. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' meta #info @ -} getMetaInfo :: MonadIO m => Meta -> m (Maybe Gst.MetaInfo.MetaInfo) getMetaInfo s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 8) :: IO (Ptr Gst.MetaInfo.MetaInfo) result <- SP.convertIfNonNull val $ \val' -> do val'' <- (newPtr Gst.MetaInfo.MetaInfo) val' return val'' return result {- | Set the value of the “@info@” field. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' meta [ #info 'Data.GI.Base.Attributes.:=' value ] @ -} setMetaInfo :: MonadIO m => Meta -> Ptr Gst.MetaInfo.MetaInfo -> m () setMetaInfo s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 8) (val :: Ptr Gst.MetaInfo.MetaInfo) {- | Set the value of the “@info@” 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' #info @ -} clearMetaInfo :: MonadIO m => Meta -> m () clearMetaInfo s = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Gst.MetaInfo.MetaInfo) #if ENABLE_OVERLOADING data MetaInfoFieldInfo instance AttrInfo MetaInfoFieldInfo where type AttrAllowedOps MetaInfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint MetaInfoFieldInfo = (~) (Ptr Gst.MetaInfo.MetaInfo) type AttrBaseTypeConstraint MetaInfoFieldInfo = (~) Meta type AttrGetType MetaInfoFieldInfo = Maybe Gst.MetaInfo.MetaInfo type AttrLabel MetaInfoFieldInfo = "info" type AttrOrigin MetaInfoFieldInfo = Meta attrGet _ = getMetaInfo attrSet _ = setMetaInfo attrConstruct = undefined attrClear _ = clearMetaInfo meta_info :: AttrLabelProxy "info" meta_info = AttrLabelProxy #endif #if ENABLE_OVERLOADING instance O.HasAttributeList Meta type instance O.AttributeList Meta = MetaAttributeList type MetaAttributeList = ('[ '("flags", MetaFlagsFieldInfo), '("info", MetaInfoFieldInfo)] :: [(Symbol, *)]) #endif -- method Meta::compare_seqnum -- method type : OrdinaryMethod -- Args : [Arg {argCName = "meta1", argType = TInterface (Name {namespace = "Gst", name = "Meta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMeta", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "meta2", argType = TInterface (Name {namespace = "Gst", name = "Meta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMeta", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "gst_meta_compare_seqnum" gst_meta_compare_seqnum :: Ptr Meta -> -- meta1 : TInterface (Name {namespace = "Gst", name = "Meta"}) Ptr Meta -> -- meta2 : TInterface (Name {namespace = "Gst", name = "Meta"}) IO Int32 {- | Meta sequence number compare function. Can be used as 'GI.GLib.Callbacks.CompareFunc' or a 'GI.GLib.Callbacks.CompareDataFunc'. /Since: 1.16/ -} metaCompareSeqnum :: (B.CallStack.HasCallStack, MonadIO m) => Meta {- ^ /@meta1@/: a 'GI.Gst.Structs.Meta.Meta' -} -> Meta {- ^ /@meta2@/: a 'GI.Gst.Structs.Meta.Meta' -} -> m Int32 {- ^ __Returns:__ a negative number if /@meta1@/ comes before /@meta2@/, 0 if both metas have an equal sequence number, or a positive integer if /@meta1@/ comes after /@meta2@/. -} metaCompareSeqnum meta1 meta2 = liftIO $ do meta1' <- unsafeManagedPtrGetPtr meta1 meta2' <- unsafeManagedPtrGetPtr meta2 result <- gst_meta_compare_seqnum meta1' meta2' touchManagedPtr meta1 touchManagedPtr meta2 return result #if ENABLE_OVERLOADING data MetaCompareSeqnumMethodInfo instance (signature ~ (Meta -> m Int32), MonadIO m) => O.MethodInfo MetaCompareSeqnumMethodInfo Meta signature where overloadedMethod _ = metaCompareSeqnum #endif -- method Meta::get_seqnum -- method type : OrdinaryMethod -- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "Gst", name = "Meta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMeta", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt64) -- throws : False -- Skip return : False foreign import ccall "gst_meta_get_seqnum" gst_meta_get_seqnum :: Ptr Meta -> -- meta : TInterface (Name {namespace = "Gst", name = "Meta"}) IO Word64 {- | Gets seqnum for this meta. /Since: 1.16/ -} metaGetSeqnum :: (B.CallStack.HasCallStack, MonadIO m) => Meta {- ^ /@meta@/: a 'GI.Gst.Structs.Meta.Meta' -} -> m Word64 metaGetSeqnum meta = liftIO $ do meta' <- unsafeManagedPtrGetPtr meta result <- gst_meta_get_seqnum meta' touchManagedPtr meta return result #if ENABLE_OVERLOADING data MetaGetSeqnumMethodInfo instance (signature ~ (m Word64), MonadIO m) => O.MethodInfo MetaGetSeqnumMethodInfo Meta signature where overloadedMethod _ = metaGetSeqnum #endif -- method Meta::api_type_get_tags -- method type : MemberFunction -- Args : [Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an API", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) -- throws : False -- Skip return : False foreign import ccall "gst_meta_api_type_get_tags" gst_meta_api_type_get_tags :: CGType -> -- api : TBasicType TGType IO (Ptr CString) {- | /No description available in the introspection data./ /Since: 1.2/ -} metaApiTypeGetTags :: (B.CallStack.HasCallStack, MonadIO m) => GType {- ^ /@api@/: an API -} -> m [T.Text] {- ^ __Returns:__ an array of tags as strings. -} metaApiTypeGetTags api = liftIO $ do let api' = gtypeToCGType api result <- gst_meta_api_type_get_tags api' checkUnexpectedReturnNULL "metaApiTypeGetTags" result result' <- unpackZeroTerminatedUTF8CArray result return result' #if ENABLE_OVERLOADING #endif -- method Meta::api_type_has_tag -- method type : MemberFunction -- Args : [Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an API", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_meta_api_type_has_tag" gst_meta_api_type_has_tag :: CGType -> -- api : TBasicType TGType Word32 -> -- tag : TBasicType TUInt32 IO CInt {- | Check if /@api@/ was registered with /@tag@/. -} metaApiTypeHasTag :: (B.CallStack.HasCallStack, MonadIO m) => GType {- ^ /@api@/: an API -} -> Word32 {- ^ /@tag@/: the tag to check -} -> m Bool {- ^ __Returns:__ 'True' if /@api@/ was registered with /@tag@/. -} metaApiTypeHasTag api tag = liftIO $ do let api' = gtypeToCGType api result <- gst_meta_api_type_has_tag api' tag let result' = (/= 0) result return result' #if ENABLE_OVERLOADING #endif -- method Meta::api_type_register -- method type : MemberFunction -- Args : [Arg {argCName = "api", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an API to register", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "tags for @api", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TGType) -- throws : False -- Skip return : False foreign import ccall "gst_meta_api_type_register" gst_meta_api_type_register :: CString -> -- api : TBasicType TUTF8 Ptr CString -> -- tags : TCArray True (-1) (-1) (TBasicType TUTF8) IO CGType {- | Register and return a GType for the /@api@/ and associate it with /@tags@/. -} metaApiTypeRegister :: (B.CallStack.HasCallStack, MonadIO m) => T.Text {- ^ /@api@/: an API to register -} -> [T.Text] {- ^ /@tags@/: tags for /@api@/ -} -> m GType {- ^ __Returns:__ a unique GType for /@api@/. -} metaApiTypeRegister api tags = liftIO $ do api' <- textToCString api tags' <- packZeroTerminatedUTF8CArray tags result <- gst_meta_api_type_register api' tags' let result' = GType result freeMem api' mapZeroTerminatedCArray freeMem tags' freeMem tags' return result' #if ENABLE_OVERLOADING #endif -- method Meta::get_info -- method type : MemberFunction -- Args : [Arg {argCName = "impl", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "MetaInfo"})) -- throws : False -- Skip return : False foreign import ccall "gst_meta_get_info" gst_meta_get_info :: CString -> -- impl : TBasicType TUTF8 IO (Ptr Gst.MetaInfo.MetaInfo) {- | Lookup a previously registered meta info structure by its implementation name /@impl@/. -} metaGetInfo :: (B.CallStack.HasCallStack, MonadIO m) => T.Text {- ^ /@impl@/: the name -} -> m (Maybe Gst.MetaInfo.MetaInfo) {- ^ __Returns:__ a 'GI.Gst.Structs.MetaInfo.MetaInfo' with /@impl@/, or 'Nothing' when no such metainfo exists. -} metaGetInfo impl = liftIO $ do impl' <- textToCString impl result <- gst_meta_get_info impl' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newPtr Gst.MetaInfo.MetaInfo) result' return result'' freeMem impl' return maybeResult #if ENABLE_OVERLOADING #endif -- method Meta::register -- method type : MemberFunction -- Args : [Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the type of the #GstMeta API", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "impl", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the #GstMeta implementation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of the #GstMeta structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "init_func", argType = TInterface (Name {namespace = "Gst", name = "MetaInitFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMetaInitFunction", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "free_func", argType = TInterface (Name {namespace = "Gst", name = "MetaFreeFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMetaFreeFunction", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "transform_func", argType = TInterface (Name {namespace = "Gst", name = "MetaTransformFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMetaTransformFunction", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "MetaInfo"})) -- throws : False -- Skip return : False foreign import ccall "gst_meta_register" gst_meta_register :: CGType -> -- api : TBasicType TGType CString -> -- impl : TBasicType TUTF8 Word64 -> -- size : TBasicType TUInt64 FunPtr Gst.Callbacks.C_MetaInitFunction -> -- init_func : TInterface (Name {namespace = "Gst", name = "MetaInitFunction"}) FunPtr Gst.Callbacks.C_MetaFreeFunction -> -- free_func : TInterface (Name {namespace = "Gst", name = "MetaFreeFunction"}) FunPtr Gst.Callbacks.C_MetaTransformFunction -> -- transform_func : TInterface (Name {namespace = "Gst", name = "MetaTransformFunction"}) IO (Ptr Gst.MetaInfo.MetaInfo) {- | Register a new 'GI.Gst.Structs.Meta.Meta' implementation. The same /@info@/ can be retrieved later with 'GI.Gst.Functions.metaGetInfo' by using /@impl@/ as the key. -} metaRegister :: (B.CallStack.HasCallStack, MonadIO m) => GType {- ^ /@api@/: the type of the 'GI.Gst.Structs.Meta.Meta' API -} -> T.Text {- ^ /@impl@/: the name of the 'GI.Gst.Structs.Meta.Meta' implementation -} -> Word64 {- ^ /@size@/: the size of the 'GI.Gst.Structs.Meta.Meta' structure -} -> Gst.Callbacks.MetaInitFunction {- ^ /@initFunc@/: a 'GI.Gst.Callbacks.MetaInitFunction' -} -> Gst.Callbacks.MetaFreeFunction {- ^ /@freeFunc@/: a 'GI.Gst.Callbacks.MetaFreeFunction' -} -> Gst.Callbacks.MetaTransformFunction {- ^ /@transformFunc@/: a 'GI.Gst.Callbacks.MetaTransformFunction' -} -> m (Maybe Gst.MetaInfo.MetaInfo) {- ^ __Returns:__ a 'GI.Gst.Structs.MetaInfo.MetaInfo' that can be used to access metadata. -} metaRegister api impl size initFunc freeFunc transformFunc = liftIO $ do let api' = gtypeToCGType api impl' <- textToCString impl ptrinitFunc <- callocMem :: IO (Ptr (FunPtr Gst.Callbacks.C_MetaInitFunction)) initFunc' <- Gst.Callbacks.mk_MetaInitFunction (Gst.Callbacks.wrap_MetaInitFunction (Just ptrinitFunc) initFunc) poke ptrinitFunc initFunc' ptrfreeFunc <- callocMem :: IO (Ptr (FunPtr Gst.Callbacks.C_MetaFreeFunction)) freeFunc' <- Gst.Callbacks.mk_MetaFreeFunction (Gst.Callbacks.wrap_MetaFreeFunction (Just ptrfreeFunc) freeFunc) poke ptrfreeFunc freeFunc' ptrtransformFunc <- callocMem :: IO (Ptr (FunPtr Gst.Callbacks.C_MetaTransformFunction)) transformFunc' <- Gst.Callbacks.mk_MetaTransformFunction (Gst.Callbacks.wrap_MetaTransformFunction (Just ptrtransformFunc) transformFunc) poke ptrtransformFunc transformFunc' result <- gst_meta_register api' impl' size initFunc' freeFunc' transformFunc' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newPtr Gst.MetaInfo.MetaInfo) result' return result'' freeMem impl' return maybeResult #if ENABLE_OVERLOADING #endif #if ENABLE_OVERLOADING type family ResolveMetaMethod (t :: Symbol) (o :: *) :: * where ResolveMetaMethod "compareSeqnum" o = MetaCompareSeqnumMethodInfo ResolveMetaMethod "getSeqnum" o = MetaGetSeqnumMethodInfo ResolveMetaMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveMetaMethod t Meta, O.MethodInfo info Meta p) => OL.IsLabel t (Meta -> 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