module GI.Gst.Structs.Meta
(
Meta(..) ,
newZeroMeta ,
noMeta ,
metaApiTypeGetTags ,
metaApiTypeHasTag ,
metaApiTypeRegister ,
metaGetInfo ,
metaRegister ,
getMetaFlags ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
meta_flags ,
#endif
setMetaFlags ,
clearMetaInfo ,
getMetaInfo ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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.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.Gst.Callbacks as Gst.Callbacks
import qualified GI.Gst.Flags as Gst.Flags
import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo
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
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
noMeta :: Maybe Meta
noMeta = Nothing
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'
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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
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
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)
clearMetaInfo :: MonadIO m => Meta -> m ()
clearMetaInfo s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Gst.MetaInfo.MetaInfo)
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList Meta
type instance O.AttributeList Meta = MetaAttributeList
type MetaAttributeList = ('[ '("flags", MetaFlagsFieldInfo), '("info", MetaInfoFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_meta_api_type_get_tags" gst_meta_api_type_get_tags ::
CGType ->
IO (Ptr CString)
metaApiTypeGetTags ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> m [T.Text]
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif
foreign import ccall "gst_meta_api_type_has_tag" gst_meta_api_type_has_tag ::
CGType ->
Word32 ->
IO CInt
metaApiTypeHasTag ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> Word32
-> m Bool
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif
foreign import ccall "gst_meta_api_type_register" gst_meta_api_type_register ::
CString ->
CString ->
IO CGType
metaApiTypeRegister ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> m GType
metaApiTypeRegister api tags = liftIO $ do
api' <- textToCString api
tags' <- textToCString tags
result <- gst_meta_api_type_register api' tags'
let result' = GType result
freeMem api'
freeMem tags'
return result'
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif
foreign import ccall "gst_meta_get_info" gst_meta_get_info ::
CString ->
IO (Ptr Gst.MetaInfo.MetaInfo)
metaGetInfo ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe Gst.MetaInfo.MetaInfo)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif
foreign import ccall "gst_meta_register" gst_meta_register ::
CGType ->
CString ->
Word64 ->
FunPtr Gst.Callbacks.C_MetaInitFunction ->
FunPtr Gst.Callbacks.C_MetaFreeFunction ->
FunPtr Gst.Callbacks.C_MetaTransformFunction ->
IO (Ptr Gst.MetaInfo.MetaInfo)
metaRegister ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> T.Text
-> Word64
-> Gst.Callbacks.MetaInitFunction
-> Gst.Callbacks.MetaFreeFunction
-> Gst.Callbacks.MetaTransformFunction
-> m Gst.MetaInfo.MetaInfo
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'
checkUnexpectedReturnNULL "metaRegister" result
result' <- (newPtr Gst.MetaInfo.MetaInfo) result
freeMem impl'
return result'
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveMetaMethod (t :: Symbol) (o :: *) :: * where
ResolveMetaMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMetaMethod t Meta, O.MethodInfo info Meta p) => O.IsLabelProxy t (Meta -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveMetaMethod t Meta, O.MethodInfo info Meta p) => O.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
#endif