#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Gst.Structs.TypeFind
(
TypeFind(..) ,
newZeroTypeFind ,
noTypeFind ,
#if ENABLE_OVERLOADING
TypeFindGetLengthMethodInfo ,
#endif
typeFindGetLength ,
#if ENABLE_OVERLOADING
TypeFindPeekMethodInfo ,
#endif
typeFindPeek ,
typeFindRegister ,
#if ENABLE_OVERLOADING
TypeFindSuggestMethodInfo ,
#endif
typeFindSuggest ,
clearTypeFindData ,
getTypeFindData ,
setTypeFindData ,
#if ENABLE_OVERLOADING
typeFind_data ,
#endif
clearTypeFindGetLength ,
getTypeFindGetLength ,
setTypeFindGetLength ,
#if ENABLE_OVERLOADING
typeFind_getLength ,
#endif
clearTypeFindPeek ,
getTypeFindPeek ,
setTypeFindPeek ,
#if ENABLE_OVERLOADING
typeFind_peek ,
#endif
clearTypeFindSuggest ,
getTypeFindSuggest ,
setTypeFindSuggest ,
#if ENABLE_OVERLOADING
typeFind_suggest ,
#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.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.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.GLib.Callbacks as GLib.Callbacks
import qualified GI.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Objects.Plugin as Gst.Plugin
import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps
newtype TypeFind = TypeFind (ManagedPtr TypeFind)
instance WrappedPtr TypeFind where
wrappedPtrCalloc = callocBytes 64
wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 64 >=> wrapPtr TypeFind)
wrappedPtrFree = Just ptr_to_g_free
newZeroTypeFind :: MonadIO m => m TypeFind
newZeroTypeFind = liftIO $ wrappedPtrCalloc >>= wrapPtr TypeFind
instance tag ~ 'AttrSet => Constructible TypeFind tag where
new _ attrs = do
o <- newZeroTypeFind
GI.Attributes.set o attrs
return o
noTypeFind :: Maybe TypeFind
noTypeFind = Nothing
getTypeFindPeek :: MonadIO m => TypeFind -> m (Maybe Gst.Callbacks.TypeFindPeekFieldCallback)
getTypeFindPeek s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 0) :: IO (FunPtr Gst.Callbacks.C_TypeFindPeekFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gst.Callbacks.dynamic_TypeFindPeekFieldCallback val'
return val''
return result
setTypeFindPeek :: MonadIO m => TypeFind -> FunPtr Gst.Callbacks.C_TypeFindPeekFieldCallback -> m ()
setTypeFindPeek s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 0) (val :: FunPtr Gst.Callbacks.C_TypeFindPeekFieldCallback)
clearTypeFindPeek :: MonadIO m => TypeFind -> m ()
clearTypeFindPeek s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 0) (FP.nullFunPtr :: FunPtr Gst.Callbacks.C_TypeFindPeekFieldCallback)
#if ENABLE_OVERLOADING
data TypeFindPeekFieldInfo
instance AttrInfo TypeFindPeekFieldInfo where
type AttrAllowedOps TypeFindPeekFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeFindPeekFieldInfo = (~) (FunPtr Gst.Callbacks.C_TypeFindPeekFieldCallback)
type AttrBaseTypeConstraint TypeFindPeekFieldInfo = (~) TypeFind
type AttrGetType TypeFindPeekFieldInfo = Maybe Gst.Callbacks.TypeFindPeekFieldCallback
type AttrLabel TypeFindPeekFieldInfo = "peek"
type AttrOrigin TypeFindPeekFieldInfo = TypeFind
attrGet _ = getTypeFindPeek
attrSet _ = setTypeFindPeek
attrConstruct = undefined
attrClear _ = clearTypeFindPeek
typeFind_peek :: AttrLabelProxy "peek"
typeFind_peek = AttrLabelProxy
#endif
getTypeFindSuggest :: MonadIO m => TypeFind -> m (Maybe Gst.Callbacks.TypeFindSuggestFieldCallback)
getTypeFindSuggest s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 8) :: IO (FunPtr Gst.Callbacks.C_TypeFindSuggestFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gst.Callbacks.dynamic_TypeFindSuggestFieldCallback val'
return val''
return result
setTypeFindSuggest :: MonadIO m => TypeFind -> FunPtr Gst.Callbacks.C_TypeFindSuggestFieldCallback -> m ()
setTypeFindSuggest s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 8) (val :: FunPtr Gst.Callbacks.C_TypeFindSuggestFieldCallback)
clearTypeFindSuggest :: MonadIO m => TypeFind -> m ()
clearTypeFindSuggest s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 8) (FP.nullFunPtr :: FunPtr Gst.Callbacks.C_TypeFindSuggestFieldCallback)
#if ENABLE_OVERLOADING
data TypeFindSuggestFieldInfo
instance AttrInfo TypeFindSuggestFieldInfo where
type AttrAllowedOps TypeFindSuggestFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeFindSuggestFieldInfo = (~) (FunPtr Gst.Callbacks.C_TypeFindSuggestFieldCallback)
type AttrBaseTypeConstraint TypeFindSuggestFieldInfo = (~) TypeFind
type AttrGetType TypeFindSuggestFieldInfo = Maybe Gst.Callbacks.TypeFindSuggestFieldCallback
type AttrLabel TypeFindSuggestFieldInfo = "suggest"
type AttrOrigin TypeFindSuggestFieldInfo = TypeFind
attrGet _ = getTypeFindSuggest
attrSet _ = setTypeFindSuggest
attrConstruct = undefined
attrClear _ = clearTypeFindSuggest
typeFind_suggest :: AttrLabelProxy "suggest"
typeFind_suggest = AttrLabelProxy
#endif
getTypeFindData :: MonadIO m => TypeFind -> m (Ptr ())
getTypeFindData s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 16) :: IO (Ptr ())
return val
setTypeFindData :: MonadIO m => TypeFind -> Ptr () -> m ()
setTypeFindData s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 16) (val :: Ptr ())
clearTypeFindData :: MonadIO m => TypeFind -> m ()
clearTypeFindData s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr ())
#if ENABLE_OVERLOADING
data TypeFindDataFieldInfo
instance AttrInfo TypeFindDataFieldInfo where
type AttrAllowedOps TypeFindDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeFindDataFieldInfo = (~) (Ptr ())
type AttrBaseTypeConstraint TypeFindDataFieldInfo = (~) TypeFind
type AttrGetType TypeFindDataFieldInfo = Ptr ()
type AttrLabel TypeFindDataFieldInfo = "data"
type AttrOrigin TypeFindDataFieldInfo = TypeFind
attrGet _ = getTypeFindData
attrSet _ = setTypeFindData
attrConstruct = undefined
attrClear _ = clearTypeFindData
typeFind_data :: AttrLabelProxy "data"
typeFind_data = AttrLabelProxy
#endif
getTypeFindGetLength :: MonadIO m => TypeFind -> m (Maybe Gst.Callbacks.TypeFindGetLengthFieldCallback)
getTypeFindGetLength s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 24) :: IO (FunPtr Gst.Callbacks.C_TypeFindGetLengthFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gst.Callbacks.dynamic_TypeFindGetLengthFieldCallback val'
return val''
return result
setTypeFindGetLength :: MonadIO m => TypeFind -> FunPtr Gst.Callbacks.C_TypeFindGetLengthFieldCallback -> m ()
setTypeFindGetLength s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 24) (val :: FunPtr Gst.Callbacks.C_TypeFindGetLengthFieldCallback)
clearTypeFindGetLength :: MonadIO m => TypeFind -> m ()
clearTypeFindGetLength s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 24) (FP.nullFunPtr :: FunPtr Gst.Callbacks.C_TypeFindGetLengthFieldCallback)
#if ENABLE_OVERLOADING
data TypeFindGetLengthFieldInfo
instance AttrInfo TypeFindGetLengthFieldInfo where
type AttrAllowedOps TypeFindGetLengthFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeFindGetLengthFieldInfo = (~) (FunPtr Gst.Callbacks.C_TypeFindGetLengthFieldCallback)
type AttrBaseTypeConstraint TypeFindGetLengthFieldInfo = (~) TypeFind
type AttrGetType TypeFindGetLengthFieldInfo = Maybe Gst.Callbacks.TypeFindGetLengthFieldCallback
type AttrLabel TypeFindGetLengthFieldInfo = "get_length"
type AttrOrigin TypeFindGetLengthFieldInfo = TypeFind
attrGet _ = getTypeFindGetLength
attrSet _ = setTypeFindGetLength
attrConstruct = undefined
attrClear _ = clearTypeFindGetLength
typeFind_getLength :: AttrLabelProxy "getLength"
typeFind_getLength = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList TypeFind
type instance O.AttributeList TypeFind = TypeFindAttributeList
type TypeFindAttributeList = ('[ '("peek", TypeFindPeekFieldInfo), '("suggest", TypeFindSuggestFieldInfo), '("data", TypeFindDataFieldInfo), '("getLength", TypeFindGetLengthFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_type_find_get_length" gst_type_find_get_length ::
Ptr TypeFind ->
IO Word64
typeFindGetLength ::
(B.CallStack.HasCallStack, MonadIO m) =>
TypeFind
-> m Word64
typeFindGetLength find = liftIO $ do
find' <- unsafeManagedPtrGetPtr find
result <- gst_type_find_get_length find'
touchManagedPtr find
return result
#if ENABLE_OVERLOADING
data TypeFindGetLengthMethodInfo
instance (signature ~ (m Word64), MonadIO m) => O.MethodInfo TypeFindGetLengthMethodInfo TypeFind signature where
overloadedMethod _ = typeFindGetLength
#endif
foreign import ccall "gst_type_find_peek" gst_type_find_peek ::
Ptr TypeFind ->
Int64 ->
Ptr Word32 ->
IO (Ptr Word8)
typeFindPeek ::
(B.CallStack.HasCallStack, MonadIO m) =>
TypeFind
-> Int64
-> m (Maybe ByteString)
typeFindPeek find offset = liftIO $ do
find' <- unsafeManagedPtrGetPtr find
size <- allocMem :: IO (Ptr Word32)
result <- gst_type_find_peek find' offset size
size' <- peek size
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (unpackByteStringWithLength size') result'
return result''
touchManagedPtr find
freeMem size
return maybeResult
#if ENABLE_OVERLOADING
data TypeFindPeekMethodInfo
instance (signature ~ (Int64 -> m (Maybe ByteString)), MonadIO m) => O.MethodInfo TypeFindPeekMethodInfo TypeFind signature where
overloadedMethod _ = typeFindPeek
#endif
foreign import ccall "gst_type_find_suggest" gst_type_find_suggest ::
Ptr TypeFind ->
Word32 ->
Ptr Gst.Caps.Caps ->
IO ()
typeFindSuggest ::
(B.CallStack.HasCallStack, MonadIO m) =>
TypeFind
-> Word32
-> Gst.Caps.Caps
-> m ()
typeFindSuggest find probability caps = liftIO $ do
find' <- unsafeManagedPtrGetPtr find
caps' <- unsafeManagedPtrGetPtr caps
gst_type_find_suggest find' probability caps'
touchManagedPtr find
touchManagedPtr caps
return ()
#if ENABLE_OVERLOADING
data TypeFindSuggestMethodInfo
instance (signature ~ (Word32 -> Gst.Caps.Caps -> m ()), MonadIO m) => O.MethodInfo TypeFindSuggestMethodInfo TypeFind signature where
overloadedMethod _ = typeFindSuggest
#endif
foreign import ccall "gst_type_find_register" gst_type_find_register ::
Ptr Gst.Plugin.Plugin ->
CString ->
Word32 ->
FunPtr Gst.Callbacks.C_TypeFindFunction ->
CString ->
Ptr Gst.Caps.Caps ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO CInt
typeFindRegister ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Plugin.IsPlugin a) =>
Maybe (a)
-> T.Text
-> Word32
-> Gst.Callbacks.TypeFindFunction
-> Maybe (T.Text)
-> Gst.Caps.Caps
-> m Bool
typeFindRegister plugin name rank func extensions possibleCaps = liftIO $ do
maybePlugin <- case plugin of
Nothing -> return nullPtr
Just jPlugin -> do
jPlugin' <- unsafeManagedPtrCastPtr jPlugin
return jPlugin'
name' <- textToCString name
func' <- Gst.Callbacks.mk_TypeFindFunction (Gst.Callbacks.wrap_TypeFindFunction Nothing (Gst.Callbacks.drop_closures_TypeFindFunction func))
maybeExtensions <- case extensions of
Nothing -> return nullPtr
Just jExtensions -> do
jExtensions' <- textToCString jExtensions
return jExtensions'
possibleCaps' <- unsafeManagedPtrGetPtr possibleCaps
let data_ = castFunPtrToPtr func'
let dataNotify = safeFreeFunPtrPtr
result <- gst_type_find_register maybePlugin name' rank func' maybeExtensions possibleCaps' data_ dataNotify
let result' = (/= 0) result
whenJust plugin touchManagedPtr
touchManagedPtr possibleCaps
freeMem name'
freeMem maybeExtensions
return result'
#if ENABLE_OVERLOADING
#endif
#if ENABLE_OVERLOADING
type family ResolveTypeFindMethod (t :: Symbol) (o :: *) :: * where
ResolveTypeFindMethod "peek" o = TypeFindPeekMethodInfo
ResolveTypeFindMethod "suggest" o = TypeFindSuggestMethodInfo
ResolveTypeFindMethod "getLength" o = TypeFindGetLengthMethodInfo
ResolveTypeFindMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTypeFindMethod t TypeFind, O.MethodInfo info TypeFind p) => O.IsLabelProxy t (TypeFind -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveTypeFindMethod t TypeFind, O.MethodInfo info TypeFind p) => O.IsLabel t (TypeFind -> 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