{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstPbutils.Objects.Discoverer
(
Discoverer(..) ,
IsDiscoverer ,
toDiscoverer ,
noDiscoverer ,
#if defined(ENABLE_OVERLOADING)
ResolveDiscovererMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DiscovererDiscoverUriMethodInfo ,
#endif
discovererDiscoverUri ,
#if defined(ENABLE_OVERLOADING)
DiscovererDiscoverUriAsyncMethodInfo ,
#endif
discovererDiscoverUriAsync ,
discovererNew ,
#if defined(ENABLE_OVERLOADING)
DiscovererStartMethodInfo ,
#endif
discovererStart ,
#if defined(ENABLE_OVERLOADING)
DiscovererStopMethodInfo ,
#endif
discovererStop ,
#if defined(ENABLE_OVERLOADING)
DiscovererTimeoutPropertyInfo ,
#endif
constructDiscovererTimeout ,
#if defined(ENABLE_OVERLOADING)
discovererTimeout ,
#endif
getDiscovererTimeout ,
setDiscovererTimeout ,
#if defined(ENABLE_OVERLOADING)
DiscovererUseCachePropertyInfo ,
#endif
constructDiscovererUseCache ,
#if defined(ENABLE_OVERLOADING)
discovererUseCache ,
#endif
getDiscovererUseCache ,
setDiscovererUseCache ,
C_DiscovererDiscoveredCallback ,
DiscovererDiscoveredCallback ,
#if defined(ENABLE_OVERLOADING)
DiscovererDiscoveredSignalInfo ,
#endif
afterDiscovererDiscovered ,
genClosure_DiscovererDiscovered ,
mk_DiscovererDiscoveredCallback ,
noDiscovererDiscoveredCallback ,
onDiscovererDiscovered ,
wrap_DiscovererDiscoveredCallback ,
C_DiscovererFinishedCallback ,
DiscovererFinishedCallback ,
#if defined(ENABLE_OVERLOADING)
DiscovererFinishedSignalInfo ,
#endif
afterDiscovererFinished ,
genClosure_DiscovererFinished ,
mk_DiscovererFinishedCallback ,
noDiscovererFinishedCallback ,
onDiscovererFinished ,
wrap_DiscovererFinishedCallback ,
C_DiscovererSourceSetupCallback ,
DiscovererSourceSetupCallback ,
#if defined(ENABLE_OVERLOADING)
DiscovererSourceSetupSignalInfo ,
#endif
afterDiscovererSourceSetup ,
genClosure_DiscovererSourceSetup ,
mk_DiscovererSourceSetupCallback ,
noDiscovererSourceSetupCallback ,
onDiscovererSourceSetup ,
wrap_DiscovererSourceSetupCallback ,
C_DiscovererStartingCallback ,
DiscovererStartingCallback ,
#if defined(ENABLE_OVERLOADING)
DiscovererStartingSignalInfo ,
#endif
afterDiscovererStarting ,
genClosure_DiscovererStarting ,
mk_DiscovererStartingCallback ,
noDiscovererStartingCallback ,
onDiscovererStarting ,
wrap_DiscovererStartingCallback ,
) 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.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Objects.Element as Gst.Element
import {-# SOURCE #-} qualified GI.GstPbutils.Objects.DiscovererInfo as GstPbutils.DiscovererInfo
newtype Discoverer = Discoverer (ManagedPtr Discoverer)
deriving (Discoverer -> Discoverer -> Bool
(Discoverer -> Discoverer -> Bool)
-> (Discoverer -> Discoverer -> Bool) -> Eq Discoverer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Discoverer -> Discoverer -> Bool
$c/= :: Discoverer -> Discoverer -> Bool
== :: Discoverer -> Discoverer -> Bool
$c== :: Discoverer -> Discoverer -> Bool
Eq)
foreign import ccall "gst_discoverer_get_type"
c_gst_discoverer_get_type :: IO GType
instance GObject Discoverer where
gobjectType :: IO GType
gobjectType = IO GType
c_gst_discoverer_get_type
instance B.GValue.IsGValue Discoverer where
toGValue :: Discoverer -> IO GValue
toGValue o :: Discoverer
o = do
GType
gtype <- IO GType
c_gst_discoverer_get_type
Discoverer -> (Ptr Discoverer -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Discoverer
o (GType
-> (GValue -> Ptr Discoverer -> IO ())
-> Ptr Discoverer
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Discoverer -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO Discoverer
fromGValue gv :: GValue
gv = do
Ptr Discoverer
ptr <- GValue -> IO (Ptr Discoverer)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Discoverer)
(ManagedPtr Discoverer -> Discoverer)
-> Ptr Discoverer -> IO Discoverer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Discoverer -> Discoverer
Discoverer Ptr Discoverer
ptr
class (GObject o, O.IsDescendantOf Discoverer o) => IsDiscoverer o
instance (GObject o, O.IsDescendantOf Discoverer o) => IsDiscoverer o
instance O.HasParentTypes Discoverer
type instance O.ParentTypes Discoverer = '[GObject.Object.Object]
toDiscoverer :: (MonadIO m, IsDiscoverer o) => o -> m Discoverer
toDiscoverer :: o -> m Discoverer
toDiscoverer = IO Discoverer -> m Discoverer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Discoverer -> m Discoverer)
-> (o -> IO Discoverer) -> o -> m Discoverer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Discoverer -> Discoverer) -> o -> IO Discoverer
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Discoverer -> Discoverer
Discoverer
noDiscoverer :: Maybe Discoverer
noDiscoverer :: Maybe Discoverer
noDiscoverer = Maybe Discoverer
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveDiscovererMethod (t :: Symbol) (o :: *) :: * where
ResolveDiscovererMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDiscovererMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDiscovererMethod "discoverUri" o = DiscovererDiscoverUriMethodInfo
ResolveDiscovererMethod "discoverUriAsync" o = DiscovererDiscoverUriAsyncMethodInfo
ResolveDiscovererMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDiscovererMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDiscovererMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDiscovererMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDiscovererMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDiscovererMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDiscovererMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveDiscovererMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDiscovererMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDiscovererMethod "start" o = DiscovererStartMethodInfo
ResolveDiscovererMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDiscovererMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDiscovererMethod "stop" o = DiscovererStopMethodInfo
ResolveDiscovererMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDiscovererMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveDiscovererMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDiscovererMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDiscovererMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDiscovererMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDiscovererMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDiscovererMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveDiscovererMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDiscovererMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDiscovererMethod t Discoverer, O.MethodInfo info Discoverer p) => OL.IsLabel t (Discoverer -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
type DiscovererDiscoveredCallback =
GstPbutils.DiscovererInfo.DiscovererInfo
-> Maybe GError
-> IO ()
noDiscovererDiscoveredCallback :: Maybe DiscovererDiscoveredCallback
noDiscovererDiscoveredCallback :: Maybe DiscovererDiscoveredCallback
noDiscovererDiscoveredCallback = Maybe DiscovererDiscoveredCallback
forall a. Maybe a
Nothing
type C_DiscovererDiscoveredCallback =
Ptr () ->
Ptr GstPbutils.DiscovererInfo.DiscovererInfo ->
Ptr GError ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererDiscoveredCallback :: C_DiscovererDiscoveredCallback -> IO (FunPtr C_DiscovererDiscoveredCallback)
genClosure_DiscovererDiscovered :: MonadIO m => DiscovererDiscoveredCallback -> m (GClosure C_DiscovererDiscoveredCallback)
genClosure_DiscovererDiscovered :: DiscovererDiscoveredCallback
-> m (GClosure C_DiscovererDiscoveredCallback)
genClosure_DiscovererDiscovered cb :: DiscovererDiscoveredCallback
cb = IO (GClosure C_DiscovererDiscoveredCallback)
-> m (GClosure C_DiscovererDiscoveredCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiscovererDiscoveredCallback)
-> m (GClosure C_DiscovererDiscoveredCallback))
-> IO (GClosure C_DiscovererDiscoveredCallback)
-> m (GClosure C_DiscovererDiscoveredCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererDiscoveredCallback
cb' = DiscovererDiscoveredCallback -> C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback DiscovererDiscoveredCallback
cb
C_DiscovererDiscoveredCallback
-> IO (FunPtr C_DiscovererDiscoveredCallback)
mk_DiscovererDiscoveredCallback C_DiscovererDiscoveredCallback
cb' IO (FunPtr C_DiscovererDiscoveredCallback)
-> (FunPtr C_DiscovererDiscoveredCallback
-> IO (GClosure C_DiscovererDiscoveredCallback))
-> IO (GClosure C_DiscovererDiscoveredCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiscovererDiscoveredCallback
-> IO (GClosure C_DiscovererDiscoveredCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiscovererDiscoveredCallback ::
DiscovererDiscoveredCallback ->
C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback :: DiscovererDiscoveredCallback -> C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback _cb :: DiscovererDiscoveredCallback
_cb _ info :: Ptr DiscovererInfo
info error_ :: Ptr GError
error_ _ = do
DiscovererInfo
info' <- ((ManagedPtr DiscovererInfo -> DiscovererInfo)
-> Ptr DiscovererInfo -> IO DiscovererInfo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DiscovererInfo -> DiscovererInfo
GstPbutils.DiscovererInfo.DiscovererInfo) Ptr DiscovererInfo
info
Maybe GError
maybeError_ <-
if Ptr GError
error_ Ptr GError -> Ptr GError -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr GError
forall a. Ptr a
nullPtr
then Maybe GError -> IO (Maybe GError)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GError
forall a. Maybe a
Nothing
else do
GError
error_' <- ((ManagedPtr GError -> GError) -> Ptr GError -> IO GError
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr GError -> GError
GError) Ptr GError
error_
Maybe GError -> IO (Maybe GError)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe GError -> IO (Maybe GError))
-> Maybe GError -> IO (Maybe GError)
forall a b. (a -> b) -> a -> b
$ GError -> Maybe GError
forall a. a -> Maybe a
Just GError
error_'
DiscovererDiscoveredCallback
_cb DiscovererInfo
info' Maybe GError
maybeError_
onDiscovererDiscovered :: (IsDiscoverer a, MonadIO m) => a -> DiscovererDiscoveredCallback -> m SignalHandlerId
onDiscovererDiscovered :: a -> DiscovererDiscoveredCallback -> m SignalHandlerId
onDiscovererDiscovered obj :: a
obj cb :: DiscovererDiscoveredCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererDiscoveredCallback
cb' = DiscovererDiscoveredCallback -> C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback DiscovererDiscoveredCallback
cb
FunPtr C_DiscovererDiscoveredCallback
cb'' <- C_DiscovererDiscoveredCallback
-> IO (FunPtr C_DiscovererDiscoveredCallback)
mk_DiscovererDiscoveredCallback C_DiscovererDiscoveredCallback
cb'
a
-> Text
-> FunPtr C_DiscovererDiscoveredCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "discovered" FunPtr C_DiscovererDiscoveredCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDiscovererDiscovered :: (IsDiscoverer a, MonadIO m) => a -> DiscovererDiscoveredCallback -> m SignalHandlerId
afterDiscovererDiscovered :: a -> DiscovererDiscoveredCallback -> m SignalHandlerId
afterDiscovererDiscovered obj :: a
obj cb :: DiscovererDiscoveredCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererDiscoveredCallback
cb' = DiscovererDiscoveredCallback -> C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback DiscovererDiscoveredCallback
cb
FunPtr C_DiscovererDiscoveredCallback
cb'' <- C_DiscovererDiscoveredCallback
-> IO (FunPtr C_DiscovererDiscoveredCallback)
mk_DiscovererDiscoveredCallback C_DiscovererDiscoveredCallback
cb'
a
-> Text
-> FunPtr C_DiscovererDiscoveredCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "discovered" FunPtr C_DiscovererDiscoveredCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data DiscovererDiscoveredSignalInfo
instance SignalInfo DiscovererDiscoveredSignalInfo where
type HaskellCallbackType DiscovererDiscoveredSignalInfo = DiscovererDiscoveredCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DiscovererDiscoveredCallback cb
cb'' <- mk_DiscovererDiscoveredCallback cb'
connectSignalFunPtr obj "discovered" cb'' connectMode detail
#endif
type DiscovererFinishedCallback =
IO ()
noDiscovererFinishedCallback :: Maybe DiscovererFinishedCallback
noDiscovererFinishedCallback :: Maybe (IO ())
noDiscovererFinishedCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_DiscovererFinishedCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererFinishedCallback :: C_DiscovererFinishedCallback -> IO (FunPtr C_DiscovererFinishedCallback)
genClosure_DiscovererFinished :: MonadIO m => DiscovererFinishedCallback -> m (GClosure C_DiscovererFinishedCallback)
genClosure_DiscovererFinished :: IO () -> m (GClosure C_DiscovererFinishedCallback)
genClosure_DiscovererFinished cb :: IO ()
cb = IO (GClosure C_DiscovererFinishedCallback)
-> m (GClosure C_DiscovererFinishedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiscovererFinishedCallback)
-> m (GClosure C_DiscovererFinishedCallback))
-> IO (GClosure C_DiscovererFinishedCallback)
-> m (GClosure C_DiscovererFinishedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererFinishedCallback
cb' = IO () -> C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback IO ()
cb
C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererFinishedCallback C_DiscovererFinishedCallback
cb' IO (FunPtr C_DiscovererFinishedCallback)
-> (FunPtr C_DiscovererFinishedCallback
-> IO (GClosure C_DiscovererFinishedCallback))
-> IO (GClosure C_DiscovererFinishedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiscovererFinishedCallback
-> IO (GClosure C_DiscovererFinishedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiscovererFinishedCallback ::
DiscovererFinishedCallback ->
C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback :: IO () -> C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback _cb :: IO ()
_cb _ _ = do
IO ()
_cb
onDiscovererFinished :: (IsDiscoverer a, MonadIO m) => a -> DiscovererFinishedCallback -> m SignalHandlerId
onDiscovererFinished :: a -> IO () -> m SignalHandlerId
onDiscovererFinished obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererFinishedCallback
cb' = IO () -> C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback IO ()
cb
FunPtr C_DiscovererFinishedCallback
cb'' <- C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererFinishedCallback C_DiscovererFinishedCallback
cb'
a
-> Text
-> FunPtr C_DiscovererFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "finished" FunPtr C_DiscovererFinishedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDiscovererFinished :: (IsDiscoverer a, MonadIO m) => a -> DiscovererFinishedCallback -> m SignalHandlerId
afterDiscovererFinished :: a -> IO () -> m SignalHandlerId
afterDiscovererFinished obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererFinishedCallback
cb' = IO () -> C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback IO ()
cb
FunPtr C_DiscovererFinishedCallback
cb'' <- C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererFinishedCallback C_DiscovererFinishedCallback
cb'
a
-> Text
-> FunPtr C_DiscovererFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "finished" FunPtr C_DiscovererFinishedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data DiscovererFinishedSignalInfo
instance SignalInfo DiscovererFinishedSignalInfo where
type HaskellCallbackType DiscovererFinishedSignalInfo = DiscovererFinishedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DiscovererFinishedCallback cb
cb'' <- mk_DiscovererFinishedCallback cb'
connectSignalFunPtr obj "finished" cb'' connectMode detail
#endif
type DiscovererSourceSetupCallback =
Gst.Element.Element
-> IO ()
noDiscovererSourceSetupCallback :: Maybe DiscovererSourceSetupCallback
noDiscovererSourceSetupCallback :: Maybe DiscovererSourceSetupCallback
noDiscovererSourceSetupCallback = Maybe DiscovererSourceSetupCallback
forall a. Maybe a
Nothing
type C_DiscovererSourceSetupCallback =
Ptr () ->
Ptr Gst.Element.Element ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererSourceSetupCallback :: C_DiscovererSourceSetupCallback -> IO (FunPtr C_DiscovererSourceSetupCallback)
genClosure_DiscovererSourceSetup :: MonadIO m => DiscovererSourceSetupCallback -> m (GClosure C_DiscovererSourceSetupCallback)
genClosure_DiscovererSourceSetup :: DiscovererSourceSetupCallback
-> m (GClosure C_DiscovererSourceSetupCallback)
genClosure_DiscovererSourceSetup cb :: DiscovererSourceSetupCallback
cb = IO (GClosure C_DiscovererSourceSetupCallback)
-> m (GClosure C_DiscovererSourceSetupCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiscovererSourceSetupCallback)
-> m (GClosure C_DiscovererSourceSetupCallback))
-> IO (GClosure C_DiscovererSourceSetupCallback)
-> m (GClosure C_DiscovererSourceSetupCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererSourceSetupCallback
cb' = DiscovererSourceSetupCallback -> C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback DiscovererSourceSetupCallback
cb
C_DiscovererSourceSetupCallback
-> IO (FunPtr C_DiscovererSourceSetupCallback)
mk_DiscovererSourceSetupCallback C_DiscovererSourceSetupCallback
cb' IO (FunPtr C_DiscovererSourceSetupCallback)
-> (FunPtr C_DiscovererSourceSetupCallback
-> IO (GClosure C_DiscovererSourceSetupCallback))
-> IO (GClosure C_DiscovererSourceSetupCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiscovererSourceSetupCallback
-> IO (GClosure C_DiscovererSourceSetupCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiscovererSourceSetupCallback ::
DiscovererSourceSetupCallback ->
C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback :: DiscovererSourceSetupCallback -> C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback _cb :: DiscovererSourceSetupCallback
_cb _ source :: Ptr Element
source _ = do
Element
source' <- ((ManagedPtr Element -> Element) -> Ptr Element -> IO Element
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Element -> Element
Gst.Element.Element) Ptr Element
source
DiscovererSourceSetupCallback
_cb Element
source'
onDiscovererSourceSetup :: (IsDiscoverer a, MonadIO m) => a -> DiscovererSourceSetupCallback -> m SignalHandlerId
onDiscovererSourceSetup :: a -> DiscovererSourceSetupCallback -> m SignalHandlerId
onDiscovererSourceSetup obj :: a
obj cb :: DiscovererSourceSetupCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererSourceSetupCallback
cb' = DiscovererSourceSetupCallback -> C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback DiscovererSourceSetupCallback
cb
FunPtr C_DiscovererSourceSetupCallback
cb'' <- C_DiscovererSourceSetupCallback
-> IO (FunPtr C_DiscovererSourceSetupCallback)
mk_DiscovererSourceSetupCallback C_DiscovererSourceSetupCallback
cb'
a
-> Text
-> FunPtr C_DiscovererSourceSetupCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "source-setup" FunPtr C_DiscovererSourceSetupCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDiscovererSourceSetup :: (IsDiscoverer a, MonadIO m) => a -> DiscovererSourceSetupCallback -> m SignalHandlerId
afterDiscovererSourceSetup :: a -> DiscovererSourceSetupCallback -> m SignalHandlerId
afterDiscovererSourceSetup obj :: a
obj cb :: DiscovererSourceSetupCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererSourceSetupCallback
cb' = DiscovererSourceSetupCallback -> C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback DiscovererSourceSetupCallback
cb
FunPtr C_DiscovererSourceSetupCallback
cb'' <- C_DiscovererSourceSetupCallback
-> IO (FunPtr C_DiscovererSourceSetupCallback)
mk_DiscovererSourceSetupCallback C_DiscovererSourceSetupCallback
cb'
a
-> Text
-> FunPtr C_DiscovererSourceSetupCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "source-setup" FunPtr C_DiscovererSourceSetupCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data DiscovererSourceSetupSignalInfo
instance SignalInfo DiscovererSourceSetupSignalInfo where
type HaskellCallbackType DiscovererSourceSetupSignalInfo = DiscovererSourceSetupCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DiscovererSourceSetupCallback cb
cb'' <- mk_DiscovererSourceSetupCallback cb'
connectSignalFunPtr obj "source-setup" cb'' connectMode detail
#endif
type DiscovererStartingCallback =
IO ()
noDiscovererStartingCallback :: Maybe DiscovererStartingCallback
noDiscovererStartingCallback :: Maybe (IO ())
noDiscovererStartingCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_DiscovererStartingCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererStartingCallback :: C_DiscovererStartingCallback -> IO (FunPtr C_DiscovererStartingCallback)
genClosure_DiscovererStarting :: MonadIO m => DiscovererStartingCallback -> m (GClosure C_DiscovererStartingCallback)
genClosure_DiscovererStarting :: IO () -> m (GClosure C_DiscovererFinishedCallback)
genClosure_DiscovererStarting cb :: IO ()
cb = IO (GClosure C_DiscovererFinishedCallback)
-> m (GClosure C_DiscovererFinishedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiscovererFinishedCallback)
-> m (GClosure C_DiscovererFinishedCallback))
-> IO (GClosure C_DiscovererFinishedCallback)
-> m (GClosure C_DiscovererFinishedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererFinishedCallback
cb' = IO () -> C_DiscovererFinishedCallback
wrap_DiscovererStartingCallback IO ()
cb
C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererStartingCallback C_DiscovererFinishedCallback
cb' IO (FunPtr C_DiscovererFinishedCallback)
-> (FunPtr C_DiscovererFinishedCallback
-> IO (GClosure C_DiscovererFinishedCallback))
-> IO (GClosure C_DiscovererFinishedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiscovererFinishedCallback
-> IO (GClosure C_DiscovererFinishedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiscovererStartingCallback ::
DiscovererStartingCallback ->
C_DiscovererStartingCallback
wrap_DiscovererStartingCallback :: IO () -> C_DiscovererFinishedCallback
wrap_DiscovererStartingCallback _cb :: IO ()
_cb _ _ = do
IO ()
_cb
onDiscovererStarting :: (IsDiscoverer a, MonadIO m) => a -> DiscovererStartingCallback -> m SignalHandlerId
onDiscovererStarting :: a -> IO () -> m SignalHandlerId
onDiscovererStarting obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererFinishedCallback
cb' = IO () -> C_DiscovererFinishedCallback
wrap_DiscovererStartingCallback IO ()
cb
FunPtr C_DiscovererFinishedCallback
cb'' <- C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererStartingCallback C_DiscovererFinishedCallback
cb'
a
-> Text
-> FunPtr C_DiscovererFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "starting" FunPtr C_DiscovererFinishedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDiscovererStarting :: (IsDiscoverer a, MonadIO m) => a -> DiscovererStartingCallback -> m SignalHandlerId
afterDiscovererStarting :: a -> IO () -> m SignalHandlerId
afterDiscovererStarting obj :: a
obj cb :: IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererFinishedCallback
cb' = IO () -> C_DiscovererFinishedCallback
wrap_DiscovererStartingCallback IO ()
cb
FunPtr C_DiscovererFinishedCallback
cb'' <- C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererStartingCallback C_DiscovererFinishedCallback
cb'
a
-> Text
-> FunPtr C_DiscovererFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "starting" FunPtr C_DiscovererFinishedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data DiscovererStartingSignalInfo
instance SignalInfo DiscovererStartingSignalInfo where
type HaskellCallbackType DiscovererStartingSignalInfo = DiscovererStartingCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DiscovererStartingCallback cb
cb'' <- mk_DiscovererStartingCallback cb'
connectSignalFunPtr obj "starting" cb'' connectMode detail
#endif
getDiscovererTimeout :: (MonadIO m, IsDiscoverer o) => o -> m Word64
getDiscovererTimeout :: o -> m Word64
getDiscovererTimeout obj :: o
obj = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word64
forall a. GObject a => a -> String -> IO Word64
B.Properties.getObjectPropertyUInt64 o
obj "timeout"
setDiscovererTimeout :: (MonadIO m, IsDiscoverer o) => o -> Word64 -> m ()
setDiscovererTimeout :: o -> Word64 -> m ()
setDiscovererTimeout obj :: o
obj val :: Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Word64 -> IO ()
forall a. GObject a => a -> String -> Word64 -> IO ()
B.Properties.setObjectPropertyUInt64 o
obj "timeout" Word64
val
constructDiscovererTimeout :: (IsDiscoverer o) => Word64 -> IO (GValueConstruct o)
constructDiscovererTimeout :: Word64 -> IO (GValueConstruct o)
constructDiscovererTimeout val :: Word64
val = String -> Word64 -> IO (GValueConstruct o)
forall o. String -> Word64 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt64 "timeout" Word64
val
#if defined(ENABLE_OVERLOADING)
data DiscovererTimeoutPropertyInfo
instance AttrInfo DiscovererTimeoutPropertyInfo where
type AttrAllowedOps DiscovererTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DiscovererTimeoutPropertyInfo = IsDiscoverer
type AttrSetTypeConstraint DiscovererTimeoutPropertyInfo = (~) Word64
type AttrTransferTypeConstraint DiscovererTimeoutPropertyInfo = (~) Word64
type AttrTransferType DiscovererTimeoutPropertyInfo = Word64
type AttrGetType DiscovererTimeoutPropertyInfo = Word64
type AttrLabel DiscovererTimeoutPropertyInfo = "timeout"
type AttrOrigin DiscovererTimeoutPropertyInfo = Discoverer
attrGet = getDiscovererTimeout
attrSet = setDiscovererTimeout
attrTransfer _ v = do
return v
attrConstruct = constructDiscovererTimeout
attrClear = undefined
#endif
getDiscovererUseCache :: (MonadIO m, IsDiscoverer o) => o -> m Bool
getDiscovererUseCache :: o -> m Bool
getDiscovererUseCache obj :: o
obj = 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
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "use-cache"
setDiscovererUseCache :: (MonadIO m, IsDiscoverer o) => o -> Bool -> m ()
setDiscovererUseCache :: o -> Bool -> m ()
setDiscovererUseCache obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj "use-cache" Bool
val
constructDiscovererUseCache :: (IsDiscoverer o) => Bool -> IO (GValueConstruct o)
constructDiscovererUseCache :: Bool -> IO (GValueConstruct o)
constructDiscovererUseCache val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "use-cache" Bool
val
#if defined(ENABLE_OVERLOADING)
data DiscovererUseCachePropertyInfo
instance AttrInfo DiscovererUseCachePropertyInfo where
type AttrAllowedOps DiscovererUseCachePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DiscovererUseCachePropertyInfo = IsDiscoverer
type AttrSetTypeConstraint DiscovererUseCachePropertyInfo = (~) Bool
type AttrTransferTypeConstraint DiscovererUseCachePropertyInfo = (~) Bool
type AttrTransferType DiscovererUseCachePropertyInfo = Bool
type AttrGetType DiscovererUseCachePropertyInfo = Bool
type AttrLabel DiscovererUseCachePropertyInfo = "use-cache"
type AttrOrigin DiscovererUseCachePropertyInfo = Discoverer
attrGet = getDiscovererUseCache
attrSet = setDiscovererUseCache
attrTransfer _ v = do
return v
attrConstruct = constructDiscovererUseCache
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Discoverer
type instance O.AttributeList Discoverer = DiscovererAttributeList
type DiscovererAttributeList = ('[ '("timeout", DiscovererTimeoutPropertyInfo), '("useCache", DiscovererUseCachePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
discovererTimeout :: AttrLabelProxy "timeout"
discovererTimeout = AttrLabelProxy
discovererUseCache :: AttrLabelProxy "useCache"
discovererUseCache = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Discoverer = DiscovererSignalList
type DiscovererSignalList = ('[ '("discovered", DiscovererDiscoveredSignalInfo), '("finished", DiscovererFinishedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sourceSetup", DiscovererSourceSetupSignalInfo), '("starting", DiscovererStartingSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_discoverer_new" gst_discoverer_new ::
Word64 ->
Ptr (Ptr GError) ->
IO (Ptr Discoverer)
discovererNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word64
-> m Discoverer
discovererNew :: Word64 -> m Discoverer
discovererNew timeout :: Word64
timeout = IO Discoverer -> m Discoverer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Discoverer -> m Discoverer) -> IO Discoverer -> m Discoverer
forall a b. (a -> b) -> a -> b
$ do
IO Discoverer -> IO () -> IO Discoverer
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Discoverer
result <- (Ptr (Ptr GError) -> IO (Ptr Discoverer)) -> IO (Ptr Discoverer)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Discoverer)) -> IO (Ptr Discoverer))
-> (Ptr (Ptr GError) -> IO (Ptr Discoverer)) -> IO (Ptr Discoverer)
forall a b. (a -> b) -> a -> b
$ Word64 -> Ptr (Ptr GError) -> IO (Ptr Discoverer)
gst_discoverer_new Word64
timeout
Text -> Ptr Discoverer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "discovererNew" Ptr Discoverer
result
Discoverer
result' <- ((ManagedPtr Discoverer -> Discoverer)
-> Ptr Discoverer -> IO Discoverer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Discoverer -> Discoverer
Discoverer) Ptr Discoverer
result
Discoverer -> IO Discoverer
forall (m :: * -> *) a. Monad m => a -> m a
return Discoverer
result'
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_discoverer_discover_uri" gst_discoverer_discover_uri ::
Ptr Discoverer ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr GstPbutils.DiscovererInfo.DiscovererInfo)
discovererDiscoverUri ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscoverer a) =>
a
-> T.Text
-> m GstPbutils.DiscovererInfo.DiscovererInfo
discovererDiscoverUri :: a -> Text -> m DiscovererInfo
discovererDiscoverUri discoverer :: a
discoverer uri :: Text
uri = IO DiscovererInfo -> m DiscovererInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DiscovererInfo -> m DiscovererInfo)
-> IO DiscovererInfo -> m DiscovererInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr Discoverer
discoverer' <- a -> IO (Ptr Discoverer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
discoverer
CString
uri' <- Text -> IO CString
textToCString Text
uri
IO DiscovererInfo -> IO () -> IO DiscovererInfo
forall a b. IO a -> IO b -> IO a
onException (do
Ptr DiscovererInfo
result <- (Ptr (Ptr GError) -> IO (Ptr DiscovererInfo))
-> IO (Ptr DiscovererInfo)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr DiscovererInfo))
-> IO (Ptr DiscovererInfo))
-> (Ptr (Ptr GError) -> IO (Ptr DiscovererInfo))
-> IO (Ptr DiscovererInfo)
forall a b. (a -> b) -> a -> b
$ Ptr Discoverer
-> CString -> Ptr (Ptr GError) -> IO (Ptr DiscovererInfo)
gst_discoverer_discover_uri Ptr Discoverer
discoverer' CString
uri'
Text -> Ptr DiscovererInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "discovererDiscoverUri" Ptr DiscovererInfo
result
DiscovererInfo
result' <- ((ManagedPtr DiscovererInfo -> DiscovererInfo)
-> Ptr DiscovererInfo -> IO DiscovererInfo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DiscovererInfo -> DiscovererInfo
GstPbutils.DiscovererInfo.DiscovererInfo) Ptr DiscovererInfo
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
discoverer
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
DiscovererInfo -> IO DiscovererInfo
forall (m :: * -> *) a. Monad m => a -> m a
return DiscovererInfo
result'
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
)
#if defined(ENABLE_OVERLOADING)
data DiscovererDiscoverUriMethodInfo
instance (signature ~ (T.Text -> m GstPbutils.DiscovererInfo.DiscovererInfo), MonadIO m, IsDiscoverer a) => O.MethodInfo DiscovererDiscoverUriMethodInfo a signature where
overloadedMethod = discovererDiscoverUri
#endif
foreign import ccall "gst_discoverer_discover_uri_async" gst_discoverer_discover_uri_async ::
Ptr Discoverer ->
CString ->
IO CInt
discovererDiscoverUriAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscoverer a) =>
a
-> T.Text
-> m Bool
discovererDiscoverUriAsync :: a -> Text -> m Bool
discovererDiscoverUriAsync discoverer :: a
discoverer uri :: Text
uri = 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 Discoverer
discoverer' <- a -> IO (Ptr Discoverer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
discoverer
CString
uri' <- Text -> IO CString
textToCString Text
uri
CInt
result <- Ptr Discoverer -> CString -> IO CInt
gst_discoverer_discover_uri_async Ptr Discoverer
discoverer' CString
uri'
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
discoverer
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data DiscovererDiscoverUriAsyncMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsDiscoverer a) => O.MethodInfo DiscovererDiscoverUriAsyncMethodInfo a signature where
overloadedMethod = discovererDiscoverUriAsync
#endif
foreign import ccall "gst_discoverer_start" gst_discoverer_start ::
Ptr Discoverer ->
IO ()
discovererStart ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscoverer a) =>
a
-> m ()
discovererStart :: a -> m ()
discovererStart discoverer :: a
discoverer = 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 Discoverer
discoverer' <- a -> IO (Ptr Discoverer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
discoverer
Ptr Discoverer -> IO ()
gst_discoverer_start Ptr Discoverer
discoverer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
discoverer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DiscovererStartMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDiscoverer a) => O.MethodInfo DiscovererStartMethodInfo a signature where
overloadedMethod = discovererStart
#endif
foreign import ccall "gst_discoverer_stop" gst_discoverer_stop ::
Ptr Discoverer ->
IO ()
discovererStop ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscoverer a) =>
a
-> m ()
discovererStop :: a -> m ()
discovererStop discoverer :: a
discoverer = 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 Discoverer
discoverer' <- a -> IO (Ptr Discoverer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
discoverer
Ptr Discoverer -> IO ()
gst_discoverer_stop Ptr Discoverer
discoverer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
discoverer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DiscovererStopMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDiscoverer a) => O.MethodInfo DiscovererStopMethodInfo a signature where
overloadedMethod = discovererStop
#endif