packages feed

gi-gstbase (empty) → 0.1.6.13

raw patch · 39 files changed

+13791/−0 lines, 39 filesdep +basedep +bytestringdep +containerssetup-changed

Dependencies added: base, bytestring, containers, gi-glib, gi-gobject, gi-gst, haskell-gi-base, text, transformers

Files

+ GI/GstBase.hs view
@@ -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+
+ GI/GstBase/Callbacks.hs view
@@ -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++
+ GI/GstBase/Constants.hs view
@@ -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++
+ GI/GstBase/Flags.hs view
@@ -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++
+ GI/GstBase/Functions.hs view
@@ -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'+++
+ GI/GstBase/Objects.hs view
@@ -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++
+ GI/GstBase/Objects/Adapter.hs view
@@ -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++
+ GI/GstBase/Objects/Adapter.hs-boot view
@@ -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
+ GI/GstBase/Objects/BaseParse.hs view
@@ -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++
+ GI/GstBase/Objects/BaseParse.hs-boot view
@@ -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
+ GI/GstBase/Objects/BaseSink.hs view
@@ -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++
+ GI/GstBase/Objects/BaseSink.hs-boot view
@@ -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
+ GI/GstBase/Objects/BaseSrc.hs view
@@ -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++
+ GI/GstBase/Objects/BaseSrc.hs-boot view
@@ -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
+ GI/GstBase/Objects/BaseTransform.hs view
@@ -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++
+ GI/GstBase/Objects/BaseTransform.hs-boot view
@@ -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
+ GI/GstBase/Objects/CollectPads.hs view
@@ -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++
+ GI/GstBase/Objects/CollectPads.hs-boot view
@@ -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
+ GI/GstBase/Objects/DataQueue.hs view
@@ -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, *)])++
+ GI/GstBase/Objects/DataQueue.hs-boot view
@@ -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
+ GI/GstBase/Objects/PushSrc.hs view
@@ -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, *)])++
+ GI/GstBase/Objects/PushSrc.hs-boot view
@@ -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
+ GI/GstBase/Structs.hs view
@@ -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++
+ GI/GstBase/Structs/BaseParseFrame.hs view
@@ -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++
+ GI/GstBase/Structs/BaseParseFrame.hs-boot view
@@ -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
+ GI/GstBase/Structs/BitReader.hs view
@@ -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++
+ GI/GstBase/Structs/BitReader.hs-boot view
@@ -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
+ GI/GstBase/Structs/ByteReader.hs view
@@ -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++
+ GI/GstBase/Structs/ByteReader.hs-boot view
@@ -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
+ GI/GstBase/Structs/ByteWriter.hs view
@@ -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++
+ GI/GstBase/Structs/ByteWriter.hs-boot view
@@ -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
+ GI/GstBase/Structs/CollectData.hs view
@@ -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++
+ GI/GstBase/Structs/CollectData.hs-boot view
@@ -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)
+ GI/GstBase/Structs/FlowCombiner.hs view
@@ -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+#GstElement<!-- -->s 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 #GstPad<!-- -->s.++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++
+ GI/GstBase/Structs/FlowCombiner.hs-boot view
@@ -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
+ GI/GstBase/Types.hs view
@@ -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+
+ LICENSE view
@@ -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.
+ Setup.hs view
@@ -0,0 +1,3 @@+#!/usr/bin/env runhaskell+import Distribution.Simple+main = defaultMain
+ gi-gstbase.cabal view
@@ -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