{-# 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 ,
#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)
TaskResumeMethodInfo ,
#endif
taskResume ,
#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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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 Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
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 GHC.Records as R
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 (SP.ManagedPtr Task)
deriving (Task -> Task -> Bool
(Task -> Task -> Bool) -> (Task -> Task -> Bool) -> Eq Task
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Task -> Task -> Bool
== :: Task -> Task -> Bool
$c/= :: Task -> Task -> Bool
/= :: Task -> Task -> Bool
Eq)
instance SP.ManagedPtrNewtype Task where
toManagedPtr :: Task -> ManagedPtr Task
toManagedPtr (Task ManagedPtr Task
p) = ManagedPtr Task
p
foreign import ccall "gst_task_get_type"
c_gst_task_get_type :: IO B.Types.GType
instance B.Types.TypedObject Task where
glibType :: IO GType
glibType = IO GType
c_gst_task_get_type
instance B.Types.GObject Task
class (SP.GObject o, O.IsDescendantOf Task o) => IsTask o
instance (SP.GObject o, O.IsDescendantOf Task o) => IsTask o
instance O.HasParentTypes Task
type instance O.ParentTypes Task = '[Gst.Object.Object, GObject.Object.Object]
toTask :: (MIO.MonadIO m, IsTask o) => o -> m Task
toTask :: forall (m :: * -> *) o. (MonadIO m, IsTask o) => o -> m Task
toTask = IO Task -> m Task
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Task -> Task
Task
instance B.GValue.IsGValue (Maybe Task) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_task_get_type
gvalueSet_ :: Ptr GValue -> Maybe Task -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Task
P.Nothing = Ptr GValue -> Ptr Task -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Task
forall a. Ptr a
FP.nullPtr :: FP.Ptr Task)
gvalueSet_ Ptr GValue
gv (P.Just Task
obj) = Task -> (Ptr Task -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Task
obj (Ptr GValue -> Ptr Task -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Task)
gvalueGet_ Ptr GValue
gv = do
Ptr Task
ptr <- Ptr GValue -> IO (Ptr Task)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Task)
if Ptr Task
ptr Ptr Task -> Ptr Task -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Task
forall a. Ptr a
FP.nullPtr
then Task -> Maybe Task
forall a. a -> Maybe a
P.Just (Task -> Maybe Task) -> IO Task -> IO (Maybe Task)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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
else Maybe Task -> IO (Maybe Task)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Task
forall a. Maybe a
P.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 "resume" o = TaskResumeMethodInfo
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.OverloadedMethod 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
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTaskMethod t Task, O.OverloadedMethod info Task p, R.HasField t Task p) => R.HasField t Task p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTaskMethod t Task, O.OverloadedMethodInfo info Task) => OL.IsLabel t (O.MethodProxy info Task) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => IO () -> m Task
taskNew IO ()
func = IO Task -> m Task
forall a. IO a -> m a
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 ())
SP.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 Text
"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 a. a -> IO a
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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m TaskPool
taskGetPool a
task = IO TaskPool -> m TaskPool
forall a. IO a -> m a
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 Text
"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 a. a -> IO a
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.OverloadedMethod TaskGetPoolMethodInfo a signature where
overloadedMethod = taskGetPool
instance O.OverloadedMethodInfo TaskGetPoolMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Task.taskGetPool",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Task.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m TaskState
taskGetState a
task = IO TaskState -> m TaskState
forall a. IO a -> m a
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 a. a -> IO a
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.OverloadedMethod TaskGetStateMethodInfo a signature where
overloadedMethod = taskGetState
instance O.OverloadedMethodInfo TaskGetStateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Task.taskGetState",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Task.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m Bool
taskJoin a
task = IO Bool -> m Bool
forall a. IO a -> m a
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
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall a. a -> IO a
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.OverloadedMethod TaskJoinMethodInfo a signature where
overloadedMethod = taskJoin
instance O.OverloadedMethodInfo TaskJoinMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Task.taskJoin",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Task.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m Bool
taskPause a
task = IO Bool -> m Bool
forall a. IO a -> m a
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
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall a. a -> IO a
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.OverloadedMethod TaskPauseMethodInfo a signature where
overloadedMethod = taskPause
instance O.OverloadedMethodInfo TaskPauseMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Task.taskPause",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Task.html#v:taskPause"
})
#endif
foreign import ccall "gst_task_resume" gst_task_resume ::
Ptr Task ->
IO CInt
taskResume ::
(B.CallStack.HasCallStack, MonadIO m, IsTask a) =>
a
-> m Bool
taskResume :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m Bool
taskResume a
task = IO Bool -> m Bool
forall a. IO a -> m a
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_resume Ptr Task
task'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data TaskResumeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTask a) => O.OverloadedMethod TaskResumeMethodInfo a signature where
overloadedMethod = taskResume
instance O.OverloadedMethodInfo TaskResumeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Task.taskResume",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Task.html#v:taskResume"
})
#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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> TaskThreadFunc -> m ()
taskSetEnterCallback a
task TaskThreadFunc
enterFunc = IO () -> m ()
forall a. IO a -> m a
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 ())
SP.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 a. a -> IO a
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.OverloadedMethod TaskSetEnterCallbackMethodInfo a signature where
overloadedMethod = taskSetEnterCallback
instance O.OverloadedMethodInfo TaskSetEnterCallbackMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Task.taskSetEnterCallback",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Task.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> TaskThreadFunc -> m ()
taskSetLeaveCallback a
task TaskThreadFunc
leaveFunc = IO () -> m ()
forall a. IO a -> m a
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 ())
SP.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 a. a -> IO a
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.OverloadedMethod TaskSetLeaveCallbackMethodInfo a signature where
overloadedMethod = taskSetLeaveCallback
instance O.OverloadedMethodInfo TaskSetLeaveCallbackMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Task.taskSetLeaveCallback",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Task.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> RecMutex -> m ()
taskSetLock a
task RecMutex
mutex = IO () -> m ()
forall a. IO a -> m a
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 a. a -> IO a
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.OverloadedMethod TaskSetLockMethodInfo a signature where
overloadedMethod = taskSetLock
instance O.OverloadedMethodInfo TaskSetLockMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Task.taskSetLock",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Task.html#v: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 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTask a, IsTaskPool b) =>
a -> b -> m ()
taskSetPool a
task b
pool = IO () -> m ()
forall a. IO a -> m a
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 a. a -> IO a
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.OverloadedMethod TaskSetPoolMethodInfo a signature where
overloadedMethod = taskSetPool
instance O.OverloadedMethodInfo TaskSetPoolMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Task.taskSetPool",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Task.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> TaskState -> m Bool
taskSetState a
task TaskState
state = IO Bool -> m Bool
forall a. IO a -> m a
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
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall a. a -> IO a
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.OverloadedMethod TaskSetStateMethodInfo a signature where
overloadedMethod = taskSetState
instance O.OverloadedMethodInfo TaskSetStateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Task.taskSetState",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Task.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m Bool
taskStart a
task = IO Bool -> m Bool
forall a. IO a -> m a
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
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall a. a -> IO a
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.OverloadedMethod TaskStartMethodInfo a signature where
overloadedMethod = taskStart
instance O.OverloadedMethodInfo TaskStartMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Task.taskStart",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Task.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTask a) =>
a -> m Bool
taskStop a
task = IO Bool -> m Bool
forall a. IO a -> m a
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
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
task
Bool -> IO Bool
forall a. a -> IO a
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.OverloadedMethod TaskStopMethodInfo a signature where
overloadedMethod = taskStop
instance O.OverloadedMethodInfo TaskStopMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Task.taskStop",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Task.html#v:taskStop"
})
#endif
foreign import ccall "gst_task_cleanup_all" gst_task_cleanup_all ::
IO ()
taskCleanupAll ::
(B.CallStack.HasCallStack, MonadIO m) =>
m ()
taskCleanupAll :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ()
taskCleanupAll = IO () -> m ()
forall a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif