{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Objects.Task
(
Task(..) ,
IsTask ,
toTask ,
noTask ,
#if defined(ENABLE_OVERLOADING)
ResolveTaskMethod ,
#endif
taskCleanupAll ,
#if defined(ENABLE_OVERLOADING)
TaskGetPoolMethodInfo ,
#endif
taskGetPool ,
#if defined(ENABLE_OVERLOADING)
TaskGetStateMethodInfo ,
#endif
taskGetState ,
#if defined(ENABLE_OVERLOADING)
TaskJoinMethodInfo ,
#endif
taskJoin ,
taskNew ,
#if defined(ENABLE_OVERLOADING)
TaskPauseMethodInfo ,
#endif
taskPause ,
#if defined(ENABLE_OVERLOADING)
TaskSetEnterCallbackMethodInfo ,
#endif
taskSetEnterCallback ,
#if defined(ENABLE_OVERLOADING)
TaskSetLeaveCallbackMethodInfo ,
#endif
taskSetLeaveCallback ,
#if defined(ENABLE_OVERLOADING)
TaskSetLockMethodInfo ,
#endif
taskSetLock ,
#if defined(ENABLE_OVERLOADING)
TaskSetPoolMethodInfo ,
#endif
taskSetPool ,
#if defined(ENABLE_OVERLOADING)
TaskSetStateMethodInfo ,
#endif
taskSetState ,
#if defined(ENABLE_OVERLOADING)
TaskStartMethodInfo ,
#endif
taskStart ,
#if defined(ENABLE_OVERLOADING)
TaskStopMethodInfo ,
#endif
taskStop ,
) 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.GI.Base.Signals as B.Signals
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.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.RecMutex as GLib.RecMutex
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.TaskPool as Gst.TaskPool
newtype Task = Task (ManagedPtr Task)
deriving (Task -> Task -> Bool
(Task -> Task -> Bool) -> (Task -> Task -> Bool) -> Eq Task
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Task -> Task -> Bool
$c/= :: Task -> Task -> Bool
== :: Task -> Task -> Bool
$c== :: Task -> Task -> Bool
Eq)
foreign import ccall "gst_task_get_type"
c_gst_task_get_type :: IO GType
instance GObject Task where
gobjectType :: IO GType
gobjectType = IO GType
c_gst_task_get_type
instance B.GValue.IsGValue Task where
toGValue :: Task -> IO GValue
toGValue o :: Task
o = do
GType
gtype <- IO GType
c_gst_task_get_type
Task -> (Ptr Task -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Task
o (GType -> (GValue -> Ptr Task -> IO ()) -> Ptr Task -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Task -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO Task
fromGValue gv :: GValue
gv = do
Ptr Task
ptr <- GValue -> IO (Ptr Task)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Task)
(ManagedPtr Task -> Task) -> Ptr Task -> IO Task
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Task -> Task
Task Ptr Task
ptr
class (GObject o, O.IsDescendantOf Task o) => IsTask o
instance (GObject o, O.IsDescendantOf Task o) => IsTask o
instance O.HasParentTypes Task
type instance O.ParentTypes Task = '[Gst.Object.Object, GObject.Object.Object]
toTask :: (MonadIO m, IsTask o) => o -> m Task
toTask :: o -> m Task
toTask = IO Task -> m Task
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Task -> m Task) -> (o -> IO Task) -> o -> m Task
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Task -> Task) -> o -> IO Task
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Task -> Task
Task
noTask :: Maybe Task
noTask :: Maybe Task
noTask = Maybe Task
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveTaskMethod (t :: Symbol) (o :: *) :: * where
ResolveTaskMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolveTaskMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveTaskMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveTaskMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolveTaskMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveTaskMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveTaskMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveTaskMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolveTaskMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolveTaskMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolveTaskMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolveTaskMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveTaskMethod "join" o = TaskJoinMethodInfo
ResolveTaskMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveTaskMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveTaskMethod "pause" o = TaskPauseMethodInfo
ResolveTaskMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolveTaskMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveTaskMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolveTaskMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveTaskMethod "start" o = TaskStartMethodInfo
ResolveTaskMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveTaskMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveTaskMethod "stop" o = TaskStopMethodInfo
ResolveTaskMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolveTaskMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolveTaskMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveTaskMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolveTaskMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolveTaskMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveTaskMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolveTaskMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolveTaskMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveTaskMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolveTaskMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
ResolveTaskMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolveTaskMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolveTaskMethod "getPool" o = TaskGetPoolMethodInfo
ResolveTaskMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveTaskMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveTaskMethod "getState" o = TaskGetStateMethodInfo
ResolveTaskMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolveTaskMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolveTaskMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolveTaskMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolveTaskMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveTaskMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveTaskMethod "setEnterCallback" o = TaskSetEnterCallbackMethodInfo
ResolveTaskMethod "setLeaveCallback" o = TaskSetLeaveCallbackMethodInfo
ResolveTaskMethod "setLock" o = TaskSetLockMethodInfo
ResolveTaskMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolveTaskMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolveTaskMethod "setPool" o = TaskSetPoolMethodInfo
ResolveTaskMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveTaskMethod "setState" o = TaskSetStateMethodInfo
ResolveTaskMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTaskMethod t Task, O.MethodInfo info Task p) => OL.IsLabel t (Task -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Task
type instance O.AttributeList Task = TaskAttributeList
type TaskAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Task = TaskSignalList
type TaskSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_task_new" gst_task_new ::
FunPtr Gst.Callbacks.C_TaskFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO (Ptr Task)
taskNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Callbacks.TaskFunction
-> m Task
taskNew :: IO () -> m Task
taskNew func :: IO ()
func = IO Task -> m Task
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Task -> m Task) -> IO Task -> m Task
forall a b. (a -> b) -> a -> b
$ do
FunPtr C_TaskFunction
func' <- C_TaskFunction -> IO (FunPtr C_TaskFunction)
Gst.Callbacks.mk_TaskFunction (Maybe (Ptr (FunPtr C_TaskFunction))
-> C_TaskFunction -> C_TaskFunction
Gst.Callbacks.wrap_TaskFunction Maybe (Ptr (FunPtr C_TaskFunction))
forall a. Maybe a
Nothing (IO () -> C_TaskFunction
Gst.Callbacks.drop_closures_TaskFunction IO ()
func))
let userData :: Ptr ()
userData = FunPtr C_TaskFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TaskFunction
func'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Task
result <- FunPtr C_TaskFunction
-> Ptr () -> FunPtr C_TaskFunction -> IO (Ptr Task)
gst_task_new FunPtr C_TaskFunction
func' Ptr ()
userData FunPtr C_TaskFunction
forall a. FunPtr (Ptr a -> IO ())
notify
Text -> Ptr Task -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "taskNew" Ptr Task
result
Task
result' <- ((ManagedPtr Task -> Task) -> Ptr Task -> IO Task
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Task -> Task
Task) Ptr Task
result
Task -> IO Task
forall (m :: * -> *) a. Monad m => a -> m a
return Task
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_task_get_pool" gst_task_get_pool ::
Ptr Task ->
IO (Ptr Gst.TaskPool.TaskPool)
taskGetPool ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Gst.TaskPool.TaskPool
taskGetPool :: a -> m TaskPool
taskGetPool task :: a
task = IO TaskPool -> m TaskPool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TaskPool -> m TaskPool) -> IO TaskPool -> m TaskPool
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr TaskPool
result <- Ptr Task -> IO (Ptr TaskPool)
gst_task_get_pool Ptr Task
task'
Text -> Ptr TaskPool -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "taskGetPool" Ptr TaskPool
result
TaskPool
result' <- ((ManagedPtr TaskPool -> TaskPool) -> Ptr TaskPool -> IO TaskPool
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr TaskPool -> TaskPool
Gst.TaskPool.TaskPool) Ptr TaskPool
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
TaskPool -> IO TaskPool
forall (m :: * -> *) a. Monad m => a -> m a
return TaskPool
result'
#if defined(ENABLE_OVERLOADING)
data TaskGetPoolMethodInfo
instance (signature ~ (m Gst.TaskPool.TaskPool), MonadIO m, IsTask a) => O.MethodInfo TaskGetPoolMethodInfo a signature where
overloadedMethod = taskGetPool
#endif
foreign import ccall "gst_task_get_state" gst_task_get_state ::
Ptr Task ->
IO CUInt
taskGetState ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Gst.Enums.TaskState
taskGetState :: a -> m TaskState
taskGetState task :: a
task = IO TaskState -> m TaskState
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TaskState -> m TaskState) -> IO TaskState -> m TaskState
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
CUInt
result <- Ptr Task -> IO CUInt
gst_task_get_state Ptr Task
task'
let result' :: TaskState
result' = (Int -> TaskState
forall a. Enum a => Int -> a
toEnum (Int -> TaskState) -> (CUInt -> Int) -> CUInt -> TaskState
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
TaskState -> IO TaskState
forall (m :: * -> *) a. Monad m => a -> m a
return TaskState
result'
#if defined(ENABLE_OVERLOADING)
data TaskGetStateMethodInfo
instance (signature ~ (m Gst.Enums.TaskState), MonadIO m, IsTask a) => O.MethodInfo TaskGetStateMethodInfo a signature where
overloadedMethod = taskGetState
#endif
foreign import ccall "gst_task_join" gst_task_join ::
Ptr Task ->
IO CInt
taskJoin ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Bool
taskJoin :: a -> m Bool
taskJoin task :: a
task = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
CInt
result <- Ptr Task -> IO CInt
gst_task_join Ptr Task
task'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TaskJoinMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTask a) => O.MethodInfo TaskJoinMethodInfo a signature where
overloadedMethod = taskJoin
#endif
foreign import ccall "gst_task_pause" gst_task_pause ::
Ptr Task ->
IO CInt
taskPause ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Bool
taskPause :: a -> m Bool
taskPause task :: a
task = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
CInt
result <- Ptr Task -> IO CInt
gst_task_pause Ptr Task
task'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TaskPauseMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTask a) => O.MethodInfo TaskPauseMethodInfo a signature where
overloadedMethod = taskPause
#endif
foreign import ccall "gst_task_set_enter_callback" gst_task_set_enter_callback ::
Ptr Task ->
FunPtr Gst.Callbacks.C_TaskThreadFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
taskSetEnterCallback ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Gst.Callbacks.TaskThreadFunc
-> m ()
taskSetEnterCallback :: a -> TaskThreadFunc -> m ()
taskSetEnterCallback task :: a
task enterFunc :: TaskThreadFunc
enterFunc = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
FunPtr C_TaskThreadFunc
enterFunc' <- C_TaskThreadFunc -> IO (FunPtr C_TaskThreadFunc)
Gst.Callbacks.mk_TaskThreadFunc (Maybe (Ptr (FunPtr C_TaskThreadFunc))
-> TaskThreadFunc_WithClosures -> C_TaskThreadFunc
Gst.Callbacks.wrap_TaskThreadFunc Maybe (Ptr (FunPtr C_TaskThreadFunc))
forall a. Maybe a
Nothing (TaskThreadFunc -> TaskThreadFunc_WithClosures
Gst.Callbacks.drop_closures_TaskThreadFunc TaskThreadFunc
enterFunc))
let userData :: Ptr ()
userData = FunPtr C_TaskThreadFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TaskThreadFunc
enterFunc'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Task
-> FunPtr C_TaskThreadFunc
-> Ptr ()
-> FunPtr C_TaskFunction
-> IO ()
gst_task_set_enter_callback Ptr Task
task' FunPtr C_TaskThreadFunc
enterFunc' Ptr ()
userData FunPtr C_TaskFunction
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskSetEnterCallbackMethodInfo
instance (signature ~ (Gst.Callbacks.TaskThreadFunc -> m ()), MonadIO m, IsTask a) => O.MethodInfo TaskSetEnterCallbackMethodInfo a signature where
overloadedMethod = taskSetEnterCallback
#endif
foreign import ccall "gst_task_set_leave_callback" gst_task_set_leave_callback ::
Ptr Task ->
FunPtr Gst.Callbacks.C_TaskThreadFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
taskSetLeaveCallback ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Gst.Callbacks.TaskThreadFunc
-> m ()
taskSetLeaveCallback :: a -> TaskThreadFunc -> m ()
taskSetLeaveCallback task :: a
task leaveFunc :: TaskThreadFunc
leaveFunc = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
FunPtr C_TaskThreadFunc
leaveFunc' <- C_TaskThreadFunc -> IO (FunPtr C_TaskThreadFunc)
Gst.Callbacks.mk_TaskThreadFunc (Maybe (Ptr (FunPtr C_TaskThreadFunc))
-> TaskThreadFunc_WithClosures -> C_TaskThreadFunc
Gst.Callbacks.wrap_TaskThreadFunc Maybe (Ptr (FunPtr C_TaskThreadFunc))
forall a. Maybe a
Nothing (TaskThreadFunc -> TaskThreadFunc_WithClosures
Gst.Callbacks.drop_closures_TaskThreadFunc TaskThreadFunc
leaveFunc))
let userData :: Ptr ()
userData = FunPtr C_TaskThreadFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TaskThreadFunc
leaveFunc'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Task
-> FunPtr C_TaskThreadFunc
-> Ptr ()
-> FunPtr C_TaskFunction
-> IO ()
gst_task_set_leave_callback Ptr Task
task' FunPtr C_TaskThreadFunc
leaveFunc' Ptr ()
userData FunPtr C_TaskFunction
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskSetLeaveCallbackMethodInfo
instance (signature ~ (Gst.Callbacks.TaskThreadFunc -> m ()), MonadIO m, IsTask a) => O.MethodInfo TaskSetLeaveCallbackMethodInfo a signature where
overloadedMethod = taskSetLeaveCallback
#endif
foreign import ccall "gst_task_set_lock" gst_task_set_lock ::
Ptr Task ->
Ptr GLib.RecMutex.RecMutex ->
IO ()
taskSetLock ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> GLib.RecMutex.RecMutex
-> m ()
taskSetLock :: a -> RecMutex -> m ()
taskSetLock task :: a
task mutex :: RecMutex
mutex = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr RecMutex
mutex' <- RecMutex -> IO (Ptr RecMutex)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RecMutex
mutex
Ptr Task -> Ptr RecMutex -> IO ()
gst_task_set_lock Ptr Task
task' Ptr RecMutex
mutex'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
RecMutex -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RecMutex
mutex
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskSetLockMethodInfo
instance (signature ~ (GLib.RecMutex.RecMutex -> m ()), MonadIO m, IsTask a) => O.MethodInfo TaskSetLockMethodInfo a signature where
overloadedMethod = taskSetLock
#endif
foreign import ccall "gst_task_set_pool" gst_task_set_pool ::
Ptr Task ->
Ptr Gst.TaskPool.TaskPool ->
IO ()
taskSetPool ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a, Gst.TaskPool.IsTaskPool b) =>
a
-> b
-> m ()
taskSetPool :: a -> b -> m ()
taskSetPool task :: a
task pool :: b
pool = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
Ptr TaskPool
pool' <- b -> IO (Ptr TaskPool)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
pool
Ptr Task -> Ptr TaskPool -> IO ()
gst_task_set_pool Ptr Task
task' Ptr TaskPool
pool'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
pool
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TaskSetPoolMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTask a, Gst.TaskPool.IsTaskPool b) => O.MethodInfo TaskSetPoolMethodInfo a signature where
overloadedMethod = taskSetPool
#endif
foreign import ccall "gst_task_set_state" gst_task_set_state ::
Ptr Task ->
CUInt ->
IO CInt
taskSetState ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> Gst.Enums.TaskState
-> m Bool
taskSetState :: a -> TaskState -> m Bool
taskSetState task :: a
task state :: TaskState
state = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
let state' :: CUInt
state' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TaskState -> Int) -> TaskState -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TaskState -> Int
forall a. Enum a => a -> Int
fromEnum) TaskState
state
CInt
result <- Ptr Task -> CUInt -> IO CInt
gst_task_set_state Ptr Task
task' CUInt
state'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TaskSetStateMethodInfo
instance (signature ~ (Gst.Enums.TaskState -> m Bool), MonadIO m, IsTask a) => O.MethodInfo TaskSetStateMethodInfo a signature where
overloadedMethod = taskSetState
#endif
foreign import ccall "gst_task_start" gst_task_start ::
Ptr Task ->
IO CInt
taskStart ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Bool
taskStart :: a -> m Bool
taskStart task :: a
task = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
CInt
result <- Ptr Task -> IO CInt
gst_task_start Ptr Task
task'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TaskStartMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTask a) => O.MethodInfo TaskStartMethodInfo a signature where
overloadedMethod = taskStart
#endif
foreign import ccall "gst_task_stop" gst_task_stop ::
Ptr Task ->
IO CInt
taskStop ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Bool
taskStop :: a -> m Bool
taskStop task :: a
task = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Task
task' <- a -> IO (Ptr Task)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
task
CInt
result <- Ptr Task -> IO CInt
gst_task_stop Ptr Task
task'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TaskStopMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTask a) => O.MethodInfo TaskStopMethodInfo a signature where
overloadedMethod = taskStop
#endif
foreign import ccall "gst_task_cleanup_all" gst_task_cleanup_all ::
IO ()
taskCleanupAll ::
(B.CallStack.HasCallStack, MonadIO m) =>
m ()
taskCleanupAll :: m ()
taskCleanupAll = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
IO ()
gst_task_cleanup_all
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif