diff --git a/GI/GstBase.hs b/GI/GstBase.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase.hs @@ -0,0 +1,42 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase + ( module GI.GstBase.Callbacks , + module GI.GstBase.Constants , + module GI.GstBase.Flags , + module GI.GstBase.Functions , + module GI.GstBase.Objects , + module GI.GstBase.Structs , + + + + module Data.GI.Base , + + + ) where + +import GI.GstBase.Callbacks +import GI.GstBase.Constants +import GI.GstBase.Flags +import GI.GstBase.Functions +import GI.GstBase.Objects +import GI.GstBase.Structs + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks + +import Data.GI.Base + diff --git a/GI/GstBase/Callbacks.hs b/GI/GstBase/Callbacks.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Callbacks.hs @@ -0,0 +1,548 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Callbacks + ( + + -- * Signals +-- ** CollectDataDestroyNotify + CollectDataDestroyNotify , + CollectDataDestroyNotifyC , + collectDataDestroyNotifyClosure , + collectDataDestroyNotifyWrapper , + mkCollectDataDestroyNotify , + noCollectDataDestroyNotify , + + +-- ** CollectPadsBufferFunction + CollectPadsBufferFunction , + CollectPadsBufferFunctionC , + collectPadsBufferFunctionClosure , + collectPadsBufferFunctionWrapper , + mkCollectPadsBufferFunction , + noCollectPadsBufferFunction , + + +-- ** CollectPadsClipFunction + CollectPadsClipFunction , + CollectPadsClipFunctionC , + collectPadsClipFunctionClosure , + collectPadsClipFunctionWrapper , + mkCollectPadsClipFunction , + noCollectPadsClipFunction , + + +-- ** CollectPadsCompareFunction + CollectPadsCompareFunction , + CollectPadsCompareFunctionC , + collectPadsCompareFunctionClosure , + collectPadsCompareFunctionWrapper , + mkCollectPadsCompareFunction , + noCollectPadsCompareFunction , + + +-- ** CollectPadsEventFunction + CollectPadsEventFunction , + CollectPadsEventFunctionC , + collectPadsEventFunctionClosure , + collectPadsEventFunctionWrapper , + mkCollectPadsEventFunction , + noCollectPadsEventFunction , + + +-- ** CollectPadsFlushFunction + CollectPadsFlushFunction , + CollectPadsFlushFunctionC , + collectPadsFlushFunctionClosure , + collectPadsFlushFunctionWrapper , + mkCollectPadsFlushFunction , + noCollectPadsFlushFunction , + + +-- ** CollectPadsFunction + CollectPadsFunction , + CollectPadsFunctionC , + collectPadsFunctionClosure , + collectPadsFunctionWrapper , + mkCollectPadsFunction , + noCollectPadsFunction , + + +-- ** CollectPadsQueryFunction + CollectPadsQueryFunction , + CollectPadsQueryFunctionC , + collectPadsQueryFunctionClosure , + collectPadsQueryFunctionWrapper , + mkCollectPadsQueryFunction , + noCollectPadsQueryFunction , + + +-- ** DataQueueEmptyCallback + DataQueueEmptyCallback , + DataQueueEmptyCallbackC , + dataQueueEmptyCallbackClosure , + dataQueueEmptyCallbackWrapper , + mkDataQueueEmptyCallback , + noDataQueueEmptyCallback , + + +-- ** DataQueueFullCallback + DataQueueFullCallback , + DataQueueFullCallbackC , + dataQueueFullCallbackClosure , + dataQueueFullCallbackWrapper , + mkDataQueueFullCallback , + noDataQueueFullCallback , + + +-- ** TypeFindHelperGetRangeFunction + TypeFindHelperGetRangeFunction , + TypeFindHelperGetRangeFunctionC , + mkTypeFindHelperGetRangeFunction , + noTypeFindHelperGetRangeFunction , + typeFindHelperGetRangeFunctionClosure , + typeFindHelperGetRangeFunctionWrapper , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types + +import qualified GI.Gst as Gst + +-- callback TypeFindHelperGetRangeFunction +typeFindHelperGetRangeFunctionClosure :: TypeFindHelperGetRangeFunction -> IO Closure +typeFindHelperGetRangeFunctionClosure cb = newCClosure =<< mkTypeFindHelperGetRangeFunction wrapped + where wrapped = typeFindHelperGetRangeFunctionWrapper Nothing cb + +type TypeFindHelperGetRangeFunctionC = + Ptr Gst.Object -> + Ptr Gst.Object -> + Word64 -> + Word32 -> + Ptr Gst.Buffer -> + IO CUInt + +foreign import ccall "wrapper" + mkTypeFindHelperGetRangeFunction :: TypeFindHelperGetRangeFunctionC -> IO (FunPtr TypeFindHelperGetRangeFunctionC) + +type TypeFindHelperGetRangeFunction = + Gst.Object -> + Maybe Gst.Object -> + Word64 -> + Word32 -> + Gst.Buffer -> + IO Gst.FlowReturn + +noTypeFindHelperGetRangeFunction :: Maybe TypeFindHelperGetRangeFunction +noTypeFindHelperGetRangeFunction = Nothing + +typeFindHelperGetRangeFunctionWrapper :: + Maybe (Ptr (FunPtr (TypeFindHelperGetRangeFunctionC))) -> + TypeFindHelperGetRangeFunction -> + Ptr Gst.Object -> + Ptr Gst.Object -> + Word64 -> + Word32 -> + Ptr Gst.Buffer -> + IO CUInt +typeFindHelperGetRangeFunctionWrapper funptrptr _cb obj parent offset length_ buffer = do + obj' <- (newObject Gst.Object) obj + maybeParent <- + if parent == nullPtr + then return Nothing + else do + parent' <- (newObject Gst.Object) parent + return $ Just parent' + buffer' <- (newBoxed Gst.Buffer) buffer + result <- _cb obj' maybeParent offset length_ buffer' + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + +-- callback DataQueueFullCallback +dataQueueFullCallbackClosure :: DataQueueFullCallback -> IO Closure +dataQueueFullCallbackClosure cb = newCClosure =<< mkDataQueueFullCallback wrapped + where wrapped = dataQueueFullCallbackWrapper Nothing cb + +type DataQueueFullCallbackC = + Ptr DataQueue -> + Ptr () -> + IO () + +foreign import ccall "wrapper" + mkDataQueueFullCallback :: DataQueueFullCallbackC -> IO (FunPtr DataQueueFullCallbackC) + +type DataQueueFullCallback = + DataQueue -> + Ptr () -> + IO () + +noDataQueueFullCallback :: Maybe DataQueueFullCallback +noDataQueueFullCallback = Nothing + +dataQueueFullCallbackWrapper :: + Maybe (Ptr (FunPtr (DataQueueFullCallbackC))) -> + DataQueueFullCallback -> + Ptr DataQueue -> + Ptr () -> + IO () +dataQueueFullCallbackWrapper funptrptr _cb queue checkdata = do + queue' <- (newObject DataQueue) queue + _cb queue' checkdata + maybeReleaseFunPtr funptrptr + +-- callback DataQueueEmptyCallback +dataQueueEmptyCallbackClosure :: DataQueueEmptyCallback -> IO Closure +dataQueueEmptyCallbackClosure cb = newCClosure =<< mkDataQueueEmptyCallback wrapped + where wrapped = dataQueueEmptyCallbackWrapper Nothing cb + +type DataQueueEmptyCallbackC = + Ptr DataQueue -> + Ptr () -> + IO () + +foreign import ccall "wrapper" + mkDataQueueEmptyCallback :: DataQueueEmptyCallbackC -> IO (FunPtr DataQueueEmptyCallbackC) + +type DataQueueEmptyCallback = + DataQueue -> + Ptr () -> + IO () + +noDataQueueEmptyCallback :: Maybe DataQueueEmptyCallback +noDataQueueEmptyCallback = Nothing + +dataQueueEmptyCallbackWrapper :: + Maybe (Ptr (FunPtr (DataQueueEmptyCallbackC))) -> + DataQueueEmptyCallback -> + Ptr DataQueue -> + Ptr () -> + IO () +dataQueueEmptyCallbackWrapper funptrptr _cb queue checkdata = do + queue' <- (newObject DataQueue) queue + _cb queue' checkdata + maybeReleaseFunPtr funptrptr + +-- callback CollectPadsQueryFunction +collectPadsQueryFunctionClosure :: CollectPadsQueryFunction -> IO Closure +collectPadsQueryFunctionClosure cb = newCClosure =<< mkCollectPadsQueryFunction wrapped + where wrapped = collectPadsQueryFunctionWrapper Nothing cb + +type CollectPadsQueryFunctionC = + Ptr CollectPads -> + Ptr CollectData -> + Ptr Gst.Query -> + Ptr () -> + IO CInt + +foreign import ccall "wrapper" + mkCollectPadsQueryFunction :: CollectPadsQueryFunctionC -> IO (FunPtr CollectPadsQueryFunctionC) + +type CollectPadsQueryFunction = + CollectPads -> + CollectData -> + Gst.Query -> + IO Bool + +noCollectPadsQueryFunction :: Maybe CollectPadsQueryFunction +noCollectPadsQueryFunction = Nothing + +collectPadsQueryFunctionWrapper :: + Maybe (Ptr (FunPtr (CollectPadsQueryFunctionC))) -> + CollectPadsQueryFunction -> + Ptr CollectPads -> + Ptr CollectData -> + Ptr Gst.Query -> + Ptr () -> + IO CInt +collectPadsQueryFunctionWrapper funptrptr _cb pads pad query _ = do + pads' <- (newObject CollectPads) pads + pad' <- (newPtr 168 CollectData) pad + query' <- (newBoxed Gst.Query) query + result <- _cb pads' pad' query' + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + +-- callback CollectPadsFunction +collectPadsFunctionClosure :: CollectPadsFunction -> IO Closure +collectPadsFunctionClosure cb = newCClosure =<< mkCollectPadsFunction wrapped + where wrapped = collectPadsFunctionWrapper Nothing cb + +type CollectPadsFunctionC = + Ptr CollectPads -> + Ptr () -> + IO CUInt + +foreign import ccall "wrapper" + mkCollectPadsFunction :: CollectPadsFunctionC -> IO (FunPtr CollectPadsFunctionC) + +type CollectPadsFunction = + CollectPads -> + IO Gst.FlowReturn + +noCollectPadsFunction :: Maybe CollectPadsFunction +noCollectPadsFunction = Nothing + +collectPadsFunctionWrapper :: + Maybe (Ptr (FunPtr (CollectPadsFunctionC))) -> + CollectPadsFunction -> + Ptr CollectPads -> + Ptr () -> + IO CUInt +collectPadsFunctionWrapper funptrptr _cb pads _ = do + pads' <- (newObject CollectPads) pads + result <- _cb pads' + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + +-- callback CollectPadsFlushFunction +collectPadsFlushFunctionClosure :: CollectPadsFlushFunction -> IO Closure +collectPadsFlushFunctionClosure cb = newCClosure =<< mkCollectPadsFlushFunction wrapped + where wrapped = collectPadsFlushFunctionWrapper Nothing cb + +type CollectPadsFlushFunctionC = + Ptr CollectPads -> + Ptr () -> + IO () + +foreign import ccall "wrapper" + mkCollectPadsFlushFunction :: CollectPadsFlushFunctionC -> IO (FunPtr CollectPadsFlushFunctionC) + +type CollectPadsFlushFunction = + CollectPads -> + IO () + +noCollectPadsFlushFunction :: Maybe CollectPadsFlushFunction +noCollectPadsFlushFunction = Nothing + +collectPadsFlushFunctionWrapper :: + Maybe (Ptr (FunPtr (CollectPadsFlushFunctionC))) -> + CollectPadsFlushFunction -> + Ptr CollectPads -> + Ptr () -> + IO () +collectPadsFlushFunctionWrapper funptrptr _cb pads _ = do + pads' <- (newObject CollectPads) pads + _cb pads' + maybeReleaseFunPtr funptrptr + +-- callback CollectPadsEventFunction +collectPadsEventFunctionClosure :: CollectPadsEventFunction -> IO Closure +collectPadsEventFunctionClosure cb = newCClosure =<< mkCollectPadsEventFunction wrapped + where wrapped = collectPadsEventFunctionWrapper Nothing cb + +type CollectPadsEventFunctionC = + Ptr CollectPads -> + Ptr CollectData -> + Ptr Gst.Event -> + Ptr () -> + IO CInt + +foreign import ccall "wrapper" + mkCollectPadsEventFunction :: CollectPadsEventFunctionC -> IO (FunPtr CollectPadsEventFunctionC) + +type CollectPadsEventFunction = + CollectPads -> + CollectData -> + Gst.Event -> + IO Bool + +noCollectPadsEventFunction :: Maybe CollectPadsEventFunction +noCollectPadsEventFunction = Nothing + +collectPadsEventFunctionWrapper :: + Maybe (Ptr (FunPtr (CollectPadsEventFunctionC))) -> + CollectPadsEventFunction -> + Ptr CollectPads -> + Ptr CollectData -> + Ptr Gst.Event -> + Ptr () -> + IO CInt +collectPadsEventFunctionWrapper funptrptr _cb pads pad event _ = do + pads' <- (newObject CollectPads) pads + pad' <- (newPtr 168 CollectData) pad + event' <- (newBoxed Gst.Event) event + result <- _cb pads' pad' event' + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + +-- callback CollectPadsCompareFunction +collectPadsCompareFunctionClosure :: CollectPadsCompareFunction -> IO Closure +collectPadsCompareFunctionClosure cb = newCClosure =<< mkCollectPadsCompareFunction wrapped + where wrapped = collectPadsCompareFunctionWrapper Nothing cb + +type CollectPadsCompareFunctionC = + Ptr CollectPads -> + Ptr CollectData -> + Word64 -> + Ptr CollectData -> + Word64 -> + Ptr () -> + IO Int32 + +foreign import ccall "wrapper" + mkCollectPadsCompareFunction :: CollectPadsCompareFunctionC -> IO (FunPtr CollectPadsCompareFunctionC) + +type CollectPadsCompareFunction = + CollectPads -> + CollectData -> + Word64 -> + CollectData -> + Word64 -> + IO Int32 + +noCollectPadsCompareFunction :: Maybe CollectPadsCompareFunction +noCollectPadsCompareFunction = Nothing + +collectPadsCompareFunctionWrapper :: + Maybe (Ptr (FunPtr (CollectPadsCompareFunctionC))) -> + CollectPadsCompareFunction -> + Ptr CollectPads -> + Ptr CollectData -> + Word64 -> + Ptr CollectData -> + Word64 -> + Ptr () -> + IO Int32 +collectPadsCompareFunctionWrapper funptrptr _cb pads data1 timestamp1 data2 timestamp2 _ = do + pads' <- (newObject CollectPads) pads + data1' <- (newPtr 168 CollectData) data1 + data2' <- (newPtr 168 CollectData) data2 + result <- _cb pads' data1' timestamp1 data2' timestamp2 + maybeReleaseFunPtr funptrptr + return result + +-- callback CollectPadsClipFunction +collectPadsClipFunctionClosure :: CollectPadsClipFunction -> IO Closure +collectPadsClipFunctionClosure cb = newCClosure =<< mkCollectPadsClipFunction wrapped + where wrapped = collectPadsClipFunctionWrapper Nothing cb + +type CollectPadsClipFunctionC = + Ptr CollectPads -> + Ptr CollectData -> + Ptr Gst.Buffer -> + Ptr Gst.Buffer -> + Ptr () -> + IO CUInt + +foreign import ccall "wrapper" + mkCollectPadsClipFunction :: CollectPadsClipFunctionC -> IO (FunPtr CollectPadsClipFunctionC) + +type CollectPadsClipFunction = + CollectPads -> + CollectData -> + Gst.Buffer -> + Gst.Buffer -> + IO Gst.FlowReturn + +noCollectPadsClipFunction :: Maybe CollectPadsClipFunction +noCollectPadsClipFunction = Nothing + +collectPadsClipFunctionWrapper :: + Maybe (Ptr (FunPtr (CollectPadsClipFunctionC))) -> + CollectPadsClipFunction -> + Ptr CollectPads -> + Ptr CollectData -> + Ptr Gst.Buffer -> + Ptr Gst.Buffer -> + Ptr () -> + IO CUInt +collectPadsClipFunctionWrapper funptrptr _cb pads data_ inbuffer outbuffer _ = do + pads' <- (newObject CollectPads) pads + data_' <- (newPtr 168 CollectData) data_ + inbuffer' <- (wrapBoxed Gst.Buffer) inbuffer + outbuffer' <- (newBoxed Gst.Buffer) outbuffer + result <- _cb pads' data_' inbuffer' outbuffer' + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + +-- callback CollectPadsBufferFunction +collectPadsBufferFunctionClosure :: CollectPadsBufferFunction -> IO Closure +collectPadsBufferFunctionClosure cb = newCClosure =<< mkCollectPadsBufferFunction wrapped + where wrapped = collectPadsBufferFunctionWrapper Nothing cb + +type CollectPadsBufferFunctionC = + Ptr CollectPads -> + Ptr CollectData -> + Ptr Gst.Buffer -> + Ptr () -> + IO CUInt + +foreign import ccall "wrapper" + mkCollectPadsBufferFunction :: CollectPadsBufferFunctionC -> IO (FunPtr CollectPadsBufferFunctionC) + +type CollectPadsBufferFunction = + CollectPads -> + CollectData -> + Gst.Buffer -> + IO Gst.FlowReturn + +noCollectPadsBufferFunction :: Maybe CollectPadsBufferFunction +noCollectPadsBufferFunction = Nothing + +collectPadsBufferFunctionWrapper :: + Maybe (Ptr (FunPtr (CollectPadsBufferFunctionC))) -> + CollectPadsBufferFunction -> + Ptr CollectPads -> + Ptr CollectData -> + Ptr Gst.Buffer -> + Ptr () -> + IO CUInt +collectPadsBufferFunctionWrapper funptrptr _cb pads data_ buffer _ = do + pads' <- (newObject CollectPads) pads + data_' <- (newPtr 168 CollectData) data_ + buffer' <- (wrapBoxed Gst.Buffer) buffer + result <- _cb pads' data_' buffer' + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + +-- callback CollectDataDestroyNotify +collectDataDestroyNotifyClosure :: CollectDataDestroyNotify -> IO Closure +collectDataDestroyNotifyClosure cb = newCClosure =<< mkCollectDataDestroyNotify wrapped + where wrapped = collectDataDestroyNotifyWrapper Nothing cb + +type CollectDataDestroyNotifyC = + Ptr CollectData -> + IO () + +foreign import ccall "wrapper" + mkCollectDataDestroyNotify :: CollectDataDestroyNotifyC -> IO (FunPtr CollectDataDestroyNotifyC) + +type CollectDataDestroyNotify = + CollectData -> + IO () + +noCollectDataDestroyNotify :: Maybe CollectDataDestroyNotify +noCollectDataDestroyNotify = Nothing + +collectDataDestroyNotifyWrapper :: + Maybe (Ptr (FunPtr (CollectDataDestroyNotifyC))) -> + CollectDataDestroyNotify -> + Ptr CollectData -> + IO () +collectDataDestroyNotifyWrapper funptrptr _cb data_ = do + data_' <- (newPtr 168 CollectData) data_ + _cb data_' + maybeReleaseFunPtr funptrptr + + diff --git a/GI/GstBase/Constants.hs b/GI/GstBase/Constants.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Constants.hs @@ -0,0 +1,41 @@ +{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-} + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Constants + ( + pattern BASE_TRANSFORM_SRC_NAME , + pattern BASE_TRANSFORM_SINK_NAME , + pattern BASE_PARSE_FLAG_LOST_SYNC , + pattern BASE_PARSE_FLAG_DRAINING , + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks + + +pattern BASE_TRANSFORM_SRC_NAME = "src" :: T.Text + + +pattern BASE_TRANSFORM_SINK_NAME = "sink" :: T.Text + + +pattern BASE_PARSE_FLAG_LOST_SYNC = 1 :: Int32 + + +pattern BASE_PARSE_FLAG_DRAINING = 2 :: Int32 + + diff --git a/GI/GstBase/Flags.hs b/GI/GstBase/Flags.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Flags.hs @@ -0,0 +1,111 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Flags + ( + +-- * Exported types + CollectPadsStateFlags(..) , + BaseSrcFlags(..) , + BaseParseFrameFlags(..) , + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + + + + +-- Flags CollectPadsStateFlags + +data CollectPadsStateFlags = + CollectPadsStateFlagsEos + | CollectPadsStateFlagsFlushing + | CollectPadsStateFlagsNewSegment + | CollectPadsStateFlagsWaiting + | CollectPadsStateFlagsLocked + | AnotherCollectPadsStateFlags Int + deriving (Show, Eq) + +instance Enum CollectPadsStateFlags where + fromEnum CollectPadsStateFlagsEos = 1 + fromEnum CollectPadsStateFlagsFlushing = 2 + fromEnum CollectPadsStateFlagsNewSegment = 4 + fromEnum CollectPadsStateFlagsWaiting = 8 + fromEnum CollectPadsStateFlagsLocked = 16 + fromEnum (AnotherCollectPadsStateFlags k) = k + + toEnum 1 = CollectPadsStateFlagsEos + toEnum 2 = CollectPadsStateFlagsFlushing + toEnum 4 = CollectPadsStateFlagsNewSegment + toEnum 8 = CollectPadsStateFlagsWaiting + toEnum 16 = CollectPadsStateFlagsLocked + toEnum k = AnotherCollectPadsStateFlags k + +instance IsGFlag CollectPadsStateFlags + +-- Flags BaseSrcFlags + +data BaseSrcFlags = + BaseSrcFlagsStarting + | BaseSrcFlagsStarted + | BaseSrcFlagsLast + | AnotherBaseSrcFlags Int + deriving (Show, Eq) + +instance Enum BaseSrcFlags where + fromEnum BaseSrcFlagsStarting = 16384 + fromEnum BaseSrcFlagsStarted = 32768 + fromEnum BaseSrcFlagsLast = 1048576 + fromEnum (AnotherBaseSrcFlags k) = k + + toEnum 16384 = BaseSrcFlagsStarting + toEnum 32768 = BaseSrcFlagsStarted + toEnum 1048576 = BaseSrcFlagsLast + toEnum k = AnotherBaseSrcFlags k + +instance IsGFlag BaseSrcFlags + +-- Flags BaseParseFrameFlags + +data BaseParseFrameFlags = + BaseParseFrameFlagsNone + | BaseParseFrameFlagsNewFrame + | BaseParseFrameFlagsNoFrame + | BaseParseFrameFlagsClip + | BaseParseFrameFlagsDrop + | BaseParseFrameFlagsQueue + | AnotherBaseParseFrameFlags Int + deriving (Show, Eq) + +instance Enum BaseParseFrameFlags where + fromEnum BaseParseFrameFlagsNone = 0 + fromEnum BaseParseFrameFlagsNewFrame = 1 + fromEnum BaseParseFrameFlagsNoFrame = 2 + fromEnum BaseParseFrameFlagsClip = 4 + fromEnum BaseParseFrameFlagsDrop = 8 + fromEnum BaseParseFrameFlagsQueue = 16 + fromEnum (AnotherBaseParseFrameFlags k) = k + + toEnum 0 = BaseParseFrameFlagsNone + toEnum 1 = BaseParseFrameFlagsNewFrame + toEnum 2 = BaseParseFrameFlagsNoFrame + toEnum 4 = BaseParseFrameFlagsClip + toEnum 8 = BaseParseFrameFlagsDrop + toEnum 16 = BaseParseFrameFlagsQueue + toEnum k = AnotherBaseParseFrameFlags k + +instance IsGFlag BaseParseFrameFlags + + diff --git a/GI/GstBase/Functions.hs b/GI/GstBase/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Functions.hs @@ -0,0 +1,232 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Functions + ( + + -- * Methods +-- ** typeFindHelper + typeFindHelper , + + +-- ** typeFindHelperForBuffer + typeFindHelperForBuffer , + + +-- ** typeFindHelperForData + typeFindHelperForData , + + +-- ** typeFindHelperForExtension + typeFindHelperForExtension , + + +-- ** typeFindHelperGetRange + typeFindHelperGetRange , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks +import qualified GI.Gst as Gst + +-- function gst_type_find_helper_get_range +-- Args : [Arg {argCName = "obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "GstBase" "TypeFindHelperGetRangeFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "extension", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "prob", argType = TInterface "Gst" "TypeFindProbability", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Caps" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_type_find_helper_get_range" gst_type_find_helper_get_range :: + Ptr Gst.Object -> -- obj : TInterface "Gst" "Object" + Ptr Gst.Object -> -- parent : TInterface "Gst" "Object" + FunPtr TypeFindHelperGetRangeFunctionC -> -- func : TInterface "GstBase" "TypeFindHelperGetRangeFunction" + Word64 -> -- size : TBasicType TUInt64 + CString -> -- extension : TBasicType TUTF8 + Ptr CUInt -> -- prob : TInterface "Gst" "TypeFindProbability" + IO (Ptr Gst.Caps) + + +typeFindHelperGetRange :: + (MonadIO m, Gst.ObjectK a, Gst.ObjectK b) => + a -- obj + -> Maybe (b) -- parent + -> TypeFindHelperGetRangeFunction -- func + -> Word64 -- size + -> T.Text -- extension + -> m (Gst.Caps,Gst.TypeFindProbability) -- result +typeFindHelperGetRange obj parent func size extension = liftIO $ do + let obj' = unsafeManagedPtrCastPtr obj + maybeParent <- case parent of + Nothing -> return nullPtr + Just jParent -> do + let jParent' = unsafeManagedPtrCastPtr jParent + return jParent' + func' <- mkTypeFindHelperGetRangeFunction (typeFindHelperGetRangeFunctionWrapper Nothing func) + extension' <- textToCString extension + prob <- allocMem :: IO (Ptr CUInt) + result <- gst_type_find_helper_get_range obj' maybeParent func' size extension' prob + checkUnexpectedReturnNULL "gst_type_find_helper_get_range" result + result' <- (wrapBoxed Gst.Caps) result + prob' <- peek prob + let prob'' = (toEnum . fromIntegral) prob' + safeFreeFunPtr $ castFunPtrToPtr func' + touchManagedPtr obj + whenJust parent touchManagedPtr + freeMem extension' + freeMem prob + return (result', prob'') + + +-- function gst_type_find_helper_for_extension +-- Args : [Arg {argCName = "obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "extension", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Caps" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_type_find_helper_for_extension" gst_type_find_helper_for_extension :: + Ptr Gst.Object -> -- obj : TInterface "Gst" "Object" + CString -> -- extension : TBasicType TUTF8 + IO (Ptr Gst.Caps) + + +typeFindHelperForExtension :: + (MonadIO m, Gst.ObjectK a) => + Maybe (a) -- obj + -> T.Text -- extension + -> m Gst.Caps -- result +typeFindHelperForExtension obj extension = liftIO $ do + maybeObj <- case obj of + Nothing -> return nullPtr + Just jObj -> do + let jObj' = unsafeManagedPtrCastPtr jObj + return jObj' + extension' <- textToCString extension + result <- gst_type_find_helper_for_extension maybeObj extension' + checkUnexpectedReturnNULL "gst_type_find_helper_for_extension" result + result' <- (wrapBoxed Gst.Caps) result + whenJust obj touchManagedPtr + freeMem extension' + return result' + + +-- function gst_type_find_helper_for_data +-- Args : [Arg {argCName = "obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "prob", argType = TInterface "Gst" "TypeFindProbability", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Caps" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_type_find_helper_for_data" gst_type_find_helper_for_data :: + Ptr Gst.Object -> -- obj : TInterface "Gst" "Object" + Word8 -> -- data : TBasicType TUInt8 + Word64 -> -- size : TBasicType TUInt64 + Ptr CUInt -> -- prob : TInterface "Gst" "TypeFindProbability" + IO (Ptr Gst.Caps) + + +typeFindHelperForData :: + (MonadIO m, Gst.ObjectK a) => + Maybe (a) -- obj + -> Word8 -- data_ + -> Word64 -- size + -> m (Gst.Caps,Gst.TypeFindProbability) -- result +typeFindHelperForData obj data_ size = liftIO $ do + maybeObj <- case obj of + Nothing -> return nullPtr + Just jObj -> do + let jObj' = unsafeManagedPtrCastPtr jObj + return jObj' + prob <- allocMem :: IO (Ptr CUInt) + result <- gst_type_find_helper_for_data maybeObj data_ size prob + checkUnexpectedReturnNULL "gst_type_find_helper_for_data" result + result' <- (wrapBoxed Gst.Caps) result + prob' <- peek prob + let prob'' = (toEnum . fromIntegral) prob' + whenJust obj touchManagedPtr + freeMem prob + return (result', prob'') + + +-- function gst_type_find_helper_for_buffer +-- Args : [Arg {argCName = "obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "prob", argType = TInterface "Gst" "TypeFindProbability", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Caps" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_type_find_helper_for_buffer" gst_type_find_helper_for_buffer :: + Ptr Gst.Object -> -- obj : TInterface "Gst" "Object" + Ptr Gst.Buffer -> -- buf : TInterface "Gst" "Buffer" + Ptr CUInt -> -- prob : TInterface "Gst" "TypeFindProbability" + IO (Ptr Gst.Caps) + + +typeFindHelperForBuffer :: + (MonadIO m, Gst.ObjectK a) => + Maybe (a) -- obj + -> Gst.Buffer -- buf + -> m (Gst.Caps,Gst.TypeFindProbability) -- result +typeFindHelperForBuffer obj buf = liftIO $ do + maybeObj <- case obj of + Nothing -> return nullPtr + Just jObj -> do + let jObj' = unsafeManagedPtrCastPtr jObj + return jObj' + let buf' = unsafeManagedPtrGetPtr buf + prob <- allocMem :: IO (Ptr CUInt) + result <- gst_type_find_helper_for_buffer maybeObj buf' prob + checkUnexpectedReturnNULL "gst_type_find_helper_for_buffer" result + result' <- (wrapBoxed Gst.Caps) result + prob' <- peek prob + let prob'' = (toEnum . fromIntegral) prob' + whenJust obj touchManagedPtr + touchManagedPtr buf + freeMem prob + return (result', prob'') + + +-- function gst_type_find_helper +-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Caps" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_type_find_helper" gst_type_find_helper :: + Ptr Gst.Pad -> -- src : TInterface "Gst" "Pad" + Word64 -> -- size : TBasicType TUInt64 + IO (Ptr Gst.Caps) + + +typeFindHelper :: + (MonadIO m, Gst.PadK a) => + a -- src + -> Word64 -- size + -> m Gst.Caps -- result +typeFindHelper src size = liftIO $ do + let src' = unsafeManagedPtrCastPtr src + result <- gst_type_find_helper src' size + checkUnexpectedReturnNULL "gst_type_find_helper" result + result' <- (wrapBoxed Gst.Caps) result + touchManagedPtr src + return result' + + + diff --git a/GI/GstBase/Objects.hs b/GI/GstBase/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects.hs @@ -0,0 +1,41 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Objects + ( module GI.GstBase.Objects.Adapter , + module GI.GstBase.Objects.BaseParse , + module GI.GstBase.Objects.BaseSink , + module GI.GstBase.Objects.BaseSrc , + module GI.GstBase.Objects.BaseTransform , + module GI.GstBase.Objects.CollectPads , + module GI.GstBase.Objects.DataQueue , + module GI.GstBase.Objects.PushSrc , + + + ) where + +import GI.GstBase.Objects.Adapter +import GI.GstBase.Objects.BaseParse +import GI.GstBase.Objects.BaseSink +import GI.GstBase.Objects.BaseSrc +import GI.GstBase.Objects.BaseTransform +import GI.GstBase.Objects.CollectPads +import GI.GstBase.Objects.DataQueue +import GI.GstBase.Objects.PushSrc + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks + + diff --git a/GI/GstBase/Objects/Adapter.hs b/GI/GstBase/Objects/Adapter.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/Adapter.hs @@ -0,0 +1,982 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Objects.Adapter + ( + +-- * Exported types + Adapter(..) , + AdapterK , + toAdapter , + noAdapter , + + + -- * Methods +-- ** adapterAvailable + AdapterAvailableMethodInfo , + adapterAvailable , + + +-- ** adapterAvailableFast + AdapterAvailableFastMethodInfo , + adapterAvailableFast , + + +-- ** adapterClear + AdapterClearMethodInfo , + adapterClear , + + +-- ** adapterCopy + AdapterCopyMethodInfo , + adapterCopy , + + +-- ** adapterFlush + AdapterFlushMethodInfo , + adapterFlush , + + +-- ** adapterGetBuffer + AdapterGetBufferMethodInfo , + adapterGetBuffer , + + +-- ** adapterGetBufferFast + AdapterGetBufferFastMethodInfo , + adapterGetBufferFast , + + +-- ** adapterGetBufferList + AdapterGetBufferListMethodInfo , + adapterGetBufferList , + + +-- ** adapterGetList + AdapterGetListMethodInfo , + adapterGetList , + + +-- ** adapterMap + AdapterMapMethodInfo , + adapterMap , + + +-- ** adapterMaskedScanUint32 + AdapterMaskedScanUint32MethodInfo , + adapterMaskedScanUint32 , + + +-- ** adapterMaskedScanUint32Peek + AdapterMaskedScanUint32PeekMethodInfo , + adapterMaskedScanUint32Peek , + + +-- ** adapterNew + adapterNew , + + +-- ** adapterPrevDts + AdapterPrevDtsMethodInfo , + adapterPrevDts , + + +-- ** adapterPrevDtsAtOffset + AdapterPrevDtsAtOffsetMethodInfo , + adapterPrevDtsAtOffset , + + +-- ** adapterPrevPts + AdapterPrevPtsMethodInfo , + adapterPrevPts , + + +-- ** adapterPrevPtsAtOffset + AdapterPrevPtsAtOffsetMethodInfo , + adapterPrevPtsAtOffset , + + +-- ** adapterPush + AdapterPushMethodInfo , + adapterPush , + + +-- ** adapterTake + AdapterTakeMethodInfo , + adapterTake , + + +-- ** adapterTakeBuffer + AdapterTakeBufferMethodInfo , + adapterTakeBuffer , + + +-- ** adapterTakeBufferFast + AdapterTakeBufferFastMethodInfo , + adapterTakeBufferFast , + + +-- ** adapterTakeBufferList + AdapterTakeBufferListMethodInfo , + adapterTakeBufferList , + + +-- ** adapterTakeList + AdapterTakeListMethodInfo , + adapterTakeList , + + +-- ** adapterUnmap + AdapterUnmapMethodInfo , + adapterUnmap , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks +import qualified GI.GLib as GLib +import qualified GI.GObject as GObject +import qualified GI.Gst as Gst + +newtype Adapter = Adapter (ForeignPtr Adapter) +foreign import ccall "gst_adapter_get_type" + c_gst_adapter_get_type :: IO GType + +type instance ParentTypes Adapter = AdapterParentTypes +type AdapterParentTypes = '[GObject.Object] + +instance GObject Adapter where + gobjectIsInitiallyUnowned _ = False + gobjectType _ = c_gst_adapter_get_type + + +class GObject o => AdapterK o +instance (GObject o, IsDescendantOf Adapter o) => AdapterK o + +toAdapter :: AdapterK o => o -> IO Adapter +toAdapter = unsafeCastTo Adapter + +noAdapter :: Maybe Adapter +noAdapter = Nothing + +type family ResolveAdapterMethod (t :: Symbol) (o :: *) :: * where + ResolveAdapterMethod "available" o = AdapterAvailableMethodInfo + ResolveAdapterMethod "availableFast" o = AdapterAvailableFastMethodInfo + ResolveAdapterMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo + ResolveAdapterMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo + ResolveAdapterMethod "clear" o = AdapterClearMethodInfo + ResolveAdapterMethod "copy" o = AdapterCopyMethodInfo + ResolveAdapterMethod "flush" o = AdapterFlushMethodInfo + ResolveAdapterMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo + ResolveAdapterMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo + ResolveAdapterMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo + ResolveAdapterMethod "map" o = AdapterMapMethodInfo + ResolveAdapterMethod "maskedScanUint32" o = AdapterMaskedScanUint32MethodInfo + ResolveAdapterMethod "maskedScanUint32Peek" o = AdapterMaskedScanUint32PeekMethodInfo + ResolveAdapterMethod "notify" o = GObject.ObjectNotifyMethodInfo + ResolveAdapterMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo + ResolveAdapterMethod "prevDts" o = AdapterPrevDtsMethodInfo + ResolveAdapterMethod "prevDtsAtOffset" o = AdapterPrevDtsAtOffsetMethodInfo + ResolveAdapterMethod "prevPts" o = AdapterPrevPtsMethodInfo + ResolveAdapterMethod "prevPtsAtOffset" o = AdapterPrevPtsAtOffsetMethodInfo + ResolveAdapterMethod "push" o = AdapterPushMethodInfo + ResolveAdapterMethod "ref" o = GObject.ObjectRefMethodInfo + ResolveAdapterMethod "refSink" o = GObject.ObjectRefSinkMethodInfo + ResolveAdapterMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo + ResolveAdapterMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo + ResolveAdapterMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo + ResolveAdapterMethod "stealData" o = GObject.ObjectStealDataMethodInfo + ResolveAdapterMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo + ResolveAdapterMethod "take" o = AdapterTakeMethodInfo + ResolveAdapterMethod "takeBuffer" o = AdapterTakeBufferMethodInfo + ResolveAdapterMethod "takeBufferFast" o = AdapterTakeBufferFastMethodInfo + ResolveAdapterMethod "takeBufferList" o = AdapterTakeBufferListMethodInfo + ResolveAdapterMethod "takeList" o = AdapterTakeListMethodInfo + ResolveAdapterMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo + ResolveAdapterMethod "unmap" o = AdapterUnmapMethodInfo + ResolveAdapterMethod "unref" o = GObject.ObjectUnrefMethodInfo + ResolveAdapterMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo + ResolveAdapterMethod "getBuffer" o = AdapterGetBufferMethodInfo + ResolveAdapterMethod "getBufferFast" o = AdapterGetBufferFastMethodInfo + ResolveAdapterMethod "getBufferList" o = AdapterGetBufferListMethodInfo + ResolveAdapterMethod "getData" o = GObject.ObjectGetDataMethodInfo + ResolveAdapterMethod "getList" o = AdapterGetListMethodInfo + ResolveAdapterMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo + ResolveAdapterMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo + ResolveAdapterMethod "setData" o = GObject.ObjectSetDataMethodInfo + ResolveAdapterMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo + ResolveAdapterMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolveAdapterMethod t Adapter, MethodInfo info Adapter p) => IsLabelProxy t (Adapter -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolveAdapterMethod t Adapter, MethodInfo info Adapter p) => IsLabel t (Adapter -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + +type instance AttributeList Adapter = AdapterAttributeList +type AdapterAttributeList = ('[ ] :: [(Symbol, *)]) + +type instance SignalList Adapter = AdapterSignalList +type AdapterSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +-- method Adapter::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : TInterface "GstBase" "Adapter" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_new" gst_adapter_new :: + IO (Ptr Adapter) + + +adapterNew :: + (MonadIO m) => + m Adapter -- result +adapterNew = liftIO $ do + result <- gst_adapter_new + checkUnexpectedReturnNULL "gst_adapter_new" result + result' <- (wrapObject Adapter) result + return result' + +-- method Adapter::available +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_available" gst_adapter_available :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + IO Word64 + + +adapterAvailable :: + (MonadIO m, AdapterK a) => + a -- _obj + -> m Word64 -- result +adapterAvailable _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_adapter_available _obj' + touchManagedPtr _obj + return result + +data AdapterAvailableMethodInfo +instance (signature ~ (m Word64), MonadIO m, AdapterK a) => MethodInfo AdapterAvailableMethodInfo a signature where + overloadedMethod _ = adapterAvailable + +-- method Adapter::available_fast +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_available_fast" gst_adapter_available_fast :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + IO Word64 + + +adapterAvailableFast :: + (MonadIO m, AdapterK a) => + a -- _obj + -> m Word64 -- result +adapterAvailableFast _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_adapter_available_fast _obj' + touchManagedPtr _obj + return result + +data AdapterAvailableFastMethodInfo +instance (signature ~ (m Word64), MonadIO m, AdapterK a) => MethodInfo AdapterAvailableFastMethodInfo a signature where + overloadedMethod _ = adapterAvailableFast + +-- method Adapter::clear +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_clear" gst_adapter_clear :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + IO () + + +adapterClear :: + (MonadIO m, AdapterK a) => + a -- _obj + -> m () -- result +adapterClear _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_adapter_clear _obj' + touchManagedPtr _obj + return () + +data AdapterClearMethodInfo +instance (signature ~ (m ()), MonadIO m, AdapterK a) => MethodInfo AdapterClearMethodInfo a signature where + overloadedMethod _ = adapterClear + +-- method Adapter::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "GLib" "Bytes" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_copy_bytes" gst_adapter_copy_bytes :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word64 -> -- offset : TBasicType TUInt64 + Word64 -> -- size : TBasicType TUInt64 + IO (Ptr GLib.Bytes) + + +adapterCopy :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word64 -- offset + -> Word64 -- size + -> m GLib.Bytes -- result +adapterCopy _obj offset size = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_adapter_copy_bytes _obj' offset size + checkUnexpectedReturnNULL "gst_adapter_copy_bytes" result + result' <- (wrapBoxed GLib.Bytes) result + touchManagedPtr _obj + return result' + +data AdapterCopyMethodInfo +instance (signature ~ (Word64 -> Word64 -> m GLib.Bytes), MonadIO m, AdapterK a) => MethodInfo AdapterCopyMethodInfo a signature where + overloadedMethod _ = adapterCopy + +-- method Adapter::flush +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flush", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_flush" gst_adapter_flush :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word64 -> -- flush : TBasicType TUInt64 + IO () + + +adapterFlush :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word64 -- flush + -> m () -- result +adapterFlush _obj flush = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_adapter_flush _obj' flush + touchManagedPtr _obj + return () + +data AdapterFlushMethodInfo +instance (signature ~ (Word64 -> m ()), MonadIO m, AdapterK a) => MethodInfo AdapterFlushMethodInfo a signature where + overloadedMethod _ = adapterFlush + +-- method Adapter::get_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nbytes", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Buffer" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_get_buffer" gst_adapter_get_buffer :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word64 -> -- nbytes : TBasicType TUInt64 + IO (Ptr Gst.Buffer) + + +adapterGetBuffer :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word64 -- nbytes + -> m Gst.Buffer -- result +adapterGetBuffer _obj nbytes = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_adapter_get_buffer _obj' nbytes + checkUnexpectedReturnNULL "gst_adapter_get_buffer" result + result' <- (wrapBoxed Gst.Buffer) result + touchManagedPtr _obj + return result' + +data AdapterGetBufferMethodInfo +instance (signature ~ (Word64 -> m Gst.Buffer), MonadIO m, AdapterK a) => MethodInfo AdapterGetBufferMethodInfo a signature where + overloadedMethod _ = adapterGetBuffer + +-- method Adapter::get_buffer_fast +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nbytes", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Buffer" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_get_buffer_fast" gst_adapter_get_buffer_fast :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word64 -> -- nbytes : TBasicType TUInt64 + IO (Ptr Gst.Buffer) + + +adapterGetBufferFast :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word64 -- nbytes + -> m Gst.Buffer -- result +adapterGetBufferFast _obj nbytes = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_adapter_get_buffer_fast _obj' nbytes + checkUnexpectedReturnNULL "gst_adapter_get_buffer_fast" result + result' <- (wrapBoxed Gst.Buffer) result + touchManagedPtr _obj + return result' + +data AdapterGetBufferFastMethodInfo +instance (signature ~ (Word64 -> m Gst.Buffer), MonadIO m, AdapterK a) => MethodInfo AdapterGetBufferFastMethodInfo a signature where + overloadedMethod _ = adapterGetBufferFast + +-- method Adapter::get_buffer_list +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nbytes", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "BufferList" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_get_buffer_list" gst_adapter_get_buffer_list :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word64 -> -- nbytes : TBasicType TUInt64 + IO (Ptr Gst.BufferList) + + +adapterGetBufferList :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word64 -- nbytes + -> m Gst.BufferList -- result +adapterGetBufferList _obj nbytes = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_adapter_get_buffer_list _obj' nbytes + checkUnexpectedReturnNULL "gst_adapter_get_buffer_list" result + result' <- (wrapBoxed Gst.BufferList) result + touchManagedPtr _obj + return result' + +data AdapterGetBufferListMethodInfo +instance (signature ~ (Word64 -> m Gst.BufferList), MonadIO m, AdapterK a) => MethodInfo AdapterGetBufferListMethodInfo a signature where + overloadedMethod _ = adapterGetBufferList + +-- method Adapter::get_list +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nbytes", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TGList (TInterface "Gst" "Buffer") +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_get_list" gst_adapter_get_list :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word64 -> -- nbytes : TBasicType TUInt64 + IO (Ptr (GList (Ptr Gst.Buffer))) + + +adapterGetList :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word64 -- nbytes + -> m [Gst.Buffer] -- result +adapterGetList _obj nbytes = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_adapter_get_list _obj' nbytes + checkUnexpectedReturnNULL "gst_adapter_get_list" result + result' <- unpackGList result + result'' <- mapM (wrapBoxed Gst.Buffer) result' + g_list_free result + touchManagedPtr _obj + return result'' + +data AdapterGetListMethodInfo +instance (signature ~ (Word64 -> m [Gst.Buffer]), MonadIO m, AdapterK a) => MethodInfo AdapterGetListMethodInfo a signature where + overloadedMethod _ = adapterGetList + +-- method Adapter::map +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : TCArray False (-1) 1 (TBasicType TUInt8) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_map" gst_adapter_map :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Ptr Word64 -> -- size : TBasicType TUInt64 + IO (Ptr Word8) + + +adapterMap :: + (MonadIO m, AdapterK a) => + a -- _obj + -> m ByteString -- result +adapterMap _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + size <- allocMem :: IO (Ptr Word64) + result <- gst_adapter_map _obj' size + size' <- peek size + checkUnexpectedReturnNULL "gst_adapter_map" result + result' <- (unpackByteStringWithLength size') result + touchManagedPtr _obj + freeMem size + return result' + +data AdapterMapMethodInfo +instance (signature ~ (m ByteString), MonadIO m, AdapterK a) => MethodInfo AdapterMapMethodInfo a signature where + overloadedMethod _ = adapterMap + +-- method Adapter::masked_scan_uint32 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mask", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pattern", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_masked_scan_uint32" gst_adapter_masked_scan_uint32 :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word32 -> -- mask : TBasicType TUInt32 + Word32 -> -- pattern : TBasicType TUInt32 + Word64 -> -- offset : TBasicType TUInt64 + Word64 -> -- size : TBasicType TUInt64 + IO Int64 + + +adapterMaskedScanUint32 :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word32 -- mask + -> Word32 -- pattern + -> Word64 -- offset + -> Word64 -- size + -> m Int64 -- result +adapterMaskedScanUint32 _obj mask pattern offset size = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_adapter_masked_scan_uint32 _obj' mask pattern offset size + touchManagedPtr _obj + return result + +data AdapterMaskedScanUint32MethodInfo +instance (signature ~ (Word32 -> Word32 -> Word64 -> Word64 -> m Int64), MonadIO m, AdapterK a) => MethodInfo AdapterMaskedScanUint32MethodInfo a signature where + overloadedMethod _ = adapterMaskedScanUint32 + +-- method Adapter::masked_scan_uint32_peek +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mask", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pattern", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_masked_scan_uint32_peek" gst_adapter_masked_scan_uint32_peek :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word32 -> -- mask : TBasicType TUInt32 + Word32 -> -- pattern : TBasicType TUInt32 + Word64 -> -- offset : TBasicType TUInt64 + Word64 -> -- size : TBasicType TUInt64 + Ptr Word32 -> -- value : TBasicType TUInt32 + IO Int64 + + +adapterMaskedScanUint32Peek :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word32 -- mask + -> Word32 -- pattern + -> Word64 -- offset + -> Word64 -- size + -> m (Int64,Word32) -- result +adapterMaskedScanUint32Peek _obj mask pattern offset size = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + value <- allocMem :: IO (Ptr Word32) + result <- gst_adapter_masked_scan_uint32_peek _obj' mask pattern offset size value + value' <- peek value + touchManagedPtr _obj + freeMem value + return (result, value') + +data AdapterMaskedScanUint32PeekMethodInfo +instance (signature ~ (Word32 -> Word32 -> Word64 -> Word64 -> m (Int64,Word32)), MonadIO m, AdapterK a) => MethodInfo AdapterMaskedScanUint32PeekMethodInfo a signature where + overloadedMethod _ = adapterMaskedScanUint32Peek + +-- method Adapter::prev_dts +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "distance", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TUInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_prev_dts" gst_adapter_prev_dts :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Ptr Word64 -> -- distance : TBasicType TUInt64 + IO Word64 + + +adapterPrevDts :: + (MonadIO m, AdapterK a) => + a -- _obj + -> m (Word64,Word64) -- result +adapterPrevDts _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + distance <- allocMem :: IO (Ptr Word64) + result <- gst_adapter_prev_dts _obj' distance + distance' <- peek distance + touchManagedPtr _obj + freeMem distance + return (result, distance') + +data AdapterPrevDtsMethodInfo +instance (signature ~ (m (Word64,Word64)), MonadIO m, AdapterK a) => MethodInfo AdapterPrevDtsMethodInfo a signature where + overloadedMethod _ = adapterPrevDts + +-- method Adapter::prev_dts_at_offset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "distance", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TUInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_prev_dts_at_offset" gst_adapter_prev_dts_at_offset :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word64 -> -- offset : TBasicType TUInt64 + Ptr Word64 -> -- distance : TBasicType TUInt64 + IO Word64 + + +adapterPrevDtsAtOffset :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word64 -- offset + -> m (Word64,Word64) -- result +adapterPrevDtsAtOffset _obj offset = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + distance <- allocMem :: IO (Ptr Word64) + result <- gst_adapter_prev_dts_at_offset _obj' offset distance + distance' <- peek distance + touchManagedPtr _obj + freeMem distance + return (result, distance') + +data AdapterPrevDtsAtOffsetMethodInfo +instance (signature ~ (Word64 -> m (Word64,Word64)), MonadIO m, AdapterK a) => MethodInfo AdapterPrevDtsAtOffsetMethodInfo a signature where + overloadedMethod _ = adapterPrevDtsAtOffset + +-- method Adapter::prev_pts +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "distance", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TUInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_prev_pts" gst_adapter_prev_pts :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Ptr Word64 -> -- distance : TBasicType TUInt64 + IO Word64 + + +adapterPrevPts :: + (MonadIO m, AdapterK a) => + a -- _obj + -> m (Word64,Word64) -- result +adapterPrevPts _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + distance <- allocMem :: IO (Ptr Word64) + result <- gst_adapter_prev_pts _obj' distance + distance' <- peek distance + touchManagedPtr _obj + freeMem distance + return (result, distance') + +data AdapterPrevPtsMethodInfo +instance (signature ~ (m (Word64,Word64)), MonadIO m, AdapterK a) => MethodInfo AdapterPrevPtsMethodInfo a signature where + overloadedMethod _ = adapterPrevPts + +-- method Adapter::prev_pts_at_offset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "distance", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TUInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_prev_pts_at_offset" gst_adapter_prev_pts_at_offset :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word64 -> -- offset : TBasicType TUInt64 + Ptr Word64 -> -- distance : TBasicType TUInt64 + IO Word64 + + +adapterPrevPtsAtOffset :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word64 -- offset + -> m (Word64,Word64) -- result +adapterPrevPtsAtOffset _obj offset = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + distance <- allocMem :: IO (Ptr Word64) + result <- gst_adapter_prev_pts_at_offset _obj' offset distance + distance' <- peek distance + touchManagedPtr _obj + freeMem distance + return (result, distance') + +data AdapterPrevPtsAtOffsetMethodInfo +instance (signature ~ (Word64 -> m (Word64,Word64)), MonadIO m, AdapterK a) => MethodInfo AdapterPrevPtsAtOffsetMethodInfo a signature where + overloadedMethod _ = adapterPrevPtsAtOffset + +-- method Adapter::push +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_push" gst_adapter_push :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Ptr Gst.Buffer -> -- buf : TInterface "Gst" "Buffer" + IO () + + +adapterPush :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Gst.Buffer -- buf + -> m () -- result +adapterPush _obj buf = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + buf' <- copyBoxed buf + gst_adapter_push _obj' buf' + touchManagedPtr _obj + touchManagedPtr buf + return () + +data AdapterPushMethodInfo +instance (signature ~ (Gst.Buffer -> m ()), MonadIO m, AdapterK a) => MethodInfo AdapterPushMethodInfo a signature where + overloadedMethod _ = adapterPush + +-- method Adapter::take +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nbytes", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [Arg {argCName = "nbytes", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : TCArray False (-1) 1 (TBasicType TUInt8) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_take" gst_adapter_take :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Ptr Word64 -> -- nbytes : TBasicType TUInt64 + IO (Ptr Word8) + + +adapterTake :: + (MonadIO m, AdapterK a) => + a -- _obj + -> m ByteString -- result +adapterTake _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + nbytes <- allocMem :: IO (Ptr Word64) + result <- gst_adapter_take _obj' nbytes + nbytes' <- peek nbytes + checkUnexpectedReturnNULL "gst_adapter_take" result + result' <- (unpackByteStringWithLength nbytes') result + freeMem result + touchManagedPtr _obj + freeMem nbytes + return result' + +data AdapterTakeMethodInfo +instance (signature ~ (m ByteString), MonadIO m, AdapterK a) => MethodInfo AdapterTakeMethodInfo a signature where + overloadedMethod _ = adapterTake + +-- method Adapter::take_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nbytes", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Buffer" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_take_buffer" gst_adapter_take_buffer :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word64 -> -- nbytes : TBasicType TUInt64 + IO (Ptr Gst.Buffer) + + +adapterTakeBuffer :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word64 -- nbytes + -> m Gst.Buffer -- result +adapterTakeBuffer _obj nbytes = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_adapter_take_buffer _obj' nbytes + checkUnexpectedReturnNULL "gst_adapter_take_buffer" result + result' <- (wrapBoxed Gst.Buffer) result + touchManagedPtr _obj + return result' + +data AdapterTakeBufferMethodInfo +instance (signature ~ (Word64 -> m Gst.Buffer), MonadIO m, AdapterK a) => MethodInfo AdapterTakeBufferMethodInfo a signature where + overloadedMethod _ = adapterTakeBuffer + +-- method Adapter::take_buffer_fast +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nbytes", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Buffer" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_take_buffer_fast" gst_adapter_take_buffer_fast :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word64 -> -- nbytes : TBasicType TUInt64 + IO (Ptr Gst.Buffer) + + +adapterTakeBufferFast :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word64 -- nbytes + -> m Gst.Buffer -- result +adapterTakeBufferFast _obj nbytes = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_adapter_take_buffer_fast _obj' nbytes + checkUnexpectedReturnNULL "gst_adapter_take_buffer_fast" result + result' <- (wrapBoxed Gst.Buffer) result + touchManagedPtr _obj + return result' + +data AdapterTakeBufferFastMethodInfo +instance (signature ~ (Word64 -> m Gst.Buffer), MonadIO m, AdapterK a) => MethodInfo AdapterTakeBufferFastMethodInfo a signature where + overloadedMethod _ = adapterTakeBufferFast + +-- method Adapter::take_buffer_list +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nbytes", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "BufferList" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_take_buffer_list" gst_adapter_take_buffer_list :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word64 -> -- nbytes : TBasicType TUInt64 + IO (Ptr Gst.BufferList) + + +adapterTakeBufferList :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word64 -- nbytes + -> m Gst.BufferList -- result +adapterTakeBufferList _obj nbytes = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_adapter_take_buffer_list _obj' nbytes + checkUnexpectedReturnNULL "gst_adapter_take_buffer_list" result + result' <- (wrapBoxed Gst.BufferList) result + touchManagedPtr _obj + return result' + +data AdapterTakeBufferListMethodInfo +instance (signature ~ (Word64 -> m Gst.BufferList), MonadIO m, AdapterK a) => MethodInfo AdapterTakeBufferListMethodInfo a signature where + overloadedMethod _ = adapterTakeBufferList + +-- method Adapter::take_list +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nbytes", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TGList (TInterface "Gst" "Buffer") +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_take_list" gst_adapter_take_list :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + Word64 -> -- nbytes : TBasicType TUInt64 + IO (Ptr (GList (Ptr Gst.Buffer))) + + +adapterTakeList :: + (MonadIO m, AdapterK a) => + a -- _obj + -> Word64 -- nbytes + -> m [Gst.Buffer] -- result +adapterTakeList _obj nbytes = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_adapter_take_list _obj' nbytes + checkUnexpectedReturnNULL "gst_adapter_take_list" result + result' <- unpackGList result + result'' <- mapM (wrapBoxed Gst.Buffer) result' + g_list_free result + touchManagedPtr _obj + return result'' + +data AdapterTakeListMethodInfo +instance (signature ~ (Word64 -> m [Gst.Buffer]), MonadIO m, AdapterK a) => MethodInfo AdapterTakeListMethodInfo a signature where + overloadedMethod _ = adapterTakeList + +-- method Adapter::unmap +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "Adapter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_adapter_unmap" gst_adapter_unmap :: + Ptr Adapter -> -- _obj : TInterface "GstBase" "Adapter" + IO () + + +adapterUnmap :: + (MonadIO m, AdapterK a) => + a -- _obj + -> m () -- result +adapterUnmap _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_adapter_unmap _obj' + touchManagedPtr _obj + return () + +data AdapterUnmapMethodInfo +instance (signature ~ (m ()), MonadIO m, AdapterK a) => MethodInfo AdapterUnmapMethodInfo a signature where + overloadedMethod _ = adapterUnmap + + diff --git a/GI/GstBase/Objects/Adapter.hs-boot b/GI/GstBase/Objects/Adapter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/Adapter.hs-boot @@ -0,0 +1,36 @@ +module GI.GstBase.Objects.Adapter where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype Adapter = Adapter (ForeignPtr Adapter) +instance GObject Adapter where +class GObject o => AdapterK o +instance (GObject o, IsDescendantOf Adapter o) => AdapterK o +data AdapterAvailableMethodInfo +data AdapterAvailableFastMethodInfo +data AdapterClearMethodInfo +data AdapterCopyMethodInfo +data AdapterFlushMethodInfo +data AdapterGetBufferMethodInfo +data AdapterGetBufferFastMethodInfo +data AdapterGetBufferListMethodInfo +data AdapterGetListMethodInfo +data AdapterMapMethodInfo +data AdapterMaskedScanUint32MethodInfo +data AdapterMaskedScanUint32PeekMethodInfo +data AdapterPrevDtsMethodInfo +data AdapterPrevDtsAtOffsetMethodInfo +data AdapterPrevPtsMethodInfo +data AdapterPrevPtsAtOffsetMethodInfo +data AdapterPushMethodInfo +data AdapterTakeMethodInfo +data AdapterTakeBufferMethodInfo +data AdapterTakeBufferFastMethodInfo +data AdapterTakeBufferListMethodInfo +data AdapterTakeListMethodInfo +data AdapterUnmapMethodInfo diff --git a/GI/GstBase/Objects/BaseParse.hs b/GI/GstBase/Objects/BaseParse.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/BaseParse.hs @@ -0,0 +1,813 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Objects.BaseParse + ( + +-- * Exported types + BaseParse(..) , + BaseParseK , + toBaseParse , + noBaseParse , + + + -- * Methods +-- ** baseParseAddIndexEntry + BaseParseAddIndexEntryMethodInfo , + baseParseAddIndexEntry , + + +-- ** baseParseConvertDefault + BaseParseConvertDefaultMethodInfo , + baseParseConvertDefault , + + +-- ** baseParseFinishFrame + BaseParseFinishFrameMethodInfo , + baseParseFinishFrame , + + +-- ** baseParseMergeTags + BaseParseMergeTagsMethodInfo , + baseParseMergeTags , + + +-- ** baseParsePushFrame + BaseParsePushFrameMethodInfo , + baseParsePushFrame , + + +-- ** baseParseSetAverageBitrate + BaseParseSetAverageBitrateMethodInfo , + baseParseSetAverageBitrate , + + +-- ** baseParseSetDuration + BaseParseSetDurationMethodInfo , + baseParseSetDuration , + + +-- ** baseParseSetFrameRate + BaseParseSetFrameRateMethodInfo , + baseParseSetFrameRate , + + +-- ** baseParseSetHasTimingInfo + BaseParseSetHasTimingInfoMethodInfo , + baseParseSetHasTimingInfo , + + +-- ** baseParseSetInferTs + BaseParseSetInferTsMethodInfo , + baseParseSetInferTs , + + +-- ** baseParseSetLatency + BaseParseSetLatencyMethodInfo , + baseParseSetLatency , + + +-- ** baseParseSetMinFrameSize + BaseParseSetMinFrameSizeMethodInfo , + baseParseSetMinFrameSize , + + +-- ** baseParseSetPassthrough + BaseParseSetPassthroughMethodInfo , + baseParseSetPassthrough , + + +-- ** baseParseSetPtsInterpolation + BaseParseSetPtsInterpolationMethodInfo , + baseParseSetPtsInterpolation , + + +-- ** baseParseSetSyncable + BaseParseSetSyncableMethodInfo , + baseParseSetSyncable , + + +-- ** baseParseSetTsAtOffset + BaseParseSetTsAtOffsetMethodInfo , + baseParseSetTsAtOffset , + + + + + -- * Properties +-- ** DisablePassthrough + BaseParseDisablePassthroughPropertyInfo , + constructBaseParseDisablePassthrough , + getBaseParseDisablePassthrough , + setBaseParseDisablePassthrough , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks +import qualified GI.GObject as GObject +import qualified GI.Gst as Gst + +newtype BaseParse = BaseParse (ForeignPtr BaseParse) +foreign import ccall "gst_base_parse_get_type" + c_gst_base_parse_get_type :: IO GType + +type instance ParentTypes BaseParse = BaseParseParentTypes +type BaseParseParentTypes = '[Gst.Element, Gst.Object, GObject.Object] + +instance GObject BaseParse where + gobjectIsInitiallyUnowned _ = True + gobjectType _ = c_gst_base_parse_get_type + + +class GObject o => BaseParseK o +instance (GObject o, IsDescendantOf BaseParse o) => BaseParseK o + +toBaseParse :: BaseParseK o => o -> IO BaseParse +toBaseParse = unsafeCastTo BaseParse + +noBaseParse :: Maybe BaseParse +noBaseParse = Nothing + +type family ResolveBaseParseMethod (t :: Symbol) (o :: *) :: * where + ResolveBaseParseMethod "abortState" o = Gst.ElementAbortStateMethodInfo + ResolveBaseParseMethod "addControlBinding" o = Gst.ObjectAddControlBindingMethodInfo + ResolveBaseParseMethod "addIndexEntry" o = BaseParseAddIndexEntryMethodInfo + ResolveBaseParseMethod "addPad" o = Gst.ElementAddPadMethodInfo + ResolveBaseParseMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo + ResolveBaseParseMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo + ResolveBaseParseMethod "changeState" o = Gst.ElementChangeStateMethodInfo + ResolveBaseParseMethod "continueState" o = Gst.ElementContinueStateMethodInfo + ResolveBaseParseMethod "convertDefault" o = BaseParseConvertDefaultMethodInfo + ResolveBaseParseMethod "createAllPads" o = Gst.ElementCreateAllPadsMethodInfo + ResolveBaseParseMethod "defaultError" o = Gst.ObjectDefaultErrorMethodInfo + ResolveBaseParseMethod "finishFrame" o = BaseParseFinishFrameMethodInfo + ResolveBaseParseMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo + ResolveBaseParseMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo + ResolveBaseParseMethod "hasActiveControlBindings" o = Gst.ObjectHasActiveControlBindingsMethodInfo + ResolveBaseParseMethod "hasAncestor" o = Gst.ObjectHasAncestorMethodInfo + ResolveBaseParseMethod "hasAsAncestor" o = Gst.ObjectHasAsAncestorMethodInfo + ResolveBaseParseMethod "hasAsParent" o = Gst.ObjectHasAsParentMethodInfo + ResolveBaseParseMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo + ResolveBaseParseMethod "isLockedState" o = Gst.ElementIsLockedStateMethodInfo + ResolveBaseParseMethod "iteratePads" o = Gst.ElementIteratePadsMethodInfo + ResolveBaseParseMethod "iterateSinkPads" o = Gst.ElementIterateSinkPadsMethodInfo + ResolveBaseParseMethod "iterateSrcPads" o = Gst.ElementIterateSrcPadsMethodInfo + ResolveBaseParseMethod "link" o = Gst.ElementLinkMethodInfo + ResolveBaseParseMethod "linkFiltered" o = Gst.ElementLinkFilteredMethodInfo + ResolveBaseParseMethod "linkPads" o = Gst.ElementLinkPadsMethodInfo + ResolveBaseParseMethod "linkPadsFiltered" o = Gst.ElementLinkPadsFilteredMethodInfo + ResolveBaseParseMethod "linkPadsFull" o = Gst.ElementLinkPadsFullMethodInfo + ResolveBaseParseMethod "lostState" o = Gst.ElementLostStateMethodInfo + ResolveBaseParseMethod "mergeTags" o = BaseParseMergeTagsMethodInfo + ResolveBaseParseMethod "messageFull" o = Gst.ElementMessageFullMethodInfo + ResolveBaseParseMethod "noMorePads" o = Gst.ElementNoMorePadsMethodInfo + ResolveBaseParseMethod "notify" o = GObject.ObjectNotifyMethodInfo + ResolveBaseParseMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo + ResolveBaseParseMethod "postMessage" o = Gst.ElementPostMessageMethodInfo + ResolveBaseParseMethod "provideClock" o = Gst.ElementProvideClockMethodInfo + ResolveBaseParseMethod "pushFrame" o = BaseParsePushFrameMethodInfo + ResolveBaseParseMethod "query" o = Gst.ElementQueryMethodInfo + ResolveBaseParseMethod "queryConvert" o = Gst.ElementQueryConvertMethodInfo + ResolveBaseParseMethod "queryDuration" o = Gst.ElementQueryDurationMethodInfo + ResolveBaseParseMethod "queryPosition" o = Gst.ElementQueryPositionMethodInfo + ResolveBaseParseMethod "refSink" o = GObject.ObjectRefSinkMethodInfo + ResolveBaseParseMethod "releaseRequestPad" o = Gst.ElementReleaseRequestPadMethodInfo + ResolveBaseParseMethod "removeControlBinding" o = Gst.ObjectRemoveControlBindingMethodInfo + ResolveBaseParseMethod "removePad" o = Gst.ElementRemovePadMethodInfo + ResolveBaseParseMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo + ResolveBaseParseMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo + ResolveBaseParseMethod "requestPad" o = Gst.ElementRequestPadMethodInfo + ResolveBaseParseMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo + ResolveBaseParseMethod "seek" o = Gst.ElementSeekMethodInfo + ResolveBaseParseMethod "seekSimple" o = Gst.ElementSeekSimpleMethodInfo + ResolveBaseParseMethod "sendEvent" o = Gst.ElementSendEventMethodInfo + ResolveBaseParseMethod "stealData" o = GObject.ObjectStealDataMethodInfo + ResolveBaseParseMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo + ResolveBaseParseMethod "suggestNextSync" o = Gst.ObjectSuggestNextSyncMethodInfo + ResolveBaseParseMethod "syncStateWithParent" o = Gst.ElementSyncStateWithParentMethodInfo + ResolveBaseParseMethod "syncValues" o = Gst.ObjectSyncValuesMethodInfo + ResolveBaseParseMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo + ResolveBaseParseMethod "unlink" o = Gst.ElementUnlinkMethodInfo + ResolveBaseParseMethod "unlinkPads" o = Gst.ElementUnlinkPadsMethodInfo + ResolveBaseParseMethod "unparent" o = Gst.ObjectUnparentMethodInfo + ResolveBaseParseMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo + ResolveBaseParseMethod "getBaseTime" o = Gst.ElementGetBaseTimeMethodInfo + ResolveBaseParseMethod "getBus" o = Gst.ElementGetBusMethodInfo + ResolveBaseParseMethod "getClock" o = Gst.ElementGetClockMethodInfo + ResolveBaseParseMethod "getCompatiblePad" o = Gst.ElementGetCompatiblePadMethodInfo + ResolveBaseParseMethod "getCompatiblePadTemplate" o = Gst.ElementGetCompatiblePadTemplateMethodInfo + ResolveBaseParseMethod "getControlBinding" o = Gst.ObjectGetControlBindingMethodInfo + ResolveBaseParseMethod "getControlRate" o = Gst.ObjectGetControlRateMethodInfo + ResolveBaseParseMethod "getData" o = GObject.ObjectGetDataMethodInfo + ResolveBaseParseMethod "getFactory" o = Gst.ElementGetFactoryMethodInfo + ResolveBaseParseMethod "getGValueArray" o = Gst.ObjectGetGValueArrayMethodInfo + ResolveBaseParseMethod "getName" o = Gst.ObjectGetNameMethodInfo + ResolveBaseParseMethod "getParent" o = Gst.ObjectGetParentMethodInfo + ResolveBaseParseMethod "getPathString" o = Gst.ObjectGetPathStringMethodInfo + ResolveBaseParseMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo + ResolveBaseParseMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo + ResolveBaseParseMethod "getRequestPad" o = Gst.ElementGetRequestPadMethodInfo + ResolveBaseParseMethod "getStartTime" o = Gst.ElementGetStartTimeMethodInfo + ResolveBaseParseMethod "getState" o = Gst.ElementGetStateMethodInfo + ResolveBaseParseMethod "getStaticPad" o = Gst.ElementGetStaticPadMethodInfo + ResolveBaseParseMethod "getValue" o = Gst.ObjectGetValueMethodInfo + ResolveBaseParseMethod "getValueArray" o = Gst.ObjectGetValueArrayMethodInfo + ResolveBaseParseMethod "setAverageBitrate" o = BaseParseSetAverageBitrateMethodInfo + ResolveBaseParseMethod "setBaseTime" o = Gst.ElementSetBaseTimeMethodInfo + ResolveBaseParseMethod "setBus" o = Gst.ElementSetBusMethodInfo + ResolveBaseParseMethod "setClock" o = Gst.ElementSetClockMethodInfo + ResolveBaseParseMethod "setContext" o = Gst.ElementSetContextMethodInfo + ResolveBaseParseMethod "setControlBindingDisabled" o = Gst.ObjectSetControlBindingDisabledMethodInfo + ResolveBaseParseMethod "setControlBindingsDisabled" o = Gst.ObjectSetControlBindingsDisabledMethodInfo + ResolveBaseParseMethod "setControlRate" o = Gst.ObjectSetControlRateMethodInfo + ResolveBaseParseMethod "setData" o = GObject.ObjectSetDataMethodInfo + ResolveBaseParseMethod "setDuration" o = BaseParseSetDurationMethodInfo + ResolveBaseParseMethod "setFrameRate" o = BaseParseSetFrameRateMethodInfo + ResolveBaseParseMethod "setHasTimingInfo" o = BaseParseSetHasTimingInfoMethodInfo + ResolveBaseParseMethod "setInferTs" o = BaseParseSetInferTsMethodInfo + ResolveBaseParseMethod "setLatency" o = BaseParseSetLatencyMethodInfo + ResolveBaseParseMethod "setLockedState" o = Gst.ElementSetLockedStateMethodInfo + ResolveBaseParseMethod "setMinFrameSize" o = BaseParseSetMinFrameSizeMethodInfo + ResolveBaseParseMethod "setName" o = Gst.ObjectSetNameMethodInfo + ResolveBaseParseMethod "setParent" o = Gst.ObjectSetParentMethodInfo + ResolveBaseParseMethod "setPassthrough" o = BaseParseSetPassthroughMethodInfo + ResolveBaseParseMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo + ResolveBaseParseMethod "setPtsInterpolation" o = BaseParseSetPtsInterpolationMethodInfo + ResolveBaseParseMethod "setStartTime" o = Gst.ElementSetStartTimeMethodInfo + ResolveBaseParseMethod "setState" o = Gst.ElementSetStateMethodInfo + ResolveBaseParseMethod "setSyncable" o = BaseParseSetSyncableMethodInfo + ResolveBaseParseMethod "setTsAtOffset" o = BaseParseSetTsAtOffsetMethodInfo + ResolveBaseParseMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolveBaseParseMethod t BaseParse, MethodInfo info BaseParse p) => IsLabelProxy t (BaseParse -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolveBaseParseMethod t BaseParse, MethodInfo info BaseParse p) => IsLabel t (BaseParse -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + +-- VVV Prop "disable-passthrough" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseParseDisablePassthrough :: (MonadIO m, BaseParseK o) => o -> m Bool +getBaseParseDisablePassthrough obj = liftIO $ getObjectPropertyBool obj "disable-passthrough" + +setBaseParseDisablePassthrough :: (MonadIO m, BaseParseK o) => o -> Bool -> m () +setBaseParseDisablePassthrough obj val = liftIO $ setObjectPropertyBool obj "disable-passthrough" val + +constructBaseParseDisablePassthrough :: Bool -> IO ([Char], GValue) +constructBaseParseDisablePassthrough val = constructObjectPropertyBool "disable-passthrough" val + +data BaseParseDisablePassthroughPropertyInfo +instance AttrInfo BaseParseDisablePassthroughPropertyInfo where + type AttrAllowedOps BaseParseDisablePassthroughPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseParseDisablePassthroughPropertyInfo = (~) Bool + type AttrBaseTypeConstraint BaseParseDisablePassthroughPropertyInfo = BaseParseK + type AttrGetType BaseParseDisablePassthroughPropertyInfo = Bool + type AttrLabel BaseParseDisablePassthroughPropertyInfo = "disable-passthrough" + attrGet _ = getBaseParseDisablePassthrough + attrSet _ = setBaseParseDisablePassthrough + attrConstruct _ = constructBaseParseDisablePassthrough + +type instance AttributeList BaseParse = BaseParseAttributeList +type BaseParseAttributeList = ('[ '("disablePassthrough", BaseParseDisablePassthroughPropertyInfo), '("name", Gst.ObjectNamePropertyInfo), '("parent", Gst.ObjectParentPropertyInfo)] :: [(Symbol, *)]) + +type instance SignalList BaseParse = BaseParseSignalList +type BaseParseSignalList = ('[ '("deepNotify", Gst.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", Gst.ElementPadAddedSignalInfo), '("padRemoved", Gst.ElementPadRemovedSignalInfo)] :: [(Symbol, *)]) + +-- method BaseParse::add_index_entry +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ts", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "force", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_add_index_entry" gst_base_parse_add_index_entry :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + Word64 -> -- offset : TBasicType TUInt64 + Word64 -> -- ts : TBasicType TUInt64 + CInt -> -- key : TBasicType TBoolean + CInt -> -- force : TBasicType TBoolean + IO CInt + + +baseParseAddIndexEntry :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Word64 -- offset + -> Word64 -- ts + -> Bool -- key + -> Bool -- force + -> m Bool -- result +baseParseAddIndexEntry _obj offset ts key force = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let key' = (fromIntegral . fromEnum) key + let force' = (fromIntegral . fromEnum) force + result <- gst_base_parse_add_index_entry _obj' offset ts key' force' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BaseParseAddIndexEntryMethodInfo +instance (signature ~ (Word64 -> Word64 -> Bool -> Bool -> m Bool), MonadIO m, BaseParseK a) => MethodInfo BaseParseAddIndexEntryMethodInfo a signature where + overloadedMethod _ = baseParseAddIndexEntry + +-- method BaseParse::convert_default +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_convert_default" gst_base_parse_convert_default :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + CUInt -> -- src_format : TInterface "Gst" "Format" + Int64 -> -- src_value : TBasicType TInt64 + CUInt -> -- dest_format : TInterface "Gst" "Format" + Int64 -> -- dest_value : TBasicType TInt64 + IO CInt + + +baseParseConvertDefault :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Gst.Format -- srcFormat + -> Int64 -- srcValue + -> Gst.Format -- destFormat + -> Int64 -- destValue + -> m Bool -- result +baseParseConvertDefault _obj srcFormat srcValue destFormat destValue = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let srcFormat' = (fromIntegral . fromEnum) srcFormat + let destFormat' = (fromIntegral . fromEnum) destFormat + result <- gst_base_parse_convert_default _obj' srcFormat' srcValue destFormat' destValue + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BaseParseConvertDefaultMethodInfo +instance (signature ~ (Gst.Format -> Int64 -> Gst.Format -> Int64 -> m Bool), MonadIO m, BaseParseK a) => MethodInfo BaseParseConvertDefaultMethodInfo a signature where + overloadedMethod _ = baseParseConvertDefault + +-- method BaseParse::finish_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface "GstBase" "BaseParseFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "FlowReturn" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_finish_frame" gst_base_parse_finish_frame :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + Ptr BaseParseFrame -> -- frame : TInterface "GstBase" "BaseParseFrame" + Int32 -> -- size : TBasicType TInt32 + IO CUInt + + +baseParseFinishFrame :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> BaseParseFrame -- frame + -> Int32 -- size + -> m Gst.FlowReturn -- result +baseParseFinishFrame _obj frame size = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let frame' = unsafeManagedPtrGetPtr frame + result <- gst_base_parse_finish_frame _obj' frame' size + let result' = (toEnum . fromIntegral) result + touchManagedPtr _obj + touchManagedPtr frame + return result' + +data BaseParseFinishFrameMethodInfo +instance (signature ~ (BaseParseFrame -> Int32 -> m Gst.FlowReturn), MonadIO m, BaseParseK a) => MethodInfo BaseParseFinishFrameMethodInfo a signature where + overloadedMethod _ = baseParseFinishFrame + +-- method BaseParse::merge_tags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_merge_tags" gst_base_parse_merge_tags :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + Ptr Gst.TagList -> -- tags : TInterface "Gst" "TagList" + CUInt -> -- mode : TInterface "Gst" "TagMergeMode" + IO () + + +baseParseMergeTags :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Maybe (Gst.TagList) -- tags + -> Gst.TagMergeMode -- mode + -> m () -- result +baseParseMergeTags _obj tags mode = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + maybeTags <- case tags of + Nothing -> return nullPtr + Just jTags -> do + let jTags' = unsafeManagedPtrGetPtr jTags + return jTags' + let mode' = (fromIntegral . fromEnum) mode + gst_base_parse_merge_tags _obj' maybeTags mode' + touchManagedPtr _obj + whenJust tags touchManagedPtr + return () + +data BaseParseMergeTagsMethodInfo +instance (signature ~ (Maybe (Gst.TagList) -> Gst.TagMergeMode -> m ()), MonadIO m, BaseParseK a) => MethodInfo BaseParseMergeTagsMethodInfo a signature where + overloadedMethod _ = baseParseMergeTags + +-- method BaseParse::push_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface "GstBase" "BaseParseFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "FlowReturn" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_push_frame" gst_base_parse_push_frame :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + Ptr BaseParseFrame -> -- frame : TInterface "GstBase" "BaseParseFrame" + IO CUInt + + +baseParsePushFrame :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> BaseParseFrame -- frame + -> m Gst.FlowReturn -- result +baseParsePushFrame _obj frame = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let frame' = unsafeManagedPtrGetPtr frame + result <- gst_base_parse_push_frame _obj' frame' + let result' = (toEnum . fromIntegral) result + touchManagedPtr _obj + touchManagedPtr frame + return result' + +data BaseParsePushFrameMethodInfo +instance (signature ~ (BaseParseFrame -> m Gst.FlowReturn), MonadIO m, BaseParseK a) => MethodInfo BaseParsePushFrameMethodInfo a signature where + overloadedMethod _ = baseParsePushFrame + +-- method BaseParse::set_average_bitrate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bitrate", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_set_average_bitrate" gst_base_parse_set_average_bitrate :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + Word32 -> -- bitrate : TBasicType TUInt32 + IO () + + +baseParseSetAverageBitrate :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Word32 -- bitrate + -> m () -- result +baseParseSetAverageBitrate _obj bitrate = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_parse_set_average_bitrate _obj' bitrate + touchManagedPtr _obj + return () + +data BaseParseSetAverageBitrateMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, BaseParseK a) => MethodInfo BaseParseSetAverageBitrateMethodInfo a signature where + overloadedMethod _ = baseParseSetAverageBitrate + +-- method BaseParse::set_duration +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fmt", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_set_duration" gst_base_parse_set_duration :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + CUInt -> -- fmt : TInterface "Gst" "Format" + Int64 -> -- duration : TBasicType TInt64 + Int32 -> -- interval : TBasicType TInt32 + IO () + + +baseParseSetDuration :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Gst.Format -- fmt + -> Int64 -- duration + -> Int32 -- interval + -> m () -- result +baseParseSetDuration _obj fmt duration interval = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let fmt' = (fromIntegral . fromEnum) fmt + gst_base_parse_set_duration _obj' fmt' duration interval + touchManagedPtr _obj + return () + +data BaseParseSetDurationMethodInfo +instance (signature ~ (Gst.Format -> Int64 -> Int32 -> m ()), MonadIO m, BaseParseK a) => MethodInfo BaseParseSetDurationMethodInfo a signature where + overloadedMethod _ = baseParseSetDuration + +-- method BaseParse::set_frame_rate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_num", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_den", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "lead_in", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "lead_out", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_set_frame_rate" gst_base_parse_set_frame_rate :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + Word32 -> -- fps_num : TBasicType TUInt32 + Word32 -> -- fps_den : TBasicType TUInt32 + Word32 -> -- lead_in : TBasicType TUInt32 + Word32 -> -- lead_out : TBasicType TUInt32 + IO () + + +baseParseSetFrameRate :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Word32 -- fpsNum + -> Word32 -- fpsDen + -> Word32 -- leadIn + -> Word32 -- leadOut + -> m () -- result +baseParseSetFrameRate _obj fpsNum fpsDen leadIn leadOut = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_parse_set_frame_rate _obj' fpsNum fpsDen leadIn leadOut + touchManagedPtr _obj + return () + +data BaseParseSetFrameRateMethodInfo +instance (signature ~ (Word32 -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m, BaseParseK a) => MethodInfo BaseParseSetFrameRateMethodInfo a signature where + overloadedMethod _ = baseParseSetFrameRate + +-- method BaseParse::set_has_timing_info +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "has_timing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_set_has_timing_info" gst_base_parse_set_has_timing_info :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + CInt -> -- has_timing : TBasicType TBoolean + IO () + + +baseParseSetHasTimingInfo :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Bool -- hasTiming + -> m () -- result +baseParseSetHasTimingInfo _obj hasTiming = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let hasTiming' = (fromIntegral . fromEnum) hasTiming + gst_base_parse_set_has_timing_info _obj' hasTiming' + touchManagedPtr _obj + return () + +data BaseParseSetHasTimingInfoMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseParseK a) => MethodInfo BaseParseSetHasTimingInfoMethodInfo a signature where + overloadedMethod _ = baseParseSetHasTimingInfo + +-- method BaseParse::set_infer_ts +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "infer_ts", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_set_infer_ts" gst_base_parse_set_infer_ts :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + CInt -> -- infer_ts : TBasicType TBoolean + IO () + + +baseParseSetInferTs :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Bool -- inferTs + -> m () -- result +baseParseSetInferTs _obj inferTs = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let inferTs' = (fromIntegral . fromEnum) inferTs + gst_base_parse_set_infer_ts _obj' inferTs' + touchManagedPtr _obj + return () + +data BaseParseSetInferTsMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseParseK a) => MethodInfo BaseParseSetInferTsMethodInfo a signature where + overloadedMethod _ = baseParseSetInferTs + +-- method BaseParse::set_latency +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_set_latency" gst_base_parse_set_latency :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + Word64 -> -- min_latency : TBasicType TUInt64 + Word64 -> -- max_latency : TBasicType TUInt64 + IO () + + +baseParseSetLatency :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Word64 -- minLatency + -> Word64 -- maxLatency + -> m () -- result +baseParseSetLatency _obj minLatency maxLatency = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_parse_set_latency _obj' minLatency maxLatency + touchManagedPtr _obj + return () + +data BaseParseSetLatencyMethodInfo +instance (signature ~ (Word64 -> Word64 -> m ()), MonadIO m, BaseParseK a) => MethodInfo BaseParseSetLatencyMethodInfo a signature where + overloadedMethod _ = baseParseSetLatency + +-- method BaseParse::set_min_frame_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_set_min_frame_size" gst_base_parse_set_min_frame_size :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + Word32 -> -- min_size : TBasicType TUInt32 + IO () + + +baseParseSetMinFrameSize :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Word32 -- minSize + -> m () -- result +baseParseSetMinFrameSize _obj minSize = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_parse_set_min_frame_size _obj' minSize + touchManagedPtr _obj + return () + +data BaseParseSetMinFrameSizeMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, BaseParseK a) => MethodInfo BaseParseSetMinFrameSizeMethodInfo a signature where + overloadedMethod _ = baseParseSetMinFrameSize + +-- method BaseParse::set_passthrough +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "passthrough", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_set_passthrough" gst_base_parse_set_passthrough :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + CInt -> -- passthrough : TBasicType TBoolean + IO () + + +baseParseSetPassthrough :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Bool -- passthrough + -> m () -- result +baseParseSetPassthrough _obj passthrough = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let passthrough' = (fromIntegral . fromEnum) passthrough + gst_base_parse_set_passthrough _obj' passthrough' + touchManagedPtr _obj + return () + +data BaseParseSetPassthroughMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseParseK a) => MethodInfo BaseParseSetPassthroughMethodInfo a signature where + overloadedMethod _ = baseParseSetPassthrough + +-- method BaseParse::set_pts_interpolation +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pts_interpolate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_set_pts_interpolation" gst_base_parse_set_pts_interpolation :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + CInt -> -- pts_interpolate : TBasicType TBoolean + IO () + + +baseParseSetPtsInterpolation :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Bool -- ptsInterpolate + -> m () -- result +baseParseSetPtsInterpolation _obj ptsInterpolate = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let ptsInterpolate' = (fromIntegral . fromEnum) ptsInterpolate + gst_base_parse_set_pts_interpolation _obj' ptsInterpolate' + touchManagedPtr _obj + return () + +data BaseParseSetPtsInterpolationMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseParseK a) => MethodInfo BaseParseSetPtsInterpolationMethodInfo a signature where + overloadedMethod _ = baseParseSetPtsInterpolation + +-- method BaseParse::set_syncable +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "syncable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_set_syncable" gst_base_parse_set_syncable :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + CInt -> -- syncable : TBasicType TBoolean + IO () + + +baseParseSetSyncable :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Bool -- syncable + -> m () -- result +baseParseSetSyncable _obj syncable = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let syncable' = (fromIntegral . fromEnum) syncable + gst_base_parse_set_syncable _obj' syncable' + touchManagedPtr _obj + return () + +data BaseParseSetSyncableMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseParseK a) => MethodInfo BaseParseSetSyncableMethodInfo a signature where + overloadedMethod _ = baseParseSetSyncable + +-- method BaseParse::set_ts_at_offset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParse", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_set_ts_at_offset" gst_base_parse_set_ts_at_offset :: + Ptr BaseParse -> -- _obj : TInterface "GstBase" "BaseParse" + Word64 -> -- offset : TBasicType TUInt64 + IO () + + +baseParseSetTsAtOffset :: + (MonadIO m, BaseParseK a) => + a -- _obj + -> Word64 -- offset + -> m () -- result +baseParseSetTsAtOffset _obj offset = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_parse_set_ts_at_offset _obj' offset + touchManagedPtr _obj + return () + +data BaseParseSetTsAtOffsetMethodInfo +instance (signature ~ (Word64 -> m ()), MonadIO m, BaseParseK a) => MethodInfo BaseParseSetTsAtOffsetMethodInfo a signature where + overloadedMethod _ = baseParseSetTsAtOffset + + diff --git a/GI/GstBase/Objects/BaseParse.hs-boot b/GI/GstBase/Objects/BaseParse.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/BaseParse.hs-boot @@ -0,0 +1,30 @@ +module GI.GstBase.Objects.BaseParse where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype BaseParse = BaseParse (ForeignPtr BaseParse) +instance GObject BaseParse where +class GObject o => BaseParseK o +instance (GObject o, IsDescendantOf BaseParse o) => BaseParseK o +data BaseParseDisablePassthroughPropertyInfo +data BaseParseAddIndexEntryMethodInfo +data BaseParseConvertDefaultMethodInfo +data BaseParseFinishFrameMethodInfo +data BaseParseMergeTagsMethodInfo +data BaseParsePushFrameMethodInfo +data BaseParseSetAverageBitrateMethodInfo +data BaseParseSetDurationMethodInfo +data BaseParseSetFrameRateMethodInfo +data BaseParseSetHasTimingInfoMethodInfo +data BaseParseSetInferTsMethodInfo +data BaseParseSetLatencyMethodInfo +data BaseParseSetMinFrameSizeMethodInfo +data BaseParseSetPassthroughMethodInfo +data BaseParseSetPtsInterpolationMethodInfo +data BaseParseSetSyncableMethodInfo +data BaseParseSetTsAtOffsetMethodInfo diff --git a/GI/GstBase/Objects/BaseSink.hs b/GI/GstBase/Objects/BaseSink.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/BaseSink.hs @@ -0,0 +1,1462 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Objects.BaseSink + ( + +-- * Exported types + BaseSink(..) , + BaseSinkK , + toBaseSink , + noBaseSink , + + + -- * Methods +-- ** baseSinkDoPreroll + BaseSinkDoPrerollMethodInfo , + baseSinkDoPreroll , + + +-- ** baseSinkGetBlocksize + BaseSinkGetBlocksizeMethodInfo , + baseSinkGetBlocksize , + + +-- ** baseSinkGetLastSample + BaseSinkGetLastSampleMethodInfo , + baseSinkGetLastSample , + + +-- ** baseSinkGetLatency + BaseSinkGetLatencyMethodInfo , + baseSinkGetLatency , + + +-- ** baseSinkGetMaxBitrate + BaseSinkGetMaxBitrateMethodInfo , + baseSinkGetMaxBitrate , + + +-- ** baseSinkGetMaxLateness + BaseSinkGetMaxLatenessMethodInfo , + baseSinkGetMaxLateness , + + +-- ** baseSinkGetRenderDelay + BaseSinkGetRenderDelayMethodInfo , + baseSinkGetRenderDelay , + + +-- ** baseSinkGetSync + BaseSinkGetSyncMethodInfo , + baseSinkGetSync , + + +-- ** baseSinkGetThrottleTime + BaseSinkGetThrottleTimeMethodInfo , + baseSinkGetThrottleTime , + + +-- ** baseSinkGetTsOffset + BaseSinkGetTsOffsetMethodInfo , + baseSinkGetTsOffset , + + +-- ** baseSinkIsAsyncEnabled + BaseSinkIsAsyncEnabledMethodInfo , + baseSinkIsAsyncEnabled , + + +-- ** baseSinkIsLastSampleEnabled + BaseSinkIsLastSampleEnabledMethodInfo , + baseSinkIsLastSampleEnabled , + + +-- ** baseSinkIsQosEnabled + BaseSinkIsQosEnabledMethodInfo , + baseSinkIsQosEnabled , + + +-- ** baseSinkQueryLatency + BaseSinkQueryLatencyMethodInfo , + baseSinkQueryLatency , + + +-- ** baseSinkSetAsyncEnabled + BaseSinkSetAsyncEnabledMethodInfo , + baseSinkSetAsyncEnabled , + + +-- ** baseSinkSetBlocksize + BaseSinkSetBlocksizeMethodInfo , + baseSinkSetBlocksize , + + +-- ** baseSinkSetLastSampleEnabled + BaseSinkSetLastSampleEnabledMethodInfo , + baseSinkSetLastSampleEnabled , + + +-- ** baseSinkSetMaxBitrate + BaseSinkSetMaxBitrateMethodInfo , + baseSinkSetMaxBitrate , + + +-- ** baseSinkSetMaxLateness + BaseSinkSetMaxLatenessMethodInfo , + baseSinkSetMaxLateness , + + +-- ** baseSinkSetQosEnabled + BaseSinkSetQosEnabledMethodInfo , + baseSinkSetQosEnabled , + + +-- ** baseSinkSetRenderDelay + BaseSinkSetRenderDelayMethodInfo , + baseSinkSetRenderDelay , + + +-- ** baseSinkSetSync + BaseSinkSetSyncMethodInfo , + baseSinkSetSync , + + +-- ** baseSinkSetThrottleTime + BaseSinkSetThrottleTimeMethodInfo , + baseSinkSetThrottleTime , + + +-- ** baseSinkSetTsOffset + BaseSinkSetTsOffsetMethodInfo , + baseSinkSetTsOffset , + + +-- ** baseSinkWait + BaseSinkWaitMethodInfo , + baseSinkWait , + + +-- ** baseSinkWaitClock + BaseSinkWaitClockMethodInfo , + baseSinkWaitClock , + + +-- ** baseSinkWaitPreroll + BaseSinkWaitPrerollMethodInfo , + baseSinkWaitPreroll , + + + + + -- * Properties +-- ** Async + BaseSinkAsyncPropertyInfo , + constructBaseSinkAsync , + getBaseSinkAsync , + setBaseSinkAsync , + + +-- ** Blocksize + BaseSinkBlocksizePropertyInfo , + constructBaseSinkBlocksize , + getBaseSinkBlocksize , + setBaseSinkBlocksize , + + +-- ** EnableLastSample + BaseSinkEnableLastSamplePropertyInfo , + constructBaseSinkEnableLastSample , + getBaseSinkEnableLastSample , + setBaseSinkEnableLastSample , + + +-- ** LastSample + BaseSinkLastSamplePropertyInfo , + getBaseSinkLastSample , + + +-- ** MaxBitrate + BaseSinkMaxBitratePropertyInfo , + constructBaseSinkMaxBitrate , + getBaseSinkMaxBitrate , + setBaseSinkMaxBitrate , + + +-- ** MaxLateness + BaseSinkMaxLatenessPropertyInfo , + constructBaseSinkMaxLateness , + getBaseSinkMaxLateness , + setBaseSinkMaxLateness , + + +-- ** Qos + BaseSinkQosPropertyInfo , + constructBaseSinkQos , + getBaseSinkQos , + setBaseSinkQos , + + +-- ** RenderDelay + BaseSinkRenderDelayPropertyInfo , + constructBaseSinkRenderDelay , + getBaseSinkRenderDelay , + setBaseSinkRenderDelay , + + +-- ** Sync + BaseSinkSyncPropertyInfo , + constructBaseSinkSync , + getBaseSinkSync , + setBaseSinkSync , + + +-- ** ThrottleTime + BaseSinkThrottleTimePropertyInfo , + constructBaseSinkThrottleTime , + getBaseSinkThrottleTime , + setBaseSinkThrottleTime , + + +-- ** TsOffset + BaseSinkTsOffsetPropertyInfo , + constructBaseSinkTsOffset , + getBaseSinkTsOffset , + setBaseSinkTsOffset , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks +import qualified GI.GObject as GObject +import qualified GI.Gst as Gst + +newtype BaseSink = BaseSink (ForeignPtr BaseSink) +foreign import ccall "gst_base_sink_get_type" + c_gst_base_sink_get_type :: IO GType + +type instance ParentTypes BaseSink = BaseSinkParentTypes +type BaseSinkParentTypes = '[Gst.Element, Gst.Object, GObject.Object] + +instance GObject BaseSink where + gobjectIsInitiallyUnowned _ = True + gobjectType _ = c_gst_base_sink_get_type + + +class GObject o => BaseSinkK o +instance (GObject o, IsDescendantOf BaseSink o) => BaseSinkK o + +toBaseSink :: BaseSinkK o => o -> IO BaseSink +toBaseSink = unsafeCastTo BaseSink + +noBaseSink :: Maybe BaseSink +noBaseSink = Nothing + +type family ResolveBaseSinkMethod (t :: Symbol) (o :: *) :: * where + ResolveBaseSinkMethod "abortState" o = Gst.ElementAbortStateMethodInfo + ResolveBaseSinkMethod "addControlBinding" o = Gst.ObjectAddControlBindingMethodInfo + ResolveBaseSinkMethod "addPad" o = Gst.ElementAddPadMethodInfo + ResolveBaseSinkMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo + ResolveBaseSinkMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo + ResolveBaseSinkMethod "changeState" o = Gst.ElementChangeStateMethodInfo + ResolveBaseSinkMethod "continueState" o = Gst.ElementContinueStateMethodInfo + ResolveBaseSinkMethod "createAllPads" o = Gst.ElementCreateAllPadsMethodInfo + ResolveBaseSinkMethod "defaultError" o = Gst.ObjectDefaultErrorMethodInfo + ResolveBaseSinkMethod "doPreroll" o = BaseSinkDoPrerollMethodInfo + ResolveBaseSinkMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo + ResolveBaseSinkMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo + ResolveBaseSinkMethod "hasActiveControlBindings" o = Gst.ObjectHasActiveControlBindingsMethodInfo + ResolveBaseSinkMethod "hasAncestor" o = Gst.ObjectHasAncestorMethodInfo + ResolveBaseSinkMethod "hasAsAncestor" o = Gst.ObjectHasAsAncestorMethodInfo + ResolveBaseSinkMethod "hasAsParent" o = Gst.ObjectHasAsParentMethodInfo + ResolveBaseSinkMethod "isAsyncEnabled" o = BaseSinkIsAsyncEnabledMethodInfo + ResolveBaseSinkMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo + ResolveBaseSinkMethod "isLastSampleEnabled" o = BaseSinkIsLastSampleEnabledMethodInfo + ResolveBaseSinkMethod "isLockedState" o = Gst.ElementIsLockedStateMethodInfo + ResolveBaseSinkMethod "isQosEnabled" o = BaseSinkIsQosEnabledMethodInfo + ResolveBaseSinkMethod "iteratePads" o = Gst.ElementIteratePadsMethodInfo + ResolveBaseSinkMethod "iterateSinkPads" o = Gst.ElementIterateSinkPadsMethodInfo + ResolveBaseSinkMethod "iterateSrcPads" o = Gst.ElementIterateSrcPadsMethodInfo + ResolveBaseSinkMethod "link" o = Gst.ElementLinkMethodInfo + ResolveBaseSinkMethod "linkFiltered" o = Gst.ElementLinkFilteredMethodInfo + ResolveBaseSinkMethod "linkPads" o = Gst.ElementLinkPadsMethodInfo + ResolveBaseSinkMethod "linkPadsFiltered" o = Gst.ElementLinkPadsFilteredMethodInfo + ResolveBaseSinkMethod "linkPadsFull" o = Gst.ElementLinkPadsFullMethodInfo + ResolveBaseSinkMethod "lostState" o = Gst.ElementLostStateMethodInfo + ResolveBaseSinkMethod "messageFull" o = Gst.ElementMessageFullMethodInfo + ResolveBaseSinkMethod "noMorePads" o = Gst.ElementNoMorePadsMethodInfo + ResolveBaseSinkMethod "notify" o = GObject.ObjectNotifyMethodInfo + ResolveBaseSinkMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo + ResolveBaseSinkMethod "postMessage" o = Gst.ElementPostMessageMethodInfo + ResolveBaseSinkMethod "provideClock" o = Gst.ElementProvideClockMethodInfo + ResolveBaseSinkMethod "query" o = Gst.ElementQueryMethodInfo + ResolveBaseSinkMethod "queryConvert" o = Gst.ElementQueryConvertMethodInfo + ResolveBaseSinkMethod "queryDuration" o = Gst.ElementQueryDurationMethodInfo + ResolveBaseSinkMethod "queryLatency" o = BaseSinkQueryLatencyMethodInfo + ResolveBaseSinkMethod "queryPosition" o = Gst.ElementQueryPositionMethodInfo + ResolveBaseSinkMethod "refSink" o = GObject.ObjectRefSinkMethodInfo + ResolveBaseSinkMethod "releaseRequestPad" o = Gst.ElementReleaseRequestPadMethodInfo + ResolveBaseSinkMethod "removeControlBinding" o = Gst.ObjectRemoveControlBindingMethodInfo + ResolveBaseSinkMethod "removePad" o = Gst.ElementRemovePadMethodInfo + ResolveBaseSinkMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo + ResolveBaseSinkMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo + ResolveBaseSinkMethod "requestPad" o = Gst.ElementRequestPadMethodInfo + ResolveBaseSinkMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo + ResolveBaseSinkMethod "seek" o = Gst.ElementSeekMethodInfo + ResolveBaseSinkMethod "seekSimple" o = Gst.ElementSeekSimpleMethodInfo + ResolveBaseSinkMethod "sendEvent" o = Gst.ElementSendEventMethodInfo + ResolveBaseSinkMethod "stealData" o = GObject.ObjectStealDataMethodInfo + ResolveBaseSinkMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo + ResolveBaseSinkMethod "suggestNextSync" o = Gst.ObjectSuggestNextSyncMethodInfo + ResolveBaseSinkMethod "syncStateWithParent" o = Gst.ElementSyncStateWithParentMethodInfo + ResolveBaseSinkMethod "syncValues" o = Gst.ObjectSyncValuesMethodInfo + ResolveBaseSinkMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo + ResolveBaseSinkMethod "unlink" o = Gst.ElementUnlinkMethodInfo + ResolveBaseSinkMethod "unlinkPads" o = Gst.ElementUnlinkPadsMethodInfo + ResolveBaseSinkMethod "unparent" o = Gst.ObjectUnparentMethodInfo + ResolveBaseSinkMethod "wait" o = BaseSinkWaitMethodInfo + ResolveBaseSinkMethod "waitClock" o = BaseSinkWaitClockMethodInfo + ResolveBaseSinkMethod "waitPreroll" o = BaseSinkWaitPrerollMethodInfo + ResolveBaseSinkMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo + ResolveBaseSinkMethod "getBaseTime" o = Gst.ElementGetBaseTimeMethodInfo + ResolveBaseSinkMethod "getBlocksize" o = BaseSinkGetBlocksizeMethodInfo + ResolveBaseSinkMethod "getBus" o = Gst.ElementGetBusMethodInfo + ResolveBaseSinkMethod "getClock" o = Gst.ElementGetClockMethodInfo + ResolveBaseSinkMethod "getCompatiblePad" o = Gst.ElementGetCompatiblePadMethodInfo + ResolveBaseSinkMethod "getCompatiblePadTemplate" o = Gst.ElementGetCompatiblePadTemplateMethodInfo + ResolveBaseSinkMethod "getControlBinding" o = Gst.ObjectGetControlBindingMethodInfo + ResolveBaseSinkMethod "getControlRate" o = Gst.ObjectGetControlRateMethodInfo + ResolveBaseSinkMethod "getData" o = GObject.ObjectGetDataMethodInfo + ResolveBaseSinkMethod "getFactory" o = Gst.ElementGetFactoryMethodInfo + ResolveBaseSinkMethod "getGValueArray" o = Gst.ObjectGetGValueArrayMethodInfo + ResolveBaseSinkMethod "getLastSample" o = BaseSinkGetLastSampleMethodInfo + ResolveBaseSinkMethod "getLatency" o = BaseSinkGetLatencyMethodInfo + ResolveBaseSinkMethod "getMaxBitrate" o = BaseSinkGetMaxBitrateMethodInfo + ResolveBaseSinkMethod "getMaxLateness" o = BaseSinkGetMaxLatenessMethodInfo + ResolveBaseSinkMethod "getName" o = Gst.ObjectGetNameMethodInfo + ResolveBaseSinkMethod "getParent" o = Gst.ObjectGetParentMethodInfo + ResolveBaseSinkMethod "getPathString" o = Gst.ObjectGetPathStringMethodInfo + ResolveBaseSinkMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo + ResolveBaseSinkMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo + ResolveBaseSinkMethod "getRenderDelay" o = BaseSinkGetRenderDelayMethodInfo + ResolveBaseSinkMethod "getRequestPad" o = Gst.ElementGetRequestPadMethodInfo + ResolveBaseSinkMethod "getStartTime" o = Gst.ElementGetStartTimeMethodInfo + ResolveBaseSinkMethod "getState" o = Gst.ElementGetStateMethodInfo + ResolveBaseSinkMethod "getStaticPad" o = Gst.ElementGetStaticPadMethodInfo + ResolveBaseSinkMethod "getSync" o = BaseSinkGetSyncMethodInfo + ResolveBaseSinkMethod "getThrottleTime" o = BaseSinkGetThrottleTimeMethodInfo + ResolveBaseSinkMethod "getTsOffset" o = BaseSinkGetTsOffsetMethodInfo + ResolveBaseSinkMethod "getValue" o = Gst.ObjectGetValueMethodInfo + ResolveBaseSinkMethod "getValueArray" o = Gst.ObjectGetValueArrayMethodInfo + ResolveBaseSinkMethod "setAsyncEnabled" o = BaseSinkSetAsyncEnabledMethodInfo + ResolveBaseSinkMethod "setBaseTime" o = Gst.ElementSetBaseTimeMethodInfo + ResolveBaseSinkMethod "setBlocksize" o = BaseSinkSetBlocksizeMethodInfo + ResolveBaseSinkMethod "setBus" o = Gst.ElementSetBusMethodInfo + ResolveBaseSinkMethod "setClock" o = Gst.ElementSetClockMethodInfo + ResolveBaseSinkMethod "setContext" o = Gst.ElementSetContextMethodInfo + ResolveBaseSinkMethod "setControlBindingDisabled" o = Gst.ObjectSetControlBindingDisabledMethodInfo + ResolveBaseSinkMethod "setControlBindingsDisabled" o = Gst.ObjectSetControlBindingsDisabledMethodInfo + ResolveBaseSinkMethod "setControlRate" o = Gst.ObjectSetControlRateMethodInfo + ResolveBaseSinkMethod "setData" o = GObject.ObjectSetDataMethodInfo + ResolveBaseSinkMethod "setLastSampleEnabled" o = BaseSinkSetLastSampleEnabledMethodInfo + ResolveBaseSinkMethod "setLockedState" o = Gst.ElementSetLockedStateMethodInfo + ResolveBaseSinkMethod "setMaxBitrate" o = BaseSinkSetMaxBitrateMethodInfo + ResolveBaseSinkMethod "setMaxLateness" o = BaseSinkSetMaxLatenessMethodInfo + ResolveBaseSinkMethod "setName" o = Gst.ObjectSetNameMethodInfo + ResolveBaseSinkMethod "setParent" o = Gst.ObjectSetParentMethodInfo + ResolveBaseSinkMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo + ResolveBaseSinkMethod "setQosEnabled" o = BaseSinkSetQosEnabledMethodInfo + ResolveBaseSinkMethod "setRenderDelay" o = BaseSinkSetRenderDelayMethodInfo + ResolveBaseSinkMethod "setStartTime" o = Gst.ElementSetStartTimeMethodInfo + ResolveBaseSinkMethod "setState" o = Gst.ElementSetStateMethodInfo + ResolveBaseSinkMethod "setSync" o = BaseSinkSetSyncMethodInfo + ResolveBaseSinkMethod "setThrottleTime" o = BaseSinkSetThrottleTimeMethodInfo + ResolveBaseSinkMethod "setTsOffset" o = BaseSinkSetTsOffsetMethodInfo + ResolveBaseSinkMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolveBaseSinkMethod t BaseSink, MethodInfo info BaseSink p) => IsLabelProxy t (BaseSink -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolveBaseSinkMethod t BaseSink, MethodInfo info BaseSink p) => IsLabel t (BaseSink -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + +-- VVV Prop "async" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSinkAsync :: (MonadIO m, BaseSinkK o) => o -> m Bool +getBaseSinkAsync obj = liftIO $ getObjectPropertyBool obj "async" + +setBaseSinkAsync :: (MonadIO m, BaseSinkK o) => o -> Bool -> m () +setBaseSinkAsync obj val = liftIO $ setObjectPropertyBool obj "async" val + +constructBaseSinkAsync :: Bool -> IO ([Char], GValue) +constructBaseSinkAsync val = constructObjectPropertyBool "async" val + +data BaseSinkAsyncPropertyInfo +instance AttrInfo BaseSinkAsyncPropertyInfo where + type AttrAllowedOps BaseSinkAsyncPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSinkAsyncPropertyInfo = (~) Bool + type AttrBaseTypeConstraint BaseSinkAsyncPropertyInfo = BaseSinkK + type AttrGetType BaseSinkAsyncPropertyInfo = Bool + type AttrLabel BaseSinkAsyncPropertyInfo = "async" + attrGet _ = getBaseSinkAsync + attrSet _ = setBaseSinkAsync + attrConstruct _ = constructBaseSinkAsync + +-- VVV Prop "blocksize" + -- Type: TBasicType TUInt32 + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSinkBlocksize :: (MonadIO m, BaseSinkK o) => o -> m Word32 +getBaseSinkBlocksize obj = liftIO $ getObjectPropertyCUInt obj "blocksize" + +setBaseSinkBlocksize :: (MonadIO m, BaseSinkK o) => o -> Word32 -> m () +setBaseSinkBlocksize obj val = liftIO $ setObjectPropertyCUInt obj "blocksize" val + +constructBaseSinkBlocksize :: Word32 -> IO ([Char], GValue) +constructBaseSinkBlocksize val = constructObjectPropertyCUInt "blocksize" val + +data BaseSinkBlocksizePropertyInfo +instance AttrInfo BaseSinkBlocksizePropertyInfo where + type AttrAllowedOps BaseSinkBlocksizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSinkBlocksizePropertyInfo = (~) Word32 + type AttrBaseTypeConstraint BaseSinkBlocksizePropertyInfo = BaseSinkK + type AttrGetType BaseSinkBlocksizePropertyInfo = Word32 + type AttrLabel BaseSinkBlocksizePropertyInfo = "blocksize" + attrGet _ = getBaseSinkBlocksize + attrSet _ = setBaseSinkBlocksize + attrConstruct _ = constructBaseSinkBlocksize + +-- VVV Prop "enable-last-sample" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSinkEnableLastSample :: (MonadIO m, BaseSinkK o) => o -> m Bool +getBaseSinkEnableLastSample obj = liftIO $ getObjectPropertyBool obj "enable-last-sample" + +setBaseSinkEnableLastSample :: (MonadIO m, BaseSinkK o) => o -> Bool -> m () +setBaseSinkEnableLastSample obj val = liftIO $ setObjectPropertyBool obj "enable-last-sample" val + +constructBaseSinkEnableLastSample :: Bool -> IO ([Char], GValue) +constructBaseSinkEnableLastSample val = constructObjectPropertyBool "enable-last-sample" val + +data BaseSinkEnableLastSamplePropertyInfo +instance AttrInfo BaseSinkEnableLastSamplePropertyInfo where + type AttrAllowedOps BaseSinkEnableLastSamplePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSinkEnableLastSamplePropertyInfo = (~) Bool + type AttrBaseTypeConstraint BaseSinkEnableLastSamplePropertyInfo = BaseSinkK + type AttrGetType BaseSinkEnableLastSamplePropertyInfo = Bool + type AttrLabel BaseSinkEnableLastSamplePropertyInfo = "enable-last-sample" + attrGet _ = getBaseSinkEnableLastSample + attrSet _ = setBaseSinkEnableLastSample + attrConstruct _ = constructBaseSinkEnableLastSample + +-- VVV Prop "last-sample" + -- Type: TInterface "Gst" "Sample" + -- Flags: [PropertyReadable] + +getBaseSinkLastSample :: (MonadIO m, BaseSinkK o) => o -> m Gst.Sample +getBaseSinkLastSample obj = liftIO $ getObjectPropertyBoxed obj "last-sample" Gst.Sample + +data BaseSinkLastSamplePropertyInfo +instance AttrInfo BaseSinkLastSamplePropertyInfo where + type AttrAllowedOps BaseSinkLastSamplePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint BaseSinkLastSamplePropertyInfo = (~) () + type AttrBaseTypeConstraint BaseSinkLastSamplePropertyInfo = BaseSinkK + type AttrGetType BaseSinkLastSamplePropertyInfo = Gst.Sample + type AttrLabel BaseSinkLastSamplePropertyInfo = "last-sample" + attrGet _ = getBaseSinkLastSample + attrSet _ = undefined + attrConstruct _ = undefined + +-- VVV Prop "max-bitrate" + -- Type: TBasicType TUInt64 + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSinkMaxBitrate :: (MonadIO m, BaseSinkK o) => o -> m Word64 +getBaseSinkMaxBitrate obj = liftIO $ getObjectPropertyUInt64 obj "max-bitrate" + +setBaseSinkMaxBitrate :: (MonadIO m, BaseSinkK o) => o -> Word64 -> m () +setBaseSinkMaxBitrate obj val = liftIO $ setObjectPropertyUInt64 obj "max-bitrate" val + +constructBaseSinkMaxBitrate :: Word64 -> IO ([Char], GValue) +constructBaseSinkMaxBitrate val = constructObjectPropertyUInt64 "max-bitrate" val + +data BaseSinkMaxBitratePropertyInfo +instance AttrInfo BaseSinkMaxBitratePropertyInfo where + type AttrAllowedOps BaseSinkMaxBitratePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSinkMaxBitratePropertyInfo = (~) Word64 + type AttrBaseTypeConstraint BaseSinkMaxBitratePropertyInfo = BaseSinkK + type AttrGetType BaseSinkMaxBitratePropertyInfo = Word64 + type AttrLabel BaseSinkMaxBitratePropertyInfo = "max-bitrate" + attrGet _ = getBaseSinkMaxBitrate + attrSet _ = setBaseSinkMaxBitrate + attrConstruct _ = constructBaseSinkMaxBitrate + +-- VVV Prop "max-lateness" + -- Type: TBasicType TInt64 + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSinkMaxLateness :: (MonadIO m, BaseSinkK o) => o -> m Int64 +getBaseSinkMaxLateness obj = liftIO $ getObjectPropertyInt64 obj "max-lateness" + +setBaseSinkMaxLateness :: (MonadIO m, BaseSinkK o) => o -> Int64 -> m () +setBaseSinkMaxLateness obj val = liftIO $ setObjectPropertyInt64 obj "max-lateness" val + +constructBaseSinkMaxLateness :: Int64 -> IO ([Char], GValue) +constructBaseSinkMaxLateness val = constructObjectPropertyInt64 "max-lateness" val + +data BaseSinkMaxLatenessPropertyInfo +instance AttrInfo BaseSinkMaxLatenessPropertyInfo where + type AttrAllowedOps BaseSinkMaxLatenessPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSinkMaxLatenessPropertyInfo = (~) Int64 + type AttrBaseTypeConstraint BaseSinkMaxLatenessPropertyInfo = BaseSinkK + type AttrGetType BaseSinkMaxLatenessPropertyInfo = Int64 + type AttrLabel BaseSinkMaxLatenessPropertyInfo = "max-lateness" + attrGet _ = getBaseSinkMaxLateness + attrSet _ = setBaseSinkMaxLateness + attrConstruct _ = constructBaseSinkMaxLateness + +-- VVV Prop "qos" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSinkQos :: (MonadIO m, BaseSinkK o) => o -> m Bool +getBaseSinkQos obj = liftIO $ getObjectPropertyBool obj "qos" + +setBaseSinkQos :: (MonadIO m, BaseSinkK o) => o -> Bool -> m () +setBaseSinkQos obj val = liftIO $ setObjectPropertyBool obj "qos" val + +constructBaseSinkQos :: Bool -> IO ([Char], GValue) +constructBaseSinkQos val = constructObjectPropertyBool "qos" val + +data BaseSinkQosPropertyInfo +instance AttrInfo BaseSinkQosPropertyInfo where + type AttrAllowedOps BaseSinkQosPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSinkQosPropertyInfo = (~) Bool + type AttrBaseTypeConstraint BaseSinkQosPropertyInfo = BaseSinkK + type AttrGetType BaseSinkQosPropertyInfo = Bool + type AttrLabel BaseSinkQosPropertyInfo = "qos" + attrGet _ = getBaseSinkQos + attrSet _ = setBaseSinkQos + attrConstruct _ = constructBaseSinkQos + +-- VVV Prop "render-delay" + -- Type: TBasicType TUInt64 + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSinkRenderDelay :: (MonadIO m, BaseSinkK o) => o -> m Word64 +getBaseSinkRenderDelay obj = liftIO $ getObjectPropertyUInt64 obj "render-delay" + +setBaseSinkRenderDelay :: (MonadIO m, BaseSinkK o) => o -> Word64 -> m () +setBaseSinkRenderDelay obj val = liftIO $ setObjectPropertyUInt64 obj "render-delay" val + +constructBaseSinkRenderDelay :: Word64 -> IO ([Char], GValue) +constructBaseSinkRenderDelay val = constructObjectPropertyUInt64 "render-delay" val + +data BaseSinkRenderDelayPropertyInfo +instance AttrInfo BaseSinkRenderDelayPropertyInfo where + type AttrAllowedOps BaseSinkRenderDelayPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSinkRenderDelayPropertyInfo = (~) Word64 + type AttrBaseTypeConstraint BaseSinkRenderDelayPropertyInfo = BaseSinkK + type AttrGetType BaseSinkRenderDelayPropertyInfo = Word64 + type AttrLabel BaseSinkRenderDelayPropertyInfo = "render-delay" + attrGet _ = getBaseSinkRenderDelay + attrSet _ = setBaseSinkRenderDelay + attrConstruct _ = constructBaseSinkRenderDelay + +-- VVV Prop "sync" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSinkSync :: (MonadIO m, BaseSinkK o) => o -> m Bool +getBaseSinkSync obj = liftIO $ getObjectPropertyBool obj "sync" + +setBaseSinkSync :: (MonadIO m, BaseSinkK o) => o -> Bool -> m () +setBaseSinkSync obj val = liftIO $ setObjectPropertyBool obj "sync" val + +constructBaseSinkSync :: Bool -> IO ([Char], GValue) +constructBaseSinkSync val = constructObjectPropertyBool "sync" val + +data BaseSinkSyncPropertyInfo +instance AttrInfo BaseSinkSyncPropertyInfo where + type AttrAllowedOps BaseSinkSyncPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSinkSyncPropertyInfo = (~) Bool + type AttrBaseTypeConstraint BaseSinkSyncPropertyInfo = BaseSinkK + type AttrGetType BaseSinkSyncPropertyInfo = Bool + type AttrLabel BaseSinkSyncPropertyInfo = "sync" + attrGet _ = getBaseSinkSync + attrSet _ = setBaseSinkSync + attrConstruct _ = constructBaseSinkSync + +-- VVV Prop "throttle-time" + -- Type: TBasicType TUInt64 + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSinkThrottleTime :: (MonadIO m, BaseSinkK o) => o -> m Word64 +getBaseSinkThrottleTime obj = liftIO $ getObjectPropertyUInt64 obj "throttle-time" + +setBaseSinkThrottleTime :: (MonadIO m, BaseSinkK o) => o -> Word64 -> m () +setBaseSinkThrottleTime obj val = liftIO $ setObjectPropertyUInt64 obj "throttle-time" val + +constructBaseSinkThrottleTime :: Word64 -> IO ([Char], GValue) +constructBaseSinkThrottleTime val = constructObjectPropertyUInt64 "throttle-time" val + +data BaseSinkThrottleTimePropertyInfo +instance AttrInfo BaseSinkThrottleTimePropertyInfo where + type AttrAllowedOps BaseSinkThrottleTimePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSinkThrottleTimePropertyInfo = (~) Word64 + type AttrBaseTypeConstraint BaseSinkThrottleTimePropertyInfo = BaseSinkK + type AttrGetType BaseSinkThrottleTimePropertyInfo = Word64 + type AttrLabel BaseSinkThrottleTimePropertyInfo = "throttle-time" + attrGet _ = getBaseSinkThrottleTime + attrSet _ = setBaseSinkThrottleTime + attrConstruct _ = constructBaseSinkThrottleTime + +-- VVV Prop "ts-offset" + -- Type: TBasicType TInt64 + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSinkTsOffset :: (MonadIO m, BaseSinkK o) => o -> m Int64 +getBaseSinkTsOffset obj = liftIO $ getObjectPropertyInt64 obj "ts-offset" + +setBaseSinkTsOffset :: (MonadIO m, BaseSinkK o) => o -> Int64 -> m () +setBaseSinkTsOffset obj val = liftIO $ setObjectPropertyInt64 obj "ts-offset" val + +constructBaseSinkTsOffset :: Int64 -> IO ([Char], GValue) +constructBaseSinkTsOffset val = constructObjectPropertyInt64 "ts-offset" val + +data BaseSinkTsOffsetPropertyInfo +instance AttrInfo BaseSinkTsOffsetPropertyInfo where + type AttrAllowedOps BaseSinkTsOffsetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSinkTsOffsetPropertyInfo = (~) Int64 + type AttrBaseTypeConstraint BaseSinkTsOffsetPropertyInfo = BaseSinkK + type AttrGetType BaseSinkTsOffsetPropertyInfo = Int64 + type AttrLabel BaseSinkTsOffsetPropertyInfo = "ts-offset" + attrGet _ = getBaseSinkTsOffset + attrSet _ = setBaseSinkTsOffset + attrConstruct _ = constructBaseSinkTsOffset + +type instance AttributeList BaseSink = BaseSinkAttributeList +type BaseSinkAttributeList = ('[ '("async", BaseSinkAsyncPropertyInfo), '("blocksize", BaseSinkBlocksizePropertyInfo), '("enableLastSample", BaseSinkEnableLastSamplePropertyInfo), '("lastSample", BaseSinkLastSamplePropertyInfo), '("maxBitrate", BaseSinkMaxBitratePropertyInfo), '("maxLateness", BaseSinkMaxLatenessPropertyInfo), '("name", Gst.ObjectNamePropertyInfo), '("parent", Gst.ObjectParentPropertyInfo), '("qos", BaseSinkQosPropertyInfo), '("renderDelay", BaseSinkRenderDelayPropertyInfo), '("sync", BaseSinkSyncPropertyInfo), '("throttleTime", BaseSinkThrottleTimePropertyInfo), '("tsOffset", BaseSinkTsOffsetPropertyInfo)] :: [(Symbol, *)]) + +type instance SignalList BaseSink = BaseSinkSignalList +type BaseSinkSignalList = ('[ '("deepNotify", Gst.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", Gst.ElementPadAddedSignalInfo), '("padRemoved", Gst.ElementPadRemovedSignalInfo)] :: [(Symbol, *)]) + +-- method BaseSink::do_preroll +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "obj", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "FlowReturn" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_do_preroll" gst_base_sink_do_preroll :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + Ptr Gst.MiniObject -> -- obj : TInterface "Gst" "MiniObject" + IO CUInt + + +baseSinkDoPreroll :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> Gst.MiniObject -- obj + -> m Gst.FlowReturn -- result +baseSinkDoPreroll _obj obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let obj' = unsafeManagedPtrGetPtr obj + result <- gst_base_sink_do_preroll _obj' obj' + let result' = (toEnum . fromIntegral) result + touchManagedPtr _obj + touchManagedPtr obj + return result' + +data BaseSinkDoPrerollMethodInfo +instance (signature ~ (Gst.MiniObject -> m Gst.FlowReturn), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkDoPrerollMethodInfo a signature where + overloadedMethod _ = baseSinkDoPreroll + +-- method BaseSink::get_blocksize +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt32 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_get_blocksize" gst_base_sink_get_blocksize :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + IO Word32 + + +baseSinkGetBlocksize :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m Word32 -- result +baseSinkGetBlocksize _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_sink_get_blocksize _obj' + touchManagedPtr _obj + return result + +data BaseSinkGetBlocksizeMethodInfo +instance (signature ~ (m Word32), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkGetBlocksizeMethodInfo a signature where + overloadedMethod _ = baseSinkGetBlocksize + +-- method BaseSink::get_last_sample +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Sample" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_get_last_sample" gst_base_sink_get_last_sample :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + IO (Ptr Gst.Sample) + + +baseSinkGetLastSample :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m Gst.Sample -- result +baseSinkGetLastSample _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_sink_get_last_sample _obj' + checkUnexpectedReturnNULL "gst_base_sink_get_last_sample" result + result' <- (wrapBoxed Gst.Sample) result + touchManagedPtr _obj + return result' + +data BaseSinkGetLastSampleMethodInfo +instance (signature ~ (m Gst.Sample), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkGetLastSampleMethodInfo a signature where + overloadedMethod _ = baseSinkGetLastSample + +-- method BaseSink::get_latency +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_get_latency" gst_base_sink_get_latency :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + IO Word64 + + +baseSinkGetLatency :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m Word64 -- result +baseSinkGetLatency _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_sink_get_latency _obj' + touchManagedPtr _obj + return result + +data BaseSinkGetLatencyMethodInfo +instance (signature ~ (m Word64), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkGetLatencyMethodInfo a signature where + overloadedMethod _ = baseSinkGetLatency + +-- method BaseSink::get_max_bitrate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_get_max_bitrate" gst_base_sink_get_max_bitrate :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + IO Word64 + + +baseSinkGetMaxBitrate :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m Word64 -- result +baseSinkGetMaxBitrate _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_sink_get_max_bitrate _obj' + touchManagedPtr _obj + return result + +data BaseSinkGetMaxBitrateMethodInfo +instance (signature ~ (m Word64), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkGetMaxBitrateMethodInfo a signature where + overloadedMethod _ = baseSinkGetMaxBitrate + +-- method BaseSink::get_max_lateness +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_get_max_lateness" gst_base_sink_get_max_lateness :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + IO Int64 + + +baseSinkGetMaxLateness :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m Int64 -- result +baseSinkGetMaxLateness _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_sink_get_max_lateness _obj' + touchManagedPtr _obj + return result + +data BaseSinkGetMaxLatenessMethodInfo +instance (signature ~ (m Int64), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkGetMaxLatenessMethodInfo a signature where + overloadedMethod _ = baseSinkGetMaxLateness + +-- method BaseSink::get_render_delay +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_get_render_delay" gst_base_sink_get_render_delay :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + IO Word64 + + +baseSinkGetRenderDelay :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m Word64 -- result +baseSinkGetRenderDelay _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_sink_get_render_delay _obj' + touchManagedPtr _obj + return result + +data BaseSinkGetRenderDelayMethodInfo +instance (signature ~ (m Word64), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkGetRenderDelayMethodInfo a signature where + overloadedMethod _ = baseSinkGetRenderDelay + +-- method BaseSink::get_sync +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_get_sync" gst_base_sink_get_sync :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + IO CInt + + +baseSinkGetSync :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m Bool -- result +baseSinkGetSync _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_sink_get_sync _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BaseSinkGetSyncMethodInfo +instance (signature ~ (m Bool), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkGetSyncMethodInfo a signature where + overloadedMethod _ = baseSinkGetSync + +-- method BaseSink::get_throttle_time +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_get_throttle_time" gst_base_sink_get_throttle_time :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + IO Word64 + + +baseSinkGetThrottleTime :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m Word64 -- result +baseSinkGetThrottleTime _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_sink_get_throttle_time _obj' + touchManagedPtr _obj + return result + +data BaseSinkGetThrottleTimeMethodInfo +instance (signature ~ (m Word64), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkGetThrottleTimeMethodInfo a signature where + overloadedMethod _ = baseSinkGetThrottleTime + +-- method BaseSink::get_ts_offset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TInt64 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_get_ts_offset" gst_base_sink_get_ts_offset :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + IO Int64 + + +baseSinkGetTsOffset :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m Int64 -- result +baseSinkGetTsOffset _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_sink_get_ts_offset _obj' + touchManagedPtr _obj + return result + +data BaseSinkGetTsOffsetMethodInfo +instance (signature ~ (m Int64), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkGetTsOffsetMethodInfo a signature where + overloadedMethod _ = baseSinkGetTsOffset + +-- method BaseSink::is_async_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_is_async_enabled" gst_base_sink_is_async_enabled :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + IO CInt + + +baseSinkIsAsyncEnabled :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m Bool -- result +baseSinkIsAsyncEnabled _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_sink_is_async_enabled _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BaseSinkIsAsyncEnabledMethodInfo +instance (signature ~ (m Bool), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkIsAsyncEnabledMethodInfo a signature where + overloadedMethod _ = baseSinkIsAsyncEnabled + +-- method BaseSink::is_last_sample_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_is_last_sample_enabled" gst_base_sink_is_last_sample_enabled :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + IO CInt + + +baseSinkIsLastSampleEnabled :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m Bool -- result +baseSinkIsLastSampleEnabled _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_sink_is_last_sample_enabled _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BaseSinkIsLastSampleEnabledMethodInfo +instance (signature ~ (m Bool), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkIsLastSampleEnabledMethodInfo a signature where + overloadedMethod _ = baseSinkIsLastSampleEnabled + +-- method BaseSink::is_qos_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_is_qos_enabled" gst_base_sink_is_qos_enabled :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + IO CInt + + +baseSinkIsQosEnabled :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m Bool -- result +baseSinkIsQosEnabled _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_sink_is_qos_enabled _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BaseSinkIsQosEnabledMethodInfo +instance (signature ~ (m Bool), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkIsQosEnabledMethodInfo a signature where + overloadedMethod _ = baseSinkIsQosEnabled + +-- method BaseSink::query_latency +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "live", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "upstream_live", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_query_latency" gst_base_sink_query_latency :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + Ptr CInt -> -- live : TBasicType TBoolean + Ptr CInt -> -- upstream_live : TBasicType TBoolean + Ptr Word64 -> -- min_latency : TBasicType TUInt64 + Ptr Word64 -> -- max_latency : TBasicType TUInt64 + IO CInt + + +baseSinkQueryLatency :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m (Bool,Bool,Bool,Word64,Word64) -- result +baseSinkQueryLatency _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + live <- allocMem :: IO (Ptr CInt) + upstreamLive <- allocMem :: IO (Ptr CInt) + minLatency <- allocMem :: IO (Ptr Word64) + maxLatency <- allocMem :: IO (Ptr Word64) + result <- gst_base_sink_query_latency _obj' live upstreamLive minLatency maxLatency + let result' = (/= 0) result + live' <- peek live + let live'' = (/= 0) live' + upstreamLive' <- peek upstreamLive + let upstreamLive'' = (/= 0) upstreamLive' + minLatency' <- peek minLatency + maxLatency' <- peek maxLatency + touchManagedPtr _obj + freeMem live + freeMem upstreamLive + freeMem minLatency + freeMem maxLatency + return (result', live'', upstreamLive'', minLatency', maxLatency') + +data BaseSinkQueryLatencyMethodInfo +instance (signature ~ (m (Bool,Bool,Bool,Word64,Word64)), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkQueryLatencyMethodInfo a signature where + overloadedMethod _ = baseSinkQueryLatency + +-- method BaseSink::set_async_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_set_async_enabled" gst_base_sink_set_async_enabled :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + CInt -> -- enabled : TBasicType TBoolean + IO () + + +baseSinkSetAsyncEnabled :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> Bool -- enabled + -> m () -- result +baseSinkSetAsyncEnabled _obj enabled = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let enabled' = (fromIntegral . fromEnum) enabled + gst_base_sink_set_async_enabled _obj' enabled' + touchManagedPtr _obj + return () + +data BaseSinkSetAsyncEnabledMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkSetAsyncEnabledMethodInfo a signature where + overloadedMethod _ = baseSinkSetAsyncEnabled + +-- method BaseSink::set_blocksize +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blocksize", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_set_blocksize" gst_base_sink_set_blocksize :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + Word32 -> -- blocksize : TBasicType TUInt32 + IO () + + +baseSinkSetBlocksize :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> Word32 -- blocksize + -> m () -- result +baseSinkSetBlocksize _obj blocksize = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_sink_set_blocksize _obj' blocksize + touchManagedPtr _obj + return () + +data BaseSinkSetBlocksizeMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkSetBlocksizeMethodInfo a signature where + overloadedMethod _ = baseSinkSetBlocksize + +-- method BaseSink::set_last_sample_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_set_last_sample_enabled" gst_base_sink_set_last_sample_enabled :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + CInt -> -- enabled : TBasicType TBoolean + IO () + + +baseSinkSetLastSampleEnabled :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> Bool -- enabled + -> m () -- result +baseSinkSetLastSampleEnabled _obj enabled = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let enabled' = (fromIntegral . fromEnum) enabled + gst_base_sink_set_last_sample_enabled _obj' enabled' + touchManagedPtr _obj + return () + +data BaseSinkSetLastSampleEnabledMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkSetLastSampleEnabledMethodInfo a signature where + overloadedMethod _ = baseSinkSetLastSampleEnabled + +-- method BaseSink::set_max_bitrate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_bitrate", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_set_max_bitrate" gst_base_sink_set_max_bitrate :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + Word64 -> -- max_bitrate : TBasicType TUInt64 + IO () + + +baseSinkSetMaxBitrate :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> Word64 -- maxBitrate + -> m () -- result +baseSinkSetMaxBitrate _obj maxBitrate = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_sink_set_max_bitrate _obj' maxBitrate + touchManagedPtr _obj + return () + +data BaseSinkSetMaxBitrateMethodInfo +instance (signature ~ (Word64 -> m ()), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkSetMaxBitrateMethodInfo a signature where + overloadedMethod _ = baseSinkSetMaxBitrate + +-- method BaseSink::set_max_lateness +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_lateness", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_set_max_lateness" gst_base_sink_set_max_lateness :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + Int64 -> -- max_lateness : TBasicType TInt64 + IO () + + +baseSinkSetMaxLateness :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> Int64 -- maxLateness + -> m () -- result +baseSinkSetMaxLateness _obj maxLateness = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_sink_set_max_lateness _obj' maxLateness + touchManagedPtr _obj + return () + +data BaseSinkSetMaxLatenessMethodInfo +instance (signature ~ (Int64 -> m ()), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkSetMaxLatenessMethodInfo a signature where + overloadedMethod _ = baseSinkSetMaxLateness + +-- method BaseSink::set_qos_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_set_qos_enabled" gst_base_sink_set_qos_enabled :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + CInt -> -- enabled : TBasicType TBoolean + IO () + + +baseSinkSetQosEnabled :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> Bool -- enabled + -> m () -- result +baseSinkSetQosEnabled _obj enabled = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let enabled' = (fromIntegral . fromEnum) enabled + gst_base_sink_set_qos_enabled _obj' enabled' + touchManagedPtr _obj + return () + +data BaseSinkSetQosEnabledMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkSetQosEnabledMethodInfo a signature where + overloadedMethod _ = baseSinkSetQosEnabled + +-- method BaseSink::set_render_delay +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delay", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_set_render_delay" gst_base_sink_set_render_delay :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + Word64 -> -- delay : TBasicType TUInt64 + IO () + + +baseSinkSetRenderDelay :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> Word64 -- delay + -> m () -- result +baseSinkSetRenderDelay _obj delay = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_sink_set_render_delay _obj' delay + touchManagedPtr _obj + return () + +data BaseSinkSetRenderDelayMethodInfo +instance (signature ~ (Word64 -> m ()), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkSetRenderDelayMethodInfo a signature where + overloadedMethod _ = baseSinkSetRenderDelay + +-- method BaseSink::set_sync +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sync", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_set_sync" gst_base_sink_set_sync :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + CInt -> -- sync : TBasicType TBoolean + IO () + + +baseSinkSetSync :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> Bool -- sync + -> m () -- result +baseSinkSetSync _obj sync = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let sync' = (fromIntegral . fromEnum) sync + gst_base_sink_set_sync _obj' sync' + touchManagedPtr _obj + return () + +data BaseSinkSetSyncMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkSetSyncMethodInfo a signature where + overloadedMethod _ = baseSinkSetSync + +-- method BaseSink::set_throttle_time +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "throttle", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_set_throttle_time" gst_base_sink_set_throttle_time :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + Word64 -> -- throttle : TBasicType TUInt64 + IO () + + +baseSinkSetThrottleTime :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> Word64 -- throttle + -> m () -- result +baseSinkSetThrottleTime _obj throttle = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_sink_set_throttle_time _obj' throttle + touchManagedPtr _obj + return () + +data BaseSinkSetThrottleTimeMethodInfo +instance (signature ~ (Word64 -> m ()), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkSetThrottleTimeMethodInfo a signature where + overloadedMethod _ = baseSinkSetThrottleTime + +-- method BaseSink::set_ts_offset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_set_ts_offset" gst_base_sink_set_ts_offset :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + Int64 -> -- offset : TBasicType TInt64 + IO () + + +baseSinkSetTsOffset :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> Int64 -- offset + -> m () -- result +baseSinkSetTsOffset _obj offset = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_sink_set_ts_offset _obj' offset + touchManagedPtr _obj + return () + +data BaseSinkSetTsOffsetMethodInfo +instance (signature ~ (Int64 -> m ()), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkSetTsOffsetMethodInfo a signature where + overloadedMethod _ = baseSinkSetTsOffset + +-- method BaseSink::wait +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "jitter", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TInterface "Gst" "FlowReturn" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_wait" gst_base_sink_wait :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + Word64 -> -- time : TBasicType TUInt64 + Ptr Int64 -> -- jitter : TBasicType TInt64 + IO CUInt + + +baseSinkWait :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> Word64 -- time + -> m (Gst.FlowReturn,Int64) -- result +baseSinkWait _obj time = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + jitter <- allocMem :: IO (Ptr Int64) + result <- gst_base_sink_wait _obj' time jitter + let result' = (toEnum . fromIntegral) result + jitter' <- peek jitter + touchManagedPtr _obj + freeMem jitter + return (result', jitter') + +data BaseSinkWaitMethodInfo +instance (signature ~ (Word64 -> m (Gst.FlowReturn,Int64)), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkWaitMethodInfo a signature where + overloadedMethod _ = baseSinkWait + +-- method BaseSink::wait_clock +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "jitter", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TInterface "Gst" "ClockReturn" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_wait_clock" gst_base_sink_wait_clock :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + Word64 -> -- time : TBasicType TUInt64 + Ptr Int64 -> -- jitter : TBasicType TInt64 + IO CUInt + + +baseSinkWaitClock :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> Word64 -- time + -> m (Gst.ClockReturn,Int64) -- result +baseSinkWaitClock _obj time = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + jitter <- allocMem :: IO (Ptr Int64) + result <- gst_base_sink_wait_clock _obj' time jitter + let result' = (toEnum . fromIntegral) result + jitter' <- peek jitter + touchManagedPtr _obj + freeMem jitter + return (result', jitter') + +data BaseSinkWaitClockMethodInfo +instance (signature ~ (Word64 -> m (Gst.ClockReturn,Int64)), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkWaitClockMethodInfo a signature where + overloadedMethod _ = baseSinkWaitClock + +-- method BaseSink::wait_preroll +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSink", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "FlowReturn" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_sink_wait_preroll" gst_base_sink_wait_preroll :: + Ptr BaseSink -> -- _obj : TInterface "GstBase" "BaseSink" + IO CUInt + + +baseSinkWaitPreroll :: + (MonadIO m, BaseSinkK a) => + a -- _obj + -> m Gst.FlowReturn -- result +baseSinkWaitPreroll _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_sink_wait_preroll _obj' + let result' = (toEnum . fromIntegral) result + touchManagedPtr _obj + return result' + +data BaseSinkWaitPrerollMethodInfo +instance (signature ~ (m Gst.FlowReturn), MonadIO m, BaseSinkK a) => MethodInfo BaseSinkWaitPrerollMethodInfo a signature where + overloadedMethod _ = baseSinkWaitPreroll + + diff --git a/GI/GstBase/Objects/BaseSink.hs-boot b/GI/GstBase/Objects/BaseSink.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/BaseSink.hs-boot @@ -0,0 +1,51 @@ +module GI.GstBase.Objects.BaseSink where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype BaseSink = BaseSink (ForeignPtr BaseSink) +instance GObject BaseSink where +class GObject o => BaseSinkK o +instance (GObject o, IsDescendantOf BaseSink o) => BaseSinkK o +data BaseSinkAsyncPropertyInfo +data BaseSinkBlocksizePropertyInfo +data BaseSinkEnableLastSamplePropertyInfo +data BaseSinkLastSamplePropertyInfo +data BaseSinkMaxBitratePropertyInfo +data BaseSinkMaxLatenessPropertyInfo +data BaseSinkQosPropertyInfo +data BaseSinkRenderDelayPropertyInfo +data BaseSinkSyncPropertyInfo +data BaseSinkThrottleTimePropertyInfo +data BaseSinkTsOffsetPropertyInfo +data BaseSinkDoPrerollMethodInfo +data BaseSinkGetBlocksizeMethodInfo +data BaseSinkGetLastSampleMethodInfo +data BaseSinkGetLatencyMethodInfo +data BaseSinkGetMaxBitrateMethodInfo +data BaseSinkGetMaxLatenessMethodInfo +data BaseSinkGetRenderDelayMethodInfo +data BaseSinkGetSyncMethodInfo +data BaseSinkGetThrottleTimeMethodInfo +data BaseSinkGetTsOffsetMethodInfo +data BaseSinkIsAsyncEnabledMethodInfo +data BaseSinkIsLastSampleEnabledMethodInfo +data BaseSinkIsQosEnabledMethodInfo +data BaseSinkQueryLatencyMethodInfo +data BaseSinkSetAsyncEnabledMethodInfo +data BaseSinkSetBlocksizeMethodInfo +data BaseSinkSetLastSampleEnabledMethodInfo +data BaseSinkSetMaxBitrateMethodInfo +data BaseSinkSetMaxLatenessMethodInfo +data BaseSinkSetQosEnabledMethodInfo +data BaseSinkSetRenderDelayMethodInfo +data BaseSinkSetSyncMethodInfo +data BaseSinkSetThrottleTimeMethodInfo +data BaseSinkSetTsOffsetMethodInfo +data BaseSinkWaitMethodInfo +data BaseSinkWaitClockMethodInfo +data BaseSinkWaitPrerollMethodInfo diff --git a/GI/GstBase/Objects/BaseSrc.hs b/GI/GstBase/Objects/BaseSrc.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/BaseSrc.hs @@ -0,0 +1,984 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Objects.BaseSrc + ( + +-- * Exported types + BaseSrc(..) , + BaseSrcK , + toBaseSrc , + noBaseSrc , + + + -- * Methods +-- ** baseSrcGetAllocator + BaseSrcGetAllocatorMethodInfo , + baseSrcGetAllocator , + + +-- ** baseSrcGetBlocksize + BaseSrcGetBlocksizeMethodInfo , + baseSrcGetBlocksize , + + +-- ** baseSrcGetBufferPool + BaseSrcGetBufferPoolMethodInfo , + baseSrcGetBufferPool , + + +-- ** baseSrcGetDoTimestamp + BaseSrcGetDoTimestampMethodInfo , + baseSrcGetDoTimestamp , + + +-- ** baseSrcIsAsync + BaseSrcIsAsyncMethodInfo , + baseSrcIsAsync , + + +-- ** baseSrcIsLive + BaseSrcIsLiveMethodInfo , + baseSrcIsLive , + + +-- ** baseSrcNewSeamlessSegment + BaseSrcNewSeamlessSegmentMethodInfo , + baseSrcNewSeamlessSegment , + + +-- ** baseSrcQueryLatency + BaseSrcQueryLatencyMethodInfo , + baseSrcQueryLatency , + + +-- ** baseSrcSetAsync + BaseSrcSetAsyncMethodInfo , + baseSrcSetAsync , + + +-- ** baseSrcSetAutomaticEos + BaseSrcSetAutomaticEosMethodInfo , + baseSrcSetAutomaticEos , + + +-- ** baseSrcSetBlocksize + BaseSrcSetBlocksizeMethodInfo , + baseSrcSetBlocksize , + + +-- ** baseSrcSetCaps + BaseSrcSetCapsMethodInfo , + baseSrcSetCaps , + + +-- ** baseSrcSetDoTimestamp + BaseSrcSetDoTimestampMethodInfo , + baseSrcSetDoTimestamp , + + +-- ** baseSrcSetDynamicSize + BaseSrcSetDynamicSizeMethodInfo , + baseSrcSetDynamicSize , + + +-- ** baseSrcSetFormat + BaseSrcSetFormatMethodInfo , + baseSrcSetFormat , + + +-- ** baseSrcSetLive + BaseSrcSetLiveMethodInfo , + baseSrcSetLive , + + +-- ** baseSrcStartComplete + BaseSrcStartCompleteMethodInfo , + baseSrcStartComplete , + + +-- ** baseSrcStartWait + BaseSrcStartWaitMethodInfo , + baseSrcStartWait , + + +-- ** baseSrcWaitPlaying + BaseSrcWaitPlayingMethodInfo , + baseSrcWaitPlaying , + + + + + -- * Properties +-- ** Blocksize + BaseSrcBlocksizePropertyInfo , + constructBaseSrcBlocksize , + getBaseSrcBlocksize , + setBaseSrcBlocksize , + + +-- ** DoTimestamp + BaseSrcDoTimestampPropertyInfo , + constructBaseSrcDoTimestamp , + getBaseSrcDoTimestamp , + setBaseSrcDoTimestamp , + + +-- ** NumBuffers + BaseSrcNumBuffersPropertyInfo , + constructBaseSrcNumBuffers , + getBaseSrcNumBuffers , + setBaseSrcNumBuffers , + + +-- ** Typefind + BaseSrcTypefindPropertyInfo , + constructBaseSrcTypefind , + getBaseSrcTypefind , + setBaseSrcTypefind , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks +import qualified GI.GObject as GObject +import qualified GI.Gst as Gst + +newtype BaseSrc = BaseSrc (ForeignPtr BaseSrc) +foreign import ccall "gst_base_src_get_type" + c_gst_base_src_get_type :: IO GType + +type instance ParentTypes BaseSrc = BaseSrcParentTypes +type BaseSrcParentTypes = '[Gst.Element, Gst.Object, GObject.Object] + +instance GObject BaseSrc where + gobjectIsInitiallyUnowned _ = True + gobjectType _ = c_gst_base_src_get_type + + +class GObject o => BaseSrcK o +instance (GObject o, IsDescendantOf BaseSrc o) => BaseSrcK o + +toBaseSrc :: BaseSrcK o => o -> IO BaseSrc +toBaseSrc = unsafeCastTo BaseSrc + +noBaseSrc :: Maybe BaseSrc +noBaseSrc = Nothing + +type family ResolveBaseSrcMethod (t :: Symbol) (o :: *) :: * where + ResolveBaseSrcMethod "abortState" o = Gst.ElementAbortStateMethodInfo + ResolveBaseSrcMethod "addControlBinding" o = Gst.ObjectAddControlBindingMethodInfo + ResolveBaseSrcMethod "addPad" o = Gst.ElementAddPadMethodInfo + ResolveBaseSrcMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo + ResolveBaseSrcMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo + ResolveBaseSrcMethod "changeState" o = Gst.ElementChangeStateMethodInfo + ResolveBaseSrcMethod "continueState" o = Gst.ElementContinueStateMethodInfo + ResolveBaseSrcMethod "createAllPads" o = Gst.ElementCreateAllPadsMethodInfo + ResolveBaseSrcMethod "defaultError" o = Gst.ObjectDefaultErrorMethodInfo + ResolveBaseSrcMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo + ResolveBaseSrcMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo + ResolveBaseSrcMethod "hasActiveControlBindings" o = Gst.ObjectHasActiveControlBindingsMethodInfo + ResolveBaseSrcMethod "hasAncestor" o = Gst.ObjectHasAncestorMethodInfo + ResolveBaseSrcMethod "hasAsAncestor" o = Gst.ObjectHasAsAncestorMethodInfo + ResolveBaseSrcMethod "hasAsParent" o = Gst.ObjectHasAsParentMethodInfo + ResolveBaseSrcMethod "isAsync" o = BaseSrcIsAsyncMethodInfo + ResolveBaseSrcMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo + ResolveBaseSrcMethod "isLive" o = BaseSrcIsLiveMethodInfo + ResolveBaseSrcMethod "isLockedState" o = Gst.ElementIsLockedStateMethodInfo + ResolveBaseSrcMethod "iteratePads" o = Gst.ElementIteratePadsMethodInfo + ResolveBaseSrcMethod "iterateSinkPads" o = Gst.ElementIterateSinkPadsMethodInfo + ResolveBaseSrcMethod "iterateSrcPads" o = Gst.ElementIterateSrcPadsMethodInfo + ResolveBaseSrcMethod "link" o = Gst.ElementLinkMethodInfo + ResolveBaseSrcMethod "linkFiltered" o = Gst.ElementLinkFilteredMethodInfo + ResolveBaseSrcMethod "linkPads" o = Gst.ElementLinkPadsMethodInfo + ResolveBaseSrcMethod "linkPadsFiltered" o = Gst.ElementLinkPadsFilteredMethodInfo + ResolveBaseSrcMethod "linkPadsFull" o = Gst.ElementLinkPadsFullMethodInfo + ResolveBaseSrcMethod "lostState" o = Gst.ElementLostStateMethodInfo + ResolveBaseSrcMethod "messageFull" o = Gst.ElementMessageFullMethodInfo + ResolveBaseSrcMethod "newSeamlessSegment" o = BaseSrcNewSeamlessSegmentMethodInfo + ResolveBaseSrcMethod "noMorePads" o = Gst.ElementNoMorePadsMethodInfo + ResolveBaseSrcMethod "notify" o = GObject.ObjectNotifyMethodInfo + ResolveBaseSrcMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo + ResolveBaseSrcMethod "postMessage" o = Gst.ElementPostMessageMethodInfo + ResolveBaseSrcMethod "provideClock" o = Gst.ElementProvideClockMethodInfo + ResolveBaseSrcMethod "query" o = Gst.ElementQueryMethodInfo + ResolveBaseSrcMethod "queryConvert" o = Gst.ElementQueryConvertMethodInfo + ResolveBaseSrcMethod "queryDuration" o = Gst.ElementQueryDurationMethodInfo + ResolveBaseSrcMethod "queryLatency" o = BaseSrcQueryLatencyMethodInfo + ResolveBaseSrcMethod "queryPosition" o = Gst.ElementQueryPositionMethodInfo + ResolveBaseSrcMethod "refSink" o = GObject.ObjectRefSinkMethodInfo + ResolveBaseSrcMethod "releaseRequestPad" o = Gst.ElementReleaseRequestPadMethodInfo + ResolveBaseSrcMethod "removeControlBinding" o = Gst.ObjectRemoveControlBindingMethodInfo + ResolveBaseSrcMethod "removePad" o = Gst.ElementRemovePadMethodInfo + ResolveBaseSrcMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo + ResolveBaseSrcMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo + ResolveBaseSrcMethod "requestPad" o = Gst.ElementRequestPadMethodInfo + ResolveBaseSrcMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo + ResolveBaseSrcMethod "seek" o = Gst.ElementSeekMethodInfo + ResolveBaseSrcMethod "seekSimple" o = Gst.ElementSeekSimpleMethodInfo + ResolveBaseSrcMethod "sendEvent" o = Gst.ElementSendEventMethodInfo + ResolveBaseSrcMethod "startComplete" o = BaseSrcStartCompleteMethodInfo + ResolveBaseSrcMethod "startWait" o = BaseSrcStartWaitMethodInfo + ResolveBaseSrcMethod "stealData" o = GObject.ObjectStealDataMethodInfo + ResolveBaseSrcMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo + ResolveBaseSrcMethod "suggestNextSync" o = Gst.ObjectSuggestNextSyncMethodInfo + ResolveBaseSrcMethod "syncStateWithParent" o = Gst.ElementSyncStateWithParentMethodInfo + ResolveBaseSrcMethod "syncValues" o = Gst.ObjectSyncValuesMethodInfo + ResolveBaseSrcMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo + ResolveBaseSrcMethod "unlink" o = Gst.ElementUnlinkMethodInfo + ResolveBaseSrcMethod "unlinkPads" o = Gst.ElementUnlinkPadsMethodInfo + ResolveBaseSrcMethod "unparent" o = Gst.ObjectUnparentMethodInfo + ResolveBaseSrcMethod "waitPlaying" o = BaseSrcWaitPlayingMethodInfo + ResolveBaseSrcMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo + ResolveBaseSrcMethod "getAllocator" o = BaseSrcGetAllocatorMethodInfo + ResolveBaseSrcMethod "getBaseTime" o = Gst.ElementGetBaseTimeMethodInfo + ResolveBaseSrcMethod "getBlocksize" o = BaseSrcGetBlocksizeMethodInfo + ResolveBaseSrcMethod "getBufferPool" o = BaseSrcGetBufferPoolMethodInfo + ResolveBaseSrcMethod "getBus" o = Gst.ElementGetBusMethodInfo + ResolveBaseSrcMethod "getClock" o = Gst.ElementGetClockMethodInfo + ResolveBaseSrcMethod "getCompatiblePad" o = Gst.ElementGetCompatiblePadMethodInfo + ResolveBaseSrcMethod "getCompatiblePadTemplate" o = Gst.ElementGetCompatiblePadTemplateMethodInfo + ResolveBaseSrcMethod "getControlBinding" o = Gst.ObjectGetControlBindingMethodInfo + ResolveBaseSrcMethod "getControlRate" o = Gst.ObjectGetControlRateMethodInfo + ResolveBaseSrcMethod "getData" o = GObject.ObjectGetDataMethodInfo + ResolveBaseSrcMethod "getDoTimestamp" o = BaseSrcGetDoTimestampMethodInfo + ResolveBaseSrcMethod "getFactory" o = Gst.ElementGetFactoryMethodInfo + ResolveBaseSrcMethod "getGValueArray" o = Gst.ObjectGetGValueArrayMethodInfo + ResolveBaseSrcMethod "getName" o = Gst.ObjectGetNameMethodInfo + ResolveBaseSrcMethod "getParent" o = Gst.ObjectGetParentMethodInfo + ResolveBaseSrcMethod "getPathString" o = Gst.ObjectGetPathStringMethodInfo + ResolveBaseSrcMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo + ResolveBaseSrcMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo + ResolveBaseSrcMethod "getRequestPad" o = Gst.ElementGetRequestPadMethodInfo + ResolveBaseSrcMethod "getStartTime" o = Gst.ElementGetStartTimeMethodInfo + ResolveBaseSrcMethod "getState" o = Gst.ElementGetStateMethodInfo + ResolveBaseSrcMethod "getStaticPad" o = Gst.ElementGetStaticPadMethodInfo + ResolveBaseSrcMethod "getValue" o = Gst.ObjectGetValueMethodInfo + ResolveBaseSrcMethod "getValueArray" o = Gst.ObjectGetValueArrayMethodInfo + ResolveBaseSrcMethod "setAsync" o = BaseSrcSetAsyncMethodInfo + ResolveBaseSrcMethod "setAutomaticEos" o = BaseSrcSetAutomaticEosMethodInfo + ResolveBaseSrcMethod "setBaseTime" o = Gst.ElementSetBaseTimeMethodInfo + ResolveBaseSrcMethod "setBlocksize" o = BaseSrcSetBlocksizeMethodInfo + ResolveBaseSrcMethod "setBus" o = Gst.ElementSetBusMethodInfo + ResolveBaseSrcMethod "setCaps" o = BaseSrcSetCapsMethodInfo + ResolveBaseSrcMethod "setClock" o = Gst.ElementSetClockMethodInfo + ResolveBaseSrcMethod "setContext" o = Gst.ElementSetContextMethodInfo + ResolveBaseSrcMethod "setControlBindingDisabled" o = Gst.ObjectSetControlBindingDisabledMethodInfo + ResolveBaseSrcMethod "setControlBindingsDisabled" o = Gst.ObjectSetControlBindingsDisabledMethodInfo + ResolveBaseSrcMethod "setControlRate" o = Gst.ObjectSetControlRateMethodInfo + ResolveBaseSrcMethod "setData" o = GObject.ObjectSetDataMethodInfo + ResolveBaseSrcMethod "setDoTimestamp" o = BaseSrcSetDoTimestampMethodInfo + ResolveBaseSrcMethod "setDynamicSize" o = BaseSrcSetDynamicSizeMethodInfo + ResolveBaseSrcMethod "setFormat" o = BaseSrcSetFormatMethodInfo + ResolveBaseSrcMethod "setLive" o = BaseSrcSetLiveMethodInfo + ResolveBaseSrcMethod "setLockedState" o = Gst.ElementSetLockedStateMethodInfo + ResolveBaseSrcMethod "setName" o = Gst.ObjectSetNameMethodInfo + ResolveBaseSrcMethod "setParent" o = Gst.ObjectSetParentMethodInfo + ResolveBaseSrcMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo + ResolveBaseSrcMethod "setStartTime" o = Gst.ElementSetStartTimeMethodInfo + ResolveBaseSrcMethod "setState" o = Gst.ElementSetStateMethodInfo + ResolveBaseSrcMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolveBaseSrcMethod t BaseSrc, MethodInfo info BaseSrc p) => IsLabelProxy t (BaseSrc -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolveBaseSrcMethod t BaseSrc, MethodInfo info BaseSrc p) => IsLabel t (BaseSrc -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + +-- VVV Prop "blocksize" + -- Type: TBasicType TUInt32 + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSrcBlocksize :: (MonadIO m, BaseSrcK o) => o -> m Word32 +getBaseSrcBlocksize obj = liftIO $ getObjectPropertyCUInt obj "blocksize" + +setBaseSrcBlocksize :: (MonadIO m, BaseSrcK o) => o -> Word32 -> m () +setBaseSrcBlocksize obj val = liftIO $ setObjectPropertyCUInt obj "blocksize" val + +constructBaseSrcBlocksize :: Word32 -> IO ([Char], GValue) +constructBaseSrcBlocksize val = constructObjectPropertyCUInt "blocksize" val + +data BaseSrcBlocksizePropertyInfo +instance AttrInfo BaseSrcBlocksizePropertyInfo where + type AttrAllowedOps BaseSrcBlocksizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSrcBlocksizePropertyInfo = (~) Word32 + type AttrBaseTypeConstraint BaseSrcBlocksizePropertyInfo = BaseSrcK + type AttrGetType BaseSrcBlocksizePropertyInfo = Word32 + type AttrLabel BaseSrcBlocksizePropertyInfo = "blocksize" + attrGet _ = getBaseSrcBlocksize + attrSet _ = setBaseSrcBlocksize + attrConstruct _ = constructBaseSrcBlocksize + +-- VVV Prop "do-timestamp" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSrcDoTimestamp :: (MonadIO m, BaseSrcK o) => o -> m Bool +getBaseSrcDoTimestamp obj = liftIO $ getObjectPropertyBool obj "do-timestamp" + +setBaseSrcDoTimestamp :: (MonadIO m, BaseSrcK o) => o -> Bool -> m () +setBaseSrcDoTimestamp obj val = liftIO $ setObjectPropertyBool obj "do-timestamp" val + +constructBaseSrcDoTimestamp :: Bool -> IO ([Char], GValue) +constructBaseSrcDoTimestamp val = constructObjectPropertyBool "do-timestamp" val + +data BaseSrcDoTimestampPropertyInfo +instance AttrInfo BaseSrcDoTimestampPropertyInfo where + type AttrAllowedOps BaseSrcDoTimestampPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSrcDoTimestampPropertyInfo = (~) Bool + type AttrBaseTypeConstraint BaseSrcDoTimestampPropertyInfo = BaseSrcK + type AttrGetType BaseSrcDoTimestampPropertyInfo = Bool + type AttrLabel BaseSrcDoTimestampPropertyInfo = "do-timestamp" + attrGet _ = getBaseSrcDoTimestamp + attrSet _ = setBaseSrcDoTimestamp + attrConstruct _ = constructBaseSrcDoTimestamp + +-- VVV Prop "num-buffers" + -- Type: TBasicType TInt32 + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSrcNumBuffers :: (MonadIO m, BaseSrcK o) => o -> m Int32 +getBaseSrcNumBuffers obj = liftIO $ getObjectPropertyCInt obj "num-buffers" + +setBaseSrcNumBuffers :: (MonadIO m, BaseSrcK o) => o -> Int32 -> m () +setBaseSrcNumBuffers obj val = liftIO $ setObjectPropertyCInt obj "num-buffers" val + +constructBaseSrcNumBuffers :: Int32 -> IO ([Char], GValue) +constructBaseSrcNumBuffers val = constructObjectPropertyCInt "num-buffers" val + +data BaseSrcNumBuffersPropertyInfo +instance AttrInfo BaseSrcNumBuffersPropertyInfo where + type AttrAllowedOps BaseSrcNumBuffersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSrcNumBuffersPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint BaseSrcNumBuffersPropertyInfo = BaseSrcK + type AttrGetType BaseSrcNumBuffersPropertyInfo = Int32 + type AttrLabel BaseSrcNumBuffersPropertyInfo = "num-buffers" + attrGet _ = getBaseSrcNumBuffers + attrSet _ = setBaseSrcNumBuffers + attrConstruct _ = constructBaseSrcNumBuffers + +-- VVV Prop "typefind" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseSrcTypefind :: (MonadIO m, BaseSrcK o) => o -> m Bool +getBaseSrcTypefind obj = liftIO $ getObjectPropertyBool obj "typefind" + +setBaseSrcTypefind :: (MonadIO m, BaseSrcK o) => o -> Bool -> m () +setBaseSrcTypefind obj val = liftIO $ setObjectPropertyBool obj "typefind" val + +constructBaseSrcTypefind :: Bool -> IO ([Char], GValue) +constructBaseSrcTypefind val = constructObjectPropertyBool "typefind" val + +data BaseSrcTypefindPropertyInfo +instance AttrInfo BaseSrcTypefindPropertyInfo where + type AttrAllowedOps BaseSrcTypefindPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseSrcTypefindPropertyInfo = (~) Bool + type AttrBaseTypeConstraint BaseSrcTypefindPropertyInfo = BaseSrcK + type AttrGetType BaseSrcTypefindPropertyInfo = Bool + type AttrLabel BaseSrcTypefindPropertyInfo = "typefind" + attrGet _ = getBaseSrcTypefind + attrSet _ = setBaseSrcTypefind + attrConstruct _ = constructBaseSrcTypefind + +type instance AttributeList BaseSrc = BaseSrcAttributeList +type BaseSrcAttributeList = ('[ '("blocksize", BaseSrcBlocksizePropertyInfo), '("doTimestamp", BaseSrcDoTimestampPropertyInfo), '("name", Gst.ObjectNamePropertyInfo), '("numBuffers", BaseSrcNumBuffersPropertyInfo), '("parent", Gst.ObjectParentPropertyInfo), '("typefind", BaseSrcTypefindPropertyInfo)] :: [(Symbol, *)]) + +type instance SignalList BaseSrc = BaseSrcSignalList +type BaseSrcSignalList = ('[ '("deepNotify", Gst.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", Gst.ElementPadAddedSignalInfo), '("padRemoved", Gst.ElementPadRemovedSignalInfo)] :: [(Symbol, *)]) + +-- method BaseSrc::get_allocator +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_get_allocator" gst_base_src_get_allocator :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + Ptr (Ptr Gst.Allocator) -> -- allocator : TInterface "Gst" "Allocator" + Ptr Gst.AllocationParams -> -- params : TInterface "Gst" "AllocationParams" + IO () + + +baseSrcGetAllocator :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> m (Gst.Allocator,Gst.AllocationParams)-- result +baseSrcGetAllocator _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + allocator <- allocMem :: IO (Ptr (Ptr Gst.Allocator)) + params <- callocBoxedBytes 64 :: IO (Ptr Gst.AllocationParams) + gst_base_src_get_allocator _obj' allocator params + allocator' <- peek allocator + allocator'' <- (wrapObject Gst.Allocator) allocator' + params' <- (wrapBoxed Gst.AllocationParams) params + touchManagedPtr _obj + freeMem allocator + return (allocator'', params') + +data BaseSrcGetAllocatorMethodInfo +instance (signature ~ (m (Gst.Allocator,Gst.AllocationParams)), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcGetAllocatorMethodInfo a signature where + overloadedMethod _ = baseSrcGetAllocator + +-- method BaseSrc::get_blocksize +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt32 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_get_blocksize" gst_base_src_get_blocksize :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + IO Word32 + + +baseSrcGetBlocksize :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> m Word32 -- result +baseSrcGetBlocksize _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_src_get_blocksize _obj' + touchManagedPtr _obj + return result + +data BaseSrcGetBlocksizeMethodInfo +instance (signature ~ (m Word32), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcGetBlocksizeMethodInfo a signature where + overloadedMethod _ = baseSrcGetBlocksize + +-- method BaseSrc::get_buffer_pool +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "BufferPool" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_get_buffer_pool" gst_base_src_get_buffer_pool :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + IO (Ptr Gst.BufferPool) + + +baseSrcGetBufferPool :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> m Gst.BufferPool -- result +baseSrcGetBufferPool _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_src_get_buffer_pool _obj' + checkUnexpectedReturnNULL "gst_base_src_get_buffer_pool" result + result' <- (wrapObject Gst.BufferPool) result + touchManagedPtr _obj + return result' + +data BaseSrcGetBufferPoolMethodInfo +instance (signature ~ (m Gst.BufferPool), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcGetBufferPoolMethodInfo a signature where + overloadedMethod _ = baseSrcGetBufferPool + +-- method BaseSrc::get_do_timestamp +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_get_do_timestamp" gst_base_src_get_do_timestamp :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + IO CInt + + +baseSrcGetDoTimestamp :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> m Bool -- result +baseSrcGetDoTimestamp _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_src_get_do_timestamp _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BaseSrcGetDoTimestampMethodInfo +instance (signature ~ (m Bool), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcGetDoTimestampMethodInfo a signature where + overloadedMethod _ = baseSrcGetDoTimestamp + +-- method BaseSrc::is_async +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_is_async" gst_base_src_is_async :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + IO CInt + + +baseSrcIsAsync :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> m Bool -- result +baseSrcIsAsync _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_src_is_async _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BaseSrcIsAsyncMethodInfo +instance (signature ~ (m Bool), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcIsAsyncMethodInfo a signature where + overloadedMethod _ = baseSrcIsAsync + +-- method BaseSrc::is_live +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_is_live" gst_base_src_is_live :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + IO CInt + + +baseSrcIsLive :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> m Bool -- result +baseSrcIsLive _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_src_is_live _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BaseSrcIsLiveMethodInfo +instance (signature ~ (m Bool), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcIsLiveMethodInfo a signature where + overloadedMethod _ = baseSrcIsLive + +-- method BaseSrc::new_seamless_segment +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_new_seamless_segment" gst_base_src_new_seamless_segment :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + Int64 -> -- start : TBasicType TInt64 + Int64 -> -- stop : TBasicType TInt64 + Int64 -> -- time : TBasicType TInt64 + IO CInt + + +baseSrcNewSeamlessSegment :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> Int64 -- start + -> Int64 -- stop + -> Int64 -- time + -> m Bool -- result +baseSrcNewSeamlessSegment _obj start stop time = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_src_new_seamless_segment _obj' start stop time + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BaseSrcNewSeamlessSegmentMethodInfo +instance (signature ~ (Int64 -> Int64 -> Int64 -> m Bool), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcNewSeamlessSegmentMethodInfo a signature where + overloadedMethod _ = baseSrcNewSeamlessSegment + +-- method BaseSrc::query_latency +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "live", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_query_latency" gst_base_src_query_latency :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + Ptr CInt -> -- live : TBasicType TBoolean + Ptr Word64 -> -- min_latency : TBasicType TUInt64 + Ptr Word64 -> -- max_latency : TBasicType TUInt64 + IO CInt + + +baseSrcQueryLatency :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> m (Bool,Bool,Word64,Word64) -- result +baseSrcQueryLatency _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + live <- allocMem :: IO (Ptr CInt) + minLatency <- allocMem :: IO (Ptr Word64) + maxLatency <- allocMem :: IO (Ptr Word64) + result <- gst_base_src_query_latency _obj' live minLatency maxLatency + let result' = (/= 0) result + live' <- peek live + let live'' = (/= 0) live' + minLatency' <- peek minLatency + maxLatency' <- peek maxLatency + touchManagedPtr _obj + freeMem live + freeMem minLatency + freeMem maxLatency + return (result', live'', minLatency', maxLatency') + +data BaseSrcQueryLatencyMethodInfo +instance (signature ~ (m (Bool,Bool,Word64,Word64)), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcQueryLatencyMethodInfo a signature where + overloadedMethod _ = baseSrcQueryLatency + +-- method BaseSrc::set_async +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "async", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_set_async" gst_base_src_set_async :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + CInt -> -- async : TBasicType TBoolean + IO () + + +baseSrcSetAsync :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> Bool -- async + -> m () -- result +baseSrcSetAsync _obj async = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let async' = (fromIntegral . fromEnum) async + gst_base_src_set_async _obj' async' + touchManagedPtr _obj + return () + +data BaseSrcSetAsyncMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcSetAsyncMethodInfo a signature where + overloadedMethod _ = baseSrcSetAsync + +-- method BaseSrc::set_automatic_eos +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "automatic_eos", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_set_automatic_eos" gst_base_src_set_automatic_eos :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + CInt -> -- automatic_eos : TBasicType TBoolean + IO () + + +baseSrcSetAutomaticEos :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> Bool -- automaticEos + -> m () -- result +baseSrcSetAutomaticEos _obj automaticEos = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let automaticEos' = (fromIntegral . fromEnum) automaticEos + gst_base_src_set_automatic_eos _obj' automaticEos' + touchManagedPtr _obj + return () + +data BaseSrcSetAutomaticEosMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcSetAutomaticEosMethodInfo a signature where + overloadedMethod _ = baseSrcSetAutomaticEos + +-- method BaseSrc::set_blocksize +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blocksize", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_set_blocksize" gst_base_src_set_blocksize :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + Word32 -> -- blocksize : TBasicType TUInt32 + IO () + + +baseSrcSetBlocksize :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> Word32 -- blocksize + -> m () -- result +baseSrcSetBlocksize _obj blocksize = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_src_set_blocksize _obj' blocksize + touchManagedPtr _obj + return () + +data BaseSrcSetBlocksizeMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcSetBlocksizeMethodInfo a signature where + overloadedMethod _ = baseSrcSetBlocksize + +-- method BaseSrc::set_caps +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_set_caps" gst_base_src_set_caps :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + Ptr Gst.Caps -> -- caps : TInterface "Gst" "Caps" + IO CInt + + +baseSrcSetCaps :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> Gst.Caps -- caps + -> m Bool -- result +baseSrcSetCaps _obj caps = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let caps' = unsafeManagedPtrGetPtr caps + result <- gst_base_src_set_caps _obj' caps' + let result' = (/= 0) result + touchManagedPtr _obj + touchManagedPtr caps + return result' + +data BaseSrcSetCapsMethodInfo +instance (signature ~ (Gst.Caps -> m Bool), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcSetCapsMethodInfo a signature where + overloadedMethod _ = baseSrcSetCaps + +-- method BaseSrc::set_do_timestamp +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_set_do_timestamp" gst_base_src_set_do_timestamp :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + CInt -> -- timestamp : TBasicType TBoolean + IO () + + +baseSrcSetDoTimestamp :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> Bool -- timestamp + -> m () -- result +baseSrcSetDoTimestamp _obj timestamp = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let timestamp' = (fromIntegral . fromEnum) timestamp + gst_base_src_set_do_timestamp _obj' timestamp' + touchManagedPtr _obj + return () + +data BaseSrcSetDoTimestampMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcSetDoTimestampMethodInfo a signature where + overloadedMethod _ = baseSrcSetDoTimestamp + +-- method BaseSrc::set_dynamic_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dynamic", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_set_dynamic_size" gst_base_src_set_dynamic_size :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + CInt -> -- dynamic : TBasicType TBoolean + IO () + + +baseSrcSetDynamicSize :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> Bool -- dynamic + -> m () -- result +baseSrcSetDynamicSize _obj dynamic = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let dynamic' = (fromIntegral . fromEnum) dynamic + gst_base_src_set_dynamic_size _obj' dynamic' + touchManagedPtr _obj + return () + +data BaseSrcSetDynamicSizeMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcSetDynamicSizeMethodInfo a signature where + overloadedMethod _ = baseSrcSetDynamicSize + +-- method BaseSrc::set_format +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_set_format" gst_base_src_set_format :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + CUInt -> -- format : TInterface "Gst" "Format" + IO () + + +baseSrcSetFormat :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> Gst.Format -- format + -> m () -- result +baseSrcSetFormat _obj format = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let format' = (fromIntegral . fromEnum) format + gst_base_src_set_format _obj' format' + touchManagedPtr _obj + return () + +data BaseSrcSetFormatMethodInfo +instance (signature ~ (Gst.Format -> m ()), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcSetFormatMethodInfo a signature where + overloadedMethod _ = baseSrcSetFormat + +-- method BaseSrc::set_live +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "live", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_set_live" gst_base_src_set_live :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + CInt -> -- live : TBasicType TBoolean + IO () + + +baseSrcSetLive :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> Bool -- live + -> m () -- result +baseSrcSetLive _obj live = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let live' = (fromIntegral . fromEnum) live + gst_base_src_set_live _obj' live' + touchManagedPtr _obj + return () + +data BaseSrcSetLiveMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcSetLiveMethodInfo a signature where + overloadedMethod _ = baseSrcSetLive + +-- method BaseSrc::start_complete +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ret", argType = TInterface "Gst" "FlowReturn", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_start_complete" gst_base_src_start_complete :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + CUInt -> -- ret : TInterface "Gst" "FlowReturn" + IO () + + +baseSrcStartComplete :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> Gst.FlowReturn -- ret + -> m () -- result +baseSrcStartComplete _obj ret = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let ret' = (fromIntegral . fromEnum) ret + gst_base_src_start_complete _obj' ret' + touchManagedPtr _obj + return () + +data BaseSrcStartCompleteMethodInfo +instance (signature ~ (Gst.FlowReturn -> m ()), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcStartCompleteMethodInfo a signature where + overloadedMethod _ = baseSrcStartComplete + +-- method BaseSrc::start_wait +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "FlowReturn" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_start_wait" gst_base_src_start_wait :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + IO CUInt + + +baseSrcStartWait :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> m Gst.FlowReturn -- result +baseSrcStartWait _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_src_start_wait _obj' + let result' = (toEnum . fromIntegral) result + touchManagedPtr _obj + return result' + +data BaseSrcStartWaitMethodInfo +instance (signature ~ (m Gst.FlowReturn), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcStartWaitMethodInfo a signature where + overloadedMethod _ = baseSrcStartWait + +-- method BaseSrc::wait_playing +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseSrc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "FlowReturn" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_src_wait_playing" gst_base_src_wait_playing :: + Ptr BaseSrc -> -- _obj : TInterface "GstBase" "BaseSrc" + IO CUInt + + +baseSrcWaitPlaying :: + (MonadIO m, BaseSrcK a) => + a -- _obj + -> m Gst.FlowReturn -- result +baseSrcWaitPlaying _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_src_wait_playing _obj' + let result' = (toEnum . fromIntegral) result + touchManagedPtr _obj + return result' + +data BaseSrcWaitPlayingMethodInfo +instance (signature ~ (m Gst.FlowReturn), MonadIO m, BaseSrcK a) => MethodInfo BaseSrcWaitPlayingMethodInfo a signature where + overloadedMethod _ = baseSrcWaitPlaying + + diff --git a/GI/GstBase/Objects/BaseSrc.hs-boot b/GI/GstBase/Objects/BaseSrc.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/BaseSrc.hs-boot @@ -0,0 +1,36 @@ +module GI.GstBase.Objects.BaseSrc where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype BaseSrc = BaseSrc (ForeignPtr BaseSrc) +instance GObject BaseSrc where +class GObject o => BaseSrcK o +instance (GObject o, IsDescendantOf BaseSrc o) => BaseSrcK o +data BaseSrcBlocksizePropertyInfo +data BaseSrcDoTimestampPropertyInfo +data BaseSrcNumBuffersPropertyInfo +data BaseSrcTypefindPropertyInfo +data BaseSrcGetAllocatorMethodInfo +data BaseSrcGetBlocksizeMethodInfo +data BaseSrcGetBufferPoolMethodInfo +data BaseSrcGetDoTimestampMethodInfo +data BaseSrcIsAsyncMethodInfo +data BaseSrcIsLiveMethodInfo +data BaseSrcNewSeamlessSegmentMethodInfo +data BaseSrcQueryLatencyMethodInfo +data BaseSrcSetAsyncMethodInfo +data BaseSrcSetAutomaticEosMethodInfo +data BaseSrcSetBlocksizeMethodInfo +data BaseSrcSetCapsMethodInfo +data BaseSrcSetDoTimestampMethodInfo +data BaseSrcSetDynamicSizeMethodInfo +data BaseSrcSetFormatMethodInfo +data BaseSrcSetLiveMethodInfo +data BaseSrcStartCompleteMethodInfo +data BaseSrcStartWaitMethodInfo +data BaseSrcWaitPlayingMethodInfo diff --git a/GI/GstBase/Objects/BaseTransform.hs b/GI/GstBase/Objects/BaseTransform.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/BaseTransform.hs @@ -0,0 +1,702 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Objects.BaseTransform + ( + +-- * Exported types + BaseTransform(..) , + BaseTransformK , + toBaseTransform , + noBaseTransform , + + + -- * Methods +-- ** baseTransformGetAllocator + BaseTransformGetAllocatorMethodInfo , + baseTransformGetAllocator , + + +-- ** baseTransformGetBufferPool + BaseTransformGetBufferPoolMethodInfo , + baseTransformGetBufferPool , + + +-- ** baseTransformIsInPlace + BaseTransformIsInPlaceMethodInfo , + baseTransformIsInPlace , + + +-- ** baseTransformIsPassthrough + BaseTransformIsPassthroughMethodInfo , + baseTransformIsPassthrough , + + +-- ** baseTransformIsQosEnabled + BaseTransformIsQosEnabledMethodInfo , + baseTransformIsQosEnabled , + + +-- ** baseTransformReconfigureSink + BaseTransformReconfigureSinkMethodInfo , + baseTransformReconfigureSink , + + +-- ** baseTransformReconfigureSrc + BaseTransformReconfigureSrcMethodInfo , + baseTransformReconfigureSrc , + + +-- ** baseTransformSetGapAware + BaseTransformSetGapAwareMethodInfo , + baseTransformSetGapAware , + + +-- ** baseTransformSetInPlace + BaseTransformSetInPlaceMethodInfo , + baseTransformSetInPlace , + + +-- ** baseTransformSetPassthrough + BaseTransformSetPassthroughMethodInfo , + baseTransformSetPassthrough , + + +-- ** baseTransformSetPreferPassthrough + BaseTransformSetPreferPassthroughMethodInfo, + baseTransformSetPreferPassthrough , + + +-- ** baseTransformSetQosEnabled + BaseTransformSetQosEnabledMethodInfo , + baseTransformSetQosEnabled , + + +-- ** baseTransformUpdateQos + BaseTransformUpdateQosMethodInfo , + baseTransformUpdateQos , + + +-- ** baseTransformUpdateSrcCaps + BaseTransformUpdateSrcCapsMethodInfo , + baseTransformUpdateSrcCaps , + + + + + -- * Properties +-- ** Qos + BaseTransformQosPropertyInfo , + constructBaseTransformQos , + getBaseTransformQos , + setBaseTransformQos , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks +import qualified GI.GObject as GObject +import qualified GI.Gst as Gst + +newtype BaseTransform = BaseTransform (ForeignPtr BaseTransform) +foreign import ccall "gst_base_transform_get_type" + c_gst_base_transform_get_type :: IO GType + +type instance ParentTypes BaseTransform = BaseTransformParentTypes +type BaseTransformParentTypes = '[Gst.Element, Gst.Object, GObject.Object] + +instance GObject BaseTransform where + gobjectIsInitiallyUnowned _ = True + gobjectType _ = c_gst_base_transform_get_type + + +class GObject o => BaseTransformK o +instance (GObject o, IsDescendantOf BaseTransform o) => BaseTransformK o + +toBaseTransform :: BaseTransformK o => o -> IO BaseTransform +toBaseTransform = unsafeCastTo BaseTransform + +noBaseTransform :: Maybe BaseTransform +noBaseTransform = Nothing + +type family ResolveBaseTransformMethod (t :: Symbol) (o :: *) :: * where + ResolveBaseTransformMethod "abortState" o = Gst.ElementAbortStateMethodInfo + ResolveBaseTransformMethod "addControlBinding" o = Gst.ObjectAddControlBindingMethodInfo + ResolveBaseTransformMethod "addPad" o = Gst.ElementAddPadMethodInfo + ResolveBaseTransformMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo + ResolveBaseTransformMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo + ResolveBaseTransformMethod "changeState" o = Gst.ElementChangeStateMethodInfo + ResolveBaseTransformMethod "continueState" o = Gst.ElementContinueStateMethodInfo + ResolveBaseTransformMethod "createAllPads" o = Gst.ElementCreateAllPadsMethodInfo + ResolveBaseTransformMethod "defaultError" o = Gst.ObjectDefaultErrorMethodInfo + ResolveBaseTransformMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo + ResolveBaseTransformMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo + ResolveBaseTransformMethod "hasActiveControlBindings" o = Gst.ObjectHasActiveControlBindingsMethodInfo + ResolveBaseTransformMethod "hasAncestor" o = Gst.ObjectHasAncestorMethodInfo + ResolveBaseTransformMethod "hasAsAncestor" o = Gst.ObjectHasAsAncestorMethodInfo + ResolveBaseTransformMethod "hasAsParent" o = Gst.ObjectHasAsParentMethodInfo + ResolveBaseTransformMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo + ResolveBaseTransformMethod "isInPlace" o = BaseTransformIsInPlaceMethodInfo + ResolveBaseTransformMethod "isLockedState" o = Gst.ElementIsLockedStateMethodInfo + ResolveBaseTransformMethod "isPassthrough" o = BaseTransformIsPassthroughMethodInfo + ResolveBaseTransformMethod "isQosEnabled" o = BaseTransformIsQosEnabledMethodInfo + ResolveBaseTransformMethod "iteratePads" o = Gst.ElementIteratePadsMethodInfo + ResolveBaseTransformMethod "iterateSinkPads" o = Gst.ElementIterateSinkPadsMethodInfo + ResolveBaseTransformMethod "iterateSrcPads" o = Gst.ElementIterateSrcPadsMethodInfo + ResolveBaseTransformMethod "link" o = Gst.ElementLinkMethodInfo + ResolveBaseTransformMethod "linkFiltered" o = Gst.ElementLinkFilteredMethodInfo + ResolveBaseTransformMethod "linkPads" o = Gst.ElementLinkPadsMethodInfo + ResolveBaseTransformMethod "linkPadsFiltered" o = Gst.ElementLinkPadsFilteredMethodInfo + ResolveBaseTransformMethod "linkPadsFull" o = Gst.ElementLinkPadsFullMethodInfo + ResolveBaseTransformMethod "lostState" o = Gst.ElementLostStateMethodInfo + ResolveBaseTransformMethod "messageFull" o = Gst.ElementMessageFullMethodInfo + ResolveBaseTransformMethod "noMorePads" o = Gst.ElementNoMorePadsMethodInfo + ResolveBaseTransformMethod "notify" o = GObject.ObjectNotifyMethodInfo + ResolveBaseTransformMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo + ResolveBaseTransformMethod "postMessage" o = Gst.ElementPostMessageMethodInfo + ResolveBaseTransformMethod "provideClock" o = Gst.ElementProvideClockMethodInfo + ResolveBaseTransformMethod "query" o = Gst.ElementQueryMethodInfo + ResolveBaseTransformMethod "queryConvert" o = Gst.ElementQueryConvertMethodInfo + ResolveBaseTransformMethod "queryDuration" o = Gst.ElementQueryDurationMethodInfo + ResolveBaseTransformMethod "queryPosition" o = Gst.ElementQueryPositionMethodInfo + ResolveBaseTransformMethod "reconfigureSink" o = BaseTransformReconfigureSinkMethodInfo + ResolveBaseTransformMethod "reconfigureSrc" o = BaseTransformReconfigureSrcMethodInfo + ResolveBaseTransformMethod "refSink" o = GObject.ObjectRefSinkMethodInfo + ResolveBaseTransformMethod "releaseRequestPad" o = Gst.ElementReleaseRequestPadMethodInfo + ResolveBaseTransformMethod "removeControlBinding" o = Gst.ObjectRemoveControlBindingMethodInfo + ResolveBaseTransformMethod "removePad" o = Gst.ElementRemovePadMethodInfo + ResolveBaseTransformMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo + ResolveBaseTransformMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo + ResolveBaseTransformMethod "requestPad" o = Gst.ElementRequestPadMethodInfo + ResolveBaseTransformMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo + ResolveBaseTransformMethod "seek" o = Gst.ElementSeekMethodInfo + ResolveBaseTransformMethod "seekSimple" o = Gst.ElementSeekSimpleMethodInfo + ResolveBaseTransformMethod "sendEvent" o = Gst.ElementSendEventMethodInfo + ResolveBaseTransformMethod "stealData" o = GObject.ObjectStealDataMethodInfo + ResolveBaseTransformMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo + ResolveBaseTransformMethod "suggestNextSync" o = Gst.ObjectSuggestNextSyncMethodInfo + ResolveBaseTransformMethod "syncStateWithParent" o = Gst.ElementSyncStateWithParentMethodInfo + ResolveBaseTransformMethod "syncValues" o = Gst.ObjectSyncValuesMethodInfo + ResolveBaseTransformMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo + ResolveBaseTransformMethod "unlink" o = Gst.ElementUnlinkMethodInfo + ResolveBaseTransformMethod "unlinkPads" o = Gst.ElementUnlinkPadsMethodInfo + ResolveBaseTransformMethod "unparent" o = Gst.ObjectUnparentMethodInfo + ResolveBaseTransformMethod "updateQos" o = BaseTransformUpdateQosMethodInfo + ResolveBaseTransformMethod "updateSrcCaps" o = BaseTransformUpdateSrcCapsMethodInfo + ResolveBaseTransformMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo + ResolveBaseTransformMethod "getAllocator" o = BaseTransformGetAllocatorMethodInfo + ResolveBaseTransformMethod "getBaseTime" o = Gst.ElementGetBaseTimeMethodInfo + ResolveBaseTransformMethod "getBufferPool" o = BaseTransformGetBufferPoolMethodInfo + ResolveBaseTransformMethod "getBus" o = Gst.ElementGetBusMethodInfo + ResolveBaseTransformMethod "getClock" o = Gst.ElementGetClockMethodInfo + ResolveBaseTransformMethod "getCompatiblePad" o = Gst.ElementGetCompatiblePadMethodInfo + ResolveBaseTransformMethod "getCompatiblePadTemplate" o = Gst.ElementGetCompatiblePadTemplateMethodInfo + ResolveBaseTransformMethod "getControlBinding" o = Gst.ObjectGetControlBindingMethodInfo + ResolveBaseTransformMethod "getControlRate" o = Gst.ObjectGetControlRateMethodInfo + ResolveBaseTransformMethod "getData" o = GObject.ObjectGetDataMethodInfo + ResolveBaseTransformMethod "getFactory" o = Gst.ElementGetFactoryMethodInfo + ResolveBaseTransformMethod "getGValueArray" o = Gst.ObjectGetGValueArrayMethodInfo + ResolveBaseTransformMethod "getName" o = Gst.ObjectGetNameMethodInfo + ResolveBaseTransformMethod "getParent" o = Gst.ObjectGetParentMethodInfo + ResolveBaseTransformMethod "getPathString" o = Gst.ObjectGetPathStringMethodInfo + ResolveBaseTransformMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo + ResolveBaseTransformMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo + ResolveBaseTransformMethod "getRequestPad" o = Gst.ElementGetRequestPadMethodInfo + ResolveBaseTransformMethod "getStartTime" o = Gst.ElementGetStartTimeMethodInfo + ResolveBaseTransformMethod "getState" o = Gst.ElementGetStateMethodInfo + ResolveBaseTransformMethod "getStaticPad" o = Gst.ElementGetStaticPadMethodInfo + ResolveBaseTransformMethod "getValue" o = Gst.ObjectGetValueMethodInfo + ResolveBaseTransformMethod "getValueArray" o = Gst.ObjectGetValueArrayMethodInfo + ResolveBaseTransformMethod "setBaseTime" o = Gst.ElementSetBaseTimeMethodInfo + ResolveBaseTransformMethod "setBus" o = Gst.ElementSetBusMethodInfo + ResolveBaseTransformMethod "setClock" o = Gst.ElementSetClockMethodInfo + ResolveBaseTransformMethod "setContext" o = Gst.ElementSetContextMethodInfo + ResolveBaseTransformMethod "setControlBindingDisabled" o = Gst.ObjectSetControlBindingDisabledMethodInfo + ResolveBaseTransformMethod "setControlBindingsDisabled" o = Gst.ObjectSetControlBindingsDisabledMethodInfo + ResolveBaseTransformMethod "setControlRate" o = Gst.ObjectSetControlRateMethodInfo + ResolveBaseTransformMethod "setData" o = GObject.ObjectSetDataMethodInfo + ResolveBaseTransformMethod "setGapAware" o = BaseTransformSetGapAwareMethodInfo + ResolveBaseTransformMethod "setInPlace" o = BaseTransformSetInPlaceMethodInfo + ResolveBaseTransformMethod "setLockedState" o = Gst.ElementSetLockedStateMethodInfo + ResolveBaseTransformMethod "setName" o = Gst.ObjectSetNameMethodInfo + ResolveBaseTransformMethod "setParent" o = Gst.ObjectSetParentMethodInfo + ResolveBaseTransformMethod "setPassthrough" o = BaseTransformSetPassthroughMethodInfo + ResolveBaseTransformMethod "setPreferPassthrough" o = BaseTransformSetPreferPassthroughMethodInfo + ResolveBaseTransformMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo + ResolveBaseTransformMethod "setQosEnabled" o = BaseTransformSetQosEnabledMethodInfo + ResolveBaseTransformMethod "setStartTime" o = Gst.ElementSetStartTimeMethodInfo + ResolveBaseTransformMethod "setState" o = Gst.ElementSetStateMethodInfo + ResolveBaseTransformMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolveBaseTransformMethod t BaseTransform, MethodInfo info BaseTransform p) => IsLabelProxy t (BaseTransform -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolveBaseTransformMethod t BaseTransform, MethodInfo info BaseTransform p) => IsLabel t (BaseTransform -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + +-- VVV Prop "qos" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + +getBaseTransformQos :: (MonadIO m, BaseTransformK o) => o -> m Bool +getBaseTransformQos obj = liftIO $ getObjectPropertyBool obj "qos" + +setBaseTransformQos :: (MonadIO m, BaseTransformK o) => o -> Bool -> m () +setBaseTransformQos obj val = liftIO $ setObjectPropertyBool obj "qos" val + +constructBaseTransformQos :: Bool -> IO ([Char], GValue) +constructBaseTransformQos val = constructObjectPropertyBool "qos" val + +data BaseTransformQosPropertyInfo +instance AttrInfo BaseTransformQosPropertyInfo where + type AttrAllowedOps BaseTransformQosPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BaseTransformQosPropertyInfo = (~) Bool + type AttrBaseTypeConstraint BaseTransformQosPropertyInfo = BaseTransformK + type AttrGetType BaseTransformQosPropertyInfo = Bool + type AttrLabel BaseTransformQosPropertyInfo = "qos" + attrGet _ = getBaseTransformQos + attrSet _ = setBaseTransformQos + attrConstruct _ = constructBaseTransformQos + +type instance AttributeList BaseTransform = BaseTransformAttributeList +type BaseTransformAttributeList = ('[ '("name", Gst.ObjectNamePropertyInfo), '("parent", Gst.ObjectParentPropertyInfo), '("qos", BaseTransformQosPropertyInfo)] :: [(Symbol, *)]) + +type instance SignalList BaseTransform = BaseTransformSignalList +type BaseTransformSignalList = ('[ '("deepNotify", Gst.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", Gst.ElementPadAddedSignalInfo), '("padRemoved", Gst.ElementPadRemovedSignalInfo)] :: [(Symbol, *)]) + +-- method BaseTransform::get_allocator +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_get_allocator" gst_base_transform_get_allocator :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + Ptr (Ptr Gst.Allocator) -> -- allocator : TInterface "Gst" "Allocator" + Ptr Gst.AllocationParams -> -- params : TInterface "Gst" "AllocationParams" + IO () + + +baseTransformGetAllocator :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> m (Gst.Allocator,Gst.AllocationParams)-- result +baseTransformGetAllocator _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + allocator <- allocMem :: IO (Ptr (Ptr Gst.Allocator)) + params <- callocBoxedBytes 64 :: IO (Ptr Gst.AllocationParams) + gst_base_transform_get_allocator _obj' allocator params + allocator' <- peek allocator + allocator'' <- (wrapObject Gst.Allocator) allocator' + params' <- (wrapBoxed Gst.AllocationParams) params + touchManagedPtr _obj + freeMem allocator + return (allocator'', params') + +data BaseTransformGetAllocatorMethodInfo +instance (signature ~ (m (Gst.Allocator,Gst.AllocationParams)), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformGetAllocatorMethodInfo a signature where + overloadedMethod _ = baseTransformGetAllocator + +-- method BaseTransform::get_buffer_pool +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "BufferPool" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_get_buffer_pool" gst_base_transform_get_buffer_pool :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + IO (Ptr Gst.BufferPool) + + +baseTransformGetBufferPool :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> m Gst.BufferPool -- result +baseTransformGetBufferPool _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_transform_get_buffer_pool _obj' + checkUnexpectedReturnNULL "gst_base_transform_get_buffer_pool" result + result' <- (wrapObject Gst.BufferPool) result + touchManagedPtr _obj + return result' + +data BaseTransformGetBufferPoolMethodInfo +instance (signature ~ (m Gst.BufferPool), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformGetBufferPoolMethodInfo a signature where + overloadedMethod _ = baseTransformGetBufferPool + +-- method BaseTransform::is_in_place +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_is_in_place" gst_base_transform_is_in_place :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + IO CInt + + +baseTransformIsInPlace :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> m Bool -- result +baseTransformIsInPlace _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_transform_is_in_place _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BaseTransformIsInPlaceMethodInfo +instance (signature ~ (m Bool), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformIsInPlaceMethodInfo a signature where + overloadedMethod _ = baseTransformIsInPlace + +-- method BaseTransform::is_passthrough +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_is_passthrough" gst_base_transform_is_passthrough :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + IO CInt + + +baseTransformIsPassthrough :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> m Bool -- result +baseTransformIsPassthrough _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_transform_is_passthrough _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BaseTransformIsPassthroughMethodInfo +instance (signature ~ (m Bool), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformIsPassthroughMethodInfo a signature where + overloadedMethod _ = baseTransformIsPassthrough + +-- method BaseTransform::is_qos_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_is_qos_enabled" gst_base_transform_is_qos_enabled :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + IO CInt + + +baseTransformIsQosEnabled :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> m Bool -- result +baseTransformIsQosEnabled _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_base_transform_is_qos_enabled _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BaseTransformIsQosEnabledMethodInfo +instance (signature ~ (m Bool), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformIsQosEnabledMethodInfo a signature where + overloadedMethod _ = baseTransformIsQosEnabled + +-- method BaseTransform::reconfigure_sink +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_reconfigure_sink" gst_base_transform_reconfigure_sink :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + IO () + + +baseTransformReconfigureSink :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> m () -- result +baseTransformReconfigureSink _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_transform_reconfigure_sink _obj' + touchManagedPtr _obj + return () + +data BaseTransformReconfigureSinkMethodInfo +instance (signature ~ (m ()), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformReconfigureSinkMethodInfo a signature where + overloadedMethod _ = baseTransformReconfigureSink + +-- method BaseTransform::reconfigure_src +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_reconfigure_src" gst_base_transform_reconfigure_src :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + IO () + + +baseTransformReconfigureSrc :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> m () -- result +baseTransformReconfigureSrc _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_base_transform_reconfigure_src _obj' + touchManagedPtr _obj + return () + +data BaseTransformReconfigureSrcMethodInfo +instance (signature ~ (m ()), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformReconfigureSrcMethodInfo a signature where + overloadedMethod _ = baseTransformReconfigureSrc + +-- method BaseTransform::set_gap_aware +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gap_aware", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_set_gap_aware" gst_base_transform_set_gap_aware :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + CInt -> -- gap_aware : TBasicType TBoolean + IO () + + +baseTransformSetGapAware :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> Bool -- gapAware + -> m () -- result +baseTransformSetGapAware _obj gapAware = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let gapAware' = (fromIntegral . fromEnum) gapAware + gst_base_transform_set_gap_aware _obj' gapAware' + touchManagedPtr _obj + return () + +data BaseTransformSetGapAwareMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformSetGapAwareMethodInfo a signature where + overloadedMethod _ = baseTransformSetGapAware + +-- method BaseTransform::set_in_place +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "in_place", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_set_in_place" gst_base_transform_set_in_place :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + CInt -> -- in_place : TBasicType TBoolean + IO () + + +baseTransformSetInPlace :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> Bool -- inPlace + -> m () -- result +baseTransformSetInPlace _obj inPlace = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let inPlace' = (fromIntegral . fromEnum) inPlace + gst_base_transform_set_in_place _obj' inPlace' + touchManagedPtr _obj + return () + +data BaseTransformSetInPlaceMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformSetInPlaceMethodInfo a signature where + overloadedMethod _ = baseTransformSetInPlace + +-- method BaseTransform::set_passthrough +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "passthrough", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_set_passthrough" gst_base_transform_set_passthrough :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + CInt -> -- passthrough : TBasicType TBoolean + IO () + + +baseTransformSetPassthrough :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> Bool -- passthrough + -> m () -- result +baseTransformSetPassthrough _obj passthrough = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let passthrough' = (fromIntegral . fromEnum) passthrough + gst_base_transform_set_passthrough _obj' passthrough' + touchManagedPtr _obj + return () + +data BaseTransformSetPassthroughMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformSetPassthroughMethodInfo a signature where + overloadedMethod _ = baseTransformSetPassthrough + +-- method BaseTransform::set_prefer_passthrough +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "prefer_passthrough", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_set_prefer_passthrough" gst_base_transform_set_prefer_passthrough :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + CInt -> -- prefer_passthrough : TBasicType TBoolean + IO () + + +baseTransformSetPreferPassthrough :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> Bool -- preferPassthrough + -> m () -- result +baseTransformSetPreferPassthrough _obj preferPassthrough = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let preferPassthrough' = (fromIntegral . fromEnum) preferPassthrough + gst_base_transform_set_prefer_passthrough _obj' preferPassthrough' + touchManagedPtr _obj + return () + +data BaseTransformSetPreferPassthroughMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformSetPreferPassthroughMethodInfo a signature where + overloadedMethod _ = baseTransformSetPreferPassthrough + +-- method BaseTransform::set_qos_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_set_qos_enabled" gst_base_transform_set_qos_enabled :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + CInt -> -- enabled : TBasicType TBoolean + IO () + + +baseTransformSetQosEnabled :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> Bool -- enabled + -> m () -- result +baseTransformSetQosEnabled _obj enabled = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let enabled' = (fromIntegral . fromEnum) enabled + gst_base_transform_set_qos_enabled _obj' enabled' + touchManagedPtr _obj + return () + +data BaseTransformSetQosEnabledMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformSetQosEnabledMethodInfo a signature where + overloadedMethod _ = baseTransformSetQosEnabled + +-- method BaseTransform::update_qos +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proportion", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "diff", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_update_qos" gst_base_transform_update_qos :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + CDouble -> -- proportion : TBasicType TDouble + Int64 -> -- diff : TBasicType TInt64 + Word64 -> -- timestamp : TBasicType TUInt64 + IO () + + +baseTransformUpdateQos :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> Double -- proportion + -> Int64 -- diff + -> Word64 -- timestamp + -> m () -- result +baseTransformUpdateQos _obj proportion diff timestamp = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let proportion' = realToFrac proportion + gst_base_transform_update_qos _obj' proportion' diff timestamp + touchManagedPtr _obj + return () + +data BaseTransformUpdateQosMethodInfo +instance (signature ~ (Double -> Int64 -> Word64 -> m ()), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformUpdateQosMethodInfo a signature where + overloadedMethod _ = baseTransformUpdateQos + +-- method BaseTransform::update_src_caps +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseTransform", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "updated_caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_transform_update_src_caps" gst_base_transform_update_src_caps :: + Ptr BaseTransform -> -- _obj : TInterface "GstBase" "BaseTransform" + Ptr Gst.Caps -> -- updated_caps : TInterface "Gst" "Caps" + IO CInt + + +baseTransformUpdateSrcCaps :: + (MonadIO m, BaseTransformK a) => + a -- _obj + -> Gst.Caps -- updatedCaps + -> m Bool -- result +baseTransformUpdateSrcCaps _obj updatedCaps = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let updatedCaps' = unsafeManagedPtrGetPtr updatedCaps + result <- gst_base_transform_update_src_caps _obj' updatedCaps' + let result' = (/= 0) result + touchManagedPtr _obj + touchManagedPtr updatedCaps + return result' + +data BaseTransformUpdateSrcCapsMethodInfo +instance (signature ~ (Gst.Caps -> m Bool), MonadIO m, BaseTransformK a) => MethodInfo BaseTransformUpdateSrcCapsMethodInfo a signature where + overloadedMethod _ = baseTransformUpdateSrcCaps + + diff --git a/GI/GstBase/Objects/BaseTransform.hs-boot b/GI/GstBase/Objects/BaseTransform.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/BaseTransform.hs-boot @@ -0,0 +1,28 @@ +module GI.GstBase.Objects.BaseTransform where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype BaseTransform = BaseTransform (ForeignPtr BaseTransform) +instance GObject BaseTransform where +class GObject o => BaseTransformK o +instance (GObject o, IsDescendantOf BaseTransform o) => BaseTransformK o +data BaseTransformQosPropertyInfo +data BaseTransformGetAllocatorMethodInfo +data BaseTransformGetBufferPoolMethodInfo +data BaseTransformIsInPlaceMethodInfo +data BaseTransformIsPassthroughMethodInfo +data BaseTransformIsQosEnabledMethodInfo +data BaseTransformReconfigureSinkMethodInfo +data BaseTransformReconfigureSrcMethodInfo +data BaseTransformSetGapAwareMethodInfo +data BaseTransformSetInPlaceMethodInfo +data BaseTransformSetPassthroughMethodInfo +data BaseTransformSetPreferPassthroughMethodInfo +data BaseTransformSetQosEnabledMethodInfo +data BaseTransformUpdateQosMethodInfo +data BaseTransformUpdateSrcCapsMethodInfo diff --git a/GI/GstBase/Objects/CollectPads.hs b/GI/GstBase/Objects/CollectPads.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/CollectPads.hs @@ -0,0 +1,1060 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Objects.CollectPads + ( + +-- * Exported types + CollectPads(..) , + CollectPadsK , + toCollectPads , + noCollectPads , + + + -- * Methods +-- ** collectPadsAddPad + CollectPadsAddPadMethodInfo , + collectPadsAddPad , + + +-- ** collectPadsAvailable + CollectPadsAvailableMethodInfo , + collectPadsAvailable , + + +-- ** collectPadsClipRunningTime + CollectPadsClipRunningTimeMethodInfo , + collectPadsClipRunningTime , + + +-- ** collectPadsEventDefault + CollectPadsEventDefaultMethodInfo , + collectPadsEventDefault , + + +-- ** collectPadsFlush + CollectPadsFlushMethodInfo , + collectPadsFlush , + + +-- ** collectPadsNew + collectPadsNew , + + +-- ** collectPadsPeek + CollectPadsPeekMethodInfo , + collectPadsPeek , + + +-- ** collectPadsPop + CollectPadsPopMethodInfo , + collectPadsPop , + + +-- ** collectPadsQueryDefault + CollectPadsQueryDefaultMethodInfo , + collectPadsQueryDefault , + + +-- ** collectPadsReadBuffer + CollectPadsReadBufferMethodInfo , + collectPadsReadBuffer , + + +-- ** collectPadsRemovePad + CollectPadsRemovePadMethodInfo , + collectPadsRemovePad , + + +-- ** collectPadsSetBufferFunction + CollectPadsSetBufferFunctionMethodInfo , + collectPadsSetBufferFunction , + + +-- ** collectPadsSetClipFunction + CollectPadsSetClipFunctionMethodInfo , + collectPadsSetClipFunction , + + +-- ** collectPadsSetCompareFunction + CollectPadsSetCompareFunctionMethodInfo , + collectPadsSetCompareFunction , + + +-- ** collectPadsSetEventFunction + CollectPadsSetEventFunctionMethodInfo , + collectPadsSetEventFunction , + + +-- ** collectPadsSetFlushFunction + CollectPadsSetFlushFunctionMethodInfo , + collectPadsSetFlushFunction , + + +-- ** collectPadsSetFlushing + CollectPadsSetFlushingMethodInfo , + collectPadsSetFlushing , + + +-- ** collectPadsSetFunction + CollectPadsSetFunctionMethodInfo , + collectPadsSetFunction , + + +-- ** collectPadsSetQueryFunction + CollectPadsSetQueryFunctionMethodInfo , + collectPadsSetQueryFunction , + + +-- ** collectPadsSetWaiting + CollectPadsSetWaitingMethodInfo , + collectPadsSetWaiting , + + +-- ** collectPadsSrcEventDefault + CollectPadsSrcEventDefaultMethodInfo , + collectPadsSrcEventDefault , + + +-- ** collectPadsStart + CollectPadsStartMethodInfo , + collectPadsStart , + + +-- ** collectPadsStop + CollectPadsStopMethodInfo , + collectPadsStop , + + +-- ** collectPadsTakeBuffer + CollectPadsTakeBufferMethodInfo , + collectPadsTakeBuffer , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks +import qualified GI.GObject as GObject +import qualified GI.Gst as Gst + +newtype CollectPads = CollectPads (ForeignPtr CollectPads) +foreign import ccall "gst_collect_pads_get_type" + c_gst_collect_pads_get_type :: IO GType + +type instance ParentTypes CollectPads = CollectPadsParentTypes +type CollectPadsParentTypes = '[Gst.Object, GObject.Object] + +instance GObject CollectPads where + gobjectIsInitiallyUnowned _ = True + gobjectType _ = c_gst_collect_pads_get_type + + +class GObject o => CollectPadsK o +instance (GObject o, IsDescendantOf CollectPads o) => CollectPadsK o + +toCollectPads :: CollectPadsK o => o -> IO CollectPads +toCollectPads = unsafeCastTo CollectPads + +noCollectPads :: Maybe CollectPads +noCollectPads = Nothing + +type family ResolveCollectPadsMethod (t :: Symbol) (o :: *) :: * where + ResolveCollectPadsMethod "addControlBinding" o = Gst.ObjectAddControlBindingMethodInfo + ResolveCollectPadsMethod "addPad" o = CollectPadsAddPadMethodInfo + ResolveCollectPadsMethod "available" o = CollectPadsAvailableMethodInfo + ResolveCollectPadsMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo + ResolveCollectPadsMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo + ResolveCollectPadsMethod "clipRunningTime" o = CollectPadsClipRunningTimeMethodInfo + ResolveCollectPadsMethod "defaultError" o = Gst.ObjectDefaultErrorMethodInfo + ResolveCollectPadsMethod "eventDefault" o = CollectPadsEventDefaultMethodInfo + ResolveCollectPadsMethod "flush" o = CollectPadsFlushMethodInfo + ResolveCollectPadsMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo + ResolveCollectPadsMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo + ResolveCollectPadsMethod "hasActiveControlBindings" o = Gst.ObjectHasActiveControlBindingsMethodInfo + ResolveCollectPadsMethod "hasAncestor" o = Gst.ObjectHasAncestorMethodInfo + ResolveCollectPadsMethod "hasAsAncestor" o = Gst.ObjectHasAsAncestorMethodInfo + ResolveCollectPadsMethod "hasAsParent" o = Gst.ObjectHasAsParentMethodInfo + ResolveCollectPadsMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo + ResolveCollectPadsMethod "notify" o = GObject.ObjectNotifyMethodInfo + ResolveCollectPadsMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo + ResolveCollectPadsMethod "peek" o = CollectPadsPeekMethodInfo + ResolveCollectPadsMethod "pop" o = CollectPadsPopMethodInfo + ResolveCollectPadsMethod "queryDefault" o = CollectPadsQueryDefaultMethodInfo + ResolveCollectPadsMethod "readBuffer" o = CollectPadsReadBufferMethodInfo + ResolveCollectPadsMethod "refSink" o = GObject.ObjectRefSinkMethodInfo + ResolveCollectPadsMethod "removeControlBinding" o = Gst.ObjectRemoveControlBindingMethodInfo + ResolveCollectPadsMethod "removePad" o = CollectPadsRemovePadMethodInfo + ResolveCollectPadsMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo + ResolveCollectPadsMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo + ResolveCollectPadsMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo + ResolveCollectPadsMethod "srcEventDefault" o = CollectPadsSrcEventDefaultMethodInfo + ResolveCollectPadsMethod "start" o = CollectPadsStartMethodInfo + ResolveCollectPadsMethod "stealData" o = GObject.ObjectStealDataMethodInfo + ResolveCollectPadsMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo + ResolveCollectPadsMethod "stop" o = CollectPadsStopMethodInfo + ResolveCollectPadsMethod "suggestNextSync" o = Gst.ObjectSuggestNextSyncMethodInfo + ResolveCollectPadsMethod "syncValues" o = Gst.ObjectSyncValuesMethodInfo + ResolveCollectPadsMethod "takeBuffer" o = CollectPadsTakeBufferMethodInfo + ResolveCollectPadsMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo + ResolveCollectPadsMethod "unparent" o = Gst.ObjectUnparentMethodInfo + ResolveCollectPadsMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo + ResolveCollectPadsMethod "getControlBinding" o = Gst.ObjectGetControlBindingMethodInfo + ResolveCollectPadsMethod "getControlRate" o = Gst.ObjectGetControlRateMethodInfo + ResolveCollectPadsMethod "getData" o = GObject.ObjectGetDataMethodInfo + ResolveCollectPadsMethod "getGValueArray" o = Gst.ObjectGetGValueArrayMethodInfo + ResolveCollectPadsMethod "getName" o = Gst.ObjectGetNameMethodInfo + ResolveCollectPadsMethod "getParent" o = Gst.ObjectGetParentMethodInfo + ResolveCollectPadsMethod "getPathString" o = Gst.ObjectGetPathStringMethodInfo + ResolveCollectPadsMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo + ResolveCollectPadsMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo + ResolveCollectPadsMethod "getValue" o = Gst.ObjectGetValueMethodInfo + ResolveCollectPadsMethod "getValueArray" o = Gst.ObjectGetValueArrayMethodInfo + ResolveCollectPadsMethod "setBufferFunction" o = CollectPadsSetBufferFunctionMethodInfo + ResolveCollectPadsMethod "setClipFunction" o = CollectPadsSetClipFunctionMethodInfo + ResolveCollectPadsMethod "setCompareFunction" o = CollectPadsSetCompareFunctionMethodInfo + ResolveCollectPadsMethod "setControlBindingDisabled" o = Gst.ObjectSetControlBindingDisabledMethodInfo + ResolveCollectPadsMethod "setControlBindingsDisabled" o = Gst.ObjectSetControlBindingsDisabledMethodInfo + ResolveCollectPadsMethod "setControlRate" o = Gst.ObjectSetControlRateMethodInfo + ResolveCollectPadsMethod "setData" o = GObject.ObjectSetDataMethodInfo + ResolveCollectPadsMethod "setEventFunction" o = CollectPadsSetEventFunctionMethodInfo + ResolveCollectPadsMethod "setFlushFunction" o = CollectPadsSetFlushFunctionMethodInfo + ResolveCollectPadsMethod "setFlushing" o = CollectPadsSetFlushingMethodInfo + ResolveCollectPadsMethod "setFunction" o = CollectPadsSetFunctionMethodInfo + ResolveCollectPadsMethod "setName" o = Gst.ObjectSetNameMethodInfo + ResolveCollectPadsMethod "setParent" o = Gst.ObjectSetParentMethodInfo + ResolveCollectPadsMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo + ResolveCollectPadsMethod "setQueryFunction" o = CollectPadsSetQueryFunctionMethodInfo + ResolveCollectPadsMethod "setWaiting" o = CollectPadsSetWaitingMethodInfo + ResolveCollectPadsMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolveCollectPadsMethod t CollectPads, MethodInfo info CollectPads p) => IsLabelProxy t (CollectPads -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolveCollectPadsMethod t CollectPads, MethodInfo info CollectPads p) => IsLabel t (CollectPads -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + +type instance AttributeList CollectPads = CollectPadsAttributeList +type CollectPadsAttributeList = ('[ '("name", Gst.ObjectNamePropertyInfo), '("parent", Gst.ObjectParentPropertyInfo)] :: [(Symbol, *)]) + +type instance SignalList CollectPads = CollectPadsSignalList +type CollectPadsSignalList = ('[ '("deepNotify", Gst.ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +-- method CollectPads::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : TInterface "GstBase" "CollectPads" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_new" gst_collect_pads_new :: + IO (Ptr CollectPads) + + +collectPadsNew :: + (MonadIO m) => + m CollectPads -- result +collectPadsNew = liftIO $ do + result <- gst_collect_pads_new + checkUnexpectedReturnNULL "gst_collect_pads_new" result + result' <- (wrapObject CollectPads) result + return result' + +-- method CollectPads::add_pad +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface "GstBase" "CollectDataDestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "lock", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "GstBase" "CollectData" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_add_pad" gst_collect_pads_add_pad :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + Ptr Gst.Pad -> -- pad : TInterface "Gst" "Pad" + Word32 -> -- size : TBasicType TUInt32 + FunPtr CollectDataDestroyNotifyC -> -- destroy_notify : TInterface "GstBase" "CollectDataDestroyNotify" + CInt -> -- lock : TBasicType TBoolean + IO (Ptr CollectData) + + +collectPadsAddPad :: + (MonadIO m, CollectPadsK a, Gst.PadK b) => + a -- _obj + -> b -- pad + -> Word32 -- size + -> CollectDataDestroyNotify -- destroyNotify + -> Bool -- lock + -> m CollectData -- result +collectPadsAddPad _obj pad size destroyNotify lock = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let pad' = unsafeManagedPtrCastPtr pad + ptrdestroyNotify <- callocMem :: IO (Ptr (FunPtr CollectDataDestroyNotifyC)) + destroyNotify' <- mkCollectDataDestroyNotify (collectDataDestroyNotifyWrapper (Just ptrdestroyNotify) destroyNotify) + poke ptrdestroyNotify destroyNotify' + let lock' = (fromIntegral . fromEnum) lock + result <- gst_collect_pads_add_pad _obj' pad' size destroyNotify' lock' + checkUnexpectedReturnNULL "gst_collect_pads_add_pad" result + result' <- (newPtr 168 CollectData) result + touchManagedPtr _obj + touchManagedPtr pad + return result' + +data CollectPadsAddPadMethodInfo +instance (signature ~ (b -> Word32 -> CollectDataDestroyNotify -> Bool -> m CollectData), MonadIO m, CollectPadsK a, Gst.PadK b) => MethodInfo CollectPadsAddPadMethodInfo a signature where + overloadedMethod _ = collectPadsAddPad + +-- method CollectPads::available +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt32 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_available" gst_collect_pads_available :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + IO Word32 + + +collectPadsAvailable :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> m Word32 -- result +collectPadsAvailable _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + result <- gst_collect_pads_available _obj' + touchManagedPtr _obj + return result + +data CollectPadsAvailableMethodInfo +instance (signature ~ (m Word32), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsAvailableMethodInfo a signature where + overloadedMethod _ = collectPadsAvailable + +-- method CollectPads::clip_running_time +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cdata", argType = TInterface "GstBase" "CollectData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "outbuf", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "FlowReturn" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_clip_running_time" gst_collect_pads_clip_running_time :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + Ptr CollectData -> -- cdata : TInterface "GstBase" "CollectData" + Ptr Gst.Buffer -> -- buf : TInterface "Gst" "Buffer" + Ptr Gst.Buffer -> -- outbuf : TInterface "Gst" "Buffer" + Ptr () -> -- user_data : TBasicType TVoid + IO CUInt + + +collectPadsClipRunningTime :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectData -- cdata + -> Gst.Buffer -- buf + -> Maybe (Gst.Buffer) -- outbuf + -> Ptr () -- userData + -> m Gst.FlowReturn -- result +collectPadsClipRunningTime _obj cdata buf outbuf userData = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let cdata' = unsafeManagedPtrGetPtr cdata + let buf' = unsafeManagedPtrGetPtr buf + maybeOutbuf <- case outbuf of + Nothing -> return nullPtr + Just jOutbuf -> do + let jOutbuf' = unsafeManagedPtrGetPtr jOutbuf + return jOutbuf' + result <- gst_collect_pads_clip_running_time _obj' cdata' buf' maybeOutbuf userData + let result' = (toEnum . fromIntegral) result + touchManagedPtr _obj + touchManagedPtr cdata + touchManagedPtr buf + whenJust outbuf touchManagedPtr + return result' + +data CollectPadsClipRunningTimeMethodInfo +instance (signature ~ (CollectData -> Gst.Buffer -> Maybe (Gst.Buffer) -> Ptr () -> m Gst.FlowReturn), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsClipRunningTimeMethodInfo a signature where + overloadedMethod _ = collectPadsClipRunningTime + +-- method CollectPads::event_default +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface "GstBase" "CollectData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "discard", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_event_default" gst_collect_pads_event_default :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + Ptr CollectData -> -- data : TInterface "GstBase" "CollectData" + Ptr Gst.Event -> -- event : TInterface "Gst" "Event" + CInt -> -- discard : TBasicType TBoolean + IO CInt + + +collectPadsEventDefault :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectData -- data_ + -> Gst.Event -- event + -> Bool -- discard + -> m Bool -- result +collectPadsEventDefault _obj data_ event discard = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let data_' = unsafeManagedPtrGetPtr data_ + let event' = unsafeManagedPtrGetPtr event + let discard' = (fromIntegral . fromEnum) discard + result <- gst_collect_pads_event_default _obj' data_' event' discard' + let result' = (/= 0) result + touchManagedPtr _obj + touchManagedPtr data_ + touchManagedPtr event + return result' + +data CollectPadsEventDefaultMethodInfo +instance (signature ~ (CollectData -> Gst.Event -> Bool -> m Bool), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsEventDefaultMethodInfo a signature where + overloadedMethod _ = collectPadsEventDefault + +-- method CollectPads::flush +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface "GstBase" "CollectData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt32 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_flush" gst_collect_pads_flush :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + Ptr CollectData -> -- data : TInterface "GstBase" "CollectData" + Word32 -> -- size : TBasicType TUInt32 + IO Word32 + + +collectPadsFlush :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectData -- data_ + -> Word32 -- size + -> m Word32 -- result +collectPadsFlush _obj data_ size = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let data_' = unsafeManagedPtrGetPtr data_ + result <- gst_collect_pads_flush _obj' data_' size + touchManagedPtr _obj + touchManagedPtr data_ + return result + +data CollectPadsFlushMethodInfo +instance (signature ~ (CollectData -> Word32 -> m Word32), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsFlushMethodInfo a signature where + overloadedMethod _ = collectPadsFlush + +-- method CollectPads::peek +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface "GstBase" "CollectData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Buffer" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_peek" gst_collect_pads_peek :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + Ptr CollectData -> -- data : TInterface "GstBase" "CollectData" + IO (Ptr Gst.Buffer) + + +collectPadsPeek :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectData -- data_ + -> m Gst.Buffer -- result +collectPadsPeek _obj data_ = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let data_' = unsafeManagedPtrGetPtr data_ + result <- gst_collect_pads_peek _obj' data_' + checkUnexpectedReturnNULL "gst_collect_pads_peek" result + result' <- (wrapBoxed Gst.Buffer) result + touchManagedPtr _obj + touchManagedPtr data_ + return result' + +data CollectPadsPeekMethodInfo +instance (signature ~ (CollectData -> m Gst.Buffer), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsPeekMethodInfo a signature where + overloadedMethod _ = collectPadsPeek + +-- method CollectPads::pop +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface "GstBase" "CollectData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Buffer" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_pop" gst_collect_pads_pop :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + Ptr CollectData -> -- data : TInterface "GstBase" "CollectData" + IO (Ptr Gst.Buffer) + + +collectPadsPop :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectData -- data_ + -> m Gst.Buffer -- result +collectPadsPop _obj data_ = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let data_' = unsafeManagedPtrGetPtr data_ + result <- gst_collect_pads_pop _obj' data_' + checkUnexpectedReturnNULL "gst_collect_pads_pop" result + result' <- (wrapBoxed Gst.Buffer) result + touchManagedPtr _obj + touchManagedPtr data_ + return result' + +data CollectPadsPopMethodInfo +instance (signature ~ (CollectData -> m Gst.Buffer), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsPopMethodInfo a signature where + overloadedMethod _ = collectPadsPop + +-- method CollectPads::query_default +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface "GstBase" "CollectData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "discard", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_query_default" gst_collect_pads_query_default :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + Ptr CollectData -> -- data : TInterface "GstBase" "CollectData" + Ptr Gst.Query -> -- query : TInterface "Gst" "Query" + CInt -> -- discard : TBasicType TBoolean + IO CInt + + +collectPadsQueryDefault :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectData -- data_ + -> Gst.Query -- query + -> Bool -- discard + -> m Bool -- result +collectPadsQueryDefault _obj data_ query discard = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let data_' = unsafeManagedPtrGetPtr data_ + let query' = unsafeManagedPtrGetPtr query + let discard' = (fromIntegral . fromEnum) discard + result <- gst_collect_pads_query_default _obj' data_' query' discard' + let result' = (/= 0) result + touchManagedPtr _obj + touchManagedPtr data_ + touchManagedPtr query + return result' + +data CollectPadsQueryDefaultMethodInfo +instance (signature ~ (CollectData -> Gst.Query -> Bool -> m Bool), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsQueryDefaultMethodInfo a signature where + overloadedMethod _ = collectPadsQueryDefault + +-- method CollectPads::read_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface "GstBase" "CollectData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Buffer" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_read_buffer" gst_collect_pads_read_buffer :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + Ptr CollectData -> -- data : TInterface "GstBase" "CollectData" + Word32 -> -- size : TBasicType TUInt32 + IO (Ptr Gst.Buffer) + + +collectPadsReadBuffer :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectData -- data_ + -> Word32 -- size + -> m Gst.Buffer -- result +collectPadsReadBuffer _obj data_ size = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let data_' = unsafeManagedPtrGetPtr data_ + result <- gst_collect_pads_read_buffer _obj' data_' size + checkUnexpectedReturnNULL "gst_collect_pads_read_buffer" result + result' <- (wrapBoxed Gst.Buffer) result + touchManagedPtr _obj + touchManagedPtr data_ + return result' + +data CollectPadsReadBufferMethodInfo +instance (signature ~ (CollectData -> Word32 -> m Gst.Buffer), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsReadBufferMethodInfo a signature where + overloadedMethod _ = collectPadsReadBuffer + +-- method CollectPads::remove_pad +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_remove_pad" gst_collect_pads_remove_pad :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + Ptr Gst.Pad -> -- pad : TInterface "Gst" "Pad" + IO CInt + + +collectPadsRemovePad :: + (MonadIO m, CollectPadsK a, Gst.PadK b) => + a -- _obj + -> b -- pad + -> m Bool -- result +collectPadsRemovePad _obj pad = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let pad' = unsafeManagedPtrCastPtr pad + result <- gst_collect_pads_remove_pad _obj' pad' + let result' = (/= 0) result + touchManagedPtr _obj + touchManagedPtr pad + return result' + +data CollectPadsRemovePadMethodInfo +instance (signature ~ (b -> m Bool), MonadIO m, CollectPadsK a, Gst.PadK b) => MethodInfo CollectPadsRemovePadMethodInfo a signature where + overloadedMethod _ = collectPadsRemovePad + +-- method CollectPads::set_buffer_function +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "GstBase" "CollectPadsBufferFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_set_buffer_function" gst_collect_pads_set_buffer_function :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + FunPtr CollectPadsBufferFunctionC -> -- func : TInterface "GstBase" "CollectPadsBufferFunction" + Ptr () -> -- user_data : TBasicType TVoid + IO () + + +collectPadsSetBufferFunction :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectPadsBufferFunction -- func + -> m () -- result +collectPadsSetBufferFunction _obj func = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + func' <- mkCollectPadsBufferFunction (collectPadsBufferFunctionWrapper Nothing func) + let userData = nullPtr + gst_collect_pads_set_buffer_function _obj' func' userData + safeFreeFunPtr $ castFunPtrToPtr func' + touchManagedPtr _obj + return () + +data CollectPadsSetBufferFunctionMethodInfo +instance (signature ~ (CollectPadsBufferFunction -> m ()), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsSetBufferFunctionMethodInfo a signature where + overloadedMethod _ = collectPadsSetBufferFunction + +-- method CollectPads::set_clip_function +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clipfunc", argType = TInterface "GstBase" "CollectPadsClipFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_set_clip_function" gst_collect_pads_set_clip_function :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + FunPtr CollectPadsClipFunctionC -> -- clipfunc : TInterface "GstBase" "CollectPadsClipFunction" + Ptr () -> -- user_data : TBasicType TVoid + IO () + + +collectPadsSetClipFunction :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectPadsClipFunction -- clipfunc + -> m () -- result +collectPadsSetClipFunction _obj clipfunc = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + clipfunc' <- mkCollectPadsClipFunction (collectPadsClipFunctionWrapper Nothing clipfunc) + let userData = nullPtr + gst_collect_pads_set_clip_function _obj' clipfunc' userData + safeFreeFunPtr $ castFunPtrToPtr clipfunc' + touchManagedPtr _obj + return () + +data CollectPadsSetClipFunctionMethodInfo +instance (signature ~ (CollectPadsClipFunction -> m ()), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsSetClipFunctionMethodInfo a signature where + overloadedMethod _ = collectPadsSetClipFunction + +-- method CollectPads::set_compare_function +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "GstBase" "CollectPadsCompareFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_set_compare_function" gst_collect_pads_set_compare_function :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + FunPtr CollectPadsCompareFunctionC -> -- func : TInterface "GstBase" "CollectPadsCompareFunction" + Ptr () -> -- user_data : TBasicType TVoid + IO () + + +collectPadsSetCompareFunction :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectPadsCompareFunction -- func + -> m () -- result +collectPadsSetCompareFunction _obj func = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + func' <- mkCollectPadsCompareFunction (collectPadsCompareFunctionWrapper Nothing func) + let userData = nullPtr + gst_collect_pads_set_compare_function _obj' func' userData + safeFreeFunPtr $ castFunPtrToPtr func' + touchManagedPtr _obj + return () + +data CollectPadsSetCompareFunctionMethodInfo +instance (signature ~ (CollectPadsCompareFunction -> m ()), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsSetCompareFunctionMethodInfo a signature where + overloadedMethod _ = collectPadsSetCompareFunction + +-- method CollectPads::set_event_function +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "GstBase" "CollectPadsEventFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_set_event_function" gst_collect_pads_set_event_function :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + FunPtr CollectPadsEventFunctionC -> -- func : TInterface "GstBase" "CollectPadsEventFunction" + Ptr () -> -- user_data : TBasicType TVoid + IO () + + +collectPadsSetEventFunction :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectPadsEventFunction -- func + -> m () -- result +collectPadsSetEventFunction _obj func = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + func' <- mkCollectPadsEventFunction (collectPadsEventFunctionWrapper Nothing func) + let userData = nullPtr + gst_collect_pads_set_event_function _obj' func' userData + safeFreeFunPtr $ castFunPtrToPtr func' + touchManagedPtr _obj + return () + +data CollectPadsSetEventFunctionMethodInfo +instance (signature ~ (CollectPadsEventFunction -> m ()), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsSetEventFunctionMethodInfo a signature where + overloadedMethod _ = collectPadsSetEventFunction + +-- method CollectPads::set_flush_function +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "GstBase" "CollectPadsFlushFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_set_flush_function" gst_collect_pads_set_flush_function :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + FunPtr CollectPadsFlushFunctionC -> -- func : TInterface "GstBase" "CollectPadsFlushFunction" + Ptr () -> -- user_data : TBasicType TVoid + IO () + + +collectPadsSetFlushFunction :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectPadsFlushFunction -- func + -> m () -- result +collectPadsSetFlushFunction _obj func = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + func' <- mkCollectPadsFlushFunction (collectPadsFlushFunctionWrapper Nothing func) + let userData = nullPtr + gst_collect_pads_set_flush_function _obj' func' userData + safeFreeFunPtr $ castFunPtrToPtr func' + touchManagedPtr _obj + return () + +data CollectPadsSetFlushFunctionMethodInfo +instance (signature ~ (CollectPadsFlushFunction -> m ()), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsSetFlushFunctionMethodInfo a signature where + overloadedMethod _ = collectPadsSetFlushFunction + +-- method CollectPads::set_flushing +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flushing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_set_flushing" gst_collect_pads_set_flushing :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + CInt -> -- flushing : TBasicType TBoolean + IO () + + +collectPadsSetFlushing :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> Bool -- flushing + -> m () -- result +collectPadsSetFlushing _obj flushing = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let flushing' = (fromIntegral . fromEnum) flushing + gst_collect_pads_set_flushing _obj' flushing' + touchManagedPtr _obj + return () + +data CollectPadsSetFlushingMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsSetFlushingMethodInfo a signature where + overloadedMethod _ = collectPadsSetFlushing + +-- method CollectPads::set_function +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "GstBase" "CollectPadsFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_set_function" gst_collect_pads_set_function :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + FunPtr CollectPadsFunctionC -> -- func : TInterface "GstBase" "CollectPadsFunction" + Ptr () -> -- user_data : TBasicType TVoid + IO () + + +collectPadsSetFunction :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectPadsFunction -- func + -> m () -- result +collectPadsSetFunction _obj func = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + func' <- mkCollectPadsFunction (collectPadsFunctionWrapper Nothing func) + let userData = nullPtr + gst_collect_pads_set_function _obj' func' userData + safeFreeFunPtr $ castFunPtrToPtr func' + touchManagedPtr _obj + return () + +data CollectPadsSetFunctionMethodInfo +instance (signature ~ (CollectPadsFunction -> m ()), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsSetFunctionMethodInfo a signature where + overloadedMethod _ = collectPadsSetFunction + +-- method CollectPads::set_query_function +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "GstBase" "CollectPadsQueryFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_set_query_function" gst_collect_pads_set_query_function :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + FunPtr CollectPadsQueryFunctionC -> -- func : TInterface "GstBase" "CollectPadsQueryFunction" + Ptr () -> -- user_data : TBasicType TVoid + IO () + + +collectPadsSetQueryFunction :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectPadsQueryFunction -- func + -> m () -- result +collectPadsSetQueryFunction _obj func = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + func' <- mkCollectPadsQueryFunction (collectPadsQueryFunctionWrapper Nothing func) + let userData = nullPtr + gst_collect_pads_set_query_function _obj' func' userData + safeFreeFunPtr $ castFunPtrToPtr func' + touchManagedPtr _obj + return () + +data CollectPadsSetQueryFunctionMethodInfo +instance (signature ~ (CollectPadsQueryFunction -> m ()), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsSetQueryFunctionMethodInfo a signature where + overloadedMethod _ = collectPadsSetQueryFunction + +-- method CollectPads::set_waiting +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface "GstBase" "CollectData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "waiting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_set_waiting" gst_collect_pads_set_waiting :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + Ptr CollectData -> -- data : TInterface "GstBase" "CollectData" + CInt -> -- waiting : TBasicType TBoolean + IO () + + +collectPadsSetWaiting :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectData -- data_ + -> Bool -- waiting + -> m () -- result +collectPadsSetWaiting _obj data_ waiting = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let data_' = unsafeManagedPtrGetPtr data_ + let waiting' = (fromIntegral . fromEnum) waiting + gst_collect_pads_set_waiting _obj' data_' waiting' + touchManagedPtr _obj + touchManagedPtr data_ + return () + +data CollectPadsSetWaitingMethodInfo +instance (signature ~ (CollectData -> Bool -> m ()), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsSetWaitingMethodInfo a signature where + overloadedMethod _ = collectPadsSetWaiting + +-- method CollectPads::src_event_default +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_src_event_default" gst_collect_pads_src_event_default :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + Ptr Gst.Pad -> -- pad : TInterface "Gst" "Pad" + Ptr Gst.Event -> -- event : TInterface "Gst" "Event" + IO CInt + + +collectPadsSrcEventDefault :: + (MonadIO m, CollectPadsK a, Gst.PadK b) => + a -- _obj + -> b -- pad + -> Gst.Event -- event + -> m Bool -- result +collectPadsSrcEventDefault _obj pad event = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let pad' = unsafeManagedPtrCastPtr pad + let event' = unsafeManagedPtrGetPtr event + result <- gst_collect_pads_src_event_default _obj' pad' event' + let result' = (/= 0) result + touchManagedPtr _obj + touchManagedPtr pad + touchManagedPtr event + return result' + +data CollectPadsSrcEventDefaultMethodInfo +instance (signature ~ (b -> Gst.Event -> m Bool), MonadIO m, CollectPadsK a, Gst.PadK b) => MethodInfo CollectPadsSrcEventDefaultMethodInfo a signature where + overloadedMethod _ = collectPadsSrcEventDefault + +-- method CollectPads::start +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_start" gst_collect_pads_start :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + IO () + + +collectPadsStart :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> m () -- result +collectPadsStart _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_collect_pads_start _obj' + touchManagedPtr _obj + return () + +data CollectPadsStartMethodInfo +instance (signature ~ (m ()), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsStartMethodInfo a signature where + overloadedMethod _ = collectPadsStart + +-- method CollectPads::stop +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_stop" gst_collect_pads_stop :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + IO () + + +collectPadsStop :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> m () -- result +collectPadsStop _obj = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + gst_collect_pads_stop _obj' + touchManagedPtr _obj + return () + +data CollectPadsStopMethodInfo +instance (signature ~ (m ()), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsStopMethodInfo a signature where + overloadedMethod _ = collectPadsStop + +-- method CollectPads::take_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "CollectPads", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface "GstBase" "CollectData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Buffer" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_collect_pads_take_buffer" gst_collect_pads_take_buffer :: + Ptr CollectPads -> -- _obj : TInterface "GstBase" "CollectPads" + Ptr CollectData -> -- data : TInterface "GstBase" "CollectData" + Word32 -> -- size : TBasicType TUInt32 + IO (Ptr Gst.Buffer) + + +collectPadsTakeBuffer :: + (MonadIO m, CollectPadsK a) => + a -- _obj + -> CollectData -- data_ + -> Word32 -- size + -> m Gst.Buffer -- result +collectPadsTakeBuffer _obj data_ size = liftIO $ do + let _obj' = unsafeManagedPtrCastPtr _obj + let data_' = unsafeManagedPtrGetPtr data_ + result <- gst_collect_pads_take_buffer _obj' data_' size + checkUnexpectedReturnNULL "gst_collect_pads_take_buffer" result + result' <- (wrapBoxed Gst.Buffer) result + touchManagedPtr _obj + touchManagedPtr data_ + return result' + +data CollectPadsTakeBufferMethodInfo +instance (signature ~ (CollectData -> Word32 -> m Gst.Buffer), MonadIO m, CollectPadsK a) => MethodInfo CollectPadsTakeBufferMethodInfo a signature where + overloadedMethod _ = collectPadsTakeBuffer + + diff --git a/GI/GstBase/Objects/CollectPads.hs-boot b/GI/GstBase/Objects/CollectPads.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/CollectPads.hs-boot @@ -0,0 +1,36 @@ +module GI.GstBase.Objects.CollectPads where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype CollectPads = CollectPads (ForeignPtr CollectPads) +instance GObject CollectPads where +class GObject o => CollectPadsK o +instance (GObject o, IsDescendantOf CollectPads o) => CollectPadsK o +data CollectPadsAddPadMethodInfo +data CollectPadsAvailableMethodInfo +data CollectPadsClipRunningTimeMethodInfo +data CollectPadsEventDefaultMethodInfo +data CollectPadsFlushMethodInfo +data CollectPadsPeekMethodInfo +data CollectPadsPopMethodInfo +data CollectPadsQueryDefaultMethodInfo +data CollectPadsReadBufferMethodInfo +data CollectPadsRemovePadMethodInfo +data CollectPadsSetBufferFunctionMethodInfo +data CollectPadsSetClipFunctionMethodInfo +data CollectPadsSetCompareFunctionMethodInfo +data CollectPadsSetEventFunctionMethodInfo +data CollectPadsSetFlushFunctionMethodInfo +data CollectPadsSetFlushingMethodInfo +data CollectPadsSetFunctionMethodInfo +data CollectPadsSetQueryFunctionMethodInfo +data CollectPadsSetWaitingMethodInfo +data CollectPadsSrcEventDefaultMethodInfo +data CollectPadsStartMethodInfo +data CollectPadsStopMethodInfo +data CollectPadsTakeBufferMethodInfo diff --git a/GI/GstBase/Objects/DataQueue.hs b/GI/GstBase/Objects/DataQueue.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/DataQueue.hs @@ -0,0 +1,164 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Objects.DataQueue + ( + +-- * Exported types + DataQueue(..) , + DataQueueK , + toDataQueue , + noDataQueue , + + + -- * Properties +-- ** CurrentLevelBytes + DataQueueCurrentLevelBytesPropertyInfo , + getDataQueueCurrentLevelBytes , + + +-- ** CurrentLevelTime + DataQueueCurrentLevelTimePropertyInfo , + getDataQueueCurrentLevelTime , + + +-- ** CurrentLevelVisible + DataQueueCurrentLevelVisiblePropertyInfo, + getDataQueueCurrentLevelVisible , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks +import qualified GI.GObject as GObject + +newtype DataQueue = DataQueue (ForeignPtr DataQueue) +foreign import ccall "gst_data_queue_get_type" + c_gst_data_queue_get_type :: IO GType + +type instance ParentTypes DataQueue = DataQueueParentTypes +type DataQueueParentTypes = '[GObject.Object] + +instance GObject DataQueue where + gobjectIsInitiallyUnowned _ = False + gobjectType _ = c_gst_data_queue_get_type + + +class GObject o => DataQueueK o +instance (GObject o, IsDescendantOf DataQueue o) => DataQueueK o + +toDataQueue :: DataQueueK o => o -> IO DataQueue +toDataQueue = unsafeCastTo DataQueue + +noDataQueue :: Maybe DataQueue +noDataQueue = Nothing + +type family ResolveDataQueueMethod (t :: Symbol) (o :: *) :: * where + ResolveDataQueueMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo + ResolveDataQueueMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo + ResolveDataQueueMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo + ResolveDataQueueMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo + ResolveDataQueueMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo + ResolveDataQueueMethod "notify" o = GObject.ObjectNotifyMethodInfo + ResolveDataQueueMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo + ResolveDataQueueMethod "ref" o = GObject.ObjectRefMethodInfo + ResolveDataQueueMethod "refSink" o = GObject.ObjectRefSinkMethodInfo + ResolveDataQueueMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo + ResolveDataQueueMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo + ResolveDataQueueMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo + ResolveDataQueueMethod "stealData" o = GObject.ObjectStealDataMethodInfo + ResolveDataQueueMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo + ResolveDataQueueMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo + ResolveDataQueueMethod "unref" o = GObject.ObjectUnrefMethodInfo + ResolveDataQueueMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo + ResolveDataQueueMethod "getData" o = GObject.ObjectGetDataMethodInfo + ResolveDataQueueMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo + ResolveDataQueueMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo + ResolveDataQueueMethod "setData" o = GObject.ObjectSetDataMethodInfo + ResolveDataQueueMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo + ResolveDataQueueMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolveDataQueueMethod t DataQueue, MethodInfo info DataQueue p) => IsLabelProxy t (DataQueue -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolveDataQueueMethod t DataQueue, MethodInfo info DataQueue p) => IsLabel t (DataQueue -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + +-- VVV Prop "current-level-bytes" + -- Type: TBasicType TUInt32 + -- Flags: [PropertyReadable] + +getDataQueueCurrentLevelBytes :: (MonadIO m, DataQueueK o) => o -> m Word32 +getDataQueueCurrentLevelBytes obj = liftIO $ getObjectPropertyCUInt obj "current-level-bytes" + +data DataQueueCurrentLevelBytesPropertyInfo +instance AttrInfo DataQueueCurrentLevelBytesPropertyInfo where + type AttrAllowedOps DataQueueCurrentLevelBytesPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DataQueueCurrentLevelBytesPropertyInfo = (~) () + type AttrBaseTypeConstraint DataQueueCurrentLevelBytesPropertyInfo = DataQueueK + type AttrGetType DataQueueCurrentLevelBytesPropertyInfo = Word32 + type AttrLabel DataQueueCurrentLevelBytesPropertyInfo = "current-level-bytes" + attrGet _ = getDataQueueCurrentLevelBytes + attrSet _ = undefined + attrConstruct _ = undefined + +-- VVV Prop "current-level-time" + -- Type: TBasicType TUInt64 + -- Flags: [PropertyReadable] + +getDataQueueCurrentLevelTime :: (MonadIO m, DataQueueK o) => o -> m Word64 +getDataQueueCurrentLevelTime obj = liftIO $ getObjectPropertyUInt64 obj "current-level-time" + +data DataQueueCurrentLevelTimePropertyInfo +instance AttrInfo DataQueueCurrentLevelTimePropertyInfo where + type AttrAllowedOps DataQueueCurrentLevelTimePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DataQueueCurrentLevelTimePropertyInfo = (~) () + type AttrBaseTypeConstraint DataQueueCurrentLevelTimePropertyInfo = DataQueueK + type AttrGetType DataQueueCurrentLevelTimePropertyInfo = Word64 + type AttrLabel DataQueueCurrentLevelTimePropertyInfo = "current-level-time" + attrGet _ = getDataQueueCurrentLevelTime + attrSet _ = undefined + attrConstruct _ = undefined + +-- VVV Prop "current-level-visible" + -- Type: TBasicType TUInt32 + -- Flags: [PropertyReadable] + +getDataQueueCurrentLevelVisible :: (MonadIO m, DataQueueK o) => o -> m Word32 +getDataQueueCurrentLevelVisible obj = liftIO $ getObjectPropertyCUInt obj "current-level-visible" + +data DataQueueCurrentLevelVisiblePropertyInfo +instance AttrInfo DataQueueCurrentLevelVisiblePropertyInfo where + type AttrAllowedOps DataQueueCurrentLevelVisiblePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DataQueueCurrentLevelVisiblePropertyInfo = (~) () + type AttrBaseTypeConstraint DataQueueCurrentLevelVisiblePropertyInfo = DataQueueK + type AttrGetType DataQueueCurrentLevelVisiblePropertyInfo = Word32 + type AttrLabel DataQueueCurrentLevelVisiblePropertyInfo = "current-level-visible" + attrGet _ = getDataQueueCurrentLevelVisible + attrSet _ = undefined + attrConstruct _ = undefined + +type instance AttributeList DataQueue = DataQueueAttributeList +type DataQueueAttributeList = ('[ '("currentLevelBytes", DataQueueCurrentLevelBytesPropertyInfo), '("currentLevelTime", DataQueueCurrentLevelTimePropertyInfo), '("currentLevelVisible", DataQueueCurrentLevelVisiblePropertyInfo)] :: [(Symbol, *)]) + +type instance SignalList DataQueue = DataQueueSignalList +type DataQueueSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + + diff --git a/GI/GstBase/Objects/DataQueue.hs-boot b/GI/GstBase/Objects/DataQueue.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/DataQueue.hs-boot @@ -0,0 +1,16 @@ +module GI.GstBase.Objects.DataQueue where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype DataQueue = DataQueue (ForeignPtr DataQueue) +instance GObject DataQueue where +class GObject o => DataQueueK o +instance (GObject o, IsDescendantOf DataQueue o) => DataQueueK o +data DataQueueCurrentLevelBytesPropertyInfo +data DataQueueCurrentLevelTimePropertyInfo +data DataQueueCurrentLevelVisiblePropertyInfo diff --git a/GI/GstBase/Objects/PushSrc.hs b/GI/GstBase/Objects/PushSrc.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/PushSrc.hs @@ -0,0 +1,182 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Objects.PushSrc + ( + +-- * Exported types + PushSrc(..) , + PushSrcK , + toPushSrc , + noPushSrc , + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks +import qualified GI.GObject as GObject +import qualified GI.Gst as Gst + +newtype PushSrc = PushSrc (ForeignPtr PushSrc) +foreign import ccall "gst_push_src_get_type" + c_gst_push_src_get_type :: IO GType + +type instance ParentTypes PushSrc = PushSrcParentTypes +type PushSrcParentTypes = '[BaseSrc, Gst.Element, Gst.Object, GObject.Object] + +instance GObject PushSrc where + gobjectIsInitiallyUnowned _ = True + gobjectType _ = c_gst_push_src_get_type + + +class GObject o => PushSrcK o +instance (GObject o, IsDescendantOf PushSrc o) => PushSrcK o + +toPushSrc :: PushSrcK o => o -> IO PushSrc +toPushSrc = unsafeCastTo PushSrc + +noPushSrc :: Maybe PushSrc +noPushSrc = Nothing + +type family ResolvePushSrcMethod (t :: Symbol) (o :: *) :: * where + ResolvePushSrcMethod "abortState" o = Gst.ElementAbortStateMethodInfo + ResolvePushSrcMethod "addControlBinding" o = Gst.ObjectAddControlBindingMethodInfo + ResolvePushSrcMethod "addPad" o = Gst.ElementAddPadMethodInfo + ResolvePushSrcMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo + ResolvePushSrcMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo + ResolvePushSrcMethod "changeState" o = Gst.ElementChangeStateMethodInfo + ResolvePushSrcMethod "continueState" o = Gst.ElementContinueStateMethodInfo + ResolvePushSrcMethod "createAllPads" o = Gst.ElementCreateAllPadsMethodInfo + ResolvePushSrcMethod "defaultError" o = Gst.ObjectDefaultErrorMethodInfo + ResolvePushSrcMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo + ResolvePushSrcMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo + ResolvePushSrcMethod "hasActiveControlBindings" o = Gst.ObjectHasActiveControlBindingsMethodInfo + ResolvePushSrcMethod "hasAncestor" o = Gst.ObjectHasAncestorMethodInfo + ResolvePushSrcMethod "hasAsAncestor" o = Gst.ObjectHasAsAncestorMethodInfo + ResolvePushSrcMethod "hasAsParent" o = Gst.ObjectHasAsParentMethodInfo + ResolvePushSrcMethod "isAsync" o = BaseSrcIsAsyncMethodInfo + ResolvePushSrcMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo + ResolvePushSrcMethod "isLive" o = BaseSrcIsLiveMethodInfo + ResolvePushSrcMethod "isLockedState" o = Gst.ElementIsLockedStateMethodInfo + ResolvePushSrcMethod "iteratePads" o = Gst.ElementIteratePadsMethodInfo + ResolvePushSrcMethod "iterateSinkPads" o = Gst.ElementIterateSinkPadsMethodInfo + ResolvePushSrcMethod "iterateSrcPads" o = Gst.ElementIterateSrcPadsMethodInfo + ResolvePushSrcMethod "link" o = Gst.ElementLinkMethodInfo + ResolvePushSrcMethod "linkFiltered" o = Gst.ElementLinkFilteredMethodInfo + ResolvePushSrcMethod "linkPads" o = Gst.ElementLinkPadsMethodInfo + ResolvePushSrcMethod "linkPadsFiltered" o = Gst.ElementLinkPadsFilteredMethodInfo + ResolvePushSrcMethod "linkPadsFull" o = Gst.ElementLinkPadsFullMethodInfo + ResolvePushSrcMethod "lostState" o = Gst.ElementLostStateMethodInfo + ResolvePushSrcMethod "messageFull" o = Gst.ElementMessageFullMethodInfo + ResolvePushSrcMethod "newSeamlessSegment" o = BaseSrcNewSeamlessSegmentMethodInfo + ResolvePushSrcMethod "noMorePads" o = Gst.ElementNoMorePadsMethodInfo + ResolvePushSrcMethod "notify" o = GObject.ObjectNotifyMethodInfo + ResolvePushSrcMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo + ResolvePushSrcMethod "postMessage" o = Gst.ElementPostMessageMethodInfo + ResolvePushSrcMethod "provideClock" o = Gst.ElementProvideClockMethodInfo + ResolvePushSrcMethod "query" o = Gst.ElementQueryMethodInfo + ResolvePushSrcMethod "queryConvert" o = Gst.ElementQueryConvertMethodInfo + ResolvePushSrcMethod "queryDuration" o = Gst.ElementQueryDurationMethodInfo + ResolvePushSrcMethod "queryLatency" o = BaseSrcQueryLatencyMethodInfo + ResolvePushSrcMethod "queryPosition" o = Gst.ElementQueryPositionMethodInfo + ResolvePushSrcMethod "refSink" o = GObject.ObjectRefSinkMethodInfo + ResolvePushSrcMethod "releaseRequestPad" o = Gst.ElementReleaseRequestPadMethodInfo + ResolvePushSrcMethod "removeControlBinding" o = Gst.ObjectRemoveControlBindingMethodInfo + ResolvePushSrcMethod "removePad" o = Gst.ElementRemovePadMethodInfo + ResolvePushSrcMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo + ResolvePushSrcMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo + ResolvePushSrcMethod "requestPad" o = Gst.ElementRequestPadMethodInfo + ResolvePushSrcMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo + ResolvePushSrcMethod "seek" o = Gst.ElementSeekMethodInfo + ResolvePushSrcMethod "seekSimple" o = Gst.ElementSeekSimpleMethodInfo + ResolvePushSrcMethod "sendEvent" o = Gst.ElementSendEventMethodInfo + ResolvePushSrcMethod "startComplete" o = BaseSrcStartCompleteMethodInfo + ResolvePushSrcMethod "startWait" o = BaseSrcStartWaitMethodInfo + ResolvePushSrcMethod "stealData" o = GObject.ObjectStealDataMethodInfo + ResolvePushSrcMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo + ResolvePushSrcMethod "suggestNextSync" o = Gst.ObjectSuggestNextSyncMethodInfo + ResolvePushSrcMethod "syncStateWithParent" o = Gst.ElementSyncStateWithParentMethodInfo + ResolvePushSrcMethod "syncValues" o = Gst.ObjectSyncValuesMethodInfo + ResolvePushSrcMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo + ResolvePushSrcMethod "unlink" o = Gst.ElementUnlinkMethodInfo + ResolvePushSrcMethod "unlinkPads" o = Gst.ElementUnlinkPadsMethodInfo + ResolvePushSrcMethod "unparent" o = Gst.ObjectUnparentMethodInfo + ResolvePushSrcMethod "waitPlaying" o = BaseSrcWaitPlayingMethodInfo + ResolvePushSrcMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo + ResolvePushSrcMethod "getAllocator" o = BaseSrcGetAllocatorMethodInfo + ResolvePushSrcMethod "getBaseTime" o = Gst.ElementGetBaseTimeMethodInfo + ResolvePushSrcMethod "getBlocksize" o = BaseSrcGetBlocksizeMethodInfo + ResolvePushSrcMethod "getBufferPool" o = BaseSrcGetBufferPoolMethodInfo + ResolvePushSrcMethod "getBus" o = Gst.ElementGetBusMethodInfo + ResolvePushSrcMethod "getClock" o = Gst.ElementGetClockMethodInfo + ResolvePushSrcMethod "getCompatiblePad" o = Gst.ElementGetCompatiblePadMethodInfo + ResolvePushSrcMethod "getCompatiblePadTemplate" o = Gst.ElementGetCompatiblePadTemplateMethodInfo + ResolvePushSrcMethod "getControlBinding" o = Gst.ObjectGetControlBindingMethodInfo + ResolvePushSrcMethod "getControlRate" o = Gst.ObjectGetControlRateMethodInfo + ResolvePushSrcMethod "getData" o = GObject.ObjectGetDataMethodInfo + ResolvePushSrcMethod "getDoTimestamp" o = BaseSrcGetDoTimestampMethodInfo + ResolvePushSrcMethod "getFactory" o = Gst.ElementGetFactoryMethodInfo + ResolvePushSrcMethod "getGValueArray" o = Gst.ObjectGetGValueArrayMethodInfo + ResolvePushSrcMethod "getName" o = Gst.ObjectGetNameMethodInfo + ResolvePushSrcMethod "getParent" o = Gst.ObjectGetParentMethodInfo + ResolvePushSrcMethod "getPathString" o = Gst.ObjectGetPathStringMethodInfo + ResolvePushSrcMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo + ResolvePushSrcMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo + ResolvePushSrcMethod "getRequestPad" o = Gst.ElementGetRequestPadMethodInfo + ResolvePushSrcMethod "getStartTime" o = Gst.ElementGetStartTimeMethodInfo + ResolvePushSrcMethod "getState" o = Gst.ElementGetStateMethodInfo + ResolvePushSrcMethod "getStaticPad" o = Gst.ElementGetStaticPadMethodInfo + ResolvePushSrcMethod "getValue" o = Gst.ObjectGetValueMethodInfo + ResolvePushSrcMethod "getValueArray" o = Gst.ObjectGetValueArrayMethodInfo + ResolvePushSrcMethod "setAsync" o = BaseSrcSetAsyncMethodInfo + ResolvePushSrcMethod "setAutomaticEos" o = BaseSrcSetAutomaticEosMethodInfo + ResolvePushSrcMethod "setBaseTime" o = Gst.ElementSetBaseTimeMethodInfo + ResolvePushSrcMethod "setBlocksize" o = BaseSrcSetBlocksizeMethodInfo + ResolvePushSrcMethod "setBus" o = Gst.ElementSetBusMethodInfo + ResolvePushSrcMethod "setCaps" o = BaseSrcSetCapsMethodInfo + ResolvePushSrcMethod "setClock" o = Gst.ElementSetClockMethodInfo + ResolvePushSrcMethod "setContext" o = Gst.ElementSetContextMethodInfo + ResolvePushSrcMethod "setControlBindingDisabled" o = Gst.ObjectSetControlBindingDisabledMethodInfo + ResolvePushSrcMethod "setControlBindingsDisabled" o = Gst.ObjectSetControlBindingsDisabledMethodInfo + ResolvePushSrcMethod "setControlRate" o = Gst.ObjectSetControlRateMethodInfo + ResolvePushSrcMethod "setData" o = GObject.ObjectSetDataMethodInfo + ResolvePushSrcMethod "setDoTimestamp" o = BaseSrcSetDoTimestampMethodInfo + ResolvePushSrcMethod "setDynamicSize" o = BaseSrcSetDynamicSizeMethodInfo + ResolvePushSrcMethod "setFormat" o = BaseSrcSetFormatMethodInfo + ResolvePushSrcMethod "setLive" o = BaseSrcSetLiveMethodInfo + ResolvePushSrcMethod "setLockedState" o = Gst.ElementSetLockedStateMethodInfo + ResolvePushSrcMethod "setName" o = Gst.ObjectSetNameMethodInfo + ResolvePushSrcMethod "setParent" o = Gst.ObjectSetParentMethodInfo + ResolvePushSrcMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo + ResolvePushSrcMethod "setStartTime" o = Gst.ElementSetStartTimeMethodInfo + ResolvePushSrcMethod "setState" o = Gst.ElementSetStateMethodInfo + ResolvePushSrcMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolvePushSrcMethod t PushSrc, MethodInfo info PushSrc p) => IsLabelProxy t (PushSrc -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolvePushSrcMethod t PushSrc, MethodInfo info PushSrc p) => IsLabel t (PushSrc -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + +type instance AttributeList PushSrc = PushSrcAttributeList +type PushSrcAttributeList = ('[ '("blocksize", BaseSrcBlocksizePropertyInfo), '("doTimestamp", BaseSrcDoTimestampPropertyInfo), '("name", Gst.ObjectNamePropertyInfo), '("numBuffers", BaseSrcNumBuffersPropertyInfo), '("parent", Gst.ObjectParentPropertyInfo), '("typefind", BaseSrcTypefindPropertyInfo)] :: [(Symbol, *)]) + +type instance SignalList PushSrc = PushSrcSignalList +type PushSrcSignalList = ('[ '("deepNotify", Gst.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", Gst.ElementPadAddedSignalInfo), '("padRemoved", Gst.ElementPadRemovedSignalInfo)] :: [(Symbol, *)]) + + diff --git a/GI/GstBase/Objects/PushSrc.hs-boot b/GI/GstBase/Objects/PushSrc.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Objects/PushSrc.hs-boot @@ -0,0 +1,13 @@ +module GI.GstBase.Objects.PushSrc where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype PushSrc = PushSrc (ForeignPtr PushSrc) +instance GObject PushSrc where +class GObject o => PushSrcK o +instance (GObject o, IsDescendantOf PushSrc o) => PushSrcK o diff --git a/GI/GstBase/Structs.hs b/GI/GstBase/Structs.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Structs.hs @@ -0,0 +1,37 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) +-} + +module GI.GstBase.Structs + ( module GI.GstBase.Structs.BaseParseFrame, + module GI.GstBase.Structs.BitReader , + module GI.GstBase.Structs.ByteReader , + module GI.GstBase.Structs.ByteWriter , + module GI.GstBase.Structs.CollectData , + module GI.GstBase.Structs.FlowCombiner , + + + ) where + +import GI.GstBase.Structs.BaseParseFrame +import GI.GstBase.Structs.BitReader +import GI.GstBase.Structs.ByteReader +import GI.GstBase.Structs.ByteWriter +import GI.GstBase.Structs.CollectData +import GI.GstBase.Structs.FlowCombiner + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks + + diff --git a/GI/GstBase/Structs/BaseParseFrame.hs b/GI/GstBase/Structs/BaseParseFrame.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Structs/BaseParseFrame.hs @@ -0,0 +1,217 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) + +Frame (context) data passed to each frame parsing virtual methods. In +addition to providing the data to be checked for a valid frame or an already +identified frame, it conveys additional metadata or control information +from and to the subclass w.r.t. the particular frame in question (rather +than global parameters). Some of these may apply to each parsing stage, others +only to some a particular one. These parameters are effectively zeroed at start +of each frame's processing, i.e. parsing virtual method invocation sequence. +-} + +module GI.GstBase.Structs.BaseParseFrame + ( + +-- * Exported types + BaseParseFrame(..) , + newZeroBaseParseFrame , + noBaseParseFrame , + + + -- * Methods +-- ** baseParseFrameFree + BaseParseFrameFreeMethodInfo , + baseParseFrameFree , + + +-- ** baseParseFrameInit + BaseParseFrameInitMethodInfo , + baseParseFrameInit , + + +-- ** baseParseFrameNew + baseParseFrameNew , + + + + + -- * Properties +-- ** Buffer + baseParseFrameReadBuffer , + + +-- ** Flags + baseParseFrameReadFlags , + + +-- ** Offset + baseParseFrameReadOffset , + + +-- ** OutBuffer + baseParseFrameReadOutBuffer , + + +-- ** Overhead + baseParseFrameReadOverhead , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks +import qualified GI.Gst as Gst + +newtype BaseParseFrame = BaseParseFrame (ForeignPtr BaseParseFrame) +foreign import ccall "gst_base_parse_frame_get_type" c_gst_base_parse_frame_get_type :: + IO GType + +instance BoxedObject BaseParseFrame where + boxedType _ = c_gst_base_parse_frame_get_type + +-- | Construct a `BaseParseFrame` struct initialized to zero. +newZeroBaseParseFrame :: MonadIO m => m BaseParseFrame +newZeroBaseParseFrame = liftIO $ callocBoxedBytes 72 >>= wrapBoxed BaseParseFrame + +noBaseParseFrame :: Maybe BaseParseFrame +noBaseParseFrame = Nothing + +baseParseFrameReadBuffer :: BaseParseFrame -> IO Gst.Buffer +baseParseFrameReadBuffer s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO (Ptr Gst.Buffer) + val' <- (newBoxed Gst.Buffer) val + return val' + +baseParseFrameReadOutBuffer :: BaseParseFrame -> IO Gst.Buffer +baseParseFrameReadOutBuffer s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO (Ptr Gst.Buffer) + val' <- (newBoxed Gst.Buffer) val + return val' + +baseParseFrameReadFlags :: BaseParseFrame -> IO Word32 +baseParseFrameReadFlags s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO Word32 + return val + +baseParseFrameReadOffset :: BaseParseFrame -> IO Word64 +baseParseFrameReadOffset s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO Word64 + return val + +baseParseFrameReadOverhead :: BaseParseFrame -> IO Int32 +baseParseFrameReadOverhead s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Int32 + return val + +-- method BaseParseFrame::new +-- method type : Constructor +-- Args : [Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "GstBase" "BaseParseFrameFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "overhead", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "GstBase" "BaseParseFrame" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_frame_new" gst_base_parse_frame_new :: + Ptr Gst.Buffer -> -- buffer : TInterface "Gst" "Buffer" + CUInt -> -- flags : TInterface "GstBase" "BaseParseFrameFlags" + Int32 -> -- overhead : TBasicType TInt32 + IO (Ptr BaseParseFrame) + + +baseParseFrameNew :: + (MonadIO m) => + Gst.Buffer -- buffer + -> [BaseParseFrameFlags] -- flags + -> Int32 -- overhead + -> m BaseParseFrame -- result +baseParseFrameNew buffer flags overhead = liftIO $ do + let buffer' = unsafeManagedPtrGetPtr buffer + let flags' = gflagsToWord flags + result <- gst_base_parse_frame_new buffer' flags' overhead + checkUnexpectedReturnNULL "gst_base_parse_frame_new" result + result' <- (wrapBoxed BaseParseFrame) result + touchManagedPtr buffer + return result' + +-- method BaseParseFrame::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParseFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_frame_free" gst_base_parse_frame_free :: + Ptr BaseParseFrame -> -- _obj : TInterface "GstBase" "BaseParseFrame" + IO () + + +baseParseFrameFree :: + (MonadIO m) => + BaseParseFrame -- _obj + -> m () -- result +baseParseFrameFree _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + gst_base_parse_frame_free _obj' + touchManagedPtr _obj + return () + +data BaseParseFrameFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => MethodInfo BaseParseFrameFreeMethodInfo BaseParseFrame signature where + overloadedMethod _ = baseParseFrameFree + +-- method BaseParseFrame::init +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BaseParseFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_base_parse_frame_init" gst_base_parse_frame_init :: + Ptr BaseParseFrame -> -- _obj : TInterface "GstBase" "BaseParseFrame" + IO () + + +baseParseFrameInit :: + (MonadIO m) => + BaseParseFrame -- _obj + -> m () -- result +baseParseFrameInit _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + gst_base_parse_frame_init _obj' + touchManagedPtr _obj + return () + +data BaseParseFrameInitMethodInfo +instance (signature ~ (m ()), MonadIO m) => MethodInfo BaseParseFrameInitMethodInfo BaseParseFrame signature where + overloadedMethod _ = baseParseFrameInit + +type family ResolveBaseParseFrameMethod (t :: Symbol) (o :: *) :: * where + ResolveBaseParseFrameMethod "free" o = BaseParseFrameFreeMethodInfo + ResolveBaseParseFrameMethod "init" o = BaseParseFrameInitMethodInfo + ResolveBaseParseFrameMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolveBaseParseFrameMethod t BaseParseFrame, MethodInfo info BaseParseFrame p) => IsLabelProxy t (BaseParseFrame -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolveBaseParseFrameMethod t BaseParseFrame, MethodInfo info BaseParseFrame p) => IsLabel t (BaseParseFrame -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + + diff --git a/GI/GstBase/Structs/BaseParseFrame.hs-boot b/GI/GstBase/Structs/BaseParseFrame.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Structs/BaseParseFrame.hs-boot @@ -0,0 +1,13 @@ +module GI.GstBase.Structs.BaseParseFrame where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype BaseParseFrame = BaseParseFrame (ForeignPtr BaseParseFrame) +instance BoxedObject BaseParseFrame where +data BaseParseFrameFreeMethodInfo +data BaseParseFrameInitMethodInfo diff --git a/GI/GstBase/Structs/BitReader.hs b/GI/GstBase/Structs/BitReader.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Structs/BitReader.hs @@ -0,0 +1,685 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) + +#GstBitReader provides a bit reader that can read any number of bits +from a memory buffer. It provides functions for reading any number of bits +into 8, 16, 32 and 64 bit variables. +-} + +module GI.GstBase.Structs.BitReader + ( + +-- * Exported types + BitReader(..) , + newZeroBitReader , + noBitReader , + + + -- * Methods +-- ** bitReaderFree + BitReaderFreeMethodInfo , + bitReaderFree , + + +-- ** bitReaderGetBitsUint16 + BitReaderGetBitsUint16MethodInfo , + bitReaderGetBitsUint16 , + + +-- ** bitReaderGetBitsUint32 + BitReaderGetBitsUint32MethodInfo , + bitReaderGetBitsUint32 , + + +-- ** bitReaderGetBitsUint64 + BitReaderGetBitsUint64MethodInfo , + bitReaderGetBitsUint64 , + + +-- ** bitReaderGetBitsUint8 + BitReaderGetBitsUint8MethodInfo , + bitReaderGetBitsUint8 , + + +-- ** bitReaderGetPos + BitReaderGetPosMethodInfo , + bitReaderGetPos , + + +-- ** bitReaderGetRemaining + BitReaderGetRemainingMethodInfo , + bitReaderGetRemaining , + + +-- ** bitReaderGetSize + BitReaderGetSizeMethodInfo , + bitReaderGetSize , + + +-- ** bitReaderInit + BitReaderInitMethodInfo , + bitReaderInit , + + +-- ** bitReaderPeekBitsUint16 + BitReaderPeekBitsUint16MethodInfo , + bitReaderPeekBitsUint16 , + + +-- ** bitReaderPeekBitsUint32 + BitReaderPeekBitsUint32MethodInfo , + bitReaderPeekBitsUint32 , + + +-- ** bitReaderPeekBitsUint64 + BitReaderPeekBitsUint64MethodInfo , + bitReaderPeekBitsUint64 , + + +-- ** bitReaderPeekBitsUint8 + BitReaderPeekBitsUint8MethodInfo , + bitReaderPeekBitsUint8 , + + +-- ** bitReaderSetPos + BitReaderSetPosMethodInfo , + bitReaderSetPos , + + +-- ** bitReaderSkip + BitReaderSkipMethodInfo , + bitReaderSkip , + + +-- ** bitReaderSkipToByte + BitReaderSkipToByteMethodInfo , + bitReaderSkipToByte , + + + + + -- * Properties +-- ** Bit + bitReaderReadBit , + + +-- ** Byte + bitReaderReadByte , + + +-- ** Size + bitReaderReadSize , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks + +newtype BitReader = BitReader (ForeignPtr BitReader) +-- | Construct a `BitReader` struct initialized to zero. +newZeroBitReader :: MonadIO m => m BitReader +newZeroBitReader = liftIO $ callocBytes 56 >>= wrapPtr BitReader + +noBitReader :: Maybe BitReader +noBitReader = Nothing + +-- XXX Skipped getter for "BitReader:data" :: Not implemented: "Don't know how to unpack C array of type TCArray False (-1) 1 (TBasicType TUInt8)" + +bitReaderReadSize :: BitReader -> IO Word32 +bitReaderReadSize s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO Word32 + return val + +bitReaderReadByte :: BitReader -> IO Word32 +bitReaderReadByte s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 12) :: IO Word32 + return val + +bitReaderReadBit :: BitReader -> IO Word32 +bitReaderReadBit s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO Word32 + return val + +-- method BitReader::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_free" gst_bit_reader_free :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + IO () + + +bitReaderFree :: + (MonadIO m) => + BitReader -- _obj + -> m () -- result +bitReaderFree _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + gst_bit_reader_free _obj' + touchManagedPtr _obj + return () + +data BitReaderFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => MethodInfo BitReaderFreeMethodInfo BitReader signature where + overloadedMethod _ = bitReaderFree + +-- method BitReader::get_bits_uint16 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt16, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_get_bits_uint16" gst_bit_reader_get_bits_uint16 :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + Ptr Word16 -> -- val : TBasicType TUInt16 + Word32 -> -- nbits : TBasicType TUInt32 + IO CInt + + +bitReaderGetBitsUint16 :: + (MonadIO m) => + BitReader -- _obj + -> Word32 -- nbits + -> m (Bool,Word16) -- result +bitReaderGetBitsUint16 _obj nbits = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word16) + result <- gst_bit_reader_get_bits_uint16 _obj' val nbits + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data BitReaderGetBitsUint16MethodInfo +instance (signature ~ (Word32 -> m (Bool,Word16)), MonadIO m) => MethodInfo BitReaderGetBitsUint16MethodInfo BitReader signature where + overloadedMethod _ = bitReaderGetBitsUint16 + +-- method BitReader::get_bits_uint32 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_get_bits_uint32" gst_bit_reader_get_bits_uint32 :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + Ptr Word32 -> -- val : TBasicType TUInt32 + Word32 -> -- nbits : TBasicType TUInt32 + IO CInt + + +bitReaderGetBitsUint32 :: + (MonadIO m) => + BitReader -- _obj + -> Word32 -- nbits + -> m (Bool,Word32) -- result +bitReaderGetBitsUint32 _obj nbits = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word32) + result <- gst_bit_reader_get_bits_uint32 _obj' val nbits + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data BitReaderGetBitsUint32MethodInfo +instance (signature ~ (Word32 -> m (Bool,Word32)), MonadIO m) => MethodInfo BitReaderGetBitsUint32MethodInfo BitReader signature where + overloadedMethod _ = bitReaderGetBitsUint32 + +-- method BitReader::get_bits_uint64 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_get_bits_uint64" gst_bit_reader_get_bits_uint64 :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + Ptr Word64 -> -- val : TBasicType TUInt64 + Word32 -> -- nbits : TBasicType TUInt32 + IO CInt + + +bitReaderGetBitsUint64 :: + (MonadIO m) => + BitReader -- _obj + -> Word32 -- nbits + -> m (Bool,Word64) -- result +bitReaderGetBitsUint64 _obj nbits = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word64) + result <- gst_bit_reader_get_bits_uint64 _obj' val nbits + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data BitReaderGetBitsUint64MethodInfo +instance (signature ~ (Word32 -> m (Bool,Word64)), MonadIO m) => MethodInfo BitReaderGetBitsUint64MethodInfo BitReader signature where + overloadedMethod _ = bitReaderGetBitsUint64 + +-- method BitReader::get_bits_uint8 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_get_bits_uint8" gst_bit_reader_get_bits_uint8 :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + Ptr Word8 -> -- val : TBasicType TUInt8 + Word32 -> -- nbits : TBasicType TUInt32 + IO CInt + + +bitReaderGetBitsUint8 :: + (MonadIO m) => + BitReader -- _obj + -> Word32 -- nbits + -> m (Bool,Word8) -- result +bitReaderGetBitsUint8 _obj nbits = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word8) + result <- gst_bit_reader_get_bits_uint8 _obj' val nbits + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data BitReaderGetBitsUint8MethodInfo +instance (signature ~ (Word32 -> m (Bool,Word8)), MonadIO m) => MethodInfo BitReaderGetBitsUint8MethodInfo BitReader signature where + overloadedMethod _ = bitReaderGetBitsUint8 + +-- method BitReader::get_pos +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt32 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_get_pos" gst_bit_reader_get_pos :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + IO Word32 + + +bitReaderGetPos :: + (MonadIO m) => + BitReader -- _obj + -> m Word32 -- result +bitReaderGetPos _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_bit_reader_get_pos _obj' + touchManagedPtr _obj + return result + +data BitReaderGetPosMethodInfo +instance (signature ~ (m Word32), MonadIO m) => MethodInfo BitReaderGetPosMethodInfo BitReader signature where + overloadedMethod _ = bitReaderGetPos + +-- method BitReader::get_remaining +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt32 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_get_remaining" gst_bit_reader_get_remaining :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + IO Word32 + + +bitReaderGetRemaining :: + (MonadIO m) => + BitReader -- _obj + -> m Word32 -- result +bitReaderGetRemaining _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_bit_reader_get_remaining _obj' + touchManagedPtr _obj + return result + +data BitReaderGetRemainingMethodInfo +instance (signature ~ (m Word32), MonadIO m) => MethodInfo BitReaderGetRemainingMethodInfo BitReader signature where + overloadedMethod _ = bitReaderGetRemaining + +-- method BitReader::get_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt32 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_get_size" gst_bit_reader_get_size :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + IO Word32 + + +bitReaderGetSize :: + (MonadIO m) => + BitReader -- _obj + -> m Word32 -- result +bitReaderGetSize _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_bit_reader_get_size _obj' + touchManagedPtr _obj + return result + +data BitReaderGetSizeMethodInfo +instance (signature ~ (m Word32), MonadIO m) => MethodInfo BitReaderGetSizeMethodInfo BitReader signature where + overloadedMethod _ = bitReaderGetSize + +-- method BitReader::init +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_init" gst_bit_reader_init :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + Ptr Word8 -> -- data : TCArray False (-1) 2 (TBasicType TUInt8) + Word32 -> -- size : TBasicType TUInt32 + IO () + + +bitReaderInit :: + (MonadIO m) => + BitReader -- _obj + -> ByteString -- data_ + -> m () -- result +bitReaderInit _obj data_ = liftIO $ do + let size = fromIntegral $ B.length data_ + let _obj' = unsafeManagedPtrGetPtr _obj + data_' <- packByteString data_ + gst_bit_reader_init _obj' data_' size + touchManagedPtr _obj + freeMem data_' + return () + +data BitReaderInitMethodInfo +instance (signature ~ (ByteString -> m ()), MonadIO m) => MethodInfo BitReaderInitMethodInfo BitReader signature where + overloadedMethod _ = bitReaderInit + +-- method BitReader::peek_bits_uint16 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt16, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_peek_bits_uint16" gst_bit_reader_peek_bits_uint16 :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + Ptr Word16 -> -- val : TBasicType TUInt16 + Word32 -> -- nbits : TBasicType TUInt32 + IO CInt + + +bitReaderPeekBitsUint16 :: + (MonadIO m) => + BitReader -- _obj + -> Word32 -- nbits + -> m (Bool,Word16) -- result +bitReaderPeekBitsUint16 _obj nbits = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word16) + result <- gst_bit_reader_peek_bits_uint16 _obj' val nbits + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data BitReaderPeekBitsUint16MethodInfo +instance (signature ~ (Word32 -> m (Bool,Word16)), MonadIO m) => MethodInfo BitReaderPeekBitsUint16MethodInfo BitReader signature where + overloadedMethod _ = bitReaderPeekBitsUint16 + +-- method BitReader::peek_bits_uint32 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_peek_bits_uint32" gst_bit_reader_peek_bits_uint32 :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + Ptr Word32 -> -- val : TBasicType TUInt32 + Word32 -> -- nbits : TBasicType TUInt32 + IO CInt + + +bitReaderPeekBitsUint32 :: + (MonadIO m) => + BitReader -- _obj + -> Word32 -- nbits + -> m (Bool,Word32) -- result +bitReaderPeekBitsUint32 _obj nbits = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word32) + result <- gst_bit_reader_peek_bits_uint32 _obj' val nbits + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data BitReaderPeekBitsUint32MethodInfo +instance (signature ~ (Word32 -> m (Bool,Word32)), MonadIO m) => MethodInfo BitReaderPeekBitsUint32MethodInfo BitReader signature where + overloadedMethod _ = bitReaderPeekBitsUint32 + +-- method BitReader::peek_bits_uint64 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_peek_bits_uint64" gst_bit_reader_peek_bits_uint64 :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + Ptr Word64 -> -- val : TBasicType TUInt64 + Word32 -> -- nbits : TBasicType TUInt32 + IO CInt + + +bitReaderPeekBitsUint64 :: + (MonadIO m) => + BitReader -- _obj + -> Word32 -- nbits + -> m (Bool,Word64) -- result +bitReaderPeekBitsUint64 _obj nbits = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word64) + result <- gst_bit_reader_peek_bits_uint64 _obj' val nbits + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data BitReaderPeekBitsUint64MethodInfo +instance (signature ~ (Word32 -> m (Bool,Word64)), MonadIO m) => MethodInfo BitReaderPeekBitsUint64MethodInfo BitReader signature where + overloadedMethod _ = bitReaderPeekBitsUint64 + +-- method BitReader::peek_bits_uint8 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nbits", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_peek_bits_uint8" gst_bit_reader_peek_bits_uint8 :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + Ptr Word8 -> -- val : TBasicType TUInt8 + Word32 -> -- nbits : TBasicType TUInt32 + IO CInt + + +bitReaderPeekBitsUint8 :: + (MonadIO m) => + BitReader -- _obj + -> Word32 -- nbits + -> m (Bool,Word8) -- result +bitReaderPeekBitsUint8 _obj nbits = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word8) + result <- gst_bit_reader_peek_bits_uint8 _obj' val nbits + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data BitReaderPeekBitsUint8MethodInfo +instance (signature ~ (Word32 -> m (Bool,Word8)), MonadIO m) => MethodInfo BitReaderPeekBitsUint8MethodInfo BitReader signature where + overloadedMethod _ = bitReaderPeekBitsUint8 + +-- method BitReader::set_pos +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_set_pos" gst_bit_reader_set_pos :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + Word32 -> -- pos : TBasicType TUInt32 + IO CInt + + +bitReaderSetPos :: + (MonadIO m) => + BitReader -- _obj + -> Word32 -- pos + -> m Bool -- result +bitReaderSetPos _obj pos = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_bit_reader_set_pos _obj' pos + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BitReaderSetPosMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo BitReaderSetPosMethodInfo BitReader signature where + overloadedMethod _ = bitReaderSetPos + +-- method BitReader::skip +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nbits", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_skip" gst_bit_reader_skip :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + Word32 -> -- nbits : TBasicType TUInt32 + IO CInt + + +bitReaderSkip :: + (MonadIO m) => + BitReader -- _obj + -> Word32 -- nbits + -> m Bool -- result +bitReaderSkip _obj nbits = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_bit_reader_skip _obj' nbits + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BitReaderSkipMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo BitReaderSkipMethodInfo BitReader signature where + overloadedMethod _ = bitReaderSkip + +-- method BitReader::skip_to_byte +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "BitReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_bit_reader_skip_to_byte" gst_bit_reader_skip_to_byte :: + Ptr BitReader -> -- _obj : TInterface "GstBase" "BitReader" + IO CInt + + +bitReaderSkipToByte :: + (MonadIO m) => + BitReader -- _obj + -> m Bool -- result +bitReaderSkipToByte _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_bit_reader_skip_to_byte _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data BitReaderSkipToByteMethodInfo +instance (signature ~ (m Bool), MonadIO m) => MethodInfo BitReaderSkipToByteMethodInfo BitReader signature where + overloadedMethod _ = bitReaderSkipToByte + +type family ResolveBitReaderMethod (t :: Symbol) (o :: *) :: * where + ResolveBitReaderMethod "free" o = BitReaderFreeMethodInfo + ResolveBitReaderMethod "init" o = BitReaderInitMethodInfo + ResolveBitReaderMethod "peekBitsUint16" o = BitReaderPeekBitsUint16MethodInfo + ResolveBitReaderMethod "peekBitsUint32" o = BitReaderPeekBitsUint32MethodInfo + ResolveBitReaderMethod "peekBitsUint64" o = BitReaderPeekBitsUint64MethodInfo + ResolveBitReaderMethod "peekBitsUint8" o = BitReaderPeekBitsUint8MethodInfo + ResolveBitReaderMethod "skip" o = BitReaderSkipMethodInfo + ResolveBitReaderMethod "skipToByte" o = BitReaderSkipToByteMethodInfo + ResolveBitReaderMethod "getBitsUint16" o = BitReaderGetBitsUint16MethodInfo + ResolveBitReaderMethod "getBitsUint32" o = BitReaderGetBitsUint32MethodInfo + ResolveBitReaderMethod "getBitsUint64" o = BitReaderGetBitsUint64MethodInfo + ResolveBitReaderMethod "getBitsUint8" o = BitReaderGetBitsUint8MethodInfo + ResolveBitReaderMethod "getPos" o = BitReaderGetPosMethodInfo + ResolveBitReaderMethod "getRemaining" o = BitReaderGetRemainingMethodInfo + ResolveBitReaderMethod "getSize" o = BitReaderGetSizeMethodInfo + ResolveBitReaderMethod "setPos" o = BitReaderSetPosMethodInfo + ResolveBitReaderMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolveBitReaderMethod t BitReader, MethodInfo info BitReader p) => IsLabelProxy t (BitReader -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolveBitReaderMethod t BitReader, MethodInfo info BitReader p) => IsLabel t (BitReader -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + + diff --git a/GI/GstBase/Structs/BitReader.hs-boot b/GI/GstBase/Structs/BitReader.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Structs/BitReader.hs-boot @@ -0,0 +1,26 @@ +module GI.GstBase.Structs.BitReader where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype BitReader = BitReader (ForeignPtr BitReader) +data BitReaderFreeMethodInfo +data BitReaderGetBitsUint16MethodInfo +data BitReaderGetBitsUint32MethodInfo +data BitReaderGetBitsUint64MethodInfo +data BitReaderGetBitsUint8MethodInfo +data BitReaderGetPosMethodInfo +data BitReaderGetRemainingMethodInfo +data BitReaderGetSizeMethodInfo +data BitReaderInitMethodInfo +data BitReaderPeekBitsUint16MethodInfo +data BitReaderPeekBitsUint32MethodInfo +data BitReaderPeekBitsUint64MethodInfo +data BitReaderPeekBitsUint8MethodInfo +data BitReaderSetPosMethodInfo +data BitReaderSkipMethodInfo +data BitReaderSkipToByteMethodInfo diff --git a/GI/GstBase/Structs/ByteReader.hs b/GI/GstBase/Structs/ByteReader.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Structs/ByteReader.hs @@ -0,0 +1,2520 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) + +#GstByteReader provides a byte reader that can read different integer and +floating point types from a memory buffer. It provides functions for reading +signed/unsigned, little/big endian integers of 8, 16, 24, 32 and 64 bits +and functions for reading little/big endian floating points numbers of +32 and 64 bits. It also provides functions to read NUL-terminated strings +in various character encodings. +-} + +module GI.GstBase.Structs.ByteReader + ( + +-- * Exported types + ByteReader(..) , + newZeroByteReader , + noByteReader , + + + -- * Methods +-- ** byteReaderDupData + ByteReaderDupDataMethodInfo , + byteReaderDupData , + + +-- ** byteReaderDupStringUtf16 + ByteReaderDupStringUtf16MethodInfo , + byteReaderDupStringUtf16 , + + +-- ** byteReaderDupStringUtf32 + ByteReaderDupStringUtf32MethodInfo , + byteReaderDupStringUtf32 , + + +-- ** byteReaderDupStringUtf8 + ByteReaderDupStringUtf8MethodInfo , + byteReaderDupStringUtf8 , + + +-- ** byteReaderFree + ByteReaderFreeMethodInfo , + byteReaderFree , + + +-- ** byteReaderGetData + ByteReaderGetDataMethodInfo , + byteReaderGetData , + + +-- ** byteReaderGetFloat32Be + ByteReaderGetFloat32BeMethodInfo , + byteReaderGetFloat32Be , + + +-- ** byteReaderGetFloat32Le + ByteReaderGetFloat32LeMethodInfo , + byteReaderGetFloat32Le , + + +-- ** byteReaderGetFloat64Be + ByteReaderGetFloat64BeMethodInfo , + byteReaderGetFloat64Be , + + +-- ** byteReaderGetFloat64Le + ByteReaderGetFloat64LeMethodInfo , + byteReaderGetFloat64Le , + + +-- ** byteReaderGetInt16Be + ByteReaderGetInt16BeMethodInfo , + byteReaderGetInt16Be , + + +-- ** byteReaderGetInt16Le + ByteReaderGetInt16LeMethodInfo , + byteReaderGetInt16Le , + + +-- ** byteReaderGetInt24Be + ByteReaderGetInt24BeMethodInfo , + byteReaderGetInt24Be , + + +-- ** byteReaderGetInt24Le + ByteReaderGetInt24LeMethodInfo , + byteReaderGetInt24Le , + + +-- ** byteReaderGetInt32Be + ByteReaderGetInt32BeMethodInfo , + byteReaderGetInt32Be , + + +-- ** byteReaderGetInt32Le + ByteReaderGetInt32LeMethodInfo , + byteReaderGetInt32Le , + + +-- ** byteReaderGetInt64Be + ByteReaderGetInt64BeMethodInfo , + byteReaderGetInt64Be , + + +-- ** byteReaderGetInt64Le + ByteReaderGetInt64LeMethodInfo , + byteReaderGetInt64Le , + + +-- ** byteReaderGetInt8 + ByteReaderGetInt8MethodInfo , + byteReaderGetInt8 , + + +-- ** byteReaderGetPos + ByteReaderGetPosMethodInfo , + byteReaderGetPos , + + +-- ** byteReaderGetRemaining + ByteReaderGetRemainingMethodInfo , + byteReaderGetRemaining , + + +-- ** byteReaderGetSize + ByteReaderGetSizeMethodInfo , + byteReaderGetSize , + + +-- ** byteReaderGetStringUtf8 + ByteReaderGetStringUtf8MethodInfo , + byteReaderGetStringUtf8 , + + +-- ** byteReaderGetUint16Be + ByteReaderGetUint16BeMethodInfo , + byteReaderGetUint16Be , + + +-- ** byteReaderGetUint16Le + ByteReaderGetUint16LeMethodInfo , + byteReaderGetUint16Le , + + +-- ** byteReaderGetUint24Be + ByteReaderGetUint24BeMethodInfo , + byteReaderGetUint24Be , + + +-- ** byteReaderGetUint24Le + ByteReaderGetUint24LeMethodInfo , + byteReaderGetUint24Le , + + +-- ** byteReaderGetUint32Be + ByteReaderGetUint32BeMethodInfo , + byteReaderGetUint32Be , + + +-- ** byteReaderGetUint32Le + ByteReaderGetUint32LeMethodInfo , + byteReaderGetUint32Le , + + +-- ** byteReaderGetUint64Be + ByteReaderGetUint64BeMethodInfo , + byteReaderGetUint64Be , + + +-- ** byteReaderGetUint64Le + ByteReaderGetUint64LeMethodInfo , + byteReaderGetUint64Le , + + +-- ** byteReaderGetUint8 + ByteReaderGetUint8MethodInfo , + byteReaderGetUint8 , + + +-- ** byteReaderInit + ByteReaderInitMethodInfo , + byteReaderInit , + + +-- ** byteReaderMaskedScanUint32 + ByteReaderMaskedScanUint32MethodInfo , + byteReaderMaskedScanUint32 , + + +-- ** byteReaderMaskedScanUint32Peek + ByteReaderMaskedScanUint32PeekMethodInfo, + byteReaderMaskedScanUint32Peek , + + +-- ** byteReaderPeekData + ByteReaderPeekDataMethodInfo , + byteReaderPeekData , + + +-- ** byteReaderPeekFloat32Be + ByteReaderPeekFloat32BeMethodInfo , + byteReaderPeekFloat32Be , + + +-- ** byteReaderPeekFloat32Le + ByteReaderPeekFloat32LeMethodInfo , + byteReaderPeekFloat32Le , + + +-- ** byteReaderPeekFloat64Be + ByteReaderPeekFloat64BeMethodInfo , + byteReaderPeekFloat64Be , + + +-- ** byteReaderPeekFloat64Le + ByteReaderPeekFloat64LeMethodInfo , + byteReaderPeekFloat64Le , + + +-- ** byteReaderPeekInt16Be + ByteReaderPeekInt16BeMethodInfo , + byteReaderPeekInt16Be , + + +-- ** byteReaderPeekInt16Le + ByteReaderPeekInt16LeMethodInfo , + byteReaderPeekInt16Le , + + +-- ** byteReaderPeekInt24Be + ByteReaderPeekInt24BeMethodInfo , + byteReaderPeekInt24Be , + + +-- ** byteReaderPeekInt24Le + ByteReaderPeekInt24LeMethodInfo , + byteReaderPeekInt24Le , + + +-- ** byteReaderPeekInt32Be + ByteReaderPeekInt32BeMethodInfo , + byteReaderPeekInt32Be , + + +-- ** byteReaderPeekInt32Le + ByteReaderPeekInt32LeMethodInfo , + byteReaderPeekInt32Le , + + +-- ** byteReaderPeekInt64Be + ByteReaderPeekInt64BeMethodInfo , + byteReaderPeekInt64Be , + + +-- ** byteReaderPeekInt64Le + ByteReaderPeekInt64LeMethodInfo , + byteReaderPeekInt64Le , + + +-- ** byteReaderPeekInt8 + ByteReaderPeekInt8MethodInfo , + byteReaderPeekInt8 , + + +-- ** byteReaderPeekStringUtf8 + ByteReaderPeekStringUtf8MethodInfo , + byteReaderPeekStringUtf8 , + + +-- ** byteReaderPeekUint16Be + ByteReaderPeekUint16BeMethodInfo , + byteReaderPeekUint16Be , + + +-- ** byteReaderPeekUint16Le + ByteReaderPeekUint16LeMethodInfo , + byteReaderPeekUint16Le , + + +-- ** byteReaderPeekUint24Be + ByteReaderPeekUint24BeMethodInfo , + byteReaderPeekUint24Be , + + +-- ** byteReaderPeekUint24Le + ByteReaderPeekUint24LeMethodInfo , + byteReaderPeekUint24Le , + + +-- ** byteReaderPeekUint32Be + ByteReaderPeekUint32BeMethodInfo , + byteReaderPeekUint32Be , + + +-- ** byteReaderPeekUint32Le + ByteReaderPeekUint32LeMethodInfo , + byteReaderPeekUint32Le , + + +-- ** byteReaderPeekUint64Be + ByteReaderPeekUint64BeMethodInfo , + byteReaderPeekUint64Be , + + +-- ** byteReaderPeekUint64Le + ByteReaderPeekUint64LeMethodInfo , + byteReaderPeekUint64Le , + + +-- ** byteReaderPeekUint8 + ByteReaderPeekUint8MethodInfo , + byteReaderPeekUint8 , + + +-- ** byteReaderSetPos + ByteReaderSetPosMethodInfo , + byteReaderSetPos , + + +-- ** byteReaderSkip + ByteReaderSkipMethodInfo , + byteReaderSkip , + + +-- ** byteReaderSkipStringUtf16 + ByteReaderSkipStringUtf16MethodInfo , + byteReaderSkipStringUtf16 , + + +-- ** byteReaderSkipStringUtf32 + ByteReaderSkipStringUtf32MethodInfo , + byteReaderSkipStringUtf32 , + + +-- ** byteReaderSkipStringUtf8 + ByteReaderSkipStringUtf8MethodInfo , + byteReaderSkipStringUtf8 , + + + + + -- * Properties +-- ** Byte + byteReaderReadByte , + + +-- ** Size + byteReaderReadSize , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks + +newtype ByteReader = ByteReader (ForeignPtr ByteReader) +-- | Construct a `ByteReader` struct initialized to zero. +newZeroByteReader :: MonadIO m => m ByteReader +newZeroByteReader = liftIO $ callocBytes 48 >>= wrapPtr ByteReader + +noByteReader :: Maybe ByteReader +noByteReader = Nothing + +-- XXX Skipped getter for "ByteReader:data" :: Not implemented: "Don't know how to unpack C array of type TCArray False (-1) 1 (TBasicType TUInt8)" + +byteReaderReadSize :: ByteReader -> IO Word32 +byteReaderReadSize s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO Word32 + return val + +byteReaderReadByte :: ByteReader -> IO Word32 +byteReaderReadByte s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 12) :: IO Word32 + return val + +-- method ByteReader::dup_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "val", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_dup_data" gst_byte_reader_dup_data :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word32 -> -- size : TBasicType TUInt32 + Ptr (Ptr Word8) -> -- val : TCArray False (-1) 1 (TBasicType TUInt8) + IO CInt + + +byteReaderDupData :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,ByteString) -- result +byteReaderDupData _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + size <- allocMem :: IO (Ptr Word32) + val <- allocMem :: IO (Ptr (Ptr Word8)) + result <- gst_byte_reader_dup_data _obj' size val + size' <- peek size + let result' = (/= 0) result + val' <- peek val + val'' <- (unpackByteStringWithLength size') val' + freeMem val' + touchManagedPtr _obj + freeMem size + freeMem val + return (result', val'') + +data ByteReaderDupDataMethodInfo +instance (signature ~ (m (Bool,ByteString)), MonadIO m) => MethodInfo ByteReaderDupDataMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderDupData + +-- method ByteReader::dup_string_utf16 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str", argType = TCArray True (-1) (-1) (TBasicType TUInt16), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_dup_string_utf16" gst_byte_reader_dup_string_utf16 :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr (Ptr Word16) -> -- str : TCArray True (-1) (-1) (TBasicType TUInt16) + IO CInt + + +byteReaderDupStringUtf16 :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,[Word16]) -- result +byteReaderDupStringUtf16 _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + str <- allocMem :: IO (Ptr (Ptr Word16)) + result <- gst_byte_reader_dup_string_utf16 _obj' str + let result' = (/= 0) result + str' <- peek str + str'' <- unpackZeroTerminatedStorableArray str' + freeMem str' + touchManagedPtr _obj + freeMem str + return (result', str'') + +data ByteReaderDupStringUtf16MethodInfo +instance (signature ~ (m (Bool,[Word16])), MonadIO m) => MethodInfo ByteReaderDupStringUtf16MethodInfo ByteReader signature where + overloadedMethod _ = byteReaderDupStringUtf16 + +-- method ByteReader::dup_string_utf32 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str", argType = TCArray True (-1) (-1) (TBasicType TUInt32), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_dup_string_utf32" gst_byte_reader_dup_string_utf32 :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr (Ptr Word32) -> -- str : TCArray True (-1) (-1) (TBasicType TUInt32) + IO CInt + + +byteReaderDupStringUtf32 :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,[Word32]) -- result +byteReaderDupStringUtf32 _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + str <- allocMem :: IO (Ptr (Ptr Word32)) + result <- gst_byte_reader_dup_string_utf32 _obj' str + let result' = (/= 0) result + str' <- peek str + str'' <- unpackZeroTerminatedStorableArray str' + freeMem str' + touchManagedPtr _obj + freeMem str + return (result', str'') + +data ByteReaderDupStringUtf32MethodInfo +instance (signature ~ (m (Bool,[Word32])), MonadIO m) => MethodInfo ByteReaderDupStringUtf32MethodInfo ByteReader signature where + overloadedMethod _ = byteReaderDupStringUtf32 + +-- method ByteReader::dup_string_utf8 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_dup_string_utf8" gst_byte_reader_dup_string_utf8 :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr (Ptr CString) -> -- str : TCArray True (-1) (-1) (TBasicType TUTF8) + IO CInt + + +byteReaderDupStringUtf8 :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,[T.Text]) -- result +byteReaderDupStringUtf8 _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + str <- allocMem :: IO (Ptr (Ptr CString)) + result <- gst_byte_reader_dup_string_utf8 _obj' str + let result' = (/= 0) result + str' <- peek str + str'' <- unpackZeroTerminatedUTF8CArray str' + mapZeroTerminatedCArray freeMem str' + freeMem str' + touchManagedPtr _obj + freeMem str + return (result', str'') + +data ByteReaderDupStringUtf8MethodInfo +instance (signature ~ (m (Bool,[T.Text])), MonadIO m) => MethodInfo ByteReaderDupStringUtf8MethodInfo ByteReader signature where + overloadedMethod _ = byteReaderDupStringUtf8 + +-- method ByteReader::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_free" gst_byte_reader_free :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + IO () + + +byteReaderFree :: + (MonadIO m) => + ByteReader -- _obj + -> m () -- result +byteReaderFree _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + gst_byte_reader_free _obj' + touchManagedPtr _obj + return () + +data ByteReaderFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => MethodInfo ByteReaderFreeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderFree + +-- method ByteReader::get_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "val", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_data" gst_byte_reader_get_data :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word32 -> -- size : TBasicType TUInt32 + Ptr (Ptr Word8) -> -- val : TCArray False (-1) 1 (TBasicType TUInt8) + IO CInt + + +byteReaderGetData :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,ByteString) -- result +byteReaderGetData _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + size <- allocMem :: IO (Ptr Word32) + val <- allocMem :: IO (Ptr (Ptr Word8)) + result <- gst_byte_reader_get_data _obj' size val + size' <- peek size + let result' = (/= 0) result + val' <- peek val + val'' <- (unpackByteStringWithLength size') val' + touchManagedPtr _obj + freeMem size + freeMem val + return (result', val'') + +data ByteReaderGetDataMethodInfo +instance (signature ~ (m (Bool,ByteString)), MonadIO m) => MethodInfo ByteReaderGetDataMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetData + +-- method ByteReader::get_float32_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_float32_be" gst_byte_reader_get_float32_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr CFloat -> -- val : TBasicType TFloat + IO CInt + + +byteReaderGetFloat32Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Float) -- result +byteReaderGetFloat32Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr CFloat) + result <- gst_byte_reader_get_float32_be _obj' val + let result' = (/= 0) result + val' <- peek val + let val'' = realToFrac val' + touchManagedPtr _obj + freeMem val + return (result', val'') + +data ByteReaderGetFloat32BeMethodInfo +instance (signature ~ (m (Bool,Float)), MonadIO m) => MethodInfo ByteReaderGetFloat32BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetFloat32Be + +-- method ByteReader::get_float32_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_float32_le" gst_byte_reader_get_float32_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr CFloat -> -- val : TBasicType TFloat + IO CInt + + +byteReaderGetFloat32Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Float) -- result +byteReaderGetFloat32Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr CFloat) + result <- gst_byte_reader_get_float32_le _obj' val + let result' = (/= 0) result + val' <- peek val + let val'' = realToFrac val' + touchManagedPtr _obj + freeMem val + return (result', val'') + +data ByteReaderGetFloat32LeMethodInfo +instance (signature ~ (m (Bool,Float)), MonadIO m) => MethodInfo ByteReaderGetFloat32LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetFloat32Le + +-- method ByteReader::get_float64_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_float64_be" gst_byte_reader_get_float64_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr CDouble -> -- val : TBasicType TDouble + IO CInt + + +byteReaderGetFloat64Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Double) -- result +byteReaderGetFloat64Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr CDouble) + result <- gst_byte_reader_get_float64_be _obj' val + let result' = (/= 0) result + val' <- peek val + let val'' = realToFrac val' + touchManagedPtr _obj + freeMem val + return (result', val'') + +data ByteReaderGetFloat64BeMethodInfo +instance (signature ~ (m (Bool,Double)), MonadIO m) => MethodInfo ByteReaderGetFloat64BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetFloat64Be + +-- method ByteReader::get_float64_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_float64_le" gst_byte_reader_get_float64_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr CDouble -> -- val : TBasicType TDouble + IO CInt + + +byteReaderGetFloat64Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Double) -- result +byteReaderGetFloat64Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr CDouble) + result <- gst_byte_reader_get_float64_le _obj' val + let result' = (/= 0) result + val' <- peek val + let val'' = realToFrac val' + touchManagedPtr _obj + freeMem val + return (result', val'') + +data ByteReaderGetFloat64LeMethodInfo +instance (signature ~ (m (Bool,Double)), MonadIO m) => MethodInfo ByteReaderGetFloat64LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetFloat64Le + +-- method ByteReader::get_int16_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt16, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_int16_be" gst_byte_reader_get_int16_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int16 -> -- val : TBasicType TInt16 + IO CInt + + +byteReaderGetInt16Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int16) -- result +byteReaderGetInt16Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int16) + result <- gst_byte_reader_get_int16_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetInt16BeMethodInfo +instance (signature ~ (m (Bool,Int16)), MonadIO m) => MethodInfo ByteReaderGetInt16BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetInt16Be + +-- method ByteReader::get_int16_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt16, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_int16_le" gst_byte_reader_get_int16_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int16 -> -- val : TBasicType TInt16 + IO CInt + + +byteReaderGetInt16Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int16) -- result +byteReaderGetInt16Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int16) + result <- gst_byte_reader_get_int16_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetInt16LeMethodInfo +instance (signature ~ (m (Bool,Int16)), MonadIO m) => MethodInfo ByteReaderGetInt16LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetInt16Le + +-- method ByteReader::get_int24_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_int24_be" gst_byte_reader_get_int24_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int32 -> -- val : TBasicType TInt32 + IO CInt + + +byteReaderGetInt24Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int32) -- result +byteReaderGetInt24Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int32) + result <- gst_byte_reader_get_int24_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetInt24BeMethodInfo +instance (signature ~ (m (Bool,Int32)), MonadIO m) => MethodInfo ByteReaderGetInt24BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetInt24Be + +-- method ByteReader::get_int24_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_int24_le" gst_byte_reader_get_int24_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int32 -> -- val : TBasicType TInt32 + IO CInt + + +byteReaderGetInt24Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int32) -- result +byteReaderGetInt24Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int32) + result <- gst_byte_reader_get_int24_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetInt24LeMethodInfo +instance (signature ~ (m (Bool,Int32)), MonadIO m) => MethodInfo ByteReaderGetInt24LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetInt24Le + +-- method ByteReader::get_int32_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_int32_be" gst_byte_reader_get_int32_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int32 -> -- val : TBasicType TInt32 + IO CInt + + +byteReaderGetInt32Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int32) -- result +byteReaderGetInt32Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int32) + result <- gst_byte_reader_get_int32_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetInt32BeMethodInfo +instance (signature ~ (m (Bool,Int32)), MonadIO m) => MethodInfo ByteReaderGetInt32BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetInt32Be + +-- method ByteReader::get_int32_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_int32_le" gst_byte_reader_get_int32_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int32 -> -- val : TBasicType TInt32 + IO CInt + + +byteReaderGetInt32Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int32) -- result +byteReaderGetInt32Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int32) + result <- gst_byte_reader_get_int32_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetInt32LeMethodInfo +instance (signature ~ (m (Bool,Int32)), MonadIO m) => MethodInfo ByteReaderGetInt32LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetInt32Le + +-- method ByteReader::get_int64_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_int64_be" gst_byte_reader_get_int64_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int64 -> -- val : TBasicType TInt64 + IO CInt + + +byteReaderGetInt64Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int64) -- result +byteReaderGetInt64Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int64) + result <- gst_byte_reader_get_int64_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetInt64BeMethodInfo +instance (signature ~ (m (Bool,Int64)), MonadIO m) => MethodInfo ByteReaderGetInt64BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetInt64Be + +-- method ByteReader::get_int64_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_int64_le" gst_byte_reader_get_int64_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int64 -> -- val : TBasicType TInt64 + IO CInt + + +byteReaderGetInt64Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int64) -- result +byteReaderGetInt64Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int64) + result <- gst_byte_reader_get_int64_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetInt64LeMethodInfo +instance (signature ~ (m (Bool,Int64)), MonadIO m) => MethodInfo ByteReaderGetInt64LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetInt64Le + +-- method ByteReader::get_int8 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_int8" gst_byte_reader_get_int8 :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int8 -> -- val : TBasicType TInt8 + IO CInt + + +byteReaderGetInt8 :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int8) -- result +byteReaderGetInt8 _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int8) + result <- gst_byte_reader_get_int8 _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetInt8MethodInfo +instance (signature ~ (m (Bool,Int8)), MonadIO m) => MethodInfo ByteReaderGetInt8MethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetInt8 + +-- method ByteReader::get_pos +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt32 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_pos" gst_byte_reader_get_pos :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + IO Word32 + + +byteReaderGetPos :: + (MonadIO m) => + ByteReader -- _obj + -> m Word32 -- result +byteReaderGetPos _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_reader_get_pos _obj' + touchManagedPtr _obj + return result + +data ByteReaderGetPosMethodInfo +instance (signature ~ (m Word32), MonadIO m) => MethodInfo ByteReaderGetPosMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetPos + +-- method ByteReader::get_remaining +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt32 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_remaining" gst_byte_reader_get_remaining :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + IO Word32 + + +byteReaderGetRemaining :: + (MonadIO m) => + ByteReader -- _obj + -> m Word32 -- result +byteReaderGetRemaining _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_reader_get_remaining _obj' + touchManagedPtr _obj + return result + +data ByteReaderGetRemainingMethodInfo +instance (signature ~ (m Word32), MonadIO m) => MethodInfo ByteReaderGetRemainingMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetRemaining + +-- method ByteReader::get_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt32 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_size" gst_byte_reader_get_size :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + IO Word32 + + +byteReaderGetSize :: + (MonadIO m) => + ByteReader -- _obj + -> m Word32 -- result +byteReaderGetSize _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_reader_get_size _obj' + touchManagedPtr _obj + return result + +data ByteReaderGetSizeMethodInfo +instance (signature ~ (m Word32), MonadIO m) => MethodInfo ByteReaderGetSizeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetSize + +-- method ByteReader::get_string_utf8 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_string_utf8" gst_byte_reader_get_string_utf8 :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr (Ptr CString) -> -- str : TCArray True (-1) (-1) (TBasicType TUTF8) + IO CInt + + +byteReaderGetStringUtf8 :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,[T.Text]) -- result +byteReaderGetStringUtf8 _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + str <- allocMem :: IO (Ptr (Ptr CString)) + result <- gst_byte_reader_get_string_utf8 _obj' str + let result' = (/= 0) result + str' <- peek str + str'' <- unpackZeroTerminatedUTF8CArray str' + touchManagedPtr _obj + freeMem str + return (result', str'') + +data ByteReaderGetStringUtf8MethodInfo +instance (signature ~ (m (Bool,[T.Text])), MonadIO m) => MethodInfo ByteReaderGetStringUtf8MethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetStringUtf8 + +-- method ByteReader::get_uint16_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt16, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_uint16_be" gst_byte_reader_get_uint16_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word16 -> -- val : TBasicType TUInt16 + IO CInt + + +byteReaderGetUint16Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word16) -- result +byteReaderGetUint16Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word16) + result <- gst_byte_reader_get_uint16_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetUint16BeMethodInfo +instance (signature ~ (m (Bool,Word16)), MonadIO m) => MethodInfo ByteReaderGetUint16BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetUint16Be + +-- method ByteReader::get_uint16_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt16, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_uint16_le" gst_byte_reader_get_uint16_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word16 -> -- val : TBasicType TUInt16 + IO CInt + + +byteReaderGetUint16Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word16) -- result +byteReaderGetUint16Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word16) + result <- gst_byte_reader_get_uint16_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetUint16LeMethodInfo +instance (signature ~ (m (Bool,Word16)), MonadIO m) => MethodInfo ByteReaderGetUint16LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetUint16Le + +-- method ByteReader::get_uint24_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_uint24_be" gst_byte_reader_get_uint24_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word32 -> -- val : TBasicType TUInt32 + IO CInt + + +byteReaderGetUint24Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word32) -- result +byteReaderGetUint24Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word32) + result <- gst_byte_reader_get_uint24_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetUint24BeMethodInfo +instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo ByteReaderGetUint24BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetUint24Be + +-- method ByteReader::get_uint24_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_uint24_le" gst_byte_reader_get_uint24_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word32 -> -- val : TBasicType TUInt32 + IO CInt + + +byteReaderGetUint24Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word32) -- result +byteReaderGetUint24Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word32) + result <- gst_byte_reader_get_uint24_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetUint24LeMethodInfo +instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo ByteReaderGetUint24LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetUint24Le + +-- method ByteReader::get_uint32_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_uint32_be" gst_byte_reader_get_uint32_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word32 -> -- val : TBasicType TUInt32 + IO CInt + + +byteReaderGetUint32Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word32) -- result +byteReaderGetUint32Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word32) + result <- gst_byte_reader_get_uint32_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetUint32BeMethodInfo +instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo ByteReaderGetUint32BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetUint32Be + +-- method ByteReader::get_uint32_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_uint32_le" gst_byte_reader_get_uint32_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word32 -> -- val : TBasicType TUInt32 + IO CInt + + +byteReaderGetUint32Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word32) -- result +byteReaderGetUint32Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word32) + result <- gst_byte_reader_get_uint32_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetUint32LeMethodInfo +instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo ByteReaderGetUint32LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetUint32Le + +-- method ByteReader::get_uint64_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_uint64_be" gst_byte_reader_get_uint64_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word64 -> -- val : TBasicType TUInt64 + IO CInt + + +byteReaderGetUint64Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word64) -- result +byteReaderGetUint64Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word64) + result <- gst_byte_reader_get_uint64_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetUint64BeMethodInfo +instance (signature ~ (m (Bool,Word64)), MonadIO m) => MethodInfo ByteReaderGetUint64BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetUint64Be + +-- method ByteReader::get_uint64_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_uint64_le" gst_byte_reader_get_uint64_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word64 -> -- val : TBasicType TUInt64 + IO CInt + + +byteReaderGetUint64Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word64) -- result +byteReaderGetUint64Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word64) + result <- gst_byte_reader_get_uint64_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetUint64LeMethodInfo +instance (signature ~ (m (Bool,Word64)), MonadIO m) => MethodInfo ByteReaderGetUint64LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetUint64Le + +-- method ByteReader::get_uint8 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_get_uint8" gst_byte_reader_get_uint8 :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word8 -> -- val : TBasicType TUInt8 + IO CInt + + +byteReaderGetUint8 :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word8) -- result +byteReaderGetUint8 _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word8) + result <- gst_byte_reader_get_uint8 _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderGetUint8MethodInfo +instance (signature ~ (m (Bool,Word8)), MonadIO m) => MethodInfo ByteReaderGetUint8MethodInfo ByteReader signature where + overloadedMethod _ = byteReaderGetUint8 + +-- method ByteReader::init +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_init" gst_byte_reader_init :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word8 -> -- data : TCArray False (-1) 2 (TBasicType TUInt8) + Word32 -> -- size : TBasicType TUInt32 + IO () + + +byteReaderInit :: + (MonadIO m) => + ByteReader -- _obj + -> ByteString -- data_ + -> m () -- result +byteReaderInit _obj data_ = liftIO $ do + let size = fromIntegral $ B.length data_ + let _obj' = unsafeManagedPtrGetPtr _obj + data_' <- packByteString data_ + gst_byte_reader_init _obj' data_' size + touchManagedPtr _obj + freeMem data_' + return () + +data ByteReaderInitMethodInfo +instance (signature ~ (ByteString -> m ()), MonadIO m) => MethodInfo ByteReaderInitMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderInit + +-- method ByteReader::masked_scan_uint32 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mask", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pattern", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt32 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_masked_scan_uint32" gst_byte_reader_masked_scan_uint32 :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Word32 -> -- mask : TBasicType TUInt32 + Word32 -> -- pattern : TBasicType TUInt32 + Word32 -> -- offset : TBasicType TUInt32 + Word32 -> -- size : TBasicType TUInt32 + IO Word32 + + +byteReaderMaskedScanUint32 :: + (MonadIO m) => + ByteReader -- _obj + -> Word32 -- mask + -> Word32 -- pattern + -> Word32 -- offset + -> Word32 -- size + -> m Word32 -- result +byteReaderMaskedScanUint32 _obj mask pattern offset size = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_reader_masked_scan_uint32 _obj' mask pattern offset size + touchManagedPtr _obj + return result + +data ByteReaderMaskedScanUint32MethodInfo +instance (signature ~ (Word32 -> Word32 -> Word32 -> Word32 -> m Word32), MonadIO m) => MethodInfo ByteReaderMaskedScanUint32MethodInfo ByteReader signature where + overloadedMethod _ = byteReaderMaskedScanUint32 + +-- method ByteReader::masked_scan_uint32_peek +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mask", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pattern", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt32 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_masked_scan_uint32_peek" gst_byte_reader_masked_scan_uint32_peek :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Word32 -> -- mask : TBasicType TUInt32 + Word32 -> -- pattern : TBasicType TUInt32 + Word32 -> -- offset : TBasicType TUInt32 + Word32 -> -- size : TBasicType TUInt32 + Word32 -> -- value : TBasicType TUInt32 + IO Word32 + + +byteReaderMaskedScanUint32Peek :: + (MonadIO m) => + ByteReader -- _obj + -> Word32 -- mask + -> Word32 -- pattern + -> Word32 -- offset + -> Word32 -- size + -> Word32 -- value + -> m Word32 -- result +byteReaderMaskedScanUint32Peek _obj mask pattern offset size value = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_reader_masked_scan_uint32_peek _obj' mask pattern offset size value + touchManagedPtr _obj + return result + +data ByteReaderMaskedScanUint32PeekMethodInfo +instance (signature ~ (Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> m Word32), MonadIO m) => MethodInfo ByteReaderMaskedScanUint32PeekMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderMaskedScanUint32Peek + +-- method ByteReader::peek_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "val", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_data" gst_byte_reader_peek_data :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word32 -> -- size : TBasicType TUInt32 + Ptr (Ptr Word8) -> -- val : TCArray False (-1) 1 (TBasicType TUInt8) + IO CInt + + +byteReaderPeekData :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,ByteString) -- result +byteReaderPeekData _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + size <- allocMem :: IO (Ptr Word32) + val <- allocMem :: IO (Ptr (Ptr Word8)) + result <- gst_byte_reader_peek_data _obj' size val + size' <- peek size + let result' = (/= 0) result + val' <- peek val + val'' <- (unpackByteStringWithLength size') val' + touchManagedPtr _obj + freeMem size + freeMem val + return (result', val'') + +data ByteReaderPeekDataMethodInfo +instance (signature ~ (m (Bool,ByteString)), MonadIO m) => MethodInfo ByteReaderPeekDataMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekData + +-- method ByteReader::peek_float32_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_float32_be" gst_byte_reader_peek_float32_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr CFloat -> -- val : TBasicType TFloat + IO CInt + + +byteReaderPeekFloat32Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Float) -- result +byteReaderPeekFloat32Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr CFloat) + result <- gst_byte_reader_peek_float32_be _obj' val + let result' = (/= 0) result + val' <- peek val + let val'' = realToFrac val' + touchManagedPtr _obj + freeMem val + return (result', val'') + +data ByteReaderPeekFloat32BeMethodInfo +instance (signature ~ (m (Bool,Float)), MonadIO m) => MethodInfo ByteReaderPeekFloat32BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekFloat32Be + +-- method ByteReader::peek_float32_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_float32_le" gst_byte_reader_peek_float32_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr CFloat -> -- val : TBasicType TFloat + IO CInt + + +byteReaderPeekFloat32Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Float) -- result +byteReaderPeekFloat32Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr CFloat) + result <- gst_byte_reader_peek_float32_le _obj' val + let result' = (/= 0) result + val' <- peek val + let val'' = realToFrac val' + touchManagedPtr _obj + freeMem val + return (result', val'') + +data ByteReaderPeekFloat32LeMethodInfo +instance (signature ~ (m (Bool,Float)), MonadIO m) => MethodInfo ByteReaderPeekFloat32LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekFloat32Le + +-- method ByteReader::peek_float64_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_float64_be" gst_byte_reader_peek_float64_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr CDouble -> -- val : TBasicType TDouble + IO CInt + + +byteReaderPeekFloat64Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Double) -- result +byteReaderPeekFloat64Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr CDouble) + result <- gst_byte_reader_peek_float64_be _obj' val + let result' = (/= 0) result + val' <- peek val + let val'' = realToFrac val' + touchManagedPtr _obj + freeMem val + return (result', val'') + +data ByteReaderPeekFloat64BeMethodInfo +instance (signature ~ (m (Bool,Double)), MonadIO m) => MethodInfo ByteReaderPeekFloat64BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekFloat64Be + +-- method ByteReader::peek_float64_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_float64_le" gst_byte_reader_peek_float64_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr CDouble -> -- val : TBasicType TDouble + IO CInt + + +byteReaderPeekFloat64Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Double) -- result +byteReaderPeekFloat64Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr CDouble) + result <- gst_byte_reader_peek_float64_le _obj' val + let result' = (/= 0) result + val' <- peek val + let val'' = realToFrac val' + touchManagedPtr _obj + freeMem val + return (result', val'') + +data ByteReaderPeekFloat64LeMethodInfo +instance (signature ~ (m (Bool,Double)), MonadIO m) => MethodInfo ByteReaderPeekFloat64LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekFloat64Le + +-- method ByteReader::peek_int16_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt16, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_int16_be" gst_byte_reader_peek_int16_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int16 -> -- val : TBasicType TInt16 + IO CInt + + +byteReaderPeekInt16Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int16) -- result +byteReaderPeekInt16Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int16) + result <- gst_byte_reader_peek_int16_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekInt16BeMethodInfo +instance (signature ~ (m (Bool,Int16)), MonadIO m) => MethodInfo ByteReaderPeekInt16BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekInt16Be + +-- method ByteReader::peek_int16_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt16, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_int16_le" gst_byte_reader_peek_int16_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int16 -> -- val : TBasicType TInt16 + IO CInt + + +byteReaderPeekInt16Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int16) -- result +byteReaderPeekInt16Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int16) + result <- gst_byte_reader_peek_int16_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekInt16LeMethodInfo +instance (signature ~ (m (Bool,Int16)), MonadIO m) => MethodInfo ByteReaderPeekInt16LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekInt16Le + +-- method ByteReader::peek_int24_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_int24_be" gst_byte_reader_peek_int24_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int32 -> -- val : TBasicType TInt32 + IO CInt + + +byteReaderPeekInt24Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int32) -- result +byteReaderPeekInt24Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int32) + result <- gst_byte_reader_peek_int24_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekInt24BeMethodInfo +instance (signature ~ (m (Bool,Int32)), MonadIO m) => MethodInfo ByteReaderPeekInt24BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekInt24Be + +-- method ByteReader::peek_int24_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_int24_le" gst_byte_reader_peek_int24_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int32 -> -- val : TBasicType TInt32 + IO CInt + + +byteReaderPeekInt24Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int32) -- result +byteReaderPeekInt24Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int32) + result <- gst_byte_reader_peek_int24_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekInt24LeMethodInfo +instance (signature ~ (m (Bool,Int32)), MonadIO m) => MethodInfo ByteReaderPeekInt24LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekInt24Le + +-- method ByteReader::peek_int32_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_int32_be" gst_byte_reader_peek_int32_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int32 -> -- val : TBasicType TInt32 + IO CInt + + +byteReaderPeekInt32Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int32) -- result +byteReaderPeekInt32Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int32) + result <- gst_byte_reader_peek_int32_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekInt32BeMethodInfo +instance (signature ~ (m (Bool,Int32)), MonadIO m) => MethodInfo ByteReaderPeekInt32BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekInt32Be + +-- method ByteReader::peek_int32_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_int32_le" gst_byte_reader_peek_int32_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int32 -> -- val : TBasicType TInt32 + IO CInt + + +byteReaderPeekInt32Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int32) -- result +byteReaderPeekInt32Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int32) + result <- gst_byte_reader_peek_int32_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekInt32LeMethodInfo +instance (signature ~ (m (Bool,Int32)), MonadIO m) => MethodInfo ByteReaderPeekInt32LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekInt32Le + +-- method ByteReader::peek_int64_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_int64_be" gst_byte_reader_peek_int64_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int64 -> -- val : TBasicType TInt64 + IO CInt + + +byteReaderPeekInt64Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int64) -- result +byteReaderPeekInt64Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int64) + result <- gst_byte_reader_peek_int64_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekInt64BeMethodInfo +instance (signature ~ (m (Bool,Int64)), MonadIO m) => MethodInfo ByteReaderPeekInt64BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekInt64Be + +-- method ByteReader::peek_int64_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_int64_le" gst_byte_reader_peek_int64_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int64 -> -- val : TBasicType TInt64 + IO CInt + + +byteReaderPeekInt64Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int64) -- result +byteReaderPeekInt64Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int64) + result <- gst_byte_reader_peek_int64_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekInt64LeMethodInfo +instance (signature ~ (m (Bool,Int64)), MonadIO m) => MethodInfo ByteReaderPeekInt64LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekInt64Le + +-- method ByteReader::peek_int8 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_int8" gst_byte_reader_peek_int8 :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Int8 -> -- val : TBasicType TInt8 + IO CInt + + +byteReaderPeekInt8 :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Int8) -- result +byteReaderPeekInt8 _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Int8) + result <- gst_byte_reader_peek_int8 _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekInt8MethodInfo +instance (signature ~ (m (Bool,Int8)), MonadIO m) => MethodInfo ByteReaderPeekInt8MethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekInt8 + +-- method ByteReader::peek_string_utf8 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_string_utf8" gst_byte_reader_peek_string_utf8 :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr (Ptr CString) -> -- str : TCArray True (-1) (-1) (TBasicType TUTF8) + IO CInt + + +byteReaderPeekStringUtf8 :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,[T.Text]) -- result +byteReaderPeekStringUtf8 _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + str <- allocMem :: IO (Ptr (Ptr CString)) + result <- gst_byte_reader_peek_string_utf8 _obj' str + let result' = (/= 0) result + str' <- peek str + str'' <- unpackZeroTerminatedUTF8CArray str' + touchManagedPtr _obj + freeMem str + return (result', str'') + +data ByteReaderPeekStringUtf8MethodInfo +instance (signature ~ (m (Bool,[T.Text])), MonadIO m) => MethodInfo ByteReaderPeekStringUtf8MethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekStringUtf8 + +-- method ByteReader::peek_uint16_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt16, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_uint16_be" gst_byte_reader_peek_uint16_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word16 -> -- val : TBasicType TUInt16 + IO CInt + + +byteReaderPeekUint16Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word16) -- result +byteReaderPeekUint16Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word16) + result <- gst_byte_reader_peek_uint16_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekUint16BeMethodInfo +instance (signature ~ (m (Bool,Word16)), MonadIO m) => MethodInfo ByteReaderPeekUint16BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekUint16Be + +-- method ByteReader::peek_uint16_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt16, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_uint16_le" gst_byte_reader_peek_uint16_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word16 -> -- val : TBasicType TUInt16 + IO CInt + + +byteReaderPeekUint16Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word16) -- result +byteReaderPeekUint16Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word16) + result <- gst_byte_reader_peek_uint16_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekUint16LeMethodInfo +instance (signature ~ (m (Bool,Word16)), MonadIO m) => MethodInfo ByteReaderPeekUint16LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekUint16Le + +-- method ByteReader::peek_uint24_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_uint24_be" gst_byte_reader_peek_uint24_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word32 -> -- val : TBasicType TUInt32 + IO CInt + + +byteReaderPeekUint24Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word32) -- result +byteReaderPeekUint24Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word32) + result <- gst_byte_reader_peek_uint24_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekUint24BeMethodInfo +instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo ByteReaderPeekUint24BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekUint24Be + +-- method ByteReader::peek_uint24_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_uint24_le" gst_byte_reader_peek_uint24_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word32 -> -- val : TBasicType TUInt32 + IO CInt + + +byteReaderPeekUint24Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word32) -- result +byteReaderPeekUint24Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word32) + result <- gst_byte_reader_peek_uint24_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekUint24LeMethodInfo +instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo ByteReaderPeekUint24LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekUint24Le + +-- method ByteReader::peek_uint32_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_uint32_be" gst_byte_reader_peek_uint32_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word32 -> -- val : TBasicType TUInt32 + IO CInt + + +byteReaderPeekUint32Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word32) -- result +byteReaderPeekUint32Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word32) + result <- gst_byte_reader_peek_uint32_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekUint32BeMethodInfo +instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo ByteReaderPeekUint32BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekUint32Be + +-- method ByteReader::peek_uint32_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_uint32_le" gst_byte_reader_peek_uint32_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word32 -> -- val : TBasicType TUInt32 + IO CInt + + +byteReaderPeekUint32Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word32) -- result +byteReaderPeekUint32Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word32) + result <- gst_byte_reader_peek_uint32_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekUint32LeMethodInfo +instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo ByteReaderPeekUint32LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekUint32Le + +-- method ByteReader::peek_uint64_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_uint64_be" gst_byte_reader_peek_uint64_be :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word64 -> -- val : TBasicType TUInt64 + IO CInt + + +byteReaderPeekUint64Be :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word64) -- result +byteReaderPeekUint64Be _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word64) + result <- gst_byte_reader_peek_uint64_be _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekUint64BeMethodInfo +instance (signature ~ (m (Bool,Word64)), MonadIO m) => MethodInfo ByteReaderPeekUint64BeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekUint64Be + +-- method ByteReader::peek_uint64_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_uint64_le" gst_byte_reader_peek_uint64_le :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word64 -> -- val : TBasicType TUInt64 + IO CInt + + +byteReaderPeekUint64Le :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word64) -- result +byteReaderPeekUint64Le _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word64) + result <- gst_byte_reader_peek_uint64_le _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekUint64LeMethodInfo +instance (signature ~ (m (Bool,Word64)), MonadIO m) => MethodInfo ByteReaderPeekUint64LeMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekUint64Le + +-- method ByteReader::peek_uint8 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_peek_uint8" gst_byte_reader_peek_uint8 :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Ptr Word8 -> -- val : TBasicType TUInt8 + IO CInt + + +byteReaderPeekUint8 :: + (MonadIO m) => + ByteReader -- _obj + -> m (Bool,Word8) -- result +byteReaderPeekUint8 _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + val <- allocMem :: IO (Ptr Word8) + result <- gst_byte_reader_peek_uint8 _obj' val + let result' = (/= 0) result + val' <- peek val + touchManagedPtr _obj + freeMem val + return (result', val') + +data ByteReaderPeekUint8MethodInfo +instance (signature ~ (m (Bool,Word8)), MonadIO m) => MethodInfo ByteReaderPeekUint8MethodInfo ByteReader signature where + overloadedMethod _ = byteReaderPeekUint8 + +-- method ByteReader::set_pos +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_set_pos" gst_byte_reader_set_pos :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Word32 -> -- pos : TBasicType TUInt32 + IO CInt + + +byteReaderSetPos :: + (MonadIO m) => + ByteReader -- _obj + -> Word32 -- pos + -> m Bool -- result +byteReaderSetPos _obj pos = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_reader_set_pos _obj' pos + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteReaderSetPosMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo ByteReaderSetPosMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderSetPos + +-- method ByteReader::skip +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nbytes", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_skip" gst_byte_reader_skip :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + Word32 -> -- nbytes : TBasicType TUInt32 + IO CInt + + +byteReaderSkip :: + (MonadIO m) => + ByteReader -- _obj + -> Word32 -- nbytes + -> m Bool -- result +byteReaderSkip _obj nbytes = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_reader_skip _obj' nbytes + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteReaderSkipMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo ByteReaderSkipMethodInfo ByteReader signature where + overloadedMethod _ = byteReaderSkip + +-- method ByteReader::skip_string_utf16 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_skip_string_utf16" gst_byte_reader_skip_string_utf16 :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + IO CInt + + +byteReaderSkipStringUtf16 :: + (MonadIO m) => + ByteReader -- _obj + -> m Bool -- result +byteReaderSkipStringUtf16 _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_reader_skip_string_utf16 _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteReaderSkipStringUtf16MethodInfo +instance (signature ~ (m Bool), MonadIO m) => MethodInfo ByteReaderSkipStringUtf16MethodInfo ByteReader signature where + overloadedMethod _ = byteReaderSkipStringUtf16 + +-- method ByteReader::skip_string_utf32 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_skip_string_utf32" gst_byte_reader_skip_string_utf32 :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + IO CInt + + +byteReaderSkipStringUtf32 :: + (MonadIO m) => + ByteReader -- _obj + -> m Bool -- result +byteReaderSkipStringUtf32 _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_reader_skip_string_utf32 _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteReaderSkipStringUtf32MethodInfo +instance (signature ~ (m Bool), MonadIO m) => MethodInfo ByteReaderSkipStringUtf32MethodInfo ByteReader signature where + overloadedMethod _ = byteReaderSkipStringUtf32 + +-- method ByteReader::skip_string_utf8 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteReader", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_reader_skip_string_utf8" gst_byte_reader_skip_string_utf8 :: + Ptr ByteReader -> -- _obj : TInterface "GstBase" "ByteReader" + IO CInt + + +byteReaderSkipStringUtf8 :: + (MonadIO m) => + ByteReader -- _obj + -> m Bool -- result +byteReaderSkipStringUtf8 _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_reader_skip_string_utf8 _obj' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteReaderSkipStringUtf8MethodInfo +instance (signature ~ (m Bool), MonadIO m) => MethodInfo ByteReaderSkipStringUtf8MethodInfo ByteReader signature where + overloadedMethod _ = byteReaderSkipStringUtf8 + +type family ResolveByteReaderMethod (t :: Symbol) (o :: *) :: * where + ResolveByteReaderMethod "dupData" o = ByteReaderDupDataMethodInfo + ResolveByteReaderMethod "dupStringUtf16" o = ByteReaderDupStringUtf16MethodInfo + ResolveByteReaderMethod "dupStringUtf32" o = ByteReaderDupStringUtf32MethodInfo + ResolveByteReaderMethod "dupStringUtf8" o = ByteReaderDupStringUtf8MethodInfo + ResolveByteReaderMethod "free" o = ByteReaderFreeMethodInfo + ResolveByteReaderMethod "init" o = ByteReaderInitMethodInfo + ResolveByteReaderMethod "maskedScanUint32" o = ByteReaderMaskedScanUint32MethodInfo + ResolveByteReaderMethod "maskedScanUint32Peek" o = ByteReaderMaskedScanUint32PeekMethodInfo + ResolveByteReaderMethod "peekData" o = ByteReaderPeekDataMethodInfo + ResolveByteReaderMethod "peekFloat32Be" o = ByteReaderPeekFloat32BeMethodInfo + ResolveByteReaderMethod "peekFloat32Le" o = ByteReaderPeekFloat32LeMethodInfo + ResolveByteReaderMethod "peekFloat64Be" o = ByteReaderPeekFloat64BeMethodInfo + ResolveByteReaderMethod "peekFloat64Le" o = ByteReaderPeekFloat64LeMethodInfo + ResolveByteReaderMethod "peekInt16Be" o = ByteReaderPeekInt16BeMethodInfo + ResolveByteReaderMethod "peekInt16Le" o = ByteReaderPeekInt16LeMethodInfo + ResolveByteReaderMethod "peekInt24Be" o = ByteReaderPeekInt24BeMethodInfo + ResolveByteReaderMethod "peekInt24Le" o = ByteReaderPeekInt24LeMethodInfo + ResolveByteReaderMethod "peekInt32Be" o = ByteReaderPeekInt32BeMethodInfo + ResolveByteReaderMethod "peekInt32Le" o = ByteReaderPeekInt32LeMethodInfo + ResolveByteReaderMethod "peekInt64Be" o = ByteReaderPeekInt64BeMethodInfo + ResolveByteReaderMethod "peekInt64Le" o = ByteReaderPeekInt64LeMethodInfo + ResolveByteReaderMethod "peekInt8" o = ByteReaderPeekInt8MethodInfo + ResolveByteReaderMethod "peekStringUtf8" o = ByteReaderPeekStringUtf8MethodInfo + ResolveByteReaderMethod "peekUint16Be" o = ByteReaderPeekUint16BeMethodInfo + ResolveByteReaderMethod "peekUint16Le" o = ByteReaderPeekUint16LeMethodInfo + ResolveByteReaderMethod "peekUint24Be" o = ByteReaderPeekUint24BeMethodInfo + ResolveByteReaderMethod "peekUint24Le" o = ByteReaderPeekUint24LeMethodInfo + ResolveByteReaderMethod "peekUint32Be" o = ByteReaderPeekUint32BeMethodInfo + ResolveByteReaderMethod "peekUint32Le" o = ByteReaderPeekUint32LeMethodInfo + ResolveByteReaderMethod "peekUint64Be" o = ByteReaderPeekUint64BeMethodInfo + ResolveByteReaderMethod "peekUint64Le" o = ByteReaderPeekUint64LeMethodInfo + ResolveByteReaderMethod "peekUint8" o = ByteReaderPeekUint8MethodInfo + ResolveByteReaderMethod "skip" o = ByteReaderSkipMethodInfo + ResolveByteReaderMethod "skipStringUtf16" o = ByteReaderSkipStringUtf16MethodInfo + ResolveByteReaderMethod "skipStringUtf32" o = ByteReaderSkipStringUtf32MethodInfo + ResolveByteReaderMethod "skipStringUtf8" o = ByteReaderSkipStringUtf8MethodInfo + ResolveByteReaderMethod "getData" o = ByteReaderGetDataMethodInfo + ResolveByteReaderMethod "getFloat32Be" o = ByteReaderGetFloat32BeMethodInfo + ResolveByteReaderMethod "getFloat32Le" o = ByteReaderGetFloat32LeMethodInfo + ResolveByteReaderMethod "getFloat64Be" o = ByteReaderGetFloat64BeMethodInfo + ResolveByteReaderMethod "getFloat64Le" o = ByteReaderGetFloat64LeMethodInfo + ResolveByteReaderMethod "getInt16Be" o = ByteReaderGetInt16BeMethodInfo + ResolveByteReaderMethod "getInt16Le" o = ByteReaderGetInt16LeMethodInfo + ResolveByteReaderMethod "getInt24Be" o = ByteReaderGetInt24BeMethodInfo + ResolveByteReaderMethod "getInt24Le" o = ByteReaderGetInt24LeMethodInfo + ResolveByteReaderMethod "getInt32Be" o = ByteReaderGetInt32BeMethodInfo + ResolveByteReaderMethod "getInt32Le" o = ByteReaderGetInt32LeMethodInfo + ResolveByteReaderMethod "getInt64Be" o = ByteReaderGetInt64BeMethodInfo + ResolveByteReaderMethod "getInt64Le" o = ByteReaderGetInt64LeMethodInfo + ResolveByteReaderMethod "getInt8" o = ByteReaderGetInt8MethodInfo + ResolveByteReaderMethod "getPos" o = ByteReaderGetPosMethodInfo + ResolveByteReaderMethod "getRemaining" o = ByteReaderGetRemainingMethodInfo + ResolveByteReaderMethod "getSize" o = ByteReaderGetSizeMethodInfo + ResolveByteReaderMethod "getStringUtf8" o = ByteReaderGetStringUtf8MethodInfo + ResolveByteReaderMethod "getUint16Be" o = ByteReaderGetUint16BeMethodInfo + ResolveByteReaderMethod "getUint16Le" o = ByteReaderGetUint16LeMethodInfo + ResolveByteReaderMethod "getUint24Be" o = ByteReaderGetUint24BeMethodInfo + ResolveByteReaderMethod "getUint24Le" o = ByteReaderGetUint24LeMethodInfo + ResolveByteReaderMethod "getUint32Be" o = ByteReaderGetUint32BeMethodInfo + ResolveByteReaderMethod "getUint32Le" o = ByteReaderGetUint32LeMethodInfo + ResolveByteReaderMethod "getUint64Be" o = ByteReaderGetUint64BeMethodInfo + ResolveByteReaderMethod "getUint64Le" o = ByteReaderGetUint64LeMethodInfo + ResolveByteReaderMethod "getUint8" o = ByteReaderGetUint8MethodInfo + ResolveByteReaderMethod "setPos" o = ByteReaderSetPosMethodInfo + ResolveByteReaderMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolveByteReaderMethod t ByteReader, MethodInfo info ByteReader p) => IsLabelProxy t (ByteReader -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolveByteReaderMethod t ByteReader, MethodInfo info ByteReader p) => IsLabel t (ByteReader -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + + diff --git a/GI/GstBase/Structs/ByteReader.hs-boot b/GI/GstBase/Structs/ByteReader.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Structs/ByteReader.hs-boot @@ -0,0 +1,74 @@ +module GI.GstBase.Structs.ByteReader where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype ByteReader = ByteReader (ForeignPtr ByteReader) +data ByteReaderDupDataMethodInfo +data ByteReaderDupStringUtf16MethodInfo +data ByteReaderDupStringUtf32MethodInfo +data ByteReaderDupStringUtf8MethodInfo +data ByteReaderFreeMethodInfo +data ByteReaderGetDataMethodInfo +data ByteReaderGetFloat32BeMethodInfo +data ByteReaderGetFloat32LeMethodInfo +data ByteReaderGetFloat64BeMethodInfo +data ByteReaderGetFloat64LeMethodInfo +data ByteReaderGetInt16BeMethodInfo +data ByteReaderGetInt16LeMethodInfo +data ByteReaderGetInt24BeMethodInfo +data ByteReaderGetInt24LeMethodInfo +data ByteReaderGetInt32BeMethodInfo +data ByteReaderGetInt32LeMethodInfo +data ByteReaderGetInt64BeMethodInfo +data ByteReaderGetInt64LeMethodInfo +data ByteReaderGetInt8MethodInfo +data ByteReaderGetPosMethodInfo +data ByteReaderGetRemainingMethodInfo +data ByteReaderGetSizeMethodInfo +data ByteReaderGetStringUtf8MethodInfo +data ByteReaderGetUint16BeMethodInfo +data ByteReaderGetUint16LeMethodInfo +data ByteReaderGetUint24BeMethodInfo +data ByteReaderGetUint24LeMethodInfo +data ByteReaderGetUint32BeMethodInfo +data ByteReaderGetUint32LeMethodInfo +data ByteReaderGetUint64BeMethodInfo +data ByteReaderGetUint64LeMethodInfo +data ByteReaderGetUint8MethodInfo +data ByteReaderInitMethodInfo +data ByteReaderMaskedScanUint32MethodInfo +data ByteReaderMaskedScanUint32PeekMethodInfo +data ByteReaderPeekDataMethodInfo +data ByteReaderPeekFloat32BeMethodInfo +data ByteReaderPeekFloat32LeMethodInfo +data ByteReaderPeekFloat64BeMethodInfo +data ByteReaderPeekFloat64LeMethodInfo +data ByteReaderPeekInt16BeMethodInfo +data ByteReaderPeekInt16LeMethodInfo +data ByteReaderPeekInt24BeMethodInfo +data ByteReaderPeekInt24LeMethodInfo +data ByteReaderPeekInt32BeMethodInfo +data ByteReaderPeekInt32LeMethodInfo +data ByteReaderPeekInt64BeMethodInfo +data ByteReaderPeekInt64LeMethodInfo +data ByteReaderPeekInt8MethodInfo +data ByteReaderPeekStringUtf8MethodInfo +data ByteReaderPeekUint16BeMethodInfo +data ByteReaderPeekUint16LeMethodInfo +data ByteReaderPeekUint24BeMethodInfo +data ByteReaderPeekUint24LeMethodInfo +data ByteReaderPeekUint32BeMethodInfo +data ByteReaderPeekUint32LeMethodInfo +data ByteReaderPeekUint64BeMethodInfo +data ByteReaderPeekUint64LeMethodInfo +data ByteReaderPeekUint8MethodInfo +data ByteReaderSetPosMethodInfo +data ByteReaderSkipMethodInfo +data ByteReaderSkipStringUtf16MethodInfo +data ByteReaderSkipStringUtf32MethodInfo +data ByteReaderSkipStringUtf8MethodInfo diff --git a/GI/GstBase/Structs/ByteWriter.hs b/GI/GstBase/Structs/ByteWriter.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Structs/ByteWriter.hs @@ -0,0 +1,1518 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) + +#GstByteWriter provides a byte writer and reader that can write/read different +integer and floating point types to/from a memory buffer. It provides functions +for writing/reading signed/unsigned, little/big endian integers of 8, 16, 24, +32 and 64 bits and functions for reading little/big endian floating points numbers of +32 and 64 bits. It also provides functions to write/read NUL-terminated strings +in various character encodings. +-} + +module GI.GstBase.Structs.ByteWriter + ( + +-- * Exported types + ByteWriter(..) , + newZeroByteWriter , + noByteWriter , + + + -- * Methods +-- ** byteWriterEnsureFreeSpace + ByteWriterEnsureFreeSpaceMethodInfo , + byteWriterEnsureFreeSpace , + + +-- ** byteWriterFill + ByteWriterFillMethodInfo , + byteWriterFill , + + +-- ** byteWriterFree + ByteWriterFreeMethodInfo , + byteWriterFree , + + +-- ** byteWriterFreeAndGetBuffer + ByteWriterFreeAndGetBufferMethodInfo , + byteWriterFreeAndGetBuffer , + + +-- ** byteWriterFreeAndGetData + ByteWriterFreeAndGetDataMethodInfo , + byteWriterFreeAndGetData , + + +-- ** byteWriterGetRemaining + ByteWriterGetRemainingMethodInfo , + byteWriterGetRemaining , + + +-- ** byteWriterInit + ByteWriterInitMethodInfo , + byteWriterInit , + + +-- ** byteWriterInitWithData + ByteWriterInitWithDataMethodInfo , + byteWriterInitWithData , + + +-- ** byteWriterInitWithSize + ByteWriterInitWithSizeMethodInfo , + byteWriterInitWithSize , + + +-- ** byteWriterPutBuffer + ByteWriterPutBufferMethodInfo , + byteWriterPutBuffer , + + +-- ** byteWriterPutData + ByteWriterPutDataMethodInfo , + byteWriterPutData , + + +-- ** byteWriterPutFloat32Be + ByteWriterPutFloat32BeMethodInfo , + byteWriterPutFloat32Be , + + +-- ** byteWriterPutFloat32Le + ByteWriterPutFloat32LeMethodInfo , + byteWriterPutFloat32Le , + + +-- ** byteWriterPutFloat64Be + ByteWriterPutFloat64BeMethodInfo , + byteWriterPutFloat64Be , + + +-- ** byteWriterPutFloat64Le + ByteWriterPutFloat64LeMethodInfo , + byteWriterPutFloat64Le , + + +-- ** byteWriterPutInt16Be + ByteWriterPutInt16BeMethodInfo , + byteWriterPutInt16Be , + + +-- ** byteWriterPutInt16Le + ByteWriterPutInt16LeMethodInfo , + byteWriterPutInt16Le , + + +-- ** byteWriterPutInt24Be + ByteWriterPutInt24BeMethodInfo , + byteWriterPutInt24Be , + + +-- ** byteWriterPutInt24Le + ByteWriterPutInt24LeMethodInfo , + byteWriterPutInt24Le , + + +-- ** byteWriterPutInt32Be + ByteWriterPutInt32BeMethodInfo , + byteWriterPutInt32Be , + + +-- ** byteWriterPutInt32Le + ByteWriterPutInt32LeMethodInfo , + byteWriterPutInt32Le , + + +-- ** byteWriterPutInt64Be + ByteWriterPutInt64BeMethodInfo , + byteWriterPutInt64Be , + + +-- ** byteWriterPutInt64Le + ByteWriterPutInt64LeMethodInfo , + byteWriterPutInt64Le , + + +-- ** byteWriterPutInt8 + ByteWriterPutInt8MethodInfo , + byteWriterPutInt8 , + + +-- ** byteWriterPutStringUtf16 + ByteWriterPutStringUtf16MethodInfo , + byteWriterPutStringUtf16 , + + +-- ** byteWriterPutStringUtf32 + ByteWriterPutStringUtf32MethodInfo , + byteWriterPutStringUtf32 , + + +-- ** byteWriterPutStringUtf8 + ByteWriterPutStringUtf8MethodInfo , + byteWriterPutStringUtf8 , + + +-- ** byteWriterPutUint16Be + ByteWriterPutUint16BeMethodInfo , + byteWriterPutUint16Be , + + +-- ** byteWriterPutUint16Le + ByteWriterPutUint16LeMethodInfo , + byteWriterPutUint16Le , + + +-- ** byteWriterPutUint24Be + ByteWriterPutUint24BeMethodInfo , + byteWriterPutUint24Be , + + +-- ** byteWriterPutUint24Le + ByteWriterPutUint24LeMethodInfo , + byteWriterPutUint24Le , + + +-- ** byteWriterPutUint32Be + ByteWriterPutUint32BeMethodInfo , + byteWriterPutUint32Be , + + +-- ** byteWriterPutUint32Le + ByteWriterPutUint32LeMethodInfo , + byteWriterPutUint32Le , + + +-- ** byteWriterPutUint64Be + ByteWriterPutUint64BeMethodInfo , + byteWriterPutUint64Be , + + +-- ** byteWriterPutUint64Le + ByteWriterPutUint64LeMethodInfo , + byteWriterPutUint64Le , + + +-- ** byteWriterPutUint8 + ByteWriterPutUint8MethodInfo , + byteWriterPutUint8 , + + +-- ** byteWriterReset + ByteWriterResetMethodInfo , + byteWriterReset , + + +-- ** byteWriterResetAndGetBuffer + ByteWriterResetAndGetBufferMethodInfo , + byteWriterResetAndGetBuffer , + + +-- ** byteWriterResetAndGetData + ByteWriterResetAndGetDataMethodInfo , + byteWriterResetAndGetData , + + + + + -- * Properties +-- ** AllocSize + byteWriterReadAllocSize , + + +-- ** Fixed + byteWriterReadFixed , + + +-- ** Owned + byteWriterReadOwned , + + +-- ** Parent + byteWriterReadParent , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks +import qualified GI.Gst as Gst + +newtype ByteWriter = ByteWriter (ForeignPtr ByteWriter) +-- | Construct a `ByteWriter` struct initialized to zero. +newZeroByteWriter :: MonadIO m => m ByteWriter +newZeroByteWriter = liftIO $ callocBytes 96 >>= wrapPtr ByteWriter + +noByteWriter :: Maybe ByteWriter +noByteWriter = Nothing + +byteWriterReadParent :: ByteWriter -> IO ByteReader +byteWriterReadParent s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO (Ptr ByteReader) + val' <- (newPtr 48 ByteReader) val + return val' + +byteWriterReadAllocSize :: ByteWriter -> IO Word32 +byteWriterReadAllocSize s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 48) :: IO Word32 + return val + +byteWriterReadFixed :: ByteWriter -> IO Bool +byteWriterReadFixed s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 52) :: IO CInt + let val' = (/= 0) val + return val' + +byteWriterReadOwned :: ByteWriter -> IO Bool +byteWriterReadOwned s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 56) :: IO CInt + let val' = (/= 0) val + return val' + +-- method ByteWriter::ensure_free_space +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_ensure_free_space" gst_byte_writer_ensure_free_space :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Word32 -> -- size : TBasicType TUInt32 + IO CInt + + +byteWriterEnsureFreeSpace :: + (MonadIO m) => + ByteWriter -- _obj + -> Word32 -- size + -> m Bool -- result +byteWriterEnsureFreeSpace _obj size = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_ensure_free_space _obj' size + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterEnsureFreeSpaceMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo ByteWriterEnsureFreeSpaceMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterEnsureFreeSpace + +-- method ByteWriter::fill +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_fill" gst_byte_writer_fill :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Word8 -> -- value : TBasicType TUInt8 + Word32 -> -- size : TBasicType TUInt32 + IO CInt + + +byteWriterFill :: + (MonadIO m) => + ByteWriter -- _obj + -> Word8 -- value + -> Word32 -- size + -> m Bool -- result +byteWriterFill _obj value size = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_fill _obj' value size + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterFillMethodInfo +instance (signature ~ (Word8 -> Word32 -> m Bool), MonadIO m) => MethodInfo ByteWriterFillMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterFill + +-- method ByteWriter::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_free" gst_byte_writer_free :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + IO () + + +byteWriterFree :: + (MonadIO m) => + ByteWriter -- _obj + -> m () -- result +byteWriterFree _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + gst_byte_writer_free _obj' + touchManagedPtr _obj + return () + +data ByteWriterFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => MethodInfo ByteWriterFreeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterFree + +-- method ByteWriter::free_and_get_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Buffer" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_free_and_get_buffer" gst_byte_writer_free_and_get_buffer :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + IO (Ptr Gst.Buffer) + + +byteWriterFreeAndGetBuffer :: + (MonadIO m) => + ByteWriter -- _obj + -> m Gst.Buffer -- result +byteWriterFreeAndGetBuffer _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_free_and_get_buffer _obj' + checkUnexpectedReturnNULL "gst_byte_writer_free_and_get_buffer" result + result' <- (wrapBoxed Gst.Buffer) result + touchManagedPtr _obj + return result' + +data ByteWriterFreeAndGetBufferMethodInfo +instance (signature ~ (m Gst.Buffer), MonadIO m) => MethodInfo ByteWriterFreeAndGetBufferMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterFreeAndGetBuffer + +-- method ByteWriter::free_and_get_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt8 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_free_and_get_data" gst_byte_writer_free_and_get_data :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + IO Word8 + + +byteWriterFreeAndGetData :: + (MonadIO m) => + ByteWriter -- _obj + -> m Word8 -- result +byteWriterFreeAndGetData _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_free_and_get_data _obj' + touchManagedPtr _obj + return result + +data ByteWriterFreeAndGetDataMethodInfo +instance (signature ~ (m Word8), MonadIO m) => MethodInfo ByteWriterFreeAndGetDataMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterFreeAndGetData + +-- method ByteWriter::get_remaining +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TUInt32 +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_get_remaining" gst_byte_writer_get_remaining :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + IO Word32 + + +byteWriterGetRemaining :: + (MonadIO m) => + ByteWriter -- _obj + -> m Word32 -- result +byteWriterGetRemaining _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_get_remaining _obj' + touchManagedPtr _obj + return result + +data ByteWriterGetRemainingMethodInfo +instance (signature ~ (m Word32), MonadIO m) => MethodInfo ByteWriterGetRemainingMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterGetRemaining + +-- method ByteWriter::init +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_init" gst_byte_writer_init :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + IO () + + +byteWriterInit :: + (MonadIO m) => + ByteWriter -- _obj + -> m () -- result +byteWriterInit _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + gst_byte_writer_init _obj' + touchManagedPtr _obj + return () + +data ByteWriterInitMethodInfo +instance (signature ~ (m ()), MonadIO m) => MethodInfo ByteWriterInitMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterInit + +-- method ByteWriter::init_with_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "initialized", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_init_with_data" gst_byte_writer_init_with_data :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Ptr Word8 -> -- data : TCArray False (-1) 2 (TBasicType TUInt8) + Word32 -> -- size : TBasicType TUInt32 + CInt -> -- initialized : TBasicType TBoolean + IO () + + +byteWriterInitWithData :: + (MonadIO m) => + ByteWriter -- _obj + -> ByteString -- data_ + -> Bool -- initialized + -> m () -- result +byteWriterInitWithData _obj data_ initialized = liftIO $ do + let size = fromIntegral $ B.length data_ + let _obj' = unsafeManagedPtrGetPtr _obj + data_' <- packByteString data_ + let initialized' = (fromIntegral . fromEnum) initialized + gst_byte_writer_init_with_data _obj' data_' size initialized' + touchManagedPtr _obj + freeMem data_' + return () + +data ByteWriterInitWithDataMethodInfo +instance (signature ~ (ByteString -> Bool -> m ()), MonadIO m) => MethodInfo ByteWriterInitWithDataMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterInitWithData + +-- method ByteWriter::init_with_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fixed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_init_with_size" gst_byte_writer_init_with_size :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Word32 -> -- size : TBasicType TUInt32 + CInt -> -- fixed : TBasicType TBoolean + IO () + + +byteWriterInitWithSize :: + (MonadIO m) => + ByteWriter -- _obj + -> Word32 -- size + -> Bool -- fixed + -> m () -- result +byteWriterInitWithSize _obj size fixed = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + let fixed' = (fromIntegral . fromEnum) fixed + gst_byte_writer_init_with_size _obj' size fixed' + touchManagedPtr _obj + return () + +data ByteWriterInitWithSizeMethodInfo +instance (signature ~ (Word32 -> Bool -> m ()), MonadIO m) => MethodInfo ByteWriterInitWithSizeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterInitWithSize + +-- method ByteWriter::put_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_buffer" gst_byte_writer_put_buffer :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Ptr Gst.Buffer -> -- buffer : TInterface "Gst" "Buffer" + Word64 -> -- offset : TBasicType TUInt64 + Int64 -> -- size : TBasicType TInt64 + IO CInt + + +byteWriterPutBuffer :: + (MonadIO m) => + ByteWriter -- _obj + -> Gst.Buffer -- buffer + -> Word64 -- offset + -> Int64 -- size + -> m Bool -- result +byteWriterPutBuffer _obj buffer offset size = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + let buffer' = unsafeManagedPtrGetPtr buffer + result <- gst_byte_writer_put_buffer _obj' buffer' offset size + let result' = (/= 0) result + touchManagedPtr _obj + touchManagedPtr buffer + return result' + +data ByteWriterPutBufferMethodInfo +instance (signature ~ (Gst.Buffer -> Word64 -> Int64 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutBufferMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutBuffer + +-- method ByteWriter::put_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_data" gst_byte_writer_put_data :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Ptr Word8 -> -- data : TCArray False (-1) 2 (TBasicType TUInt8) + Word32 -> -- size : TBasicType TUInt32 + IO CInt + + +byteWriterPutData :: + (MonadIO m) => + ByteWriter -- _obj + -> ByteString -- data_ + -> m Bool -- result +byteWriterPutData _obj data_ = liftIO $ do + let size = fromIntegral $ B.length data_ + let _obj' = unsafeManagedPtrGetPtr _obj + data_' <- packByteString data_ + result <- gst_byte_writer_put_data _obj' data_' size + let result' = (/= 0) result + touchManagedPtr _obj + freeMem data_' + return result' + +data ByteWriterPutDataMethodInfo +instance (signature ~ (ByteString -> m Bool), MonadIO m) => MethodInfo ByteWriterPutDataMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutData + +-- method ByteWriter::put_float32_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_float32_be" gst_byte_writer_put_float32_be :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + CFloat -> -- val : TBasicType TFloat + IO CInt + + +byteWriterPutFloat32Be :: + (MonadIO m) => + ByteWriter -- _obj + -> Float -- val + -> m Bool -- result +byteWriterPutFloat32Be _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + let val' = realToFrac val + result <- gst_byte_writer_put_float32_be _obj' val' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutFloat32BeMethodInfo +instance (signature ~ (Float -> m Bool), MonadIO m) => MethodInfo ByteWriterPutFloat32BeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutFloat32Be + +-- method ByteWriter::put_float32_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_float32_le" gst_byte_writer_put_float32_le :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + CFloat -> -- val : TBasicType TFloat + IO CInt + + +byteWriterPutFloat32Le :: + (MonadIO m) => + ByteWriter -- _obj + -> Float -- val + -> m Bool -- result +byteWriterPutFloat32Le _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + let val' = realToFrac val + result <- gst_byte_writer_put_float32_le _obj' val' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutFloat32LeMethodInfo +instance (signature ~ (Float -> m Bool), MonadIO m) => MethodInfo ByteWriterPutFloat32LeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutFloat32Le + +-- method ByteWriter::put_float64_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_float64_be" gst_byte_writer_put_float64_be :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + CDouble -> -- val : TBasicType TDouble + IO CInt + + +byteWriterPutFloat64Be :: + (MonadIO m) => + ByteWriter -- _obj + -> Double -- val + -> m Bool -- result +byteWriterPutFloat64Be _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + let val' = realToFrac val + result <- gst_byte_writer_put_float64_be _obj' val' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutFloat64BeMethodInfo +instance (signature ~ (Double -> m Bool), MonadIO m) => MethodInfo ByteWriterPutFloat64BeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutFloat64Be + +-- method ByteWriter::put_float64_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_float64_le" gst_byte_writer_put_float64_le :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + CDouble -> -- val : TBasicType TDouble + IO CInt + + +byteWriterPutFloat64Le :: + (MonadIO m) => + ByteWriter -- _obj + -> Double -- val + -> m Bool -- result +byteWriterPutFloat64Le _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + let val' = realToFrac val + result <- gst_byte_writer_put_float64_le _obj' val' + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutFloat64LeMethodInfo +instance (signature ~ (Double -> m Bool), MonadIO m) => MethodInfo ByteWriterPutFloat64LeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutFloat64Le + +-- method ByteWriter::put_int16_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_int16_be" gst_byte_writer_put_int16_be :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Int16 -> -- val : TBasicType TInt16 + IO CInt + + +byteWriterPutInt16Be :: + (MonadIO m) => + ByteWriter -- _obj + -> Int16 -- val + -> m Bool -- result +byteWriterPutInt16Be _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_int16_be _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutInt16BeMethodInfo +instance (signature ~ (Int16 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutInt16BeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutInt16Be + +-- method ByteWriter::put_int16_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_int16_le" gst_byte_writer_put_int16_le :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Int16 -> -- val : TBasicType TInt16 + IO CInt + + +byteWriterPutInt16Le :: + (MonadIO m) => + ByteWriter -- _obj + -> Int16 -- val + -> m Bool -- result +byteWriterPutInt16Le _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_int16_le _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutInt16LeMethodInfo +instance (signature ~ (Int16 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutInt16LeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutInt16Le + +-- method ByteWriter::put_int24_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_int24_be" gst_byte_writer_put_int24_be :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Int32 -> -- val : TBasicType TInt32 + IO CInt + + +byteWriterPutInt24Be :: + (MonadIO m) => + ByteWriter -- _obj + -> Int32 -- val + -> m Bool -- result +byteWriterPutInt24Be _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_int24_be _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutInt24BeMethodInfo +instance (signature ~ (Int32 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutInt24BeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutInt24Be + +-- method ByteWriter::put_int24_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_int24_le" gst_byte_writer_put_int24_le :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Int32 -> -- val : TBasicType TInt32 + IO CInt + + +byteWriterPutInt24Le :: + (MonadIO m) => + ByteWriter -- _obj + -> Int32 -- val + -> m Bool -- result +byteWriterPutInt24Le _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_int24_le _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutInt24LeMethodInfo +instance (signature ~ (Int32 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutInt24LeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutInt24Le + +-- method ByteWriter::put_int32_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_int32_be" gst_byte_writer_put_int32_be :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Int32 -> -- val : TBasicType TInt32 + IO CInt + + +byteWriterPutInt32Be :: + (MonadIO m) => + ByteWriter -- _obj + -> Int32 -- val + -> m Bool -- result +byteWriterPutInt32Be _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_int32_be _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutInt32BeMethodInfo +instance (signature ~ (Int32 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutInt32BeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutInt32Be + +-- method ByteWriter::put_int32_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_int32_le" gst_byte_writer_put_int32_le :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Int32 -> -- val : TBasicType TInt32 + IO CInt + + +byteWriterPutInt32Le :: + (MonadIO m) => + ByteWriter -- _obj + -> Int32 -- val + -> m Bool -- result +byteWriterPutInt32Le _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_int32_le _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutInt32LeMethodInfo +instance (signature ~ (Int32 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutInt32LeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutInt32Le + +-- method ByteWriter::put_int64_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_int64_be" gst_byte_writer_put_int64_be :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Int64 -> -- val : TBasicType TInt64 + IO CInt + + +byteWriterPutInt64Be :: + (MonadIO m) => + ByteWriter -- _obj + -> Int64 -- val + -> m Bool -- result +byteWriterPutInt64Be _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_int64_be _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutInt64BeMethodInfo +instance (signature ~ (Int64 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutInt64BeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutInt64Be + +-- method ByteWriter::put_int64_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_int64_le" gst_byte_writer_put_int64_le :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Int64 -> -- val : TBasicType TInt64 + IO CInt + + +byteWriterPutInt64Le :: + (MonadIO m) => + ByteWriter -- _obj + -> Int64 -- val + -> m Bool -- result +byteWriterPutInt64Le _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_int64_le _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutInt64LeMethodInfo +instance (signature ~ (Int64 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutInt64LeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutInt64Le + +-- method ByteWriter::put_int8 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_int8" gst_byte_writer_put_int8 :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Int8 -> -- val : TBasicType TInt8 + IO CInt + + +byteWriterPutInt8 :: + (MonadIO m) => + ByteWriter -- _obj + -> Int8 -- val + -> m Bool -- result +byteWriterPutInt8 _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_int8 _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutInt8MethodInfo +instance (signature ~ (Int8 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutInt8MethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutInt8 + +-- method ByteWriter::put_string_utf16 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray True (-1) (-1) (TBasicType TUInt16), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_string_utf16" gst_byte_writer_put_string_utf16 :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Ptr Word16 -> -- data : TCArray True (-1) (-1) (TBasicType TUInt16) + IO CInt + + +byteWriterPutStringUtf16 :: + (MonadIO m) => + ByteWriter -- _obj + -> [Word16] -- data_ + -> m Bool -- result +byteWriterPutStringUtf16 _obj data_ = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + data_' <- packZeroTerminatedStorableArray data_ + result <- gst_byte_writer_put_string_utf16 _obj' data_' + let result' = (/= 0) result + touchManagedPtr _obj + freeMem data_' + return result' + +data ByteWriterPutStringUtf16MethodInfo +instance (signature ~ ([Word16] -> m Bool), MonadIO m) => MethodInfo ByteWriterPutStringUtf16MethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutStringUtf16 + +-- method ByteWriter::put_string_utf32 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray True (-1) (-1) (TBasicType TUInt32), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_string_utf32" gst_byte_writer_put_string_utf32 :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Ptr Word32 -> -- data : TCArray True (-1) (-1) (TBasicType TUInt32) + IO CInt + + +byteWriterPutStringUtf32 :: + (MonadIO m) => + ByteWriter -- _obj + -> [Word32] -- data_ + -> m Bool -- result +byteWriterPutStringUtf32 _obj data_ = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + data_' <- packZeroTerminatedStorableArray data_ + result <- gst_byte_writer_put_string_utf32 _obj' data_' + let result' = (/= 0) result + touchManagedPtr _obj + freeMem data_' + return result' + +data ByteWriterPutStringUtf32MethodInfo +instance (signature ~ ([Word32] -> m Bool), MonadIO m) => MethodInfo ByteWriterPutStringUtf32MethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutStringUtf32 + +-- method ByteWriter::put_string_utf8 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_string_utf8" gst_byte_writer_put_string_utf8 :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Ptr CString -> -- data : TCArray True (-1) (-1) (TBasicType TUTF8) + IO CInt + + +byteWriterPutStringUtf8 :: + (MonadIO m) => + ByteWriter -- _obj + -> [T.Text] -- data_ + -> m Bool -- result +byteWriterPutStringUtf8 _obj data_ = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + data_' <- packZeroTerminatedUTF8CArray data_ + result <- gst_byte_writer_put_string_utf8 _obj' data_' + let result' = (/= 0) result + touchManagedPtr _obj + mapZeroTerminatedCArray freeMem data_' + freeMem data_' + return result' + +data ByteWriterPutStringUtf8MethodInfo +instance (signature ~ ([T.Text] -> m Bool), MonadIO m) => MethodInfo ByteWriterPutStringUtf8MethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutStringUtf8 + +-- method ByteWriter::put_uint16_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_uint16_be" gst_byte_writer_put_uint16_be :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Word16 -> -- val : TBasicType TUInt16 + IO CInt + + +byteWriterPutUint16Be :: + (MonadIO m) => + ByteWriter -- _obj + -> Word16 -- val + -> m Bool -- result +byteWriterPutUint16Be _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_uint16_be _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutUint16BeMethodInfo +instance (signature ~ (Word16 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutUint16BeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutUint16Be + +-- method ByteWriter::put_uint16_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_uint16_le" gst_byte_writer_put_uint16_le :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Word16 -> -- val : TBasicType TUInt16 + IO CInt + + +byteWriterPutUint16Le :: + (MonadIO m) => + ByteWriter -- _obj + -> Word16 -- val + -> m Bool -- result +byteWriterPutUint16Le _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_uint16_le _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutUint16LeMethodInfo +instance (signature ~ (Word16 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutUint16LeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutUint16Le + +-- method ByteWriter::put_uint24_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_uint24_be" gst_byte_writer_put_uint24_be :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Word32 -> -- val : TBasicType TUInt32 + IO CInt + + +byteWriterPutUint24Be :: + (MonadIO m) => + ByteWriter -- _obj + -> Word32 -- val + -> m Bool -- result +byteWriterPutUint24Be _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_uint24_be _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutUint24BeMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutUint24BeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutUint24Be + +-- method ByteWriter::put_uint24_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_uint24_le" gst_byte_writer_put_uint24_le :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Word32 -> -- val : TBasicType TUInt32 + IO CInt + + +byteWriterPutUint24Le :: + (MonadIO m) => + ByteWriter -- _obj + -> Word32 -- val + -> m Bool -- result +byteWriterPutUint24Le _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_uint24_le _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutUint24LeMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutUint24LeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutUint24Le + +-- method ByteWriter::put_uint32_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_uint32_be" gst_byte_writer_put_uint32_be :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Word32 -> -- val : TBasicType TUInt32 + IO CInt + + +byteWriterPutUint32Be :: + (MonadIO m) => + ByteWriter -- _obj + -> Word32 -- val + -> m Bool -- result +byteWriterPutUint32Be _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_uint32_be _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutUint32BeMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutUint32BeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutUint32Be + +-- method ByteWriter::put_uint32_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_uint32_le" gst_byte_writer_put_uint32_le :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Word32 -> -- val : TBasicType TUInt32 + IO CInt + + +byteWriterPutUint32Le :: + (MonadIO m) => + ByteWriter -- _obj + -> Word32 -- val + -> m Bool -- result +byteWriterPutUint32Le _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_uint32_le _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutUint32LeMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutUint32LeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutUint32Le + +-- method ByteWriter::put_uint64_be +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_uint64_be" gst_byte_writer_put_uint64_be :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Word64 -> -- val : TBasicType TUInt64 + IO CInt + + +byteWriterPutUint64Be :: + (MonadIO m) => + ByteWriter -- _obj + -> Word64 -- val + -> m Bool -- result +byteWriterPutUint64Be _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_uint64_be _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutUint64BeMethodInfo +instance (signature ~ (Word64 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutUint64BeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutUint64Be + +-- method ByteWriter::put_uint64_le +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_uint64_le" gst_byte_writer_put_uint64_le :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Word64 -> -- val : TBasicType TUInt64 + IO CInt + + +byteWriterPutUint64Le :: + (MonadIO m) => + ByteWriter -- _obj + -> Word64 -- val + -> m Bool -- result +byteWriterPutUint64Le _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_uint64_le _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutUint64LeMethodInfo +instance (signature ~ (Word64 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutUint64LeMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutUint64Le + +-- method ByteWriter::put_uint8 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TBoolean +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_put_uint8" gst_byte_writer_put_uint8 :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + Word8 -> -- val : TBasicType TUInt8 + IO CInt + + +byteWriterPutUint8 :: + (MonadIO m) => + ByteWriter -- _obj + -> Word8 -- val + -> m Bool -- result +byteWriterPutUint8 _obj val = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_put_uint8 _obj' val + let result' = (/= 0) result + touchManagedPtr _obj + return result' + +data ByteWriterPutUint8MethodInfo +instance (signature ~ (Word8 -> m Bool), MonadIO m) => MethodInfo ByteWriterPutUint8MethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterPutUint8 + +-- method ByteWriter::reset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_reset" gst_byte_writer_reset :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + IO () + + +byteWriterReset :: + (MonadIO m) => + ByteWriter -- _obj + -> m () -- result +byteWriterReset _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + gst_byte_writer_reset _obj' + touchManagedPtr _obj + return () + +data ByteWriterResetMethodInfo +instance (signature ~ (m ()), MonadIO m) => MethodInfo ByteWriterResetMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterReset + +-- method ByteWriter::reset_and_get_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "Buffer" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_reset_and_get_buffer" gst_byte_writer_reset_and_get_buffer :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + IO (Ptr Gst.Buffer) + + +byteWriterResetAndGetBuffer :: + (MonadIO m) => + ByteWriter -- _obj + -> m Gst.Buffer -- result +byteWriterResetAndGetBuffer _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_reset_and_get_buffer _obj' + checkUnexpectedReturnNULL "gst_byte_writer_reset_and_get_buffer" result + result' <- (wrapBoxed Gst.Buffer) result + touchManagedPtr _obj + return result' + +data ByteWriterResetAndGetBufferMethodInfo +instance (signature ~ (m Gst.Buffer), MonadIO m) => MethodInfo ByteWriterResetAndGetBufferMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterResetAndGetBuffer + +-- method ByteWriter::reset_and_get_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "ByteWriter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TCArray False (-1) (-1) (TBasicType TUInt8) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_byte_writer_reset_and_get_data" gst_byte_writer_reset_and_get_data :: + Ptr ByteWriter -> -- _obj : TInterface "GstBase" "ByteWriter" + IO (Ptr Word8) + + +byteWriterResetAndGetData :: + (MonadIO m) => + ByteWriter -- _obj + -> m (Ptr Word8) -- result +byteWriterResetAndGetData _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + result <- gst_byte_writer_reset_and_get_data _obj' + checkUnexpectedReturnNULL "gst_byte_writer_reset_and_get_data" result + touchManagedPtr _obj + return result + +data ByteWriterResetAndGetDataMethodInfo +instance (signature ~ (m (Ptr Word8)), MonadIO m) => MethodInfo ByteWriterResetAndGetDataMethodInfo ByteWriter signature where + overloadedMethod _ = byteWriterResetAndGetData + +type family ResolveByteWriterMethod (t :: Symbol) (o :: *) :: * where + ResolveByteWriterMethod "ensureFreeSpace" o = ByteWriterEnsureFreeSpaceMethodInfo + ResolveByteWriterMethod "fill" o = ByteWriterFillMethodInfo + ResolveByteWriterMethod "free" o = ByteWriterFreeMethodInfo + ResolveByteWriterMethod "freeAndGetBuffer" o = ByteWriterFreeAndGetBufferMethodInfo + ResolveByteWriterMethod "freeAndGetData" o = ByteWriterFreeAndGetDataMethodInfo + ResolveByteWriterMethod "init" o = ByteWriterInitMethodInfo + ResolveByteWriterMethod "initWithData" o = ByteWriterInitWithDataMethodInfo + ResolveByteWriterMethod "initWithSize" o = ByteWriterInitWithSizeMethodInfo + ResolveByteWriterMethod "putBuffer" o = ByteWriterPutBufferMethodInfo + ResolveByteWriterMethod "putData" o = ByteWriterPutDataMethodInfo + ResolveByteWriterMethod "putFloat32Be" o = ByteWriterPutFloat32BeMethodInfo + ResolveByteWriterMethod "putFloat32Le" o = ByteWriterPutFloat32LeMethodInfo + ResolveByteWriterMethod "putFloat64Be" o = ByteWriterPutFloat64BeMethodInfo + ResolveByteWriterMethod "putFloat64Le" o = ByteWriterPutFloat64LeMethodInfo + ResolveByteWriterMethod "putInt16Be" o = ByteWriterPutInt16BeMethodInfo + ResolveByteWriterMethod "putInt16Le" o = ByteWriterPutInt16LeMethodInfo + ResolveByteWriterMethod "putInt24Be" o = ByteWriterPutInt24BeMethodInfo + ResolveByteWriterMethod "putInt24Le" o = ByteWriterPutInt24LeMethodInfo + ResolveByteWriterMethod "putInt32Be" o = ByteWriterPutInt32BeMethodInfo + ResolveByteWriterMethod "putInt32Le" o = ByteWriterPutInt32LeMethodInfo + ResolveByteWriterMethod "putInt64Be" o = ByteWriterPutInt64BeMethodInfo + ResolveByteWriterMethod "putInt64Le" o = ByteWriterPutInt64LeMethodInfo + ResolveByteWriterMethod "putInt8" o = ByteWriterPutInt8MethodInfo + ResolveByteWriterMethod "putStringUtf16" o = ByteWriterPutStringUtf16MethodInfo + ResolveByteWriterMethod "putStringUtf32" o = ByteWriterPutStringUtf32MethodInfo + ResolveByteWriterMethod "putStringUtf8" o = ByteWriterPutStringUtf8MethodInfo + ResolveByteWriterMethod "putUint16Be" o = ByteWriterPutUint16BeMethodInfo + ResolveByteWriterMethod "putUint16Le" o = ByteWriterPutUint16LeMethodInfo + ResolveByteWriterMethod "putUint24Be" o = ByteWriterPutUint24BeMethodInfo + ResolveByteWriterMethod "putUint24Le" o = ByteWriterPutUint24LeMethodInfo + ResolveByteWriterMethod "putUint32Be" o = ByteWriterPutUint32BeMethodInfo + ResolveByteWriterMethod "putUint32Le" o = ByteWriterPutUint32LeMethodInfo + ResolveByteWriterMethod "putUint64Be" o = ByteWriterPutUint64BeMethodInfo + ResolveByteWriterMethod "putUint64Le" o = ByteWriterPutUint64LeMethodInfo + ResolveByteWriterMethod "putUint8" o = ByteWriterPutUint8MethodInfo + ResolveByteWriterMethod "reset" o = ByteWriterResetMethodInfo + ResolveByteWriterMethod "resetAndGetBuffer" o = ByteWriterResetAndGetBufferMethodInfo + ResolveByteWriterMethod "resetAndGetData" o = ByteWriterResetAndGetDataMethodInfo + ResolveByteWriterMethod "getRemaining" o = ByteWriterGetRemainingMethodInfo + ResolveByteWriterMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolveByteWriterMethod t ByteWriter, MethodInfo info ByteWriter p) => IsLabelProxy t (ByteWriter -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolveByteWriterMethod t ByteWriter, MethodInfo info ByteWriter p) => IsLabel t (ByteWriter -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + + diff --git a/GI/GstBase/Structs/ByteWriter.hs-boot b/GI/GstBase/Structs/ByteWriter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Structs/ByteWriter.hs-boot @@ -0,0 +1,49 @@ +module GI.GstBase.Structs.ByteWriter where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype ByteWriter = ByteWriter (ForeignPtr ByteWriter) +data ByteWriterEnsureFreeSpaceMethodInfo +data ByteWriterFillMethodInfo +data ByteWriterFreeMethodInfo +data ByteWriterFreeAndGetBufferMethodInfo +data ByteWriterFreeAndGetDataMethodInfo +data ByteWriterGetRemainingMethodInfo +data ByteWriterInitMethodInfo +data ByteWriterInitWithDataMethodInfo +data ByteWriterInitWithSizeMethodInfo +data ByteWriterPutBufferMethodInfo +data ByteWriterPutDataMethodInfo +data ByteWriterPutFloat32BeMethodInfo +data ByteWriterPutFloat32LeMethodInfo +data ByteWriterPutFloat64BeMethodInfo +data ByteWriterPutFloat64LeMethodInfo +data ByteWriterPutInt16BeMethodInfo +data ByteWriterPutInt16LeMethodInfo +data ByteWriterPutInt24BeMethodInfo +data ByteWriterPutInt24LeMethodInfo +data ByteWriterPutInt32BeMethodInfo +data ByteWriterPutInt32LeMethodInfo +data ByteWriterPutInt64BeMethodInfo +data ByteWriterPutInt64LeMethodInfo +data ByteWriterPutInt8MethodInfo +data ByteWriterPutStringUtf16MethodInfo +data ByteWriterPutStringUtf32MethodInfo +data ByteWriterPutStringUtf8MethodInfo +data ByteWriterPutUint16BeMethodInfo +data ByteWriterPutUint16LeMethodInfo +data ByteWriterPutUint24BeMethodInfo +data ByteWriterPutUint24LeMethodInfo +data ByteWriterPutUint32BeMethodInfo +data ByteWriterPutUint32LeMethodInfo +data ByteWriterPutUint64BeMethodInfo +data ByteWriterPutUint64LeMethodInfo +data ByteWriterPutUint8MethodInfo +data ByteWriterResetMethodInfo +data ByteWriterResetAndGetBufferMethodInfo +data ByteWriterResetAndGetDataMethodInfo diff --git a/GI/GstBase/Structs/CollectData.hs b/GI/GstBase/Structs/CollectData.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Structs/CollectData.hs @@ -0,0 +1,104 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) + +Structure used by the collect_pads. +-} + +module GI.GstBase.Structs.CollectData + ( + +-- * Exported types + CollectData(..) , + newZeroCollectData , + noCollectData , + + + -- * Properties +-- ** Buffer + collectDataReadBuffer , + + +-- ** Collect + collectDataReadCollect , + + +-- ** Pad + collectDataReadPad , + + +-- ** Pos + collectDataReadPos , + + +-- ** Segment + collectDataReadSegment , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks +import qualified GI.Gst as Gst + +newtype CollectData = CollectData (ForeignPtr CollectData) +-- | Construct a `CollectData` struct initialized to zero. +newZeroCollectData :: MonadIO m => m CollectData +newZeroCollectData = liftIO $ callocBytes 168 >>= wrapPtr CollectData + +noCollectData :: Maybe CollectData +noCollectData = Nothing + +collectDataReadCollect :: CollectData -> IO CollectPads +collectDataReadCollect s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO (Ptr CollectPads) + val' <- (newObject CollectPads) val + return val' + +collectDataReadPad :: CollectData -> IO Gst.Pad +collectDataReadPad s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO (Ptr Gst.Pad) + val' <- (newObject Gst.Pad) val + return val' + +collectDataReadBuffer :: CollectData -> IO Gst.Buffer +collectDataReadBuffer s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO (Ptr Gst.Buffer) + val' <- (newBoxed Gst.Buffer) val + return val' + +collectDataReadPos :: CollectData -> IO Word32 +collectDataReadPos s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO Word32 + return val + +collectDataReadSegment :: CollectData -> IO Gst.Segment +collectDataReadSegment s = withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO (Ptr Gst.Segment) + val' <- (newBoxed Gst.Segment) val + return val' + +type family ResolveCollectDataMethod (t :: Symbol) (o :: *) :: * where + ResolveCollectDataMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolveCollectDataMethod t CollectData, MethodInfo info CollectData p) => IsLabelProxy t (CollectData -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolveCollectDataMethod t CollectData, MethodInfo info CollectData p) => IsLabel t (CollectData -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + + diff --git a/GI/GstBase/Structs/CollectData.hs-boot b/GI/GstBase/Structs/CollectData.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Structs/CollectData.hs-boot @@ -0,0 +1,10 @@ +module GI.GstBase.Structs.CollectData where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype CollectData = CollectData (ForeignPtr CollectData) diff --git a/GI/GstBase/Structs/FlowCombiner.hs b/GI/GstBase/Structs/FlowCombiner.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Structs/FlowCombiner.hs @@ -0,0 +1,362 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) + +Utility struct to help handling #GstFlowReturn combination. Useful for +#GstElements that have multiple source pads and need to combine +the different #GstFlowReturn for those pads. + +#GstFlowCombiner works by using the last #GstFlowReturn for all #GstPad +it has in its list and computes the combined return value and provides +it to the caller. + +To add a new pad to the #GstFlowCombiner use gst_flow_combiner_add_pad(). +The new #GstPad is stored with a default value of %GST_FLOW_OK. + +In case you want a #GstPad to be removed, use gst_flow_combiner_remove_pad(). + +Please be aware that this struct isn't thread safe as its designed to be + used by demuxers, those usually will have a single thread operating it. + +These functions will take refs on the passed #GstPads. + +Aside from reducing the user's code size, the main advantage of using this +helper struct is to follow the standard rules for #GstFlowReturn combination. +These rules are: + +* %GST_FLOW_EOS: only if all returns are EOS too +* %GST_FLOW_NOT_LINKED: only if all returns are NOT_LINKED too +* %GST_FLOW_ERROR or below: if at least one returns an error return +* %GST_FLOW_NOT_NEGOTIATED: if at least one returns a not-negotiated return +* %GST_FLOW_FLUSHING: if at least one returns flushing +* %GST_FLOW_OK: otherwise + +%GST_FLOW_ERROR or below, GST_FLOW_NOT_NEGOTIATED and GST_FLOW_FLUSHING are +returned immediatelly from the gst_flow_combiner_update_flow() function. +-} + +module GI.GstBase.Structs.FlowCombiner + ( + +-- * Exported types + FlowCombiner(..) , + noFlowCombiner , + + + -- * Methods +-- ** flowCombinerAddPad + FlowCombinerAddPadMethodInfo , + flowCombinerAddPad , + + +-- ** flowCombinerClear + FlowCombinerClearMethodInfo , + flowCombinerClear , + + +-- ** flowCombinerFree + FlowCombinerFreeMethodInfo , + flowCombinerFree , + + +-- ** flowCombinerNew + flowCombinerNew , + + +-- ** flowCombinerRemovePad + FlowCombinerRemovePadMethodInfo , + flowCombinerRemovePad , + + +-- ** flowCombinerReset + FlowCombinerResetMethodInfo , + flowCombinerReset , + + +-- ** flowCombinerUpdateFlow + FlowCombinerUpdateFlowMethodInfo , + flowCombinerUpdateFlow , + + +-- ** flowCombinerUpdatePadFlow + FlowCombinerUpdatePadFlowMethodInfo , + flowCombinerUpdatePadFlow , + + + + + ) where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +import GI.GstBase.Types +import GI.GstBase.Callbacks +import qualified GI.Gst as Gst + +newtype FlowCombiner = FlowCombiner (ForeignPtr FlowCombiner) +foreign import ccall "gst_flow_combiner_get_type" c_gst_flow_combiner_get_type :: + IO GType + +instance BoxedObject FlowCombiner where + boxedType _ = c_gst_flow_combiner_get_type + +noFlowCombiner :: Maybe FlowCombiner +noFlowCombiner = Nothing + +-- method FlowCombiner::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : TInterface "GstBase" "FlowCombiner" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_flow_combiner_new" gst_flow_combiner_new :: + IO (Ptr FlowCombiner) + + +flowCombinerNew :: + (MonadIO m) => + m FlowCombiner -- result +flowCombinerNew = liftIO $ do + result <- gst_flow_combiner_new + checkUnexpectedReturnNULL "gst_flow_combiner_new" result + result' <- (wrapBoxed FlowCombiner) result + return result' + +-- method FlowCombiner::add_pad +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "FlowCombiner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_flow_combiner_add_pad" gst_flow_combiner_add_pad :: + Ptr FlowCombiner -> -- _obj : TInterface "GstBase" "FlowCombiner" + Ptr Gst.Pad -> -- pad : TInterface "Gst" "Pad" + IO () + + +flowCombinerAddPad :: + (MonadIO m, Gst.PadK a) => + FlowCombiner -- _obj + -> a -- pad + -> m () -- result +flowCombinerAddPad _obj pad = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + let pad' = unsafeManagedPtrCastPtr pad + gst_flow_combiner_add_pad _obj' pad' + touchManagedPtr _obj + touchManagedPtr pad + return () + +data FlowCombinerAddPadMethodInfo +instance (signature ~ (a -> m ()), MonadIO m, Gst.PadK a) => MethodInfo FlowCombinerAddPadMethodInfo FlowCombiner signature where + overloadedMethod _ = flowCombinerAddPad + +-- method FlowCombiner::clear +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "FlowCombiner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_flow_combiner_clear" gst_flow_combiner_clear :: + Ptr FlowCombiner -> -- _obj : TInterface "GstBase" "FlowCombiner" + IO () + + +flowCombinerClear :: + (MonadIO m) => + FlowCombiner -- _obj + -> m () -- result +flowCombinerClear _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + gst_flow_combiner_clear _obj' + touchManagedPtr _obj + return () + +data FlowCombinerClearMethodInfo +instance (signature ~ (m ()), MonadIO m) => MethodInfo FlowCombinerClearMethodInfo FlowCombiner signature where + overloadedMethod _ = flowCombinerClear + +-- method FlowCombiner::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "FlowCombiner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_flow_combiner_free" gst_flow_combiner_free :: + Ptr FlowCombiner -> -- _obj : TInterface "GstBase" "FlowCombiner" + IO () + + +flowCombinerFree :: + (MonadIO m) => + FlowCombiner -- _obj + -> m () -- result +flowCombinerFree _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + gst_flow_combiner_free _obj' + touchManagedPtr _obj + return () + +data FlowCombinerFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => MethodInfo FlowCombinerFreeMethodInfo FlowCombiner signature where + overloadedMethod _ = flowCombinerFree + +-- method FlowCombiner::remove_pad +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "FlowCombiner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_flow_combiner_remove_pad" gst_flow_combiner_remove_pad :: + Ptr FlowCombiner -> -- _obj : TInterface "GstBase" "FlowCombiner" + Ptr Gst.Pad -> -- pad : TInterface "Gst" "Pad" + IO () + + +flowCombinerRemovePad :: + (MonadIO m, Gst.PadK a) => + FlowCombiner -- _obj + -> a -- pad + -> m () -- result +flowCombinerRemovePad _obj pad = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + let pad' = unsafeManagedPtrCastPtr pad + gst_flow_combiner_remove_pad _obj' pad' + touchManagedPtr _obj + touchManagedPtr pad + return () + +data FlowCombinerRemovePadMethodInfo +instance (signature ~ (a -> m ()), MonadIO m, Gst.PadK a) => MethodInfo FlowCombinerRemovePadMethodInfo FlowCombiner signature where + overloadedMethod _ = flowCombinerRemovePad + +-- method FlowCombiner::reset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "FlowCombiner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TBasicType TVoid +-- throws : False +-- Skip return : False + +foreign import ccall "gst_flow_combiner_reset" gst_flow_combiner_reset :: + Ptr FlowCombiner -> -- _obj : TInterface "GstBase" "FlowCombiner" + IO () + + +flowCombinerReset :: + (MonadIO m) => + FlowCombiner -- _obj + -> m () -- result +flowCombinerReset _obj = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + gst_flow_combiner_reset _obj' + touchManagedPtr _obj + return () + +data FlowCombinerResetMethodInfo +instance (signature ~ (m ()), MonadIO m) => MethodInfo FlowCombinerResetMethodInfo FlowCombiner signature where + overloadedMethod _ = flowCombinerReset + +-- method FlowCombiner::update_flow +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "FlowCombiner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fret", argType = TInterface "Gst" "FlowReturn", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "FlowReturn" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_flow_combiner_update_flow" gst_flow_combiner_update_flow :: + Ptr FlowCombiner -> -- _obj : TInterface "GstBase" "FlowCombiner" + CUInt -> -- fret : TInterface "Gst" "FlowReturn" + IO CUInt + + +flowCombinerUpdateFlow :: + (MonadIO m) => + FlowCombiner -- _obj + -> Gst.FlowReturn -- fret + -> m Gst.FlowReturn -- result +flowCombinerUpdateFlow _obj fret = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + let fret' = (fromIntegral . fromEnum) fret + result <- gst_flow_combiner_update_flow _obj' fret' + let result' = (toEnum . fromIntegral) result + touchManagedPtr _obj + return result' + +data FlowCombinerUpdateFlowMethodInfo +instance (signature ~ (Gst.FlowReturn -> m Gst.FlowReturn), MonadIO m) => MethodInfo FlowCombinerUpdateFlowMethodInfo FlowCombiner signature where + overloadedMethod _ = flowCombinerUpdateFlow + +-- method FlowCombiner::update_pad_flow +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "_obj", argType = TInterface "GstBase" "FlowCombiner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fret", argType = TInterface "Gst" "FlowReturn", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : TInterface "Gst" "FlowReturn" +-- throws : False +-- Skip return : False + +foreign import ccall "gst_flow_combiner_update_pad_flow" gst_flow_combiner_update_pad_flow :: + Ptr FlowCombiner -> -- _obj : TInterface "GstBase" "FlowCombiner" + Ptr Gst.Pad -> -- pad : TInterface "Gst" "Pad" + CUInt -> -- fret : TInterface "Gst" "FlowReturn" + IO CUInt + + +flowCombinerUpdatePadFlow :: + (MonadIO m, Gst.PadK a) => + FlowCombiner -- _obj + -> a -- pad + -> Gst.FlowReturn -- fret + -> m Gst.FlowReturn -- result +flowCombinerUpdatePadFlow _obj pad fret = liftIO $ do + let _obj' = unsafeManagedPtrGetPtr _obj + let pad' = unsafeManagedPtrCastPtr pad + let fret' = (fromIntegral . fromEnum) fret + result <- gst_flow_combiner_update_pad_flow _obj' pad' fret' + let result' = (toEnum . fromIntegral) result + touchManagedPtr _obj + touchManagedPtr pad + return result' + +data FlowCombinerUpdatePadFlowMethodInfo +instance (signature ~ (a -> Gst.FlowReturn -> m Gst.FlowReturn), MonadIO m, Gst.PadK a) => MethodInfo FlowCombinerUpdatePadFlowMethodInfo FlowCombiner signature where + overloadedMethod _ = flowCombinerUpdatePadFlow + +type family ResolveFlowCombinerMethod (t :: Symbol) (o :: *) :: * where + ResolveFlowCombinerMethod "addPad" o = FlowCombinerAddPadMethodInfo + ResolveFlowCombinerMethod "clear" o = FlowCombinerClearMethodInfo + ResolveFlowCombinerMethod "free" o = FlowCombinerFreeMethodInfo + ResolveFlowCombinerMethod "removePad" o = FlowCombinerRemovePadMethodInfo + ResolveFlowCombinerMethod "reset" o = FlowCombinerResetMethodInfo + ResolveFlowCombinerMethod "updateFlow" o = FlowCombinerUpdateFlowMethodInfo + ResolveFlowCombinerMethod "updatePadFlow" o = FlowCombinerUpdatePadFlowMethodInfo + ResolveFlowCombinerMethod l o = MethodResolutionFailed l o + +instance (info ~ ResolveFlowCombinerMethod t FlowCombiner, MethodInfo info FlowCombiner p) => IsLabelProxy t (FlowCombiner -> p) where + fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info) + +#if MIN_VERSION_base(4,9,0) +instance (info ~ ResolveFlowCombinerMethod t FlowCombiner, MethodInfo info FlowCombiner p) => IsLabel t (FlowCombiner -> p) where + fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info) +#endif + + diff --git a/GI/GstBase/Structs/FlowCombiner.hs-boot b/GI/GstBase/Structs/FlowCombiner.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstBase/Structs/FlowCombiner.hs-boot @@ -0,0 +1,18 @@ +module GI.GstBase.Structs.FlowCombiner where + +import Prelude () +import Data.GI.Base.ShortPrelude + +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map + +newtype FlowCombiner = FlowCombiner (ForeignPtr FlowCombiner) +instance BoxedObject FlowCombiner where +data FlowCombinerAddPadMethodInfo +data FlowCombinerClearMethodInfo +data FlowCombinerFreeMethodInfo +data FlowCombinerRemovePadMethodInfo +data FlowCombinerResetMethodInfo +data FlowCombinerUpdateFlowMethodInfo +data FlowCombinerUpdatePadFlowMethodInfo diff --git a/GI/GstBase/Types.hs b/GI/GstBase/Types.hs new file mode 100644 --- /dev/null +++ b/GI/GstBase/Types.hs @@ -0,0 +1,38 @@ +module GI.GstBase.Types + ( module GI.GstBase.Objects.Adapter , + module GI.GstBase.Objects.BaseParse , + module GI.GstBase.Objects.BaseSink , + module GI.GstBase.Objects.BaseSrc , + module GI.GstBase.Objects.BaseTransform , + module GI.GstBase.Objects.CollectPads , + module GI.GstBase.Objects.DataQueue , + module GI.GstBase.Objects.PushSrc , + module GI.GstBase.Structs.BaseParseFrame, + module GI.GstBase.Structs.BitReader , + module GI.GstBase.Structs.ByteReader , + module GI.GstBase.Structs.ByteWriter , + module GI.GstBase.Structs.CollectData , + module GI.GstBase.Structs.FlowCombiner , + module GI.GstBase.Flags , + + + ) where + + +import {-# SOURCE #-} GI.GstBase.Objects.Adapter +import {-# SOURCE #-} GI.GstBase.Objects.BaseParse +import {-# SOURCE #-} GI.GstBase.Objects.BaseSink +import {-# SOURCE #-} GI.GstBase.Objects.BaseSrc +import {-# SOURCE #-} GI.GstBase.Objects.BaseTransform +import {-# SOURCE #-} GI.GstBase.Objects.CollectPads +import {-# SOURCE #-} GI.GstBase.Objects.DataQueue +import {-# SOURCE #-} GI.GstBase.Objects.PushSrc +import {-# SOURCE #-} GI.GstBase.Structs.BaseParseFrame +import {-# SOURCE #-} GI.GstBase.Structs.BitReader +import {-# SOURCE #-} GI.GstBase.Structs.ByteReader +import {-# SOURCE #-} GI.GstBase.Structs.ByteWriter +import {-# SOURCE #-} GI.GstBase.Structs.CollectData +import {-# SOURCE #-} GI.GstBase.Structs.FlowCombiner + +import GI.GstBase.Flags + diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,456 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,3 @@ +#!/usr/bin/env runhaskell +import Distribution.Simple +main = defaultMain diff --git a/gi-gstbase.cabal b/gi-gstbase.cabal new file mode 100644 --- /dev/null +++ b/gi-gstbase.cabal @@ -0,0 +1,51 @@ +-- Autogenerated, do not edit. +name: gi-gstbase +version: 0.1.6.13 +synopsis: GstBase bindings +description: Bindings for GstBase, autogenerated by haskell-gi. +homepage: https://github.com/haskell-gi/haskell-gi +license: LGPL-2.1 +license-file: LICENSE +author: Will Thompson, Iñaki García Etxebarria and Jonas Platte +maintainer: Iñaki García Etxebarria (garetxe@gmail.com) +category: Bindings +build-type: Simple +cabal-version: >=1.10 + +library + default-language: Haskell2010 + default-extensions: ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts + other-extensions: PatternSynonyms ViewPatterns + ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations + exposed-modules: GI.GstBase.Types + GI.GstBase + GI.GstBase.Callbacks + GI.GstBase.Constants + GI.GstBase.Flags + GI.GstBase.Functions + GI.GstBase.Objects + GI.GstBase.Objects.Adapter + GI.GstBase.Objects.BaseParse + GI.GstBase.Objects.BaseSink + GI.GstBase.Objects.BaseSrc + GI.GstBase.Objects.BaseTransform + GI.GstBase.Objects.CollectPads + GI.GstBase.Objects.DataQueue + GI.GstBase.Objects.PushSrc + GI.GstBase.Structs + GI.GstBase.Structs.BaseParseFrame + GI.GstBase.Structs.BitReader + GI.GstBase.Structs.ByteReader + GI.GstBase.Structs.ByteWriter + GI.GstBase.Structs.CollectData + GI.GstBase.Structs.FlowCombiner + pkgconfig-depends: gstreamer-base-1.0 >= 1.6 + build-depends: base >= 4.7 && <5, + haskell-gi-base >= 0.13 && < 1, + gi-glib >= 0.2.46.13 && < 0.2.47, + gi-gobject >= 0.2.46.13 && < 0.2.47, + gi-gst >= 0.1.6.13 && < 0.1.7, + bytestring >= 0.10, + containers >= 0.5, + text >= 1.0, + transformers >= 0.3