{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) A 'GI.Gst.Objects.BufferPool.BufferPool' is an object that can be used to pre-allocate and recycle buffers of the same size and with the same properties. A 'GI.Gst.Objects.BufferPool.BufferPool' is created with 'GI.Gst.Objects.BufferPool.bufferPoolNew'. Once a pool is created, it needs to be configured. A call to 'GI.Gst.Objects.BufferPool.bufferPoolGetConfig' returns the current configuration structure from the pool. With 'GI.Gst.Objects.BufferPool.bufferPoolConfigSetParams' and 'GI.Gst.Objects.BufferPool.bufferPoolConfigSetAllocator' the bufferpool parameters and allocator can be configured. Other properties can be configured in the pool depending on the pool implementation. A bufferpool can have extra options that can be enabled with 'GI.Gst.Objects.BufferPool.bufferPoolConfigAddOption'. The available options can be retrieved with 'GI.Gst.Objects.BufferPool.bufferPoolGetOptions'. Some options allow for additional configuration properties to be set. After the configuration structure has been configured, 'GI.Gst.Objects.BufferPool.bufferPoolSetConfig' updates the configuration in the pool. This can fail when the configuration structure is not accepted. After the a pool has been configured, it can be activated with 'GI.Gst.Objects.BufferPool.bufferPoolSetActive'. This will preallocate the configured resources in the pool. When the pool is active, 'GI.Gst.Objects.BufferPool.bufferPoolAcquireBuffer' can be used to retrieve a buffer from the pool. Buffers allocated from a bufferpool will automatically be returned to the pool with 'GI.Gst.Objects.BufferPool.bufferPoolReleaseBuffer' when their refcount drops to 0. The bufferpool can be deactivated again with 'GI.Gst.Objects.BufferPool.bufferPoolSetActive'. All further 'GI.Gst.Objects.BufferPool.bufferPoolAcquireBuffer' calls will return an error. When all buffers are returned to the pool they will be freed. Use 'GI.Gst.Objects.Object.objectUnref' to release the reference to a bufferpool. If the refcount of the pool reaches 0, the pool will be freed. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gst.Objects.BufferPool ( -- * Exported types BufferPool(..) , IsBufferPool , toBufferPool , noBufferPool , -- * Methods -- ** acquireBuffer #method:acquireBuffer# #if ENABLE_OVERLOADING BufferPoolAcquireBufferMethodInfo , #endif bufferPoolAcquireBuffer , -- ** configAddOption #method:configAddOption# bufferPoolConfigAddOption , -- ** configGetAllocator #method:configGetAllocator# bufferPoolConfigGetAllocator , -- ** configGetOption #method:configGetOption# bufferPoolConfigGetOption , -- ** configGetParams #method:configGetParams# bufferPoolConfigGetParams , -- ** configHasOption #method:configHasOption# bufferPoolConfigHasOption , -- ** configNOptions #method:configNOptions# bufferPoolConfigNOptions , -- ** configSetAllocator #method:configSetAllocator# bufferPoolConfigSetAllocator , -- ** configSetParams #method:configSetParams# bufferPoolConfigSetParams , -- ** configValidateParams #method:configValidateParams# bufferPoolConfigValidateParams , -- ** getConfig #method:getConfig# #if ENABLE_OVERLOADING BufferPoolGetConfigMethodInfo , #endif bufferPoolGetConfig , -- ** getOptions #method:getOptions# #if ENABLE_OVERLOADING BufferPoolGetOptionsMethodInfo , #endif bufferPoolGetOptions , -- ** hasOption #method:hasOption# #if ENABLE_OVERLOADING BufferPoolHasOptionMethodInfo , #endif bufferPoolHasOption , -- ** isActive #method:isActive# #if ENABLE_OVERLOADING BufferPoolIsActiveMethodInfo , #endif bufferPoolIsActive , -- ** new #method:new# bufferPoolNew , -- ** releaseBuffer #method:releaseBuffer# #if ENABLE_OVERLOADING BufferPoolReleaseBufferMethodInfo , #endif bufferPoolReleaseBuffer , -- ** setActive #method:setActive# #if ENABLE_OVERLOADING BufferPoolSetActiveMethodInfo , #endif bufferPoolSetActive , -- ** setConfig #method:setConfig# #if ENABLE_OVERLOADING BufferPoolSetConfigMethodInfo , #endif bufferPoolSetConfig , -- ** setFlushing #method:setFlushing# #if ENABLE_OVERLOADING BufferPoolSetFlushingMethodInfo , #endif bufferPoolSetFlushing , ) where import Data.GI.Base.ShortPrelude import qualified Data.GI.Base.ShortPrelude as SP import qualified Data.GI.Base.Overloading as O import qualified Prelude as P import qualified Data.GI.Base.Attributes as GI.Attributes import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr import qualified Data.GI.Base.GClosure as B.GClosure import qualified Data.GI.Base.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GValue as B.GValue import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack import qualified Data.GI.Base.Properties as B.Properties import qualified Data.Text as T import qualified Data.ByteString.Char8 as B import qualified Data.Map as Map import qualified Foreign.Ptr as FP import qualified GHC.OverloadedLabels as OL import qualified GI.GObject.Objects.Object as GObject.Object import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums import {-# SOURCE #-} qualified GI.Gst.Objects.Allocator as Gst.Allocator import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object import {-# SOURCE #-} qualified GI.Gst.Structs.AllocationParams as Gst.AllocationParams import {-# SOURCE #-} qualified GI.Gst.Structs.Buffer as Gst.Buffer import {-# SOURCE #-} qualified GI.Gst.Structs.BufferPoolAcquireParams as Gst.BufferPoolAcquireParams import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps import {-# SOURCE #-} qualified GI.Gst.Structs.Structure as Gst.Structure -- | Memory-managed wrapper type. newtype BufferPool = BufferPool (ManagedPtr BufferPool) foreign import ccall "gst_buffer_pool_get_type" c_gst_buffer_pool_get_type :: IO GType instance GObject BufferPool where gobjectType = c_gst_buffer_pool_get_type -- | Type class for types which can be safely cast to `BufferPool`, for instance with `toBufferPool`. class (GObject o, O.IsDescendantOf BufferPool o) => IsBufferPool o instance (GObject o, O.IsDescendantOf BufferPool o) => IsBufferPool o instance O.HasParentTypes BufferPool type instance O.ParentTypes BufferPool = '[Gst.Object.Object, GObject.Object.Object] -- | Cast to `BufferPool`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toBufferPool :: (MonadIO m, IsBufferPool o) => o -> m BufferPool toBufferPool = liftIO . unsafeCastTo BufferPool -- | A convenience alias for `Nothing` :: `Maybe` `BufferPool`. noBufferPool :: Maybe BufferPool noBufferPool = Nothing #if ENABLE_OVERLOADING type family ResolveBufferPoolMethod (t :: Symbol) (o :: *) :: * where ResolveBufferPoolMethod "acquireBuffer" o = BufferPoolAcquireBufferMethodInfo ResolveBufferPoolMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo ResolveBufferPoolMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveBufferPoolMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveBufferPoolMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo ResolveBufferPoolMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveBufferPoolMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveBufferPoolMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveBufferPoolMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo ResolveBufferPoolMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo ResolveBufferPoolMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo ResolveBufferPoolMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo ResolveBufferPoolMethod "hasOption" o = BufferPoolHasOptionMethodInfo ResolveBufferPoolMethod "isActive" o = BufferPoolIsActiveMethodInfo ResolveBufferPoolMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveBufferPoolMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveBufferPoolMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveBufferPoolMethod "ref" o = Gst.Object.ObjectRefMethodInfo ResolveBufferPoolMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveBufferPoolMethod "releaseBuffer" o = BufferPoolReleaseBufferMethodInfo ResolveBufferPoolMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo ResolveBufferPoolMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveBufferPoolMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveBufferPoolMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveBufferPoolMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo ResolveBufferPoolMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo ResolveBufferPoolMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveBufferPoolMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo ResolveBufferPoolMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo ResolveBufferPoolMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveBufferPoolMethod "getConfig" o = BufferPoolGetConfigMethodInfo ResolveBufferPoolMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo ResolveBufferPoolMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo ResolveBufferPoolMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveBufferPoolMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo ResolveBufferPoolMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo ResolveBufferPoolMethod "getOptions" o = BufferPoolGetOptionsMethodInfo ResolveBufferPoolMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo ResolveBufferPoolMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo ResolveBufferPoolMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveBufferPoolMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveBufferPoolMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo ResolveBufferPoolMethod "setActive" o = BufferPoolSetActiveMethodInfo ResolveBufferPoolMethod "setConfig" o = BufferPoolSetConfigMethodInfo ResolveBufferPoolMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo ResolveBufferPoolMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo ResolveBufferPoolMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo ResolveBufferPoolMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveBufferPoolMethod "setFlushing" o = BufferPoolSetFlushingMethodInfo ResolveBufferPoolMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo ResolveBufferPoolMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo ResolveBufferPoolMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveBufferPoolMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveBufferPoolMethod t BufferPool, O.MethodInfo info BufferPool p) => OL.IsLabel t (BufferPool -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif #if ENABLE_OVERLOADING instance O.HasAttributeList BufferPool type instance O.AttributeList BufferPool = BufferPoolAttributeList type BufferPoolAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING #endif #if ENABLE_OVERLOADING type instance O.SignalList BufferPool = BufferPoolSignalList type BufferPoolSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method BufferPool::new -- method type : Constructor -- Args : [] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "BufferPool"})) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_new" gst_buffer_pool_new :: IO (Ptr BufferPool) {- | Creates a new 'GI.Gst.Objects.BufferPool.BufferPool' instance. -} bufferPoolNew :: (B.CallStack.HasCallStack, MonadIO m) => m BufferPool {- ^ __Returns:__ a new 'GI.Gst.Objects.BufferPool.BufferPool' instance -} bufferPoolNew = liftIO $ do result <- gst_buffer_pool_new checkUnexpectedReturnNULL "bufferPoolNew" result result' <- (wrapObject BufferPool) result return result' #if ENABLE_OVERLOADING #endif -- method BufferPool::acquire_buffer -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pool", argType = TInterface (Name {namespace = "Gst", name = "BufferPool"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location for a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TInterface (Name {namespace = "Gst", name = "BufferPoolAcquireParams"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "parameters.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_acquire_buffer" gst_buffer_pool_acquire_buffer :: Ptr BufferPool -> -- pool : TInterface (Name {namespace = "Gst", name = "BufferPool"}) Ptr (Ptr Gst.Buffer.Buffer) -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) Ptr Gst.BufferPoolAcquireParams.BufferPoolAcquireParams -> -- params : TInterface (Name {namespace = "Gst", name = "BufferPoolAcquireParams"}) IO CInt {- | Acquire a buffer from /@pool@/. /@buffer@/ should point to a memory location that can hold a pointer to the new buffer. /@params@/ can be 'Nothing' or contain optional parameters to influence the allocation. -} bufferPoolAcquireBuffer :: (B.CallStack.HasCallStack, MonadIO m, IsBufferPool a) => a {- ^ /@pool@/: a 'GI.Gst.Objects.BufferPool.BufferPool' -} -> Maybe (Gst.BufferPoolAcquireParams.BufferPoolAcquireParams) {- ^ /@params@/: parameters. -} -> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer)) {- ^ __Returns:__ a 'GI.Gst.Enums.FlowReturn' such as 'GI.Gst.Enums.FlowReturnFlushing' when the pool is inactive. -} bufferPoolAcquireBuffer pool params = liftIO $ do pool' <- unsafeManagedPtrCastPtr pool buffer <- allocMem :: IO (Ptr (Ptr Gst.Buffer.Buffer)) maybeParams <- case params of Nothing -> return nullPtr Just jParams -> do jParams' <- unsafeManagedPtrGetPtr jParams return jParams' result <- gst_buffer_pool_acquire_buffer pool' buffer maybeParams let result' = (toEnum . fromIntegral) result buffer' <- peek buffer buffer'' <- (wrapBoxed Gst.Buffer.Buffer) buffer' touchManagedPtr pool whenJust params touchManagedPtr freeMem buffer return (result', buffer'') #if ENABLE_OVERLOADING data BufferPoolAcquireBufferMethodInfo instance (signature ~ (Maybe (Gst.BufferPoolAcquireParams.BufferPoolAcquireParams) -> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))), MonadIO m, IsBufferPool a) => O.MethodInfo BufferPoolAcquireBufferMethodInfo a signature where overloadedMethod _ = bufferPoolAcquireBuffer #endif -- method BufferPool::get_config -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pool", argType = TInterface (Name {namespace = "Gst", name = "BufferPool"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Structure"})) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_get_config" gst_buffer_pool_get_config :: Ptr BufferPool -> -- pool : TInterface (Name {namespace = "Gst", name = "BufferPool"}) IO (Ptr Gst.Structure.Structure) {- | Get a copy of the current configuration of the pool. This configuration can either be modified and used for the 'GI.Gst.Objects.BufferPool.bufferPoolSetConfig' call or it must be freed after usage. -} bufferPoolGetConfig :: (B.CallStack.HasCallStack, MonadIO m, IsBufferPool a) => a {- ^ /@pool@/: a 'GI.Gst.Objects.BufferPool.BufferPool' -} -> m Gst.Structure.Structure {- ^ __Returns:__ a copy of the current configuration of /@pool@/. use 'GI.Gst.Structs.Structure.structureFree' after usage or 'GI.Gst.Objects.BufferPool.bufferPoolSetConfig'. -} bufferPoolGetConfig pool = liftIO $ do pool' <- unsafeManagedPtrCastPtr pool result <- gst_buffer_pool_get_config pool' checkUnexpectedReturnNULL "bufferPoolGetConfig" result result' <- (wrapBoxed Gst.Structure.Structure) result touchManagedPtr pool return result' #if ENABLE_OVERLOADING data BufferPoolGetConfigMethodInfo instance (signature ~ (m Gst.Structure.Structure), MonadIO m, IsBufferPool a) => O.MethodInfo BufferPoolGetConfigMethodInfo a signature where overloadedMethod _ = bufferPoolGetConfig #endif -- method BufferPool::get_options -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pool", argType = TInterface (Name {namespace = "Gst", name = "BufferPool"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_get_options" gst_buffer_pool_get_options :: Ptr BufferPool -> -- pool : TInterface (Name {namespace = "Gst", name = "BufferPool"}) IO (Ptr CString) {- | Get a 'Nothing' terminated array of string with supported bufferpool options for /@pool@/. An option would typically be enabled with 'GI.Gst.Objects.BufferPool.bufferPoolConfigAddOption'. -} bufferPoolGetOptions :: (B.CallStack.HasCallStack, MonadIO m, IsBufferPool a) => a {- ^ /@pool@/: a 'GI.Gst.Objects.BufferPool.BufferPool' -} -> m [T.Text] {- ^ __Returns:__ a 'Nothing' terminated array of strings. -} bufferPoolGetOptions pool = liftIO $ do pool' <- unsafeManagedPtrCastPtr pool result <- gst_buffer_pool_get_options pool' checkUnexpectedReturnNULL "bufferPoolGetOptions" result result' <- unpackZeroTerminatedUTF8CArray result touchManagedPtr pool return result' #if ENABLE_OVERLOADING data BufferPoolGetOptionsMethodInfo instance (signature ~ (m [T.Text]), MonadIO m, IsBufferPool a) => O.MethodInfo BufferPoolGetOptionsMethodInfo a signature where overloadedMethod _ = bufferPoolGetOptions #endif -- method BufferPool::has_option -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pool", argType = TInterface (Name {namespace = "Gst", name = "BufferPool"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an option", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_has_option" gst_buffer_pool_has_option :: Ptr BufferPool -> -- pool : TInterface (Name {namespace = "Gst", name = "BufferPool"}) CString -> -- option : TBasicType TUTF8 IO CInt {- | Check if the bufferpool supports /@option@/. -} bufferPoolHasOption :: (B.CallStack.HasCallStack, MonadIO m, IsBufferPool a) => a {- ^ /@pool@/: a 'GI.Gst.Objects.BufferPool.BufferPool' -} -> T.Text {- ^ /@option@/: an option -} -> m Bool {- ^ __Returns:__ 'True' if the buffer pool contains /@option@/. -} bufferPoolHasOption pool option = liftIO $ do pool' <- unsafeManagedPtrCastPtr pool option' <- textToCString option result <- gst_buffer_pool_has_option pool' option' let result' = (/= 0) result touchManagedPtr pool freeMem option' return result' #if ENABLE_OVERLOADING data BufferPoolHasOptionMethodInfo instance (signature ~ (T.Text -> m Bool), MonadIO m, IsBufferPool a) => O.MethodInfo BufferPoolHasOptionMethodInfo a signature where overloadedMethod _ = bufferPoolHasOption #endif -- method BufferPool::is_active -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pool", argType = TInterface (Name {namespace = "Gst", name = "BufferPool"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_is_active" gst_buffer_pool_is_active :: Ptr BufferPool -> -- pool : TInterface (Name {namespace = "Gst", name = "BufferPool"}) IO CInt {- | Check if /@pool@/ is active. A pool can be activated with the 'GI.Gst.Objects.BufferPool.bufferPoolSetActive' call. -} bufferPoolIsActive :: (B.CallStack.HasCallStack, MonadIO m, IsBufferPool a) => a {- ^ /@pool@/: a 'GI.Gst.Objects.BufferPool.BufferPool' -} -> m Bool {- ^ __Returns:__ 'True' when the pool is active. -} bufferPoolIsActive pool = liftIO $ do pool' <- unsafeManagedPtrCastPtr pool result <- gst_buffer_pool_is_active pool' let result' = (/= 0) result touchManagedPtr pool return result' #if ENABLE_OVERLOADING data BufferPoolIsActiveMethodInfo instance (signature ~ (m Bool), MonadIO m, IsBufferPool a) => O.MethodInfo BufferPoolIsActiveMethodInfo a signature where overloadedMethod _ = bufferPoolIsActive #endif -- method BufferPool::release_buffer -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pool", argType = TInterface (Name {namespace = "Gst", name = "BufferPool"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_release_buffer" gst_buffer_pool_release_buffer :: Ptr BufferPool -> -- pool : TInterface (Name {namespace = "Gst", name = "BufferPool"}) Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) IO () {- | Release /@buffer@/ to /@pool@/. /@buffer@/ should have previously been allocated from /@pool@/ with 'GI.Gst.Objects.BufferPool.bufferPoolAcquireBuffer'. This function is usually called automatically when the last ref on /@buffer@/ disappears. -} bufferPoolReleaseBuffer :: (B.CallStack.HasCallStack, MonadIO m, IsBufferPool a) => a {- ^ /@pool@/: a 'GI.Gst.Objects.BufferPool.BufferPool' -} -> Gst.Buffer.Buffer {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} -> m () bufferPoolReleaseBuffer pool buffer = liftIO $ do pool' <- unsafeManagedPtrCastPtr pool buffer' <- B.ManagedPtr.disownBoxed buffer gst_buffer_pool_release_buffer pool' buffer' touchManagedPtr pool touchManagedPtr buffer return () #if ENABLE_OVERLOADING data BufferPoolReleaseBufferMethodInfo instance (signature ~ (Gst.Buffer.Buffer -> m ()), MonadIO m, IsBufferPool a) => O.MethodInfo BufferPoolReleaseBufferMethodInfo a signature where overloadedMethod _ = bufferPoolReleaseBuffer #endif -- method BufferPool::set_active -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pool", argType = TInterface (Name {namespace = "Gst", name = "BufferPool"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new active state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_set_active" gst_buffer_pool_set_active :: Ptr BufferPool -> -- pool : TInterface (Name {namespace = "Gst", name = "BufferPool"}) CInt -> -- active : TBasicType TBoolean IO CInt {- | Control the active state of /@pool@/. When the pool is inactive, new calls to 'GI.Gst.Objects.BufferPool.bufferPoolAcquireBuffer' will return with 'GI.Gst.Enums.FlowReturnFlushing'. Activating the bufferpool will preallocate all resources in the pool based on the configuration of the pool. Deactivating will free the resources again when there are no outstanding buffers. When there are outstanding buffers, they will be freed as soon as they are all returned to the pool. -} bufferPoolSetActive :: (B.CallStack.HasCallStack, MonadIO m, IsBufferPool a) => a {- ^ /@pool@/: a 'GI.Gst.Objects.BufferPool.BufferPool' -} -> Bool {- ^ /@active@/: the new active state -} -> m Bool {- ^ __Returns:__ 'False' when the pool was not configured or when preallocation of the buffers failed. -} bufferPoolSetActive pool active = liftIO $ do pool' <- unsafeManagedPtrCastPtr pool let active' = (fromIntegral . fromEnum) active result <- gst_buffer_pool_set_active pool' active' let result' = (/= 0) result touchManagedPtr pool return result' #if ENABLE_OVERLOADING data BufferPoolSetActiveMethodInfo instance (signature ~ (Bool -> m Bool), MonadIO m, IsBufferPool a) => O.MethodInfo BufferPoolSetActiveMethodInfo a signature where overloadedMethod _ = bufferPoolSetActive #endif -- method BufferPool::set_config -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pool", argType = TInterface (Name {namespace = "Gst", name = "BufferPool"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_set_config" gst_buffer_pool_set_config :: Ptr BufferPool -> -- pool : TInterface (Name {namespace = "Gst", name = "BufferPool"}) Ptr Gst.Structure.Structure -> -- config : TInterface (Name {namespace = "Gst", name = "Structure"}) IO CInt {- | Set the configuration of the pool. If the pool is already configured, and the configuration haven\'t change, this function will return 'True'. If the pool is active, this method will return 'False' and active configuration will remain. Buffers allocated form this pool must be returned or else this function will do nothing and return 'False'. /@config@/ is a 'GI.Gst.Structs.Structure.Structure' that contains the configuration parameters for the pool. A default and mandatory set of parameters can be configured with 'GI.Gst.Objects.BufferPool.bufferPoolConfigSetParams', 'GI.Gst.Objects.BufferPool.bufferPoolConfigSetAllocator' and 'GI.Gst.Objects.BufferPool.bufferPoolConfigAddOption'. If the parameters in /@config@/ can not be set exactly, this function returns 'False' and will try to update as much state as possible. The new state can then be retrieved and refined with 'GI.Gst.Objects.BufferPool.bufferPoolGetConfig'. This function takes ownership of /@config@/. -} bufferPoolSetConfig :: (B.CallStack.HasCallStack, MonadIO m, IsBufferPool a) => a {- ^ /@pool@/: a 'GI.Gst.Objects.BufferPool.BufferPool' -} -> Gst.Structure.Structure {- ^ /@config@/: a 'GI.Gst.Structs.Structure.Structure' -} -> m Bool {- ^ __Returns:__ 'True' when the configuration could be set. -} bufferPoolSetConfig pool config = liftIO $ do pool' <- unsafeManagedPtrCastPtr pool config' <- B.ManagedPtr.disownBoxed config result <- gst_buffer_pool_set_config pool' config' let result' = (/= 0) result touchManagedPtr pool touchManagedPtr config return result' #if ENABLE_OVERLOADING data BufferPoolSetConfigMethodInfo instance (signature ~ (Gst.Structure.Structure -> m Bool), MonadIO m, IsBufferPool a) => O.MethodInfo BufferPoolSetConfigMethodInfo a signature where overloadedMethod _ = bufferPoolSetConfig #endif -- method BufferPool::set_flushing -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pool", argType = TInterface (Name {namespace = "Gst", name = "BufferPool"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flushing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to start or stop flushing", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_set_flushing" gst_buffer_pool_set_flushing :: Ptr BufferPool -> -- pool : TInterface (Name {namespace = "Gst", name = "BufferPool"}) CInt -> -- flushing : TBasicType TBoolean IO () {- | Enable or disable the flushing state of a /@pool@/ without freeing or allocating buffers. /Since: 1.4/ -} bufferPoolSetFlushing :: (B.CallStack.HasCallStack, MonadIO m, IsBufferPool a) => a {- ^ /@pool@/: a 'GI.Gst.Objects.BufferPool.BufferPool' -} -> Bool {- ^ /@flushing@/: whether to start or stop flushing -} -> m () bufferPoolSetFlushing pool flushing = liftIO $ do pool' <- unsafeManagedPtrCastPtr pool let flushing' = (fromIntegral . fromEnum) flushing gst_buffer_pool_set_flushing pool' flushing' touchManagedPtr pool return () #if ENABLE_OVERLOADING data BufferPoolSetFlushingMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m, IsBufferPool a) => O.MethodInfo BufferPoolSetFlushingMethodInfo a signature where overloadedMethod _ = bufferPoolSetFlushing #endif -- method BufferPool::config_add_option -- method type : MemberFunction -- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool configuration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an option to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_config_add_option" gst_buffer_pool_config_add_option :: Ptr Gst.Structure.Structure -> -- config : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- option : TBasicType TUTF8 IO () {- | Enabled the option in /@config@/. This will instruct the /@bufferpool@/ to enable the specified option on the buffers that it allocates. The supported options by /@pool@/ can be retrieved with 'GI.Gst.Objects.BufferPool.bufferPoolGetOptions'. -} bufferPoolConfigAddOption :: (B.CallStack.HasCallStack, MonadIO m) => Gst.Structure.Structure {- ^ /@config@/: a 'GI.Gst.Objects.BufferPool.BufferPool' configuration -} -> T.Text {- ^ /@option@/: an option to add -} -> m () bufferPoolConfigAddOption config option = liftIO $ do config' <- unsafeManagedPtrGetPtr config option' <- textToCString option gst_buffer_pool_config_add_option config' option' touchManagedPtr config freeMem option' return () #if ENABLE_OVERLOADING #endif -- method BufferPool::config_get_allocator -- method type : MemberFunction -- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool configuration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface (Name {namespace = "Gst", name = "Allocator"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAllocator, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface (Name {namespace = "Gst", name = "AllocationParams"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstAllocationParams, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_config_get_allocator" gst_buffer_pool_config_get_allocator :: Ptr Gst.Structure.Structure -> -- config : TInterface (Name {namespace = "Gst", name = "Structure"}) Ptr (Ptr Gst.Allocator.Allocator) -> -- allocator : TInterface (Name {namespace = "Gst", name = "Allocator"}) Ptr Gst.AllocationParams.AllocationParams -> -- params : TInterface (Name {namespace = "Gst", name = "AllocationParams"}) IO CInt {- | Get the /@allocator@/ and /@params@/ from /@config@/. -} bufferPoolConfigGetAllocator :: (B.CallStack.HasCallStack, MonadIO m) => Gst.Structure.Structure {- ^ /@config@/: a 'GI.Gst.Objects.BufferPool.BufferPool' configuration -} -> m ((Bool, Gst.Allocator.Allocator, Gst.AllocationParams.AllocationParams)) {- ^ __Returns:__ 'True', if the values are set. -} bufferPoolConfigGetAllocator config = liftIO $ do config' <- unsafeManagedPtrGetPtr config allocator <- allocMem :: IO (Ptr (Ptr Gst.Allocator.Allocator)) params <- callocBoxedBytes 64 :: IO (Ptr Gst.AllocationParams.AllocationParams) result <- gst_buffer_pool_config_get_allocator config' allocator params let result' = (/= 0) result allocator' <- peek allocator allocator'' <- (newObject Gst.Allocator.Allocator) allocator' params' <- (wrapBoxed Gst.AllocationParams.AllocationParams) params touchManagedPtr config freeMem allocator return (result', allocator'', params') #if ENABLE_OVERLOADING #endif -- method BufferPool::config_get_option -- method type : MemberFunction -- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool configuration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position in the option array to read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_config_get_option" gst_buffer_pool_config_get_option :: Ptr Gst.Structure.Structure -> -- config : TInterface (Name {namespace = "Gst", name = "Structure"}) Word32 -> -- index : TBasicType TUInt IO CString {- | Parse an available /@config@/ and get the option at /@index@/ of the options API array. -} bufferPoolConfigGetOption :: (B.CallStack.HasCallStack, MonadIO m) => Gst.Structure.Structure {- ^ /@config@/: a 'GI.Gst.Objects.BufferPool.BufferPool' configuration -} -> Word32 {- ^ /@index@/: position in the option array to read -} -> m T.Text {- ^ __Returns:__ a @/gchar/@ of the option at /@index@/. -} bufferPoolConfigGetOption config index = liftIO $ do config' <- unsafeManagedPtrGetPtr config result <- gst_buffer_pool_config_get_option config' index checkUnexpectedReturnNULL "bufferPoolConfigGetOption" result result' <- cstringToText result touchManagedPtr config return result' #if ENABLE_OVERLOADING #endif -- method BufferPool::config_get_params -- method type : MemberFunction -- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool configuration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the caps of buffers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of each buffer, not including prefix and padding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "min_buffers", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimum amount of buffers to allocate.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_buffers", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum amount of buffers to allocate or 0 for unlimited.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_config_get_params" gst_buffer_pool_config_get_params :: Ptr Gst.Structure.Structure -> -- config : TInterface (Name {namespace = "Gst", name = "Structure"}) Ptr (Ptr Gst.Caps.Caps) -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"}) Ptr Word32 -> -- size : TBasicType TUInt Ptr Word32 -> -- min_buffers : TBasicType TUInt Ptr Word32 -> -- max_buffers : TBasicType TUInt IO CInt {- | Get the configuration values from /@config@/. -} bufferPoolConfigGetParams :: (B.CallStack.HasCallStack, MonadIO m) => Gst.Structure.Structure {- ^ /@config@/: a 'GI.Gst.Objects.BufferPool.BufferPool' configuration -} -> m ((Bool, Gst.Caps.Caps, Word32, Word32, Word32)) {- ^ __Returns:__ 'True' if all parameters could be fetched. -} bufferPoolConfigGetParams config = liftIO $ do config' <- unsafeManagedPtrGetPtr config caps <- allocMem :: IO (Ptr (Ptr Gst.Caps.Caps)) size <- allocMem :: IO (Ptr Word32) minBuffers <- allocMem :: IO (Ptr Word32) maxBuffers <- allocMem :: IO (Ptr Word32) result <- gst_buffer_pool_config_get_params config' caps size minBuffers maxBuffers let result' = (/= 0) result caps' <- peek caps caps'' <- (newBoxed Gst.Caps.Caps) caps' size' <- peek size minBuffers' <- peek minBuffers maxBuffers' <- peek maxBuffers touchManagedPtr config freeMem caps freeMem size freeMem minBuffers freeMem maxBuffers return (result', caps'', size', minBuffers', maxBuffers') #if ENABLE_OVERLOADING #endif -- method BufferPool::config_has_option -- method type : MemberFunction -- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool configuration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an option", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_config_has_option" gst_buffer_pool_config_has_option :: Ptr Gst.Structure.Structure -> -- config : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- option : TBasicType TUTF8 IO CInt {- | Check if /@config@/ contains /@option@/. -} bufferPoolConfigHasOption :: (B.CallStack.HasCallStack, MonadIO m) => Gst.Structure.Structure {- ^ /@config@/: a 'GI.Gst.Objects.BufferPool.BufferPool' configuration -} -> T.Text {- ^ /@option@/: an option -} -> m Bool {- ^ __Returns:__ 'True' if the options array contains /@option@/. -} bufferPoolConfigHasOption config option = liftIO $ do config' <- unsafeManagedPtrGetPtr config option' <- textToCString option result <- gst_buffer_pool_config_has_option config' option' let result' = (/= 0) result touchManagedPtr config freeMem option' return result' #if ENABLE_OVERLOADING #endif -- method BufferPool::config_n_options -- method type : MemberFunction -- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool configuration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_config_n_options" gst_buffer_pool_config_n_options :: Ptr Gst.Structure.Structure -> -- config : TInterface (Name {namespace = "Gst", name = "Structure"}) IO Word32 {- | Retrieve the number of values currently stored in the options array of the /@config@/ structure. -} bufferPoolConfigNOptions :: (B.CallStack.HasCallStack, MonadIO m) => Gst.Structure.Structure {- ^ /@config@/: a 'GI.Gst.Objects.BufferPool.BufferPool' configuration -} -> m Word32 {- ^ __Returns:__ the options array size as a @/guint/@. -} bufferPoolConfigNOptions config = liftIO $ do config' <- unsafeManagedPtrGetPtr config result <- gst_buffer_pool_config_n_options config' touchManagedPtr config return result #if ENABLE_OVERLOADING #endif -- method BufferPool::config_set_allocator -- method type : MemberFunction -- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool configuration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface (Name {namespace = "Gst", name = "Allocator"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GstAllocator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface (Name {namespace = "Gst", name = "AllocationParams"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "#GstAllocationParams", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_config_set_allocator" gst_buffer_pool_config_set_allocator :: Ptr Gst.Structure.Structure -> -- config : TInterface (Name {namespace = "Gst", name = "Structure"}) Ptr Gst.Allocator.Allocator -> -- allocator : TInterface (Name {namespace = "Gst", name = "Allocator"}) Ptr Gst.AllocationParams.AllocationParams -> -- params : TInterface (Name {namespace = "Gst", name = "AllocationParams"}) IO () {- | Set the /@allocator@/ and /@params@/ on /@config@/. One of /@allocator@/ and /@params@/ can be 'Nothing', but not both. When /@allocator@/ is 'Nothing', the default allocator of the pool will use the values in /@param@/ to perform its allocation. When /@param@/ is 'Nothing', the pool will use the provided /@allocator@/ with its default 'GI.Gst.Structs.AllocationParams.AllocationParams'. A call to 'GI.Gst.Objects.BufferPool.bufferPoolSetConfig' can update the allocator and params with the values that it is able to do. Some pools are, for example, not able to operate with different allocators or cannot allocate with the values specified in /@params@/. Use 'GI.Gst.Objects.BufferPool.bufferPoolGetConfig' to get the currently used values. -} bufferPoolConfigSetAllocator :: (B.CallStack.HasCallStack, MonadIO m, Gst.Allocator.IsAllocator a) => Gst.Structure.Structure {- ^ /@config@/: a 'GI.Gst.Objects.BufferPool.BufferPool' configuration -} -> Maybe (a) {- ^ /@allocator@/: a 'GI.Gst.Objects.Allocator.Allocator' -} -> Maybe (Gst.AllocationParams.AllocationParams) {- ^ /@params@/: 'GI.Gst.Structs.AllocationParams.AllocationParams' -} -> m () bufferPoolConfigSetAllocator config allocator params = liftIO $ do config' <- unsafeManagedPtrGetPtr config maybeAllocator <- case allocator of Nothing -> return nullPtr Just jAllocator -> do jAllocator' <- unsafeManagedPtrCastPtr jAllocator return jAllocator' maybeParams <- case params of Nothing -> return nullPtr Just jParams -> do jParams' <- unsafeManagedPtrGetPtr jParams return jParams' gst_buffer_pool_config_set_allocator config' maybeAllocator maybeParams touchManagedPtr config whenJust allocator touchManagedPtr whenJust params touchManagedPtr return () #if ENABLE_OVERLOADING #endif -- method BufferPool::config_set_params -- method type : MemberFunction -- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool configuration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "caps for the buffers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of each buffer, not including prefix and padding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_buffers", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimum amount of buffers to allocate.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_buffers", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum amount of buffers to allocate or 0 for unlimited.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_config_set_params" gst_buffer_pool_config_set_params :: Ptr Gst.Structure.Structure -> -- config : TInterface (Name {namespace = "Gst", name = "Structure"}) Ptr Gst.Caps.Caps -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"}) Word32 -> -- size : TBasicType TUInt Word32 -> -- min_buffers : TBasicType TUInt Word32 -> -- max_buffers : TBasicType TUInt IO () {- | Configure /@config@/ with the given parameters. -} bufferPoolConfigSetParams :: (B.CallStack.HasCallStack, MonadIO m) => Gst.Structure.Structure {- ^ /@config@/: a 'GI.Gst.Objects.BufferPool.BufferPool' configuration -} -> Gst.Caps.Caps {- ^ /@caps@/: caps for the buffers -} -> Word32 {- ^ /@size@/: the size of each buffer, not including prefix and padding -} -> Word32 {- ^ /@minBuffers@/: the minimum amount of buffers to allocate. -} -> Word32 {- ^ /@maxBuffers@/: the maximum amount of buffers to allocate or 0 for unlimited. -} -> m () bufferPoolConfigSetParams config caps size minBuffers maxBuffers = liftIO $ do config' <- unsafeManagedPtrGetPtr config caps' <- unsafeManagedPtrGetPtr caps gst_buffer_pool_config_set_params config' caps' size minBuffers maxBuffers touchManagedPtr config touchManagedPtr caps return () #if ENABLE_OVERLOADING #endif -- method BufferPool::config_validate_params -- method type : MemberFunction -- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPool configuration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the excepted caps of buffers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the expected size of each buffer, not including prefix and padding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_buffers", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the expected minimum amount of buffers to allocate.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_buffers", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the expect maximum amount of buffers to allocate or 0 for unlimited.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_buffer_pool_config_validate_params" gst_buffer_pool_config_validate_params :: Ptr Gst.Structure.Structure -> -- config : TInterface (Name {namespace = "Gst", name = "Structure"}) Ptr Gst.Caps.Caps -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"}) Word32 -> -- size : TBasicType TUInt Word32 -> -- min_buffers : TBasicType TUInt Word32 -> -- max_buffers : TBasicType TUInt IO CInt {- | Validate that changes made to /@config@/ are still valid in the context of the expected parameters. This function is a helper that can be used to validate changes made by a pool to a config when 'GI.Gst.Objects.BufferPool.bufferPoolSetConfig' returns 'False'. This expects that /@caps@/ haven\'t changed and that /@minBuffers@/ aren\'t lower then what we initially expected. This does not check if options or allocator parameters are still valid, won\'t check if size have changed, since changing the size is valid to adapt padding. /Since: 1.4/ -} bufferPoolConfigValidateParams :: (B.CallStack.HasCallStack, MonadIO m) => Gst.Structure.Structure {- ^ /@config@/: a 'GI.Gst.Objects.BufferPool.BufferPool' configuration -} -> Gst.Caps.Caps {- ^ /@caps@/: the excepted caps of buffers -} -> Word32 {- ^ /@size@/: the expected size of each buffer, not including prefix and padding -} -> Word32 {- ^ /@minBuffers@/: the expected minimum amount of buffers to allocate. -} -> Word32 {- ^ /@maxBuffers@/: the expect maximum amount of buffers to allocate or 0 for unlimited. -} -> m Bool {- ^ __Returns:__ 'True', if the parameters are valid in this context. -} bufferPoolConfigValidateParams config caps size minBuffers maxBuffers = liftIO $ do config' <- unsafeManagedPtrGetPtr config caps' <- unsafeManagedPtrGetPtr caps result <- gst_buffer_pool_config_validate_params config' caps' size minBuffers maxBuffers let result' = (/= 0) result touchManagedPtr config touchManagedPtr caps return result' #if ENABLE_OVERLOADING #endif