{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Objects.Element
(
Element(..) ,
IsElement ,
toElement ,
noElement ,
#if defined(ENABLE_OVERLOADING)
ResolveElementMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ElementAbortStateMethodInfo ,
#endif
elementAbortState ,
#if defined(ENABLE_OVERLOADING)
ElementAddPadMethodInfo ,
#endif
elementAddPad ,
#if defined(ENABLE_OVERLOADING)
ElementAddPropertyDeepNotifyWatchMethodInfo,
#endif
elementAddPropertyDeepNotifyWatch ,
#if defined(ENABLE_OVERLOADING)
ElementAddPropertyNotifyWatchMethodInfo ,
#endif
elementAddPropertyNotifyWatch ,
#if defined(ENABLE_OVERLOADING)
ElementCallAsyncMethodInfo ,
#endif
elementCallAsync ,
#if defined(ENABLE_OVERLOADING)
ElementChangeStateMethodInfo ,
#endif
elementChangeState ,
#if defined(ENABLE_OVERLOADING)
ElementContinueStateMethodInfo ,
#endif
elementContinueState ,
#if defined(ENABLE_OVERLOADING)
ElementCreateAllPadsMethodInfo ,
#endif
elementCreateAllPads ,
#if defined(ENABLE_OVERLOADING)
ElementForeachPadMethodInfo ,
#endif
elementForeachPad ,
#if defined(ENABLE_OVERLOADING)
ElementForeachSinkPadMethodInfo ,
#endif
elementForeachSinkPad ,
#if defined(ENABLE_OVERLOADING)
ElementForeachSrcPadMethodInfo ,
#endif
elementForeachSrcPad ,
#if defined(ENABLE_OVERLOADING)
ElementGetBaseTimeMethodInfo ,
#endif
elementGetBaseTime ,
#if defined(ENABLE_OVERLOADING)
ElementGetBusMethodInfo ,
#endif
elementGetBus ,
#if defined(ENABLE_OVERLOADING)
ElementGetClockMethodInfo ,
#endif
elementGetClock ,
#if defined(ENABLE_OVERLOADING)
ElementGetCompatiblePadMethodInfo ,
#endif
elementGetCompatiblePad ,
#if defined(ENABLE_OVERLOADING)
ElementGetCompatiblePadTemplateMethodInfo,
#endif
elementGetCompatiblePadTemplate ,
#if defined(ENABLE_OVERLOADING)
ElementGetContextMethodInfo ,
#endif
elementGetContext ,
#if defined(ENABLE_OVERLOADING)
ElementGetContextUnlockedMethodInfo ,
#endif
elementGetContextUnlocked ,
#if defined(ENABLE_OVERLOADING)
ElementGetContextsMethodInfo ,
#endif
elementGetContexts ,
#if defined(ENABLE_OVERLOADING)
ElementGetFactoryMethodInfo ,
#endif
elementGetFactory ,
#if defined(ENABLE_OVERLOADING)
ElementGetMetadataMethodInfo ,
#endif
elementGetMetadata ,
#if defined(ENABLE_OVERLOADING)
ElementGetPadTemplateMethodInfo ,
#endif
elementGetPadTemplate ,
#if defined(ENABLE_OVERLOADING)
ElementGetPadTemplateListMethodInfo ,
#endif
elementGetPadTemplateList ,
#if defined(ENABLE_OVERLOADING)
ElementGetRequestPadMethodInfo ,
#endif
elementGetRequestPad ,
#if defined(ENABLE_OVERLOADING)
ElementGetStartTimeMethodInfo ,
#endif
elementGetStartTime ,
#if defined(ENABLE_OVERLOADING)
ElementGetStateMethodInfo ,
#endif
elementGetState ,
#if defined(ENABLE_OVERLOADING)
ElementGetStaticPadMethodInfo ,
#endif
elementGetStaticPad ,
#if defined(ENABLE_OVERLOADING)
ElementIsLockedStateMethodInfo ,
#endif
elementIsLockedState ,
#if defined(ENABLE_OVERLOADING)
ElementIteratePadsMethodInfo ,
#endif
elementIteratePads ,
#if defined(ENABLE_OVERLOADING)
ElementIterateSinkPadsMethodInfo ,
#endif
elementIterateSinkPads ,
#if defined(ENABLE_OVERLOADING)
ElementIterateSrcPadsMethodInfo ,
#endif
elementIterateSrcPads ,
#if defined(ENABLE_OVERLOADING)
ElementLinkMethodInfo ,
#endif
elementLink ,
#if defined(ENABLE_OVERLOADING)
ElementLinkFilteredMethodInfo ,
#endif
elementLinkFiltered ,
#if defined(ENABLE_OVERLOADING)
ElementLinkPadsMethodInfo ,
#endif
elementLinkPads ,
#if defined(ENABLE_OVERLOADING)
ElementLinkPadsFilteredMethodInfo ,
#endif
elementLinkPadsFiltered ,
#if defined(ENABLE_OVERLOADING)
ElementLinkPadsFullMethodInfo ,
#endif
elementLinkPadsFull ,
#if defined(ENABLE_OVERLOADING)
ElementLostStateMethodInfo ,
#endif
elementLostState ,
elementMakeFromUri ,
#if defined(ENABLE_OVERLOADING)
ElementMessageFullMethodInfo ,
#endif
elementMessageFull ,
#if defined(ENABLE_OVERLOADING)
ElementMessageFullWithDetailsMethodInfo ,
#endif
elementMessageFullWithDetails ,
#if defined(ENABLE_OVERLOADING)
ElementNoMorePadsMethodInfo ,
#endif
elementNoMorePads ,
#if defined(ENABLE_OVERLOADING)
ElementPostMessageMethodInfo ,
#endif
elementPostMessage ,
#if defined(ENABLE_OVERLOADING)
ElementProvideClockMethodInfo ,
#endif
elementProvideClock ,
#if defined(ENABLE_OVERLOADING)
ElementQueryMethodInfo ,
#endif
elementQuery ,
#if defined(ENABLE_OVERLOADING)
ElementQueryConvertMethodInfo ,
#endif
elementQueryConvert ,
#if defined(ENABLE_OVERLOADING)
ElementQueryDurationMethodInfo ,
#endif
elementQueryDuration ,
#if defined(ENABLE_OVERLOADING)
ElementQueryPositionMethodInfo ,
#endif
elementQueryPosition ,
elementRegister ,
#if defined(ENABLE_OVERLOADING)
ElementReleaseRequestPadMethodInfo ,
#endif
elementReleaseRequestPad ,
#if defined(ENABLE_OVERLOADING)
ElementRemovePadMethodInfo ,
#endif
elementRemovePad ,
#if defined(ENABLE_OVERLOADING)
ElementRemovePropertyNotifyWatchMethodInfo,
#endif
elementRemovePropertyNotifyWatch ,
#if defined(ENABLE_OVERLOADING)
ElementRequestPadMethodInfo ,
#endif
elementRequestPad ,
#if defined(ENABLE_OVERLOADING)
ElementSeekMethodInfo ,
#endif
elementSeek ,
#if defined(ENABLE_OVERLOADING)
ElementSeekSimpleMethodInfo ,
#endif
elementSeekSimple ,
#if defined(ENABLE_OVERLOADING)
ElementSendEventMethodInfo ,
#endif
elementSendEvent ,
#if defined(ENABLE_OVERLOADING)
ElementSetBaseTimeMethodInfo ,
#endif
elementSetBaseTime ,
#if defined(ENABLE_OVERLOADING)
ElementSetBusMethodInfo ,
#endif
elementSetBus ,
#if defined(ENABLE_OVERLOADING)
ElementSetClockMethodInfo ,
#endif
elementSetClock ,
#if defined(ENABLE_OVERLOADING)
ElementSetContextMethodInfo ,
#endif
elementSetContext ,
#if defined(ENABLE_OVERLOADING)
ElementSetLockedStateMethodInfo ,
#endif
elementSetLockedState ,
#if defined(ENABLE_OVERLOADING)
ElementSetStartTimeMethodInfo ,
#endif
elementSetStartTime ,
#if defined(ENABLE_OVERLOADING)
ElementSetStateMethodInfo ,
#endif
elementSetState ,
elementStateChangeReturnGetName ,
elementStateGetName ,
#if defined(ENABLE_OVERLOADING)
ElementSyncStateWithParentMethodInfo ,
#endif
elementSyncStateWithParent ,
#if defined(ENABLE_OVERLOADING)
ElementUnlinkMethodInfo ,
#endif
elementUnlink ,
#if defined(ENABLE_OVERLOADING)
ElementUnlinkPadsMethodInfo ,
#endif
elementUnlinkPads ,
C_ElementNoMorePadsCallback ,
ElementNoMorePadsCallback ,
#if defined(ENABLE_OVERLOADING)
ElementNoMorePadsSignalInfo ,
#endif
afterElementNoMorePads ,
genClosure_ElementNoMorePads ,
mk_ElementNoMorePadsCallback ,
noElementNoMorePadsCallback ,
onElementNoMorePads ,
wrap_ElementNoMorePadsCallback ,
C_ElementPadAddedCallback ,
ElementPadAddedCallback ,
#if defined(ENABLE_OVERLOADING)
ElementPadAddedSignalInfo ,
#endif
afterElementPadAdded ,
genClosure_ElementPadAdded ,
mk_ElementPadAddedCallback ,
noElementPadAddedCallback ,
onElementPadAdded ,
wrap_ElementPadAddedCallback ,
C_ElementPadRemovedCallback ,
ElementPadRemovedCallback ,
#if defined(ENABLE_OVERLOADING)
ElementPadRemovedSignalInfo ,
#endif
afterElementPadRemoved ,
genClosure_ElementPadRemoved ,
mk_ElementPadRemovedCallback ,
noElementPadRemovedCallback ,
onElementPadRemoved ,
wrap_ElementPadRemovedCallback ,
) 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.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.Flags as Gst.Flags
import {-# SOURCE #-} qualified GI.Gst.Objects.Bus as Gst.Bus
import {-# SOURCE #-} qualified GI.Gst.Objects.Clock as Gst.Clock
import {-# SOURCE #-} qualified GI.Gst.Objects.ElementFactory as Gst.ElementFactory
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Pad as Gst.Pad
import {-# SOURCE #-} qualified GI.Gst.Objects.PadTemplate as Gst.PadTemplate
import {-# SOURCE #-} qualified GI.Gst.Objects.Plugin as Gst.Plugin
import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.Gst.Structs.Context as Gst.Context
import {-# SOURCE #-} qualified GI.Gst.Structs.Event as Gst.Event
import {-# SOURCE #-} qualified GI.Gst.Structs.Iterator as Gst.Iterator
import {-# SOURCE #-} qualified GI.Gst.Structs.Message as Gst.Message
import {-# SOURCE #-} qualified GI.Gst.Structs.Query as Gst.Query
import {-# SOURCE #-} qualified GI.Gst.Structs.Structure as Gst.Structure
newtype Element = Element (ManagedPtr Element)
deriving (Element -> Element -> Bool
(Element -> Element -> Bool)
-> (Element -> Element -> Bool) -> Eq Element
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Element -> Element -> Bool
$c/= :: Element -> Element -> Bool
== :: Element -> Element -> Bool
$c== :: Element -> Element -> Bool
Eq)
foreign import ccall "gst_element_get_type"
c_gst_element_get_type :: IO GType
instance GObject Element where
gobjectType :: IO GType
gobjectType = IO GType
c_gst_element_get_type
instance B.GValue.IsGValue Element where
toGValue :: Element -> IO GValue
toGValue o :: Element
o = do
GType
gtype <- IO GType
c_gst_element_get_type
Element -> (Ptr Element -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Element
o (GType
-> (GValue -> Ptr Element -> IO ()) -> Ptr Element -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Element -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO Element
fromGValue gv :: GValue
gv = do
Ptr Element
ptr <- GValue -> IO (Ptr Element)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Element)
(ManagedPtr Element -> Element) -> Ptr Element -> IO Element
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Element -> Element
Element Ptr Element
ptr
class (GObject o, O.IsDescendantOf Element o) => IsElement o
instance (GObject o, O.IsDescendantOf Element o) => IsElement o
instance O.HasParentTypes Element
type instance O.ParentTypes Element = '[Gst.Object.Object, GObject.Object.Object]
toElement :: (MonadIO m, IsElement o) => o -> m Element
toElement :: o -> m Element
toElement = IO Element -> m Element
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Element -> m Element) -> (o -> IO Element) -> o -> m Element
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Element -> Element) -> o -> IO Element
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Element -> Element
Element
noElement :: Maybe Element
noElement :: Maybe Element
noElement = Maybe Element
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveElementMethod (t :: Symbol) (o :: *) :: * where
ResolveElementMethod "abortState" o = ElementAbortStateMethodInfo
ResolveElementMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolveElementMethod "addPad" o = ElementAddPadMethodInfo
ResolveElementMethod "addPropertyDeepNotifyWatch" o = ElementAddPropertyDeepNotifyWatchMethodInfo
ResolveElementMethod "addPropertyNotifyWatch" o = ElementAddPropertyNotifyWatchMethodInfo
ResolveElementMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveElementMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveElementMethod "callAsync" o = ElementCallAsyncMethodInfo
ResolveElementMethod "changeState" o = ElementChangeStateMethodInfo
ResolveElementMethod "continueState" o = ElementContinueStateMethodInfo
ResolveElementMethod "createAllPads" o = ElementCreateAllPadsMethodInfo
ResolveElementMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolveElementMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveElementMethod "foreachPad" o = ElementForeachPadMethodInfo
ResolveElementMethod "foreachSinkPad" o = ElementForeachSinkPadMethodInfo
ResolveElementMethod "foreachSrcPad" o = ElementForeachSrcPadMethodInfo
ResolveElementMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveElementMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveElementMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolveElementMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolveElementMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolveElementMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolveElementMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveElementMethod "isLockedState" o = ElementIsLockedStateMethodInfo
ResolveElementMethod "iteratePads" o = ElementIteratePadsMethodInfo
ResolveElementMethod "iterateSinkPads" o = ElementIterateSinkPadsMethodInfo
ResolveElementMethod "iterateSrcPads" o = ElementIterateSrcPadsMethodInfo
ResolveElementMethod "link" o = ElementLinkMethodInfo
ResolveElementMethod "linkFiltered" o = ElementLinkFilteredMethodInfo
ResolveElementMethod "linkPads" o = ElementLinkPadsMethodInfo
ResolveElementMethod "linkPadsFiltered" o = ElementLinkPadsFilteredMethodInfo
ResolveElementMethod "linkPadsFull" o = ElementLinkPadsFullMethodInfo
ResolveElementMethod "lostState" o = ElementLostStateMethodInfo
ResolveElementMethod "messageFull" o = ElementMessageFullMethodInfo
ResolveElementMethod "messageFullWithDetails" o = ElementMessageFullWithDetailsMethodInfo
ResolveElementMethod "noMorePads" o = ElementNoMorePadsMethodInfo
ResolveElementMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveElementMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveElementMethod "postMessage" o = ElementPostMessageMethodInfo
ResolveElementMethod "provideClock" o = ElementProvideClockMethodInfo
ResolveElementMethod "query" o = ElementQueryMethodInfo
ResolveElementMethod "queryConvert" o = ElementQueryConvertMethodInfo
ResolveElementMethod "queryDuration" o = ElementQueryDurationMethodInfo
ResolveElementMethod "queryPosition" o = ElementQueryPositionMethodInfo
ResolveElementMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolveElementMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveElementMethod "releaseRequestPad" o = ElementReleaseRequestPadMethodInfo
ResolveElementMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolveElementMethod "removePad" o = ElementRemovePadMethodInfo
ResolveElementMethod "removePropertyNotifyWatch" o = ElementRemovePropertyNotifyWatchMethodInfo
ResolveElementMethod "requestPad" o = ElementRequestPadMethodInfo
ResolveElementMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveElementMethod "seek" o = ElementSeekMethodInfo
ResolveElementMethod "seekSimple" o = ElementSeekSimpleMethodInfo
ResolveElementMethod "sendEvent" o = ElementSendEventMethodInfo
ResolveElementMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveElementMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveElementMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolveElementMethod "syncStateWithParent" o = ElementSyncStateWithParentMethodInfo
ResolveElementMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolveElementMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveElementMethod "unlink" o = ElementUnlinkMethodInfo
ResolveElementMethod "unlinkPads" o = ElementUnlinkPadsMethodInfo
ResolveElementMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolveElementMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolveElementMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveElementMethod "getBaseTime" o = ElementGetBaseTimeMethodInfo
ResolveElementMethod "getBus" o = ElementGetBusMethodInfo
ResolveElementMethod "getClock" o = ElementGetClockMethodInfo
ResolveElementMethod "getCompatiblePad" o = ElementGetCompatiblePadMethodInfo
ResolveElementMethod "getCompatiblePadTemplate" o = ElementGetCompatiblePadTemplateMethodInfo
ResolveElementMethod "getContext" o = ElementGetContextMethodInfo
ResolveElementMethod "getContextUnlocked" o = ElementGetContextUnlockedMethodInfo
ResolveElementMethod "getContexts" o = ElementGetContextsMethodInfo
ResolveElementMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolveElementMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolveElementMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveElementMethod "getFactory" o = ElementGetFactoryMethodInfo
ResolveElementMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolveElementMethod "getMetadata" o = ElementGetMetadataMethodInfo
ResolveElementMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
ResolveElementMethod "getPadTemplate" o = ElementGetPadTemplateMethodInfo
ResolveElementMethod "getPadTemplateList" o = ElementGetPadTemplateListMethodInfo
ResolveElementMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolveElementMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolveElementMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveElementMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveElementMethod "getRequestPad" o = ElementGetRequestPadMethodInfo
ResolveElementMethod "getStartTime" o = ElementGetStartTimeMethodInfo
ResolveElementMethod "getState" o = ElementGetStateMethodInfo
ResolveElementMethod "getStaticPad" o = ElementGetStaticPadMethodInfo
ResolveElementMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolveElementMethod "setBaseTime" o = ElementSetBaseTimeMethodInfo
ResolveElementMethod "setBus" o = ElementSetBusMethodInfo
ResolveElementMethod "setClock" o = ElementSetClockMethodInfo
ResolveElementMethod "setContext" o = ElementSetContextMethodInfo
ResolveElementMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolveElementMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolveElementMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolveElementMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveElementMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveElementMethod "setLockedState" o = ElementSetLockedStateMethodInfo
ResolveElementMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolveElementMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolveElementMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveElementMethod "setStartTime" o = ElementSetStartTimeMethodInfo
ResolveElementMethod "setState" o = ElementSetStateMethodInfo
ResolveElementMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveElementMethod t Element, O.MethodInfo info Element p) => OL.IsLabel t (Element -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
type ElementNoMorePadsCallback =
IO ()
noElementNoMorePadsCallback :: Maybe ElementNoMorePadsCallback
noElementNoMorePadsCallback :: Maybe (IO ())
noElementNoMorePadsCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_ElementNoMorePadsCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_ElementNoMorePadsCallback :: C_ElementNoMorePadsCallback -> IO (FunPtr C_ElementNoMorePadsCallback)
genClosure_ElementNoMorePads :: MonadIO m => ElementNoMorePadsCallback -> m (GClosure C_ElementNoMorePadsCallback)
genClosure_ElementNoMorePads :: IO () -> m (GClosure C_ElementNoMorePadsCallback)
genClosure_ElementNoMorePads cb :: IO ()
cb = IO (GClosure C_ElementNoMorePadsCallback)
-> m (GClosure C_ElementNoMorePadsCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ElementNoMorePadsCallback)
-> m (GClosure C_ElementNoMorePadsCallback))
-> IO (GClosure C_ElementNoMorePadsCallback)
-> m (GClosure C_ElementNoMorePadsCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_ElementNoMorePadsCallback
cb' = IO () -> C_ElementNoMorePadsCallback
wrap_ElementNoMorePadsCallback IO ()
cb
C_ElementNoMorePadsCallback
-> IO (FunPtr C_ElementNoMorePadsCallback)
mk_ElementNoMorePadsCallback C_ElementNoMorePadsCallback
cb' IO (FunPtr C_ElementNoMorePadsCallback)
-> (FunPtr C_ElementNoMorePadsCallback
-> IO (GClosure C_ElementNoMorePadsCallback))
-> IO (GClosure C_ElementNoMorePadsCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ElementNoMorePadsCallback
-> IO (GClosure C_ElementNoMorePadsCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ElementNoMorePadsCallback ::
ElementNoMorePadsCallback ->
C_ElementNoMorePadsCallback
wrap_ElementNoMorePadsCallback :: IO () -> C_ElementNoMorePadsCallback
wrap_ElementNoMorePadsCallback _cb :: IO ()
_cb _ _ = do
IO ()
_cb
onElementNoMorePads :: (IsElement a, MonadIO m) => a -> ElementNoMorePadsCallback -> m SignalHandlerId
onElementNoMorePads :: a -> IO () -> m SignalHandlerId
onElementNoMorePads 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_ElementNoMorePadsCallback
cb' = IO () -> C_ElementNoMorePadsCallback
wrap_ElementNoMorePadsCallback IO ()
cb
FunPtr C_ElementNoMorePadsCallback
cb'' <- C_ElementNoMorePadsCallback
-> IO (FunPtr C_ElementNoMorePadsCallback)
mk_ElementNoMorePadsCallback C_ElementNoMorePadsCallback
cb'
a
-> Text
-> FunPtr C_ElementNoMorePadsCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "no-more-pads" FunPtr C_ElementNoMorePadsCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterElementNoMorePads :: (IsElement a, MonadIO m) => a -> ElementNoMorePadsCallback -> m SignalHandlerId
afterElementNoMorePads :: a -> IO () -> m SignalHandlerId
afterElementNoMorePads 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_ElementNoMorePadsCallback
cb' = IO () -> C_ElementNoMorePadsCallback
wrap_ElementNoMorePadsCallback IO ()
cb
FunPtr C_ElementNoMorePadsCallback
cb'' <- C_ElementNoMorePadsCallback
-> IO (FunPtr C_ElementNoMorePadsCallback)
mk_ElementNoMorePadsCallback C_ElementNoMorePadsCallback
cb'
a
-> Text
-> FunPtr C_ElementNoMorePadsCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "no-more-pads" FunPtr C_ElementNoMorePadsCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data ElementNoMorePadsSignalInfo
instance SignalInfo ElementNoMorePadsSignalInfo where
type HaskellCallbackType ElementNoMorePadsSignalInfo = ElementNoMorePadsCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_ElementNoMorePadsCallback cb
cb'' <- mk_ElementNoMorePadsCallback cb'
connectSignalFunPtr obj "no-more-pads" cb'' connectMode detail
#endif
type ElementPadAddedCallback =
Gst.Pad.Pad
-> IO ()
noElementPadAddedCallback :: Maybe ElementPadAddedCallback
noElementPadAddedCallback :: Maybe ElementPadAddedCallback
noElementPadAddedCallback = Maybe ElementPadAddedCallback
forall a. Maybe a
Nothing
type C_ElementPadAddedCallback =
Ptr () ->
Ptr Gst.Pad.Pad ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_ElementPadAddedCallback :: C_ElementPadAddedCallback -> IO (FunPtr C_ElementPadAddedCallback)
genClosure_ElementPadAdded :: MonadIO m => ElementPadAddedCallback -> m (GClosure C_ElementPadAddedCallback)
genClosure_ElementPadAdded :: ElementPadAddedCallback -> m (GClosure C_ElementPadAddedCallback)
genClosure_ElementPadAdded cb :: ElementPadAddedCallback
cb = IO (GClosure C_ElementPadAddedCallback)
-> m (GClosure C_ElementPadAddedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ElementPadAddedCallback)
-> m (GClosure C_ElementPadAddedCallback))
-> IO (GClosure C_ElementPadAddedCallback)
-> m (GClosure C_ElementPadAddedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_ElementPadAddedCallback
cb' = ElementPadAddedCallback -> C_ElementPadAddedCallback
wrap_ElementPadAddedCallback ElementPadAddedCallback
cb
C_ElementPadAddedCallback -> IO (FunPtr C_ElementPadAddedCallback)
mk_ElementPadAddedCallback C_ElementPadAddedCallback
cb' IO (FunPtr C_ElementPadAddedCallback)
-> (FunPtr C_ElementPadAddedCallback
-> IO (GClosure C_ElementPadAddedCallback))
-> IO (GClosure C_ElementPadAddedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ElementPadAddedCallback
-> IO (GClosure C_ElementPadAddedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ElementPadAddedCallback ::
ElementPadAddedCallback ->
C_ElementPadAddedCallback
wrap_ElementPadAddedCallback :: ElementPadAddedCallback -> C_ElementPadAddedCallback
wrap_ElementPadAddedCallback _cb :: ElementPadAddedCallback
_cb _ newPad :: Ptr Pad
newPad _ = do
Pad
newPad' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pad -> Pad
Gst.Pad.Pad) Ptr Pad
newPad
ElementPadAddedCallback
_cb Pad
newPad'
onElementPadAdded :: (IsElement a, MonadIO m) => a -> ElementPadAddedCallback -> m SignalHandlerId
onElementPadAdded :: a -> ElementPadAddedCallback -> m SignalHandlerId
onElementPadAdded obj :: a
obj cb :: ElementPadAddedCallback
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_ElementPadAddedCallback
cb' = ElementPadAddedCallback -> C_ElementPadAddedCallback
wrap_ElementPadAddedCallback ElementPadAddedCallback
cb
FunPtr C_ElementPadAddedCallback
cb'' <- C_ElementPadAddedCallback -> IO (FunPtr C_ElementPadAddedCallback)
mk_ElementPadAddedCallback C_ElementPadAddedCallback
cb'
a
-> Text
-> FunPtr C_ElementPadAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "pad-added" FunPtr C_ElementPadAddedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterElementPadAdded :: (IsElement a, MonadIO m) => a -> ElementPadAddedCallback -> m SignalHandlerId
afterElementPadAdded :: a -> ElementPadAddedCallback -> m SignalHandlerId
afterElementPadAdded obj :: a
obj cb :: ElementPadAddedCallback
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_ElementPadAddedCallback
cb' = ElementPadAddedCallback -> C_ElementPadAddedCallback
wrap_ElementPadAddedCallback ElementPadAddedCallback
cb
FunPtr C_ElementPadAddedCallback
cb'' <- C_ElementPadAddedCallback -> IO (FunPtr C_ElementPadAddedCallback)
mk_ElementPadAddedCallback C_ElementPadAddedCallback
cb'
a
-> Text
-> FunPtr C_ElementPadAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "pad-added" FunPtr C_ElementPadAddedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data ElementPadAddedSignalInfo
instance SignalInfo ElementPadAddedSignalInfo where
type HaskellCallbackType ElementPadAddedSignalInfo = ElementPadAddedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_ElementPadAddedCallback cb
cb'' <- mk_ElementPadAddedCallback cb'
connectSignalFunPtr obj "pad-added" cb'' connectMode detail
#endif
type ElementPadRemovedCallback =
Gst.Pad.Pad
-> IO ()
noElementPadRemovedCallback :: Maybe ElementPadRemovedCallback
noElementPadRemovedCallback :: Maybe ElementPadAddedCallback
noElementPadRemovedCallback = Maybe ElementPadAddedCallback
forall a. Maybe a
Nothing
type C_ElementPadRemovedCallback =
Ptr () ->
Ptr Gst.Pad.Pad ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_ElementPadRemovedCallback :: C_ElementPadRemovedCallback -> IO (FunPtr C_ElementPadRemovedCallback)
genClosure_ElementPadRemoved :: MonadIO m => ElementPadRemovedCallback -> m (GClosure C_ElementPadRemovedCallback)
genClosure_ElementPadRemoved :: ElementPadAddedCallback -> m (GClosure C_ElementPadAddedCallback)
genClosure_ElementPadRemoved cb :: ElementPadAddedCallback
cb = IO (GClosure C_ElementPadAddedCallback)
-> m (GClosure C_ElementPadAddedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ElementPadAddedCallback)
-> m (GClosure C_ElementPadAddedCallback))
-> IO (GClosure C_ElementPadAddedCallback)
-> m (GClosure C_ElementPadAddedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_ElementPadAddedCallback
cb' = ElementPadAddedCallback -> C_ElementPadAddedCallback
wrap_ElementPadRemovedCallback ElementPadAddedCallback
cb
C_ElementPadAddedCallback -> IO (FunPtr C_ElementPadAddedCallback)
mk_ElementPadRemovedCallback C_ElementPadAddedCallback
cb' IO (FunPtr C_ElementPadAddedCallback)
-> (FunPtr C_ElementPadAddedCallback
-> IO (GClosure C_ElementPadAddedCallback))
-> IO (GClosure C_ElementPadAddedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ElementPadAddedCallback
-> IO (GClosure C_ElementPadAddedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ElementPadRemovedCallback ::
ElementPadRemovedCallback ->
C_ElementPadRemovedCallback
wrap_ElementPadRemovedCallback :: ElementPadAddedCallback -> C_ElementPadAddedCallback
wrap_ElementPadRemovedCallback _cb :: ElementPadAddedCallback
_cb _ oldPad :: Ptr Pad
oldPad _ = do
Pad
oldPad' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pad -> Pad
Gst.Pad.Pad) Ptr Pad
oldPad
ElementPadAddedCallback
_cb Pad
oldPad'
onElementPadRemoved :: (IsElement a, MonadIO m) => a -> ElementPadRemovedCallback -> m SignalHandlerId
onElementPadRemoved :: a -> ElementPadAddedCallback -> m SignalHandlerId
onElementPadRemoved obj :: a
obj cb :: ElementPadAddedCallback
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_ElementPadAddedCallback
cb' = ElementPadAddedCallback -> C_ElementPadAddedCallback
wrap_ElementPadRemovedCallback ElementPadAddedCallback
cb
FunPtr C_ElementPadAddedCallback
cb'' <- C_ElementPadAddedCallback -> IO (FunPtr C_ElementPadAddedCallback)
mk_ElementPadRemovedCallback C_ElementPadAddedCallback
cb'
a
-> Text
-> FunPtr C_ElementPadAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "pad-removed" FunPtr C_ElementPadAddedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterElementPadRemoved :: (IsElement a, MonadIO m) => a -> ElementPadRemovedCallback -> m SignalHandlerId
afterElementPadRemoved :: a -> ElementPadAddedCallback -> m SignalHandlerId
afterElementPadRemoved obj :: a
obj cb :: ElementPadAddedCallback
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_ElementPadAddedCallback
cb' = ElementPadAddedCallback -> C_ElementPadAddedCallback
wrap_ElementPadRemovedCallback ElementPadAddedCallback
cb
FunPtr C_ElementPadAddedCallback
cb'' <- C_ElementPadAddedCallback -> IO (FunPtr C_ElementPadAddedCallback)
mk_ElementPadRemovedCallback C_ElementPadAddedCallback
cb'
a
-> Text
-> FunPtr C_ElementPadAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "pad-removed" FunPtr C_ElementPadAddedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data ElementPadRemovedSignalInfo
instance SignalInfo ElementPadRemovedSignalInfo where
type HaskellCallbackType ElementPadRemovedSignalInfo = ElementPadRemovedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_ElementPadRemovedCallback cb
cb'' <- mk_ElementPadRemovedCallback cb'
connectSignalFunPtr obj "pad-removed" cb'' connectMode detail
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Element
type instance O.AttributeList Element = ElementAttributeList
type ElementAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Element = ElementSignalList
type ElementSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("noMorePads", ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", ElementPadAddedSignalInfo), '("padRemoved", ElementPadRemovedSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_element_abort_state" gst_element_abort_state ::
Ptr Element ->
IO ()
elementAbortState ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m ()
elementAbortState :: a -> m ()
elementAbortState element :: a
element = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Element -> IO ()
gst_element_abort_state Ptr Element
element'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementAbortStateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsElement a) => O.MethodInfo ElementAbortStateMethodInfo a signature where
overloadedMethod = elementAbortState
#endif
foreign import ccall "gst_element_add_pad" gst_element_add_pad ::
Ptr Element ->
Ptr Gst.Pad.Pad ->
IO CInt
elementAddPad ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, Gst.Pad.IsPad b) =>
a
-> b
-> m Bool
elementAddPad :: a -> b -> m Bool
elementAddPad element :: a
element pad :: b
pad = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Pad
pad' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
pad
CInt
result <- Ptr Element -> Ptr Pad -> IO CInt
gst_element_add_pad Ptr Element
element' Ptr Pad
pad'
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
element
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementAddPadMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsElement a, Gst.Pad.IsPad b) => O.MethodInfo ElementAddPadMethodInfo a signature where
overloadedMethod = elementAddPad
#endif
foreign import ccall "gst_element_add_property_deep_notify_watch" gst_element_add_property_deep_notify_watch ::
Ptr Element ->
CString ->
CInt ->
IO CULong
elementAddPropertyDeepNotifyWatch ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Maybe (T.Text)
-> Bool
-> m CULong
elementAddPropertyDeepNotifyWatch :: a -> Maybe Text -> Bool -> m SignalHandlerId
elementAddPropertyDeepNotifyWatch element :: a
element propertyName :: Maybe Text
propertyName includeValue :: Bool
includeValue = 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
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr CChar
maybePropertyName <- case Maybe Text
propertyName of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jPropertyName :: Text
jPropertyName -> do
Ptr CChar
jPropertyName' <- Text -> IO (Ptr CChar)
textToCString Text
jPropertyName
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jPropertyName'
let includeValue' :: CInt
includeValue' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
includeValue
SignalHandlerId
result <- Ptr Element -> Ptr CChar -> CInt -> IO SignalHandlerId
gst_element_add_property_deep_notify_watch Ptr Element
element' Ptr CChar
maybePropertyName CInt
includeValue'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybePropertyName
SignalHandlerId -> IO SignalHandlerId
forall (m :: * -> *) a. Monad m => a -> m a
return SignalHandlerId
result
#if defined(ENABLE_OVERLOADING)
data ElementAddPropertyDeepNotifyWatchMethodInfo
instance (signature ~ (Maybe (T.Text) -> Bool -> m CULong), MonadIO m, IsElement a) => O.MethodInfo ElementAddPropertyDeepNotifyWatchMethodInfo a signature where
overloadedMethod = elementAddPropertyDeepNotifyWatch
#endif
foreign import ccall "gst_element_add_property_notify_watch" gst_element_add_property_notify_watch ::
Ptr Element ->
CString ->
CInt ->
IO CULong
elementAddPropertyNotifyWatch ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Maybe (T.Text)
-> Bool
-> m CULong
elementAddPropertyNotifyWatch :: a -> Maybe Text -> Bool -> m SignalHandlerId
elementAddPropertyNotifyWatch element :: a
element propertyName :: Maybe Text
propertyName includeValue :: Bool
includeValue = 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
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr CChar
maybePropertyName <- case Maybe Text
propertyName of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jPropertyName :: Text
jPropertyName -> do
Ptr CChar
jPropertyName' <- Text -> IO (Ptr CChar)
textToCString Text
jPropertyName
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jPropertyName'
let includeValue' :: CInt
includeValue' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
includeValue
SignalHandlerId
result <- Ptr Element -> Ptr CChar -> CInt -> IO SignalHandlerId
gst_element_add_property_notify_watch Ptr Element
element' Ptr CChar
maybePropertyName CInt
includeValue'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybePropertyName
SignalHandlerId -> IO SignalHandlerId
forall (m :: * -> *) a. Monad m => a -> m a
return SignalHandlerId
result
#if defined(ENABLE_OVERLOADING)
data ElementAddPropertyNotifyWatchMethodInfo
instance (signature ~ (Maybe (T.Text) -> Bool -> m CULong), MonadIO m, IsElement a) => O.MethodInfo ElementAddPropertyNotifyWatchMethodInfo a signature where
overloadedMethod = elementAddPropertyNotifyWatch
#endif
foreign import ccall "gst_element_call_async" gst_element_call_async ::
Ptr Element ->
FunPtr Gst.Callbacks.C_ElementCallAsyncFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
elementCallAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Callbacks.ElementCallAsyncFunc
-> m ()
elementCallAsync :: a -> ElementCallAsyncFunc -> m ()
elementCallAsync element :: a
element func :: ElementCallAsyncFunc
func = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
FunPtr C_ElementCallAsyncFunc
func' <- C_ElementCallAsyncFunc -> IO (FunPtr C_ElementCallAsyncFunc)
Gst.Callbacks.mk_ElementCallAsyncFunc (Maybe (Ptr (FunPtr C_ElementCallAsyncFunc))
-> ElementCallAsyncFunc_WithClosures -> C_ElementCallAsyncFunc
Gst.Callbacks.wrap_ElementCallAsyncFunc Maybe (Ptr (FunPtr C_ElementCallAsyncFunc))
forall a. Maybe a
Nothing (ElementCallAsyncFunc -> ElementCallAsyncFunc_WithClosures
Gst.Callbacks.drop_closures_ElementCallAsyncFunc ElementCallAsyncFunc
func))
let userData :: Ptr ()
userData = FunPtr C_ElementCallAsyncFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_ElementCallAsyncFunc
func'
let destroyNotify :: FunPtr (Ptr a -> IO ())
destroyNotify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Element
-> FunPtr C_ElementCallAsyncFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_element_call_async Ptr Element
element' FunPtr C_ElementCallAsyncFunc
func' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroyNotify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementCallAsyncMethodInfo
instance (signature ~ (Gst.Callbacks.ElementCallAsyncFunc -> m ()), MonadIO m, IsElement a) => O.MethodInfo ElementCallAsyncMethodInfo a signature where
overloadedMethod = elementCallAsync
#endif
foreign import ccall "gst_element_change_state" gst_element_change_state ::
Ptr Element ->
CUInt ->
IO CUInt
elementChangeState ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Enums.StateChange
-> m Gst.Enums.StateChangeReturn
elementChangeState :: a -> StateChange -> m StateChangeReturn
elementChangeState element :: a
element transition :: StateChange
transition = IO StateChangeReturn -> m StateChangeReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StateChangeReturn -> m StateChangeReturn)
-> IO StateChangeReturn -> m StateChangeReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
let transition' :: CUInt
transition' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (StateChange -> Int) -> StateChange -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StateChange -> Int
forall a. Enum a => a -> Int
fromEnum) StateChange
transition
CUInt
result <- Ptr Element -> CUInt -> IO CUInt
gst_element_change_state Ptr Element
element' CUInt
transition'
let result' :: StateChangeReturn
result' = (Int -> StateChangeReturn
forall a. Enum a => Int -> a
toEnum (Int -> StateChangeReturn)
-> (CUInt -> Int) -> CUInt -> StateChangeReturn
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
element
StateChangeReturn -> IO StateChangeReturn
forall (m :: * -> *) a. Monad m => a -> m a
return StateChangeReturn
result'
#if defined(ENABLE_OVERLOADING)
data ElementChangeStateMethodInfo
instance (signature ~ (Gst.Enums.StateChange -> m Gst.Enums.StateChangeReturn), MonadIO m, IsElement a) => O.MethodInfo ElementChangeStateMethodInfo a signature where
overloadedMethod = elementChangeState
#endif
foreign import ccall "gst_element_continue_state" gst_element_continue_state ::
Ptr Element ->
CUInt ->
IO CUInt
elementContinueState ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Enums.StateChangeReturn
-> m Gst.Enums.StateChangeReturn
elementContinueState :: a -> StateChangeReturn -> m StateChangeReturn
elementContinueState element :: a
element ret :: StateChangeReturn
ret = IO StateChangeReturn -> m StateChangeReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StateChangeReturn -> m StateChangeReturn)
-> IO StateChangeReturn -> m StateChangeReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
let ret' :: CUInt
ret' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (StateChangeReturn -> Int) -> StateChangeReturn -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StateChangeReturn -> Int
forall a. Enum a => a -> Int
fromEnum) StateChangeReturn
ret
CUInt
result <- Ptr Element -> CUInt -> IO CUInt
gst_element_continue_state Ptr Element
element' CUInt
ret'
let result' :: StateChangeReturn
result' = (Int -> StateChangeReturn
forall a. Enum a => Int -> a
toEnum (Int -> StateChangeReturn)
-> (CUInt -> Int) -> CUInt -> StateChangeReturn
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
element
StateChangeReturn -> IO StateChangeReturn
forall (m :: * -> *) a. Monad m => a -> m a
return StateChangeReturn
result'
#if defined(ENABLE_OVERLOADING)
data ElementContinueStateMethodInfo
instance (signature ~ (Gst.Enums.StateChangeReturn -> m Gst.Enums.StateChangeReturn), MonadIO m, IsElement a) => O.MethodInfo ElementContinueStateMethodInfo a signature where
overloadedMethod = elementContinueState
#endif
foreign import ccall "gst_element_create_all_pads" gst_element_create_all_pads ::
Ptr Element ->
IO ()
elementCreateAllPads ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m ()
elementCreateAllPads :: a -> m ()
elementCreateAllPads element :: a
element = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Element -> IO ()
gst_element_create_all_pads Ptr Element
element'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementCreateAllPadsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsElement a) => O.MethodInfo ElementCreateAllPadsMethodInfo a signature where
overloadedMethod = elementCreateAllPads
#endif
foreign import ccall "gst_element_foreach_pad" gst_element_foreach_pad ::
Ptr Element ->
FunPtr Gst.Callbacks.C_ElementForeachPadFunc ->
Ptr () ->
IO CInt
elementForeachPad ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Callbacks.ElementForeachPadFunc
-> m Bool
elementForeachPad :: a -> ElementForeachPadFunc -> m Bool
elementForeachPad element :: a
element func :: ElementForeachPadFunc
func = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
FunPtr C_ElementForeachPadFunc
func' <- C_ElementForeachPadFunc -> IO (FunPtr C_ElementForeachPadFunc)
Gst.Callbacks.mk_ElementForeachPadFunc (Maybe (Ptr (FunPtr C_ElementForeachPadFunc))
-> ElementForeachPadFunc_WithClosures -> C_ElementForeachPadFunc
Gst.Callbacks.wrap_ElementForeachPadFunc Maybe (Ptr (FunPtr C_ElementForeachPadFunc))
forall a. Maybe a
Nothing (ElementForeachPadFunc -> ElementForeachPadFunc_WithClosures
Gst.Callbacks.drop_closures_ElementForeachPadFunc ElementForeachPadFunc
func))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
CInt
result <- Ptr Element -> FunPtr C_ElementForeachPadFunc -> Ptr () -> IO CInt
gst_element_foreach_pad Ptr Element
element' FunPtr C_ElementForeachPadFunc
func' Ptr ()
forall a. Ptr a
userData
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_ElementForeachPadFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_ElementForeachPadFunc
func'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementForeachPadMethodInfo
instance (signature ~ (Gst.Callbacks.ElementForeachPadFunc -> m Bool), MonadIO m, IsElement a) => O.MethodInfo ElementForeachPadMethodInfo a signature where
overloadedMethod = elementForeachPad
#endif
foreign import ccall "gst_element_foreach_sink_pad" gst_element_foreach_sink_pad ::
Ptr Element ->
FunPtr Gst.Callbacks.C_ElementForeachPadFunc ->
Ptr () ->
IO CInt
elementForeachSinkPad ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Callbacks.ElementForeachPadFunc
-> m Bool
elementForeachSinkPad :: a -> ElementForeachPadFunc -> m Bool
elementForeachSinkPad element :: a
element func :: ElementForeachPadFunc
func = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
FunPtr C_ElementForeachPadFunc
func' <- C_ElementForeachPadFunc -> IO (FunPtr C_ElementForeachPadFunc)
Gst.Callbacks.mk_ElementForeachPadFunc (Maybe (Ptr (FunPtr C_ElementForeachPadFunc))
-> ElementForeachPadFunc_WithClosures -> C_ElementForeachPadFunc
Gst.Callbacks.wrap_ElementForeachPadFunc Maybe (Ptr (FunPtr C_ElementForeachPadFunc))
forall a. Maybe a
Nothing (ElementForeachPadFunc -> ElementForeachPadFunc_WithClosures
Gst.Callbacks.drop_closures_ElementForeachPadFunc ElementForeachPadFunc
func))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
CInt
result <- Ptr Element -> FunPtr C_ElementForeachPadFunc -> Ptr () -> IO CInt
gst_element_foreach_sink_pad Ptr Element
element' FunPtr C_ElementForeachPadFunc
func' Ptr ()
forall a. Ptr a
userData
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_ElementForeachPadFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_ElementForeachPadFunc
func'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementForeachSinkPadMethodInfo
instance (signature ~ (Gst.Callbacks.ElementForeachPadFunc -> m Bool), MonadIO m, IsElement a) => O.MethodInfo ElementForeachSinkPadMethodInfo a signature where
overloadedMethod = elementForeachSinkPad
#endif
foreign import ccall "gst_element_foreach_src_pad" gst_element_foreach_src_pad ::
Ptr Element ->
FunPtr Gst.Callbacks.C_ElementForeachPadFunc ->
Ptr () ->
IO CInt
elementForeachSrcPad ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Callbacks.ElementForeachPadFunc
-> m Bool
elementForeachSrcPad :: a -> ElementForeachPadFunc -> m Bool
elementForeachSrcPad element :: a
element func :: ElementForeachPadFunc
func = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
FunPtr C_ElementForeachPadFunc
func' <- C_ElementForeachPadFunc -> IO (FunPtr C_ElementForeachPadFunc)
Gst.Callbacks.mk_ElementForeachPadFunc (Maybe (Ptr (FunPtr C_ElementForeachPadFunc))
-> ElementForeachPadFunc_WithClosures -> C_ElementForeachPadFunc
Gst.Callbacks.wrap_ElementForeachPadFunc Maybe (Ptr (FunPtr C_ElementForeachPadFunc))
forall a. Maybe a
Nothing (ElementForeachPadFunc -> ElementForeachPadFunc_WithClosures
Gst.Callbacks.drop_closures_ElementForeachPadFunc ElementForeachPadFunc
func))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
CInt
result <- Ptr Element -> FunPtr C_ElementForeachPadFunc -> Ptr () -> IO CInt
gst_element_foreach_src_pad Ptr Element
element' FunPtr C_ElementForeachPadFunc
func' Ptr ()
forall a. Ptr a
userData
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_ElementForeachPadFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_ElementForeachPadFunc
func'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementForeachSrcPadMethodInfo
instance (signature ~ (Gst.Callbacks.ElementForeachPadFunc -> m Bool), MonadIO m, IsElement a) => O.MethodInfo ElementForeachSrcPadMethodInfo a signature where
overloadedMethod = elementForeachSrcPad
#endif
foreign import ccall "gst_element_get_base_time" gst_element_get_base_time ::
Ptr Element ->
IO Word64
elementGetBaseTime ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m Word64
elementGetBaseTime :: a -> m Word64
elementGetBaseTime element :: a
element = 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
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Word64
result <- Ptr Element -> IO Word64
gst_element_get_base_time Ptr Element
element'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data ElementGetBaseTimeMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsElement a) => O.MethodInfo ElementGetBaseTimeMethodInfo a signature where
overloadedMethod = elementGetBaseTime
#endif
foreign import ccall "gst_element_get_bus" gst_element_get_bus ::
Ptr Element ->
IO (Ptr Gst.Bus.Bus)
elementGetBus ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m (Maybe Gst.Bus.Bus)
elementGetBus :: a -> m (Maybe Bus)
elementGetBus element :: a
element = IO (Maybe Bus) -> m (Maybe Bus)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Bus) -> m (Maybe Bus))
-> IO (Maybe Bus) -> m (Maybe Bus)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Bus
result <- Ptr Element -> IO (Ptr Bus)
gst_element_get_bus Ptr Element
element'
Maybe Bus
maybeResult <- Ptr Bus -> (Ptr Bus -> IO Bus) -> IO (Maybe Bus)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Bus
result ((Ptr Bus -> IO Bus) -> IO (Maybe Bus))
-> (Ptr Bus -> IO Bus) -> IO (Maybe Bus)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Bus
result' -> do
Bus
result'' <- ((ManagedPtr Bus -> Bus) -> Ptr Bus -> IO Bus
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Bus -> Bus
Gst.Bus.Bus) Ptr Bus
result'
Bus -> IO Bus
forall (m :: * -> *) a. Monad m => a -> m a
return Bus
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Maybe Bus -> IO (Maybe Bus)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Bus
maybeResult
#if defined(ENABLE_OVERLOADING)
data ElementGetBusMethodInfo
instance (signature ~ (m (Maybe Gst.Bus.Bus)), MonadIO m, IsElement a) => O.MethodInfo ElementGetBusMethodInfo a signature where
overloadedMethod = elementGetBus
#endif
foreign import ccall "gst_element_get_clock" gst_element_get_clock ::
Ptr Element ->
IO (Ptr Gst.Clock.Clock)
elementGetClock ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m (Maybe Gst.Clock.Clock)
elementGetClock :: a -> m (Maybe Clock)
elementGetClock element :: a
element = IO (Maybe Clock) -> m (Maybe Clock)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Clock) -> m (Maybe Clock))
-> IO (Maybe Clock) -> m (Maybe Clock)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Clock
result <- Ptr Element -> IO (Ptr Clock)
gst_element_get_clock Ptr Element
element'
Maybe Clock
maybeResult <- Ptr Clock -> (Ptr Clock -> IO Clock) -> IO (Maybe Clock)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Clock
result ((Ptr Clock -> IO Clock) -> IO (Maybe Clock))
-> (Ptr Clock -> IO Clock) -> IO (Maybe Clock)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Clock
result' -> do
Clock
result'' <- ((ManagedPtr Clock -> Clock) -> Ptr Clock -> IO Clock
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Clock -> Clock
Gst.Clock.Clock) Ptr Clock
result'
Clock -> IO Clock
forall (m :: * -> *) a. Monad m => a -> m a
return Clock
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Maybe Clock -> IO (Maybe Clock)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Clock
maybeResult
#if defined(ENABLE_OVERLOADING)
data ElementGetClockMethodInfo
instance (signature ~ (m (Maybe Gst.Clock.Clock)), MonadIO m, IsElement a) => O.MethodInfo ElementGetClockMethodInfo a signature where
overloadedMethod = elementGetClock
#endif
foreign import ccall "gst_element_get_compatible_pad" gst_element_get_compatible_pad ::
Ptr Element ->
Ptr Gst.Pad.Pad ->
Ptr Gst.Caps.Caps ->
IO (Ptr Gst.Pad.Pad)
elementGetCompatiblePad ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, Gst.Pad.IsPad b) =>
a
-> b
-> Maybe (Gst.Caps.Caps)
-> m (Maybe Gst.Pad.Pad)
elementGetCompatiblePad :: a -> b -> Maybe Caps -> m (Maybe Pad)
elementGetCompatiblePad element :: a
element pad :: b
pad caps :: Maybe Caps
caps = IO (Maybe Pad) -> m (Maybe Pad)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Pad) -> m (Maybe Pad))
-> IO (Maybe Pad) -> m (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Pad
pad' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
pad
Ptr Caps
maybeCaps <- case Maybe Caps
caps of
Nothing -> Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
forall a. Ptr a
nullPtr
Just jCaps :: Caps
jCaps -> do
Ptr Caps
jCaps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
jCaps
Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
jCaps'
Ptr Pad
result <- Ptr Element -> Ptr Pad -> Ptr Caps -> IO (Ptr Pad)
gst_element_get_compatible_pad Ptr Element
element' Ptr Pad
pad' Ptr Caps
maybeCaps
Maybe Pad
maybeResult <- Ptr Pad -> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Pad
result ((Ptr Pad -> IO Pad) -> IO (Maybe Pad))
-> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Pad
result' -> do
Pad
result'' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Pad -> Pad
Gst.Pad.Pad) Ptr Pad
result'
Pad -> IO Pad
forall (m :: * -> *) a. Monad m => a -> m a
return Pad
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
pad
Maybe Caps -> (Caps -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Caps
caps Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Pad -> IO (Maybe Pad)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pad
maybeResult
#if defined(ENABLE_OVERLOADING)
data ElementGetCompatiblePadMethodInfo
instance (signature ~ (b -> Maybe (Gst.Caps.Caps) -> m (Maybe Gst.Pad.Pad)), MonadIO m, IsElement a, Gst.Pad.IsPad b) => O.MethodInfo ElementGetCompatiblePadMethodInfo a signature where
overloadedMethod = elementGetCompatiblePad
#endif
foreign import ccall "gst_element_get_compatible_pad_template" gst_element_get_compatible_pad_template ::
Ptr Element ->
Ptr Gst.PadTemplate.PadTemplate ->
IO (Ptr Gst.PadTemplate.PadTemplate)
elementGetCompatiblePadTemplate ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, Gst.PadTemplate.IsPadTemplate b) =>
a
-> b
-> m (Maybe Gst.PadTemplate.PadTemplate)
elementGetCompatiblePadTemplate :: a -> b -> m (Maybe PadTemplate)
elementGetCompatiblePadTemplate element :: a
element compattempl :: b
compattempl = IO (Maybe PadTemplate) -> m (Maybe PadTemplate)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe PadTemplate) -> m (Maybe PadTemplate))
-> IO (Maybe PadTemplate) -> m (Maybe PadTemplate)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr PadTemplate
compattempl' <- b -> IO (Ptr PadTemplate)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
compattempl
Ptr PadTemplate
result <- Ptr Element -> Ptr PadTemplate -> IO (Ptr PadTemplate)
gst_element_get_compatible_pad_template Ptr Element
element' Ptr PadTemplate
compattempl'
Maybe PadTemplate
maybeResult <- Ptr PadTemplate
-> (Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr PadTemplate
result ((Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate))
-> (Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr PadTemplate
result' -> do
PadTemplate
result'' <- ((ManagedPtr PadTemplate -> PadTemplate)
-> Ptr PadTemplate -> IO PadTemplate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr PadTemplate -> PadTemplate
Gst.PadTemplate.PadTemplate) Ptr PadTemplate
result'
PadTemplate -> IO PadTemplate
forall (m :: * -> *) a. Monad m => a -> m a
return PadTemplate
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
compattempl
Maybe PadTemplate -> IO (Maybe PadTemplate)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PadTemplate
maybeResult
#if defined(ENABLE_OVERLOADING)
data ElementGetCompatiblePadTemplateMethodInfo
instance (signature ~ (b -> m (Maybe Gst.PadTemplate.PadTemplate)), MonadIO m, IsElement a, Gst.PadTemplate.IsPadTemplate b) => O.MethodInfo ElementGetCompatiblePadTemplateMethodInfo a signature where
overloadedMethod = elementGetCompatiblePadTemplate
#endif
foreign import ccall "gst_element_get_context" gst_element_get_context ::
Ptr Element ->
CString ->
IO (Ptr Gst.Context.Context)
elementGetContext ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> T.Text
-> m Gst.Context.Context
elementGetContext :: a -> Text -> m Context
elementGetContext element :: a
element contextType :: Text
contextType = IO Context -> m Context
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Context -> m Context) -> IO Context -> m Context
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr CChar
contextType' <- Text -> IO (Ptr CChar)
textToCString Text
contextType
Ptr Context
result <- Ptr Element -> Ptr CChar -> IO (Ptr Context)
gst_element_get_context Ptr Element
element' Ptr CChar
contextType'
Text -> Ptr Context -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "elementGetContext" Ptr Context
result
Context
result' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Context -> Context
Gst.Context.Context) Ptr Context
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
contextType'
Context -> IO Context
forall (m :: * -> *) a. Monad m => a -> m a
return Context
result'
#if defined(ENABLE_OVERLOADING)
data ElementGetContextMethodInfo
instance (signature ~ (T.Text -> m Gst.Context.Context), MonadIO m, IsElement a) => O.MethodInfo ElementGetContextMethodInfo a signature where
overloadedMethod = elementGetContext
#endif
foreign import ccall "gst_element_get_context_unlocked" gst_element_get_context_unlocked ::
Ptr Element ->
CString ->
IO (Ptr Gst.Context.Context)
elementGetContextUnlocked ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> T.Text
-> m (Maybe Gst.Context.Context)
elementGetContextUnlocked :: a -> Text -> m (Maybe Context)
elementGetContextUnlocked element :: a
element contextType :: Text
contextType = IO (Maybe Context) -> m (Maybe Context)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Context) -> m (Maybe Context))
-> IO (Maybe Context) -> m (Maybe Context)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr CChar
contextType' <- Text -> IO (Ptr CChar)
textToCString Text
contextType
Ptr Context
result <- Ptr Element -> Ptr CChar -> IO (Ptr Context)
gst_element_get_context_unlocked Ptr Element
element' Ptr CChar
contextType'
Maybe Context
maybeResult <- Ptr Context -> (Ptr Context -> IO Context) -> IO (Maybe Context)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Context
result ((Ptr Context -> IO Context) -> IO (Maybe Context))
-> (Ptr Context -> IO Context) -> IO (Maybe Context)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Context
result' -> do
Context
result'' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Context -> Context
Gst.Context.Context) Ptr Context
result'
Context -> IO Context
forall (m :: * -> *) a. Monad m => a -> m a
return Context
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
contextType'
Maybe Context -> IO (Maybe Context)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Context
maybeResult
#if defined(ENABLE_OVERLOADING)
data ElementGetContextUnlockedMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gst.Context.Context)), MonadIO m, IsElement a) => O.MethodInfo ElementGetContextUnlockedMethodInfo a signature where
overloadedMethod = elementGetContextUnlocked
#endif
foreign import ccall "gst_element_get_contexts" gst_element_get_contexts ::
Ptr Element ->
IO (Ptr (GList (Ptr Gst.Context.Context)))
elementGetContexts ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m [Gst.Context.Context]
elementGetContexts :: a -> m [Context]
elementGetContexts element :: a
element = IO [Context] -> m [Context]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Context] -> m [Context]) -> IO [Context] -> m [Context]
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr (GList (Ptr Context))
result <- Ptr Element -> IO (Ptr (GList (Ptr Context)))
gst_element_get_contexts Ptr Element
element'
[Ptr Context]
result' <- Ptr (GList (Ptr Context)) -> IO [Ptr Context]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Context))
result
[Context]
result'' <- (Ptr Context -> IO Context) -> [Ptr Context] -> IO [Context]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Context -> Context
Gst.Context.Context) [Ptr Context]
result'
Ptr (GList (Ptr Context)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Context))
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
[Context] -> IO [Context]
forall (m :: * -> *) a. Monad m => a -> m a
return [Context]
result''
#if defined(ENABLE_OVERLOADING)
data ElementGetContextsMethodInfo
instance (signature ~ (m [Gst.Context.Context]), MonadIO m, IsElement a) => O.MethodInfo ElementGetContextsMethodInfo a signature where
overloadedMethod = elementGetContexts
#endif
foreign import ccall "gst_element_get_factory" gst_element_get_factory ::
Ptr Element ->
IO (Ptr Gst.ElementFactory.ElementFactory)
elementGetFactory ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m (Maybe Gst.ElementFactory.ElementFactory)
elementGetFactory :: a -> m (Maybe ElementFactory)
elementGetFactory element :: a
element = IO (Maybe ElementFactory) -> m (Maybe ElementFactory)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ElementFactory) -> m (Maybe ElementFactory))
-> IO (Maybe ElementFactory) -> m (Maybe ElementFactory)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr ElementFactory
result <- Ptr Element -> IO (Ptr ElementFactory)
gst_element_get_factory Ptr Element
element'
Maybe ElementFactory
maybeResult <- Ptr ElementFactory
-> (Ptr ElementFactory -> IO ElementFactory)
-> IO (Maybe ElementFactory)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ElementFactory
result ((Ptr ElementFactory -> IO ElementFactory)
-> IO (Maybe ElementFactory))
-> (Ptr ElementFactory -> IO ElementFactory)
-> IO (Maybe ElementFactory)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr ElementFactory
result' -> do
ElementFactory
result'' <- ((ManagedPtr ElementFactory -> ElementFactory)
-> Ptr ElementFactory -> IO ElementFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ElementFactory -> ElementFactory
Gst.ElementFactory.ElementFactory) Ptr ElementFactory
result'
ElementFactory -> IO ElementFactory
forall (m :: * -> *) a. Monad m => a -> m a
return ElementFactory
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Maybe ElementFactory -> IO (Maybe ElementFactory)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ElementFactory
maybeResult
#if defined(ENABLE_OVERLOADING)
data ElementGetFactoryMethodInfo
instance (signature ~ (m (Maybe Gst.ElementFactory.ElementFactory)), MonadIO m, IsElement a) => O.MethodInfo ElementGetFactoryMethodInfo a signature where
overloadedMethod = elementGetFactory
#endif
foreign import ccall "gst_element_get_metadata" gst_element_get_metadata ::
Ptr Element ->
CString ->
IO CString
elementGetMetadata ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> T.Text
-> m T.Text
elementGetMetadata :: a -> Text -> m Text
elementGetMetadata element :: a
element key :: Text
key = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr CChar
key' <- Text -> IO (Ptr CChar)
textToCString Text
key
Ptr CChar
result <- Ptr Element -> Ptr CChar -> IO (Ptr CChar)
gst_element_get_metadata Ptr Element
element' Ptr CChar
key'
Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "elementGetMetadata" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
key'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data ElementGetMetadataMethodInfo
instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsElement a) => O.MethodInfo ElementGetMetadataMethodInfo a signature where
overloadedMethod = elementGetMetadata
#endif
foreign import ccall "gst_element_get_pad_template" gst_element_get_pad_template ::
Ptr Element ->
CString ->
IO (Ptr Gst.PadTemplate.PadTemplate)
elementGetPadTemplate ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> T.Text
-> m (Maybe Gst.PadTemplate.PadTemplate)
elementGetPadTemplate :: a -> Text -> m (Maybe PadTemplate)
elementGetPadTemplate element :: a
element name :: Text
name = IO (Maybe PadTemplate) -> m (Maybe PadTemplate)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe PadTemplate) -> m (Maybe PadTemplate))
-> IO (Maybe PadTemplate) -> m (Maybe PadTemplate)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr CChar
name' <- Text -> IO (Ptr CChar)
textToCString Text
name
Ptr PadTemplate
result <- Ptr Element -> Ptr CChar -> IO (Ptr PadTemplate)
gst_element_get_pad_template Ptr Element
element' Ptr CChar
name'
Maybe PadTemplate
maybeResult <- Ptr PadTemplate
-> (Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr PadTemplate
result ((Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate))
-> (Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr PadTemplate
result' -> do
PadTemplate
result'' <- ((ManagedPtr PadTemplate -> PadTemplate)
-> Ptr PadTemplate -> IO PadTemplate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr PadTemplate -> PadTemplate
Gst.PadTemplate.PadTemplate) Ptr PadTemplate
result'
PadTemplate -> IO PadTemplate
forall (m :: * -> *) a. Monad m => a -> m a
return PadTemplate
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
name'
Maybe PadTemplate -> IO (Maybe PadTemplate)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PadTemplate
maybeResult
#if defined(ENABLE_OVERLOADING)
data ElementGetPadTemplateMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gst.PadTemplate.PadTemplate)), MonadIO m, IsElement a) => O.MethodInfo ElementGetPadTemplateMethodInfo a signature where
overloadedMethod = elementGetPadTemplate
#endif
foreign import ccall "gst_element_get_pad_template_list" gst_element_get_pad_template_list ::
Ptr Element ->
IO (Ptr (GList (Ptr Gst.PadTemplate.PadTemplate)))
elementGetPadTemplateList ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m [Gst.PadTemplate.PadTemplate]
elementGetPadTemplateList :: a -> m [PadTemplate]
elementGetPadTemplateList element :: a
element = IO [PadTemplate] -> m [PadTemplate]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [PadTemplate] -> m [PadTemplate])
-> IO [PadTemplate] -> m [PadTemplate]
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr (GList (Ptr PadTemplate))
result <- Ptr Element -> IO (Ptr (GList (Ptr PadTemplate)))
gst_element_get_pad_template_list Ptr Element
element'
[Ptr PadTemplate]
result' <- Ptr (GList (Ptr PadTemplate)) -> IO [Ptr PadTemplate]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr PadTemplate))
result
[PadTemplate]
result'' <- (Ptr PadTemplate -> IO PadTemplate)
-> [Ptr PadTemplate] -> IO [PadTemplate]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr PadTemplate -> PadTemplate)
-> Ptr PadTemplate -> IO PadTemplate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr PadTemplate -> PadTemplate
Gst.PadTemplate.PadTemplate) [Ptr PadTemplate]
result'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
[PadTemplate] -> IO [PadTemplate]
forall (m :: * -> *) a. Monad m => a -> m a
return [PadTemplate]
result''
#if defined(ENABLE_OVERLOADING)
data ElementGetPadTemplateListMethodInfo
instance (signature ~ (m [Gst.PadTemplate.PadTemplate]), MonadIO m, IsElement a) => O.MethodInfo ElementGetPadTemplateListMethodInfo a signature where
overloadedMethod = elementGetPadTemplateList
#endif
foreign import ccall "gst_element_get_request_pad" gst_element_get_request_pad ::
Ptr Element ->
CString ->
IO (Ptr Gst.Pad.Pad)
elementGetRequestPad ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> T.Text
-> m (Maybe Gst.Pad.Pad)
elementGetRequestPad :: a -> Text -> m (Maybe Pad)
elementGetRequestPad element :: a
element name :: Text
name = IO (Maybe Pad) -> m (Maybe Pad)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Pad) -> m (Maybe Pad))
-> IO (Maybe Pad) -> m (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr CChar
name' <- Text -> IO (Ptr CChar)
textToCString Text
name
Ptr Pad
result <- Ptr Element -> Ptr CChar -> IO (Ptr Pad)
gst_element_get_request_pad Ptr Element
element' Ptr CChar
name'
Maybe Pad
maybeResult <- Ptr Pad -> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Pad
result ((Ptr Pad -> IO Pad) -> IO (Maybe Pad))
-> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Pad
result' -> do
Pad
result'' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Pad -> Pad
Gst.Pad.Pad) Ptr Pad
result'
Pad -> IO Pad
forall (m :: * -> *) a. Monad m => a -> m a
return Pad
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
name'
Maybe Pad -> IO (Maybe Pad)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pad
maybeResult
#if defined(ENABLE_OVERLOADING)
data ElementGetRequestPadMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gst.Pad.Pad)), MonadIO m, IsElement a) => O.MethodInfo ElementGetRequestPadMethodInfo a signature where
overloadedMethod = elementGetRequestPad
#endif
foreign import ccall "gst_element_get_start_time" gst_element_get_start_time ::
Ptr Element ->
IO Word64
elementGetStartTime ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m Word64
elementGetStartTime :: a -> m Word64
elementGetStartTime element :: a
element = 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
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Word64
result <- Ptr Element -> IO Word64
gst_element_get_start_time Ptr Element
element'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data ElementGetStartTimeMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsElement a) => O.MethodInfo ElementGetStartTimeMethodInfo a signature where
overloadedMethod = elementGetStartTime
#endif
foreign import ccall "gst_element_get_state" gst_element_get_state ::
Ptr Element ->
Ptr CUInt ->
Ptr CUInt ->
Word64 ->
IO CUInt
elementGetState ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Word64
-> m ((Gst.Enums.StateChangeReturn, Gst.Enums.State, Gst.Enums.State))
elementGetState :: a -> Word64 -> m (StateChangeReturn, State, State)
elementGetState element :: a
element timeout :: Word64
timeout = IO (StateChangeReturn, State, State)
-> m (StateChangeReturn, State, State)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (StateChangeReturn, State, State)
-> m (StateChangeReturn, State, State))
-> IO (StateChangeReturn, State, State)
-> m (StateChangeReturn, State, State)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr CUInt
state <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr CUInt
pending <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
CUInt
result <- Ptr Element -> Ptr CUInt -> Ptr CUInt -> Word64 -> IO CUInt
gst_element_get_state Ptr Element
element' Ptr CUInt
state Ptr CUInt
pending Word64
timeout
let result' :: StateChangeReturn
result' = (Int -> StateChangeReturn
forall a. Enum a => Int -> a
toEnum (Int -> StateChangeReturn)
-> (CUInt -> Int) -> CUInt -> StateChangeReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
CUInt
state' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
state
let state'' :: State
state'' = (Int -> State
forall a. Enum a => Int -> a
toEnum (Int -> State) -> (CUInt -> Int) -> CUInt -> State
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
state'
CUInt
pending' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
pending
let pending'' :: State
pending'' = (Int -> State
forall a. Enum a => Int -> a
toEnum (Int -> State) -> (CUInt -> Int) -> CUInt -> State
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
pending'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
state
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
pending
(StateChangeReturn, State, State)
-> IO (StateChangeReturn, State, State)
forall (m :: * -> *) a. Monad m => a -> m a
return (StateChangeReturn
result', State
state'', State
pending'')
#if defined(ENABLE_OVERLOADING)
data ElementGetStateMethodInfo
instance (signature ~ (Word64 -> m ((Gst.Enums.StateChangeReturn, Gst.Enums.State, Gst.Enums.State))), MonadIO m, IsElement a) => O.MethodInfo ElementGetStateMethodInfo a signature where
overloadedMethod = elementGetState
#endif
foreign import ccall "gst_element_get_static_pad" gst_element_get_static_pad ::
Ptr Element ->
CString ->
IO (Ptr Gst.Pad.Pad)
elementGetStaticPad ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> T.Text
-> m (Maybe Gst.Pad.Pad)
elementGetStaticPad :: a -> Text -> m (Maybe Pad)
elementGetStaticPad element :: a
element name :: Text
name = IO (Maybe Pad) -> m (Maybe Pad)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Pad) -> m (Maybe Pad))
-> IO (Maybe Pad) -> m (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr CChar
name' <- Text -> IO (Ptr CChar)
textToCString Text
name
Ptr Pad
result <- Ptr Element -> Ptr CChar -> IO (Ptr Pad)
gst_element_get_static_pad Ptr Element
element' Ptr CChar
name'
Maybe Pad
maybeResult <- Ptr Pad -> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Pad
result ((Ptr Pad -> IO Pad) -> IO (Maybe Pad))
-> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Pad
result' -> do
Pad
result'' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Pad -> Pad
Gst.Pad.Pad) Ptr Pad
result'
Pad -> IO Pad
forall (m :: * -> *) a. Monad m => a -> m a
return Pad
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
name'
Maybe Pad -> IO (Maybe Pad)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pad
maybeResult
#if defined(ENABLE_OVERLOADING)
data ElementGetStaticPadMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gst.Pad.Pad)), MonadIO m, IsElement a) => O.MethodInfo ElementGetStaticPadMethodInfo a signature where
overloadedMethod = elementGetStaticPad
#endif
foreign import ccall "gst_element_is_locked_state" gst_element_is_locked_state ::
Ptr Element ->
IO CInt
elementIsLockedState ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m Bool
elementIsLockedState :: a -> m Bool
elementIsLockedState element :: a
element = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
CInt
result <- Ptr Element -> IO CInt
gst_element_is_locked_state Ptr Element
element'
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
element
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementIsLockedStateMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsElement a) => O.MethodInfo ElementIsLockedStateMethodInfo a signature where
overloadedMethod = elementIsLockedState
#endif
foreign import ccall "gst_element_iterate_pads" gst_element_iterate_pads ::
Ptr Element ->
IO (Ptr Gst.Iterator.Iterator)
elementIteratePads ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m Gst.Iterator.Iterator
elementIteratePads :: a -> m Iterator
elementIteratePads element :: a
element = IO Iterator -> m Iterator
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Iterator -> m Iterator) -> IO Iterator -> m Iterator
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Iterator
result <- Ptr Element -> IO (Ptr Iterator)
gst_element_iterate_pads Ptr Element
element'
Text -> Ptr Iterator -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "elementIteratePads" Ptr Iterator
result
Iterator
result' <- ((ManagedPtr Iterator -> Iterator) -> Ptr Iterator -> IO Iterator
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Iterator -> Iterator
Gst.Iterator.Iterator) Ptr Iterator
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Iterator -> IO Iterator
forall (m :: * -> *) a. Monad m => a -> m a
return Iterator
result'
#if defined(ENABLE_OVERLOADING)
data ElementIteratePadsMethodInfo
instance (signature ~ (m Gst.Iterator.Iterator), MonadIO m, IsElement a) => O.MethodInfo ElementIteratePadsMethodInfo a signature where
overloadedMethod = elementIteratePads
#endif
foreign import ccall "gst_element_iterate_sink_pads" gst_element_iterate_sink_pads ::
Ptr Element ->
IO (Ptr Gst.Iterator.Iterator)
elementIterateSinkPads ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m Gst.Iterator.Iterator
elementIterateSinkPads :: a -> m Iterator
elementIterateSinkPads element :: a
element = IO Iterator -> m Iterator
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Iterator -> m Iterator) -> IO Iterator -> m Iterator
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Iterator
result <- Ptr Element -> IO (Ptr Iterator)
gst_element_iterate_sink_pads Ptr Element
element'
Text -> Ptr Iterator -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "elementIterateSinkPads" Ptr Iterator
result
Iterator
result' <- ((ManagedPtr Iterator -> Iterator) -> Ptr Iterator -> IO Iterator
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Iterator -> Iterator
Gst.Iterator.Iterator) Ptr Iterator
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Iterator -> IO Iterator
forall (m :: * -> *) a. Monad m => a -> m a
return Iterator
result'
#if defined(ENABLE_OVERLOADING)
data ElementIterateSinkPadsMethodInfo
instance (signature ~ (m Gst.Iterator.Iterator), MonadIO m, IsElement a) => O.MethodInfo ElementIterateSinkPadsMethodInfo a signature where
overloadedMethod = elementIterateSinkPads
#endif
foreign import ccall "gst_element_iterate_src_pads" gst_element_iterate_src_pads ::
Ptr Element ->
IO (Ptr Gst.Iterator.Iterator)
elementIterateSrcPads ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m Gst.Iterator.Iterator
elementIterateSrcPads :: a -> m Iterator
elementIterateSrcPads element :: a
element = IO Iterator -> m Iterator
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Iterator -> m Iterator) -> IO Iterator -> m Iterator
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Iterator
result <- Ptr Element -> IO (Ptr Iterator)
gst_element_iterate_src_pads Ptr Element
element'
Text -> Ptr Iterator -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "elementIterateSrcPads" Ptr Iterator
result
Iterator
result' <- ((ManagedPtr Iterator -> Iterator) -> Ptr Iterator -> IO Iterator
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Iterator -> Iterator
Gst.Iterator.Iterator) Ptr Iterator
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Iterator -> IO Iterator
forall (m :: * -> *) a. Monad m => a -> m a
return Iterator
result'
#if defined(ENABLE_OVERLOADING)
data ElementIterateSrcPadsMethodInfo
instance (signature ~ (m Gst.Iterator.Iterator), MonadIO m, IsElement a) => O.MethodInfo ElementIterateSrcPadsMethodInfo a signature where
overloadedMethod = elementIterateSrcPads
#endif
foreign import ccall "gst_element_link" gst_element_link ::
Ptr Element ->
Ptr Element ->
IO CInt
elementLink ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, IsElement b) =>
a
-> b
-> m Bool
elementLink :: a -> b -> m Bool
elementLink src :: a
src dest :: b
dest = 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 Element
src' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Element
dest' <- b -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dest
CInt
result <- Ptr Element -> Ptr Element -> IO CInt
gst_element_link Ptr Element
src' Ptr Element
dest'
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
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dest
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementLinkMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsElement a, IsElement b) => O.MethodInfo ElementLinkMethodInfo a signature where
overloadedMethod = elementLink
#endif
foreign import ccall "gst_element_link_filtered" gst_element_link_filtered ::
Ptr Element ->
Ptr Element ->
Ptr Gst.Caps.Caps ->
IO CInt
elementLinkFiltered ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, IsElement b) =>
a
-> b
-> Maybe (Gst.Caps.Caps)
-> m Bool
elementLinkFiltered :: a -> b -> Maybe Caps -> m Bool
elementLinkFiltered src :: a
src dest :: b
dest filter :: Maybe Caps
filter = 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 Element
src' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Element
dest' <- b -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dest
Ptr Caps
maybeFilter <- case Maybe Caps
filter of
Nothing -> Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
forall a. Ptr a
nullPtr
Just jFilter :: Caps
jFilter -> do
Ptr Caps
jFilter' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
jFilter
Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
jFilter'
CInt
result <- Ptr Element -> Ptr Element -> Ptr Caps -> IO CInt
gst_element_link_filtered Ptr Element
src' Ptr Element
dest' Ptr Caps
maybeFilter
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
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dest
Maybe Caps -> (Caps -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Caps
filter Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementLinkFilteredMethodInfo
instance (signature ~ (b -> Maybe (Gst.Caps.Caps) -> m Bool), MonadIO m, IsElement a, IsElement b) => O.MethodInfo ElementLinkFilteredMethodInfo a signature where
overloadedMethod = elementLinkFiltered
#endif
foreign import ccall "gst_element_link_pads" gst_element_link_pads ::
Ptr Element ->
CString ->
Ptr Element ->
CString ->
IO CInt
elementLinkPads ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, IsElement b) =>
a
-> Maybe (T.Text)
-> b
-> Maybe (T.Text)
-> m Bool
elementLinkPads :: a -> Maybe Text -> b -> Maybe Text -> m Bool
elementLinkPads src :: a
src srcpadname :: Maybe Text
srcpadname dest :: b
dest destpadname :: Maybe Text
destpadname = 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 Element
src' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr CChar
maybeSrcpadname <- case Maybe Text
srcpadname of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jSrcpadname :: Text
jSrcpadname -> do
Ptr CChar
jSrcpadname' <- Text -> IO (Ptr CChar)
textToCString Text
jSrcpadname
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jSrcpadname'
Ptr Element
dest' <- b -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dest
Ptr CChar
maybeDestpadname <- case Maybe Text
destpadname of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jDestpadname :: Text
jDestpadname -> do
Ptr CChar
jDestpadname' <- Text -> IO (Ptr CChar)
textToCString Text
jDestpadname
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jDestpadname'
CInt
result <- Ptr Element -> Ptr CChar -> Ptr Element -> Ptr CChar -> IO CInt
gst_element_link_pads Ptr Element
src' Ptr CChar
maybeSrcpadname Ptr Element
dest' Ptr CChar
maybeDestpadname
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
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dest
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeSrcpadname
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeDestpadname
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementLinkPadsMethodInfo
instance (signature ~ (Maybe (T.Text) -> b -> Maybe (T.Text) -> m Bool), MonadIO m, IsElement a, IsElement b) => O.MethodInfo ElementLinkPadsMethodInfo a signature where
overloadedMethod = elementLinkPads
#endif
foreign import ccall "gst_element_link_pads_filtered" gst_element_link_pads_filtered ::
Ptr Element ->
CString ->
Ptr Element ->
CString ->
Ptr Gst.Caps.Caps ->
IO CInt
elementLinkPadsFiltered ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, IsElement b) =>
a
-> Maybe (T.Text)
-> b
-> Maybe (T.Text)
-> Maybe (Gst.Caps.Caps)
-> m Bool
elementLinkPadsFiltered :: a -> Maybe Text -> b -> Maybe Text -> Maybe Caps -> m Bool
elementLinkPadsFiltered src :: a
src srcpadname :: Maybe Text
srcpadname dest :: b
dest destpadname :: Maybe Text
destpadname filter :: Maybe Caps
filter = 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 Element
src' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr CChar
maybeSrcpadname <- case Maybe Text
srcpadname of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jSrcpadname :: Text
jSrcpadname -> do
Ptr CChar
jSrcpadname' <- Text -> IO (Ptr CChar)
textToCString Text
jSrcpadname
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jSrcpadname'
Ptr Element
dest' <- b -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dest
Ptr CChar
maybeDestpadname <- case Maybe Text
destpadname of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jDestpadname :: Text
jDestpadname -> do
Ptr CChar
jDestpadname' <- Text -> IO (Ptr CChar)
textToCString Text
jDestpadname
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jDestpadname'
Ptr Caps
maybeFilter <- case Maybe Caps
filter of
Nothing -> Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
forall a. Ptr a
nullPtr
Just jFilter :: Caps
jFilter -> do
Ptr Caps
jFilter' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
jFilter
Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
jFilter'
CInt
result <- Ptr Element
-> Ptr CChar -> Ptr Element -> Ptr CChar -> Ptr Caps -> IO CInt
gst_element_link_pads_filtered Ptr Element
src' Ptr CChar
maybeSrcpadname Ptr Element
dest' Ptr CChar
maybeDestpadname Ptr Caps
maybeFilter
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
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dest
Maybe Caps -> (Caps -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Caps
filter Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeSrcpadname
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeDestpadname
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementLinkPadsFilteredMethodInfo
instance (signature ~ (Maybe (T.Text) -> b -> Maybe (T.Text) -> Maybe (Gst.Caps.Caps) -> m Bool), MonadIO m, IsElement a, IsElement b) => O.MethodInfo ElementLinkPadsFilteredMethodInfo a signature where
overloadedMethod = elementLinkPadsFiltered
#endif
foreign import ccall "gst_element_link_pads_full" gst_element_link_pads_full ::
Ptr Element ->
CString ->
Ptr Element ->
CString ->
CUInt ->
IO CInt
elementLinkPadsFull ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, IsElement b) =>
a
-> Maybe (T.Text)
-> b
-> Maybe (T.Text)
-> [Gst.Flags.PadLinkCheck]
-> m Bool
elementLinkPadsFull :: a -> Maybe Text -> b -> Maybe Text -> [PadLinkCheck] -> m Bool
elementLinkPadsFull src :: a
src srcpadname :: Maybe Text
srcpadname dest :: b
dest destpadname :: Maybe Text
destpadname flags :: [PadLinkCheck]
flags = 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 Element
src' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr CChar
maybeSrcpadname <- case Maybe Text
srcpadname of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jSrcpadname :: Text
jSrcpadname -> do
Ptr CChar
jSrcpadname' <- Text -> IO (Ptr CChar)
textToCString Text
jSrcpadname
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jSrcpadname'
Ptr Element
dest' <- b -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dest
Ptr CChar
maybeDestpadname <- case Maybe Text
destpadname of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jDestpadname :: Text
jDestpadname -> do
Ptr CChar
jDestpadname' <- Text -> IO (Ptr CChar)
textToCString Text
jDestpadname
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jDestpadname'
let flags' :: CUInt
flags' = [PadLinkCheck] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PadLinkCheck]
flags
CInt
result <- Ptr Element
-> Ptr CChar -> Ptr Element -> Ptr CChar -> CUInt -> IO CInt
gst_element_link_pads_full Ptr Element
src' Ptr CChar
maybeSrcpadname Ptr Element
dest' Ptr CChar
maybeDestpadname CUInt
flags'
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
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dest
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeSrcpadname
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeDestpadname
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementLinkPadsFullMethodInfo
instance (signature ~ (Maybe (T.Text) -> b -> Maybe (T.Text) -> [Gst.Flags.PadLinkCheck] -> m Bool), MonadIO m, IsElement a, IsElement b) => O.MethodInfo ElementLinkPadsFullMethodInfo a signature where
overloadedMethod = elementLinkPadsFull
#endif
foreign import ccall "gst_element_lost_state" gst_element_lost_state ::
Ptr Element ->
IO ()
elementLostState ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m ()
elementLostState :: a -> m ()
elementLostState element :: a
element = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Element -> IO ()
gst_element_lost_state Ptr Element
element'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementLostStateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsElement a) => O.MethodInfo ElementLostStateMethodInfo a signature where
overloadedMethod = elementLostState
#endif
foreign import ccall "gst_element_message_full" gst_element_message_full ::
Ptr Element ->
CUInt ->
Word32 ->
Int32 ->
CString ->
CString ->
CString ->
CString ->
Int32 ->
IO ()
elementMessageFull ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> [Gst.Flags.MessageType]
-> Word32
-> Int32
-> Maybe (T.Text)
-> Maybe (T.Text)
-> T.Text
-> T.Text
-> Int32
-> m ()
elementMessageFull :: a
-> [MessageType]
-> Word32
-> Int32
-> Maybe Text
-> Maybe Text
-> Text
-> Text
-> Int32
-> m ()
elementMessageFull element :: a
element type_ :: [MessageType]
type_ domain :: Word32
domain code :: Int32
code text :: Maybe Text
text debug :: Maybe Text
debug file :: Text
file function :: Text
function line :: Int32
line = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
let type_' :: CUInt
type_' = [MessageType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MessageType]
type_
Ptr CChar
maybeText <- case Maybe Text
text of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jText :: Text
jText -> do
Ptr CChar
jText' <- Text -> IO (Ptr CChar)
textToCString Text
jText
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jText'
Ptr CChar
maybeDebug <- case Maybe Text
debug of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jDebug :: Text
jDebug -> do
Ptr CChar
jDebug' <- Text -> IO (Ptr CChar)
textToCString Text
jDebug
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jDebug'
Ptr CChar
file' <- Text -> IO (Ptr CChar)
textToCString Text
file
Ptr CChar
function' <- Text -> IO (Ptr CChar)
textToCString Text
function
Ptr Element
-> CUInt
-> Word32
-> Int32
-> Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Int32
-> IO ()
gst_element_message_full Ptr Element
element' CUInt
type_' Word32
domain Int32
code Ptr CChar
maybeText Ptr CChar
maybeDebug Ptr CChar
file' Ptr CChar
function' Int32
line
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
file'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
function'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementMessageFullMethodInfo
instance (signature ~ ([Gst.Flags.MessageType] -> Word32 -> Int32 -> Maybe (T.Text) -> Maybe (T.Text) -> T.Text -> T.Text -> Int32 -> m ()), MonadIO m, IsElement a) => O.MethodInfo ElementMessageFullMethodInfo a signature where
overloadedMethod = elementMessageFull
#endif
foreign import ccall "gst_element_message_full_with_details" gst_element_message_full_with_details ::
Ptr Element ->
CUInt ->
Word32 ->
Int32 ->
CString ->
CString ->
CString ->
CString ->
Int32 ->
Ptr Gst.Structure.Structure ->
IO ()
elementMessageFullWithDetails ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> [Gst.Flags.MessageType]
-> Word32
-> Int32
-> Maybe (T.Text)
-> Maybe (T.Text)
-> T.Text
-> T.Text
-> Int32
-> Gst.Structure.Structure
-> m ()
elementMessageFullWithDetails :: a
-> [MessageType]
-> Word32
-> Int32
-> Maybe Text
-> Maybe Text
-> Text
-> Text
-> Int32
-> Structure
-> m ()
elementMessageFullWithDetails element :: a
element type_ :: [MessageType]
type_ domain :: Word32
domain code :: Int32
code text :: Maybe Text
text debug :: Maybe Text
debug file :: Text
file function :: Text
function line :: Int32
line structure :: Structure
structure = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
let type_' :: CUInt
type_' = [MessageType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MessageType]
type_
Ptr CChar
maybeText <- case Maybe Text
text of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jText :: Text
jText -> do
Ptr CChar
jText' <- Text -> IO (Ptr CChar)
textToCString Text
jText
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jText'
Ptr CChar
maybeDebug <- case Maybe Text
debug of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jDebug :: Text
jDebug -> do
Ptr CChar
jDebug' <- Text -> IO (Ptr CChar)
textToCString Text
jDebug
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jDebug'
Ptr CChar
file' <- Text -> IO (Ptr CChar)
textToCString Text
file
Ptr CChar
function' <- Text -> IO (Ptr CChar)
textToCString Text
function
Ptr Structure
structure' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, BoxedObject a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
structure
Ptr Element
-> CUInt
-> Word32
-> Int32
-> Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Int32
-> Ptr Structure
-> IO ()
gst_element_message_full_with_details Ptr Element
element' CUInt
type_' Word32
domain Int32
code Ptr CChar
maybeText Ptr CChar
maybeDebug Ptr CChar
file' Ptr CChar
function' Int32
line Ptr Structure
structure'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Structure
structure
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
file'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
function'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementMessageFullWithDetailsMethodInfo
instance (signature ~ ([Gst.Flags.MessageType] -> Word32 -> Int32 -> Maybe (T.Text) -> Maybe (T.Text) -> T.Text -> T.Text -> Int32 -> Gst.Structure.Structure -> m ()), MonadIO m, IsElement a) => O.MethodInfo ElementMessageFullWithDetailsMethodInfo a signature where
overloadedMethod = elementMessageFullWithDetails
#endif
foreign import ccall "gst_element_no_more_pads" gst_element_no_more_pads ::
Ptr Element ->
IO ()
elementNoMorePads ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m ()
elementNoMorePads :: a -> m ()
elementNoMorePads element :: a
element = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Element -> IO ()
gst_element_no_more_pads Ptr Element
element'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementNoMorePadsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsElement a) => O.MethodInfo ElementNoMorePadsMethodInfo a signature where
overloadedMethod = elementNoMorePads
#endif
foreign import ccall "gst_element_post_message" gst_element_post_message ::
Ptr Element ->
Ptr Gst.Message.Message ->
IO CInt
elementPostMessage ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Message.Message
-> m Bool
elementPostMessage :: a -> Message -> m Bool
elementPostMessage element :: a
element message :: Message
message = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, BoxedObject a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Message
message
CInt
result <- Ptr Element -> Ptr Message -> IO CInt
gst_element_post_message Ptr Element
element' Ptr Message
message'
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
element
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementPostMessageMethodInfo
instance (signature ~ (Gst.Message.Message -> m Bool), MonadIO m, IsElement a) => O.MethodInfo ElementPostMessageMethodInfo a signature where
overloadedMethod = elementPostMessage
#endif
foreign import ccall "gst_element_provide_clock" gst_element_provide_clock ::
Ptr Element ->
IO (Ptr Gst.Clock.Clock)
elementProvideClock ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m (Maybe Gst.Clock.Clock)
elementProvideClock :: a -> m (Maybe Clock)
elementProvideClock element :: a
element = IO (Maybe Clock) -> m (Maybe Clock)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Clock) -> m (Maybe Clock))
-> IO (Maybe Clock) -> m (Maybe Clock)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Clock
result <- Ptr Element -> IO (Ptr Clock)
gst_element_provide_clock Ptr Element
element'
Maybe Clock
maybeResult <- Ptr Clock -> (Ptr Clock -> IO Clock) -> IO (Maybe Clock)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Clock
result ((Ptr Clock -> IO Clock) -> IO (Maybe Clock))
-> (Ptr Clock -> IO Clock) -> IO (Maybe Clock)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Clock
result' -> do
Clock
result'' <- ((ManagedPtr Clock -> Clock) -> Ptr Clock -> IO Clock
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Clock -> Clock
Gst.Clock.Clock) Ptr Clock
result'
Clock -> IO Clock
forall (m :: * -> *) a. Monad m => a -> m a
return Clock
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Maybe Clock -> IO (Maybe Clock)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Clock
maybeResult
#if defined(ENABLE_OVERLOADING)
data ElementProvideClockMethodInfo
instance (signature ~ (m (Maybe Gst.Clock.Clock)), MonadIO m, IsElement a) => O.MethodInfo ElementProvideClockMethodInfo a signature where
overloadedMethod = elementProvideClock
#endif
foreign import ccall "gst_element_query" gst_element_query ::
Ptr Element ->
Ptr Gst.Query.Query ->
IO CInt
elementQuery ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Query.Query
-> m Bool
elementQuery :: a -> Query -> m Bool
elementQuery element :: a
element query :: Query
query = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
CInt
result <- Ptr Element -> Ptr Query -> IO CInt
gst_element_query Ptr Element
element' Ptr Query
query'
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
element
Query -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Query
query
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementQueryMethodInfo
instance (signature ~ (Gst.Query.Query -> m Bool), MonadIO m, IsElement a) => O.MethodInfo ElementQueryMethodInfo a signature where
overloadedMethod = elementQuery
#endif
foreign import ccall "gst_element_query_convert" gst_element_query_convert ::
Ptr Element ->
CUInt ->
Int64 ->
CUInt ->
Ptr Int64 ->
IO CInt
elementQueryConvert ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Enums.Format
-> Int64
-> Gst.Enums.Format
-> m ((Bool, Int64))
elementQueryConvert :: a -> Format -> Int64 -> Format -> m (Bool, Int64)
elementQueryConvert element :: a
element srcFormat :: Format
srcFormat srcVal :: Int64
srcVal destFormat :: Format
destFormat = IO (Bool, Int64) -> m (Bool, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
let srcFormat' :: CUInt
srcFormat' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
srcFormat
let destFormat' :: CUInt
destFormat' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
destFormat
Ptr Int64
destVal <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
CInt
result <- Ptr Element -> CUInt -> Int64 -> CUInt -> Ptr Int64 -> IO CInt
gst_element_query_convert Ptr Element
element' CUInt
srcFormat' Int64
srcVal CUInt
destFormat' Ptr Int64
destVal
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Int64
destVal' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
destVal
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
destVal
(Bool, Int64) -> IO (Bool, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
destVal')
#if defined(ENABLE_OVERLOADING)
data ElementQueryConvertMethodInfo
instance (signature ~ (Gst.Enums.Format -> Int64 -> Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsElement a) => O.MethodInfo ElementQueryConvertMethodInfo a signature where
overloadedMethod = elementQueryConvert
#endif
foreign import ccall "gst_element_query_duration" gst_element_query_duration ::
Ptr Element ->
CUInt ->
Ptr Int64 ->
IO CInt
elementQueryDuration ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Enums.Format
-> m ((Bool, Int64))
elementQueryDuration :: a -> Format -> m (Bool, Int64)
elementQueryDuration element :: a
element format :: Format
format = IO (Bool, Int64) -> m (Bool, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
Ptr Int64
duration <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
CInt
result <- Ptr Element -> CUInt -> Ptr Int64 -> IO CInt
gst_element_query_duration Ptr Element
element' CUInt
format' Ptr Int64
duration
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Int64
duration' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
duration
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
duration
(Bool, Int64) -> IO (Bool, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
duration')
#if defined(ENABLE_OVERLOADING)
data ElementQueryDurationMethodInfo
instance (signature ~ (Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsElement a) => O.MethodInfo ElementQueryDurationMethodInfo a signature where
overloadedMethod = elementQueryDuration
#endif
foreign import ccall "gst_element_query_position" gst_element_query_position ::
Ptr Element ->
CUInt ->
Ptr Int64 ->
IO CInt
elementQueryPosition ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Enums.Format
-> m ((Bool, Int64))
elementQueryPosition :: a -> Format -> m (Bool, Int64)
elementQueryPosition element :: a
element format :: Format
format = IO (Bool, Int64) -> m (Bool, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
Ptr Int64
cur <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
CInt
result <- Ptr Element -> CUInt -> Ptr Int64 -> IO CInt
gst_element_query_position Ptr Element
element' CUInt
format' Ptr Int64
cur
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Int64
cur' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
cur
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
cur
(Bool, Int64) -> IO (Bool, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
cur')
#if defined(ENABLE_OVERLOADING)
data ElementQueryPositionMethodInfo
instance (signature ~ (Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsElement a) => O.MethodInfo ElementQueryPositionMethodInfo a signature where
overloadedMethod = elementQueryPosition
#endif
foreign import ccall "gst_element_release_request_pad" gst_element_release_request_pad ::
Ptr Element ->
Ptr Gst.Pad.Pad ->
IO ()
elementReleaseRequestPad ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, Gst.Pad.IsPad b) =>
a
-> b
-> m ()
elementReleaseRequestPad :: a -> b -> m ()
elementReleaseRequestPad element :: a
element pad :: b
pad = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Pad
pad' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
pad
Ptr Element -> Ptr Pad -> IO ()
gst_element_release_request_pad Ptr Element
element' Ptr Pad
pad'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementReleaseRequestPadMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsElement a, Gst.Pad.IsPad b) => O.MethodInfo ElementReleaseRequestPadMethodInfo a signature where
overloadedMethod = elementReleaseRequestPad
#endif
foreign import ccall "gst_element_remove_pad" gst_element_remove_pad ::
Ptr Element ->
Ptr Gst.Pad.Pad ->
IO CInt
elementRemovePad ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, Gst.Pad.IsPad b) =>
a
-> b
-> m Bool
elementRemovePad :: a -> b -> m Bool
elementRemovePad element :: a
element pad :: b
pad = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Pad
pad' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
pad
CInt
result <- Ptr Element -> Ptr Pad -> IO CInt
gst_element_remove_pad Ptr Element
element' Ptr Pad
pad'
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
element
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementRemovePadMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsElement a, Gst.Pad.IsPad b) => O.MethodInfo ElementRemovePadMethodInfo a signature where
overloadedMethod = elementRemovePad
#endif
foreign import ccall "gst_element_remove_property_notify_watch" gst_element_remove_property_notify_watch ::
Ptr Element ->
CULong ->
IO ()
elementRemovePropertyNotifyWatch ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> CULong
-> m ()
elementRemovePropertyNotifyWatch :: a -> SignalHandlerId -> m ()
elementRemovePropertyNotifyWatch element :: a
element watchId :: SignalHandlerId
watchId = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Element -> SignalHandlerId -> IO ()
gst_element_remove_property_notify_watch Ptr Element
element' SignalHandlerId
watchId
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementRemovePropertyNotifyWatchMethodInfo
instance (signature ~ (CULong -> m ()), MonadIO m, IsElement a) => O.MethodInfo ElementRemovePropertyNotifyWatchMethodInfo a signature where
overloadedMethod = elementRemovePropertyNotifyWatch
#endif
foreign import ccall "gst_element_request_pad" gst_element_request_pad ::
Ptr Element ->
Ptr Gst.PadTemplate.PadTemplate ->
CString ->
Ptr Gst.Caps.Caps ->
IO (Ptr Gst.Pad.Pad)
elementRequestPad ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, Gst.PadTemplate.IsPadTemplate b) =>
a
-> b
-> Maybe (T.Text)
-> Maybe (Gst.Caps.Caps)
-> m (Maybe Gst.Pad.Pad)
elementRequestPad :: a -> b -> Maybe Text -> Maybe Caps -> m (Maybe Pad)
elementRequestPad element :: a
element templ :: b
templ name :: Maybe Text
name caps :: Maybe Caps
caps = IO (Maybe Pad) -> m (Maybe Pad)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Pad) -> m (Maybe Pad))
-> IO (Maybe Pad) -> m (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr PadTemplate
templ' <- b -> IO (Ptr PadTemplate)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
templ
Ptr CChar
maybeName <- case Maybe Text
name of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jName :: Text
jName -> do
Ptr CChar
jName' <- Text -> IO (Ptr CChar)
textToCString Text
jName
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jName'
Ptr Caps
maybeCaps <- case Maybe Caps
caps of
Nothing -> Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
forall a. Ptr a
nullPtr
Just jCaps :: Caps
jCaps -> do
Ptr Caps
jCaps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
jCaps
Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
jCaps'
Ptr Pad
result <- Ptr Element
-> Ptr PadTemplate -> Ptr CChar -> Ptr Caps -> IO (Ptr Pad)
gst_element_request_pad Ptr Element
element' Ptr PadTemplate
templ' Ptr CChar
maybeName Ptr Caps
maybeCaps
Maybe Pad
maybeResult <- Ptr Pad -> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Pad
result ((Ptr Pad -> IO Pad) -> IO (Maybe Pad))
-> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Pad
result' -> do
Pad
result'' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Pad -> Pad
Gst.Pad.Pad) Ptr Pad
result'
Pad -> IO Pad
forall (m :: * -> *) a. Monad m => a -> m a
return Pad
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
templ
Maybe Caps -> (Caps -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Caps
caps Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeName
Maybe Pad -> IO (Maybe Pad)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pad
maybeResult
#if defined(ENABLE_OVERLOADING)
data ElementRequestPadMethodInfo
instance (signature ~ (b -> Maybe (T.Text) -> Maybe (Gst.Caps.Caps) -> m (Maybe Gst.Pad.Pad)), MonadIO m, IsElement a, Gst.PadTemplate.IsPadTemplate b) => O.MethodInfo ElementRequestPadMethodInfo a signature where
overloadedMethod = elementRequestPad
#endif
foreign import ccall "gst_element_seek" gst_element_seek ::
Ptr Element ->
CDouble ->
CUInt ->
CUInt ->
CUInt ->
Int64 ->
CUInt ->
Int64 ->
IO CInt
elementSeek ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Double
-> Gst.Enums.Format
-> [Gst.Flags.SeekFlags]
-> Gst.Enums.SeekType
-> Int64
-> Gst.Enums.SeekType
-> Int64
-> m Bool
elementSeek :: a
-> Double
-> Format
-> [SeekFlags]
-> SeekType
-> Int64
-> SeekType
-> Int64
-> m Bool
elementSeek element :: a
element rate :: Double
rate format :: Format
format flags :: [SeekFlags]
flags startType :: SeekType
startType start :: Int64
start stopType :: SeekType
stopType stop :: Int64
stop = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
let rate' :: CDouble
rate' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
rate
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
let flags' :: CUInt
flags' = [SeekFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [SeekFlags]
flags
let startType' :: CUInt
startType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (SeekType -> Int) -> SeekType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SeekType -> Int
forall a. Enum a => a -> Int
fromEnum) SeekType
startType
let stopType' :: CUInt
stopType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (SeekType -> Int) -> SeekType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SeekType -> Int
forall a. Enum a => a -> Int
fromEnum) SeekType
stopType
CInt
result <- Ptr Element
-> CDouble
-> CUInt
-> CUInt
-> CUInt
-> Int64
-> CUInt
-> Int64
-> IO CInt
gst_element_seek Ptr Element
element' CDouble
rate' CUInt
format' CUInt
flags' CUInt
startType' Int64
start CUInt
stopType' Int64
stop
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
element
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementSeekMethodInfo
instance (signature ~ (Double -> Gst.Enums.Format -> [Gst.Flags.SeekFlags] -> Gst.Enums.SeekType -> Int64 -> Gst.Enums.SeekType -> Int64 -> m Bool), MonadIO m, IsElement a) => O.MethodInfo ElementSeekMethodInfo a signature where
overloadedMethod = elementSeek
#endif
foreign import ccall "gst_element_seek_simple" gst_element_seek_simple ::
Ptr Element ->
CUInt ->
CUInt ->
Int64 ->
IO CInt
elementSeekSimple ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Enums.Format
-> [Gst.Flags.SeekFlags]
-> Int64
-> m Bool
elementSeekSimple :: a -> Format -> [SeekFlags] -> Int64 -> m Bool
elementSeekSimple element :: a
element format :: Format
format seekFlags :: [SeekFlags]
seekFlags seekPos :: Int64
seekPos = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
let seekFlags' :: CUInt
seekFlags' = [SeekFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [SeekFlags]
seekFlags
CInt
result <- Ptr Element -> CUInt -> CUInt -> Int64 -> IO CInt
gst_element_seek_simple Ptr Element
element' CUInt
format' CUInt
seekFlags' Int64
seekPos
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
element
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementSeekSimpleMethodInfo
instance (signature ~ (Gst.Enums.Format -> [Gst.Flags.SeekFlags] -> Int64 -> m Bool), MonadIO m, IsElement a) => O.MethodInfo ElementSeekSimpleMethodInfo a signature where
overloadedMethod = elementSeekSimple
#endif
foreign import ccall "gst_element_send_event" gst_element_send_event ::
Ptr Element ->
Ptr Gst.Event.Event ->
IO CInt
elementSendEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Event.Event
-> m Bool
elementSendEvent :: a -> Event -> m Bool
elementSendEvent element :: a
element event :: Event
event = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, BoxedObject a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Event
event
CInt
result <- Ptr Element -> Ptr Event -> IO CInt
gst_element_send_event Ptr Element
element' Ptr Event
event'
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
element
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementSendEventMethodInfo
instance (signature ~ (Gst.Event.Event -> m Bool), MonadIO m, IsElement a) => O.MethodInfo ElementSendEventMethodInfo a signature where
overloadedMethod = elementSendEvent
#endif
foreign import ccall "gst_element_set_base_time" gst_element_set_base_time ::
Ptr Element ->
Word64 ->
IO ()
elementSetBaseTime ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Word64
-> m ()
elementSetBaseTime :: a -> Word64 -> m ()
elementSetBaseTime element :: a
element time :: Word64
time = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Element -> Word64 -> IO ()
gst_element_set_base_time Ptr Element
element' Word64
time
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementSetBaseTimeMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m, IsElement a) => O.MethodInfo ElementSetBaseTimeMethodInfo a signature where
overloadedMethod = elementSetBaseTime
#endif
foreign import ccall "gst_element_set_bus" gst_element_set_bus ::
Ptr Element ->
Ptr Gst.Bus.Bus ->
IO ()
elementSetBus ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, Gst.Bus.IsBus b) =>
a
-> Maybe (b)
-> m ()
elementSetBus :: a -> Maybe b -> m ()
elementSetBus element :: a
element bus :: Maybe b
bus = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Bus
maybeBus <- case Maybe b
bus of
Nothing -> Ptr Bus -> IO (Ptr Bus)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Bus
forall a. Ptr a
nullPtr
Just jBus :: b
jBus -> do
Ptr Bus
jBus' <- b -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jBus
Ptr Bus -> IO (Ptr Bus)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Bus
jBus'
Ptr Element -> Ptr Bus -> IO ()
gst_element_set_bus Ptr Element
element' Ptr Bus
maybeBus
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
bus b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementSetBusMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsElement a, Gst.Bus.IsBus b) => O.MethodInfo ElementSetBusMethodInfo a signature where
overloadedMethod = elementSetBus
#endif
foreign import ccall "gst_element_set_clock" gst_element_set_clock ::
Ptr Element ->
Ptr Gst.Clock.Clock ->
IO CInt
elementSetClock ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, Gst.Clock.IsClock b) =>
a
-> Maybe (b)
-> m Bool
elementSetClock :: a -> Maybe b -> m Bool
elementSetClock element :: a
element clock :: Maybe b
clock = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Clock
maybeClock <- case Maybe b
clock of
Nothing -> Ptr Clock -> IO (Ptr Clock)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Clock
forall a. Ptr a
nullPtr
Just jClock :: b
jClock -> do
Ptr Clock
jClock' <- b -> IO (Ptr Clock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jClock
Ptr Clock -> IO (Ptr Clock)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Clock
jClock'
CInt
result <- Ptr Element -> Ptr Clock -> IO CInt
gst_element_set_clock Ptr Element
element' Ptr Clock
maybeClock
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
element
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
clock b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementSetClockMethodInfo
instance (signature ~ (Maybe (b) -> m Bool), MonadIO m, IsElement a, Gst.Clock.IsClock b) => O.MethodInfo ElementSetClockMethodInfo a signature where
overloadedMethod = elementSetClock
#endif
foreign import ccall "gst_element_set_context" gst_element_set_context ::
Ptr Element ->
Ptr Gst.Context.Context ->
IO ()
elementSetContext ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Context.Context
-> m ()
elementSetContext :: a -> Context -> m ()
elementSetContext element :: a
element context :: Context
context = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Context
context' <- Context -> IO (Ptr Context)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Context
context
Ptr Element -> Ptr Context -> IO ()
gst_element_set_context Ptr Element
element' Ptr Context
context'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
Context -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Context
context
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementSetContextMethodInfo
instance (signature ~ (Gst.Context.Context -> m ()), MonadIO m, IsElement a) => O.MethodInfo ElementSetContextMethodInfo a signature where
overloadedMethod = elementSetContext
#endif
foreign import ccall "gst_element_set_locked_state" gst_element_set_locked_state ::
Ptr Element ->
CInt ->
IO CInt
elementSetLockedState ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Bool
-> m Bool
elementSetLockedState :: a -> Bool -> m Bool
elementSetLockedState element :: a
element lockedState :: Bool
lockedState = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
let lockedState' :: CInt
lockedState' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
lockedState
CInt
result <- Ptr Element -> CInt -> IO CInt
gst_element_set_locked_state Ptr Element
element' CInt
lockedState'
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
element
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementSetLockedStateMethodInfo
instance (signature ~ (Bool -> m Bool), MonadIO m, IsElement a) => O.MethodInfo ElementSetLockedStateMethodInfo a signature where
overloadedMethod = elementSetLockedState
#endif
foreign import ccall "gst_element_set_start_time" gst_element_set_start_time ::
Ptr Element ->
Word64 ->
IO ()
elementSetStartTime ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Word64
-> m ()
elementSetStartTime :: a -> Word64 -> m ()
elementSetStartTime element :: a
element time :: Word64
time = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
Ptr Element -> Word64 -> IO ()
gst_element_set_start_time Ptr Element
element' Word64
time
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
element
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementSetStartTimeMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m, IsElement a) => O.MethodInfo ElementSetStartTimeMethodInfo a signature where
overloadedMethod = elementSetStartTime
#endif
foreign import ccall "gst_element_set_state" gst_element_set_state ::
Ptr Element ->
CUInt ->
IO CUInt
elementSetState ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> Gst.Enums.State
-> m Gst.Enums.StateChangeReturn
elementSetState :: a -> State -> m StateChangeReturn
elementSetState element :: a
element state :: State
state = IO StateChangeReturn -> m StateChangeReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StateChangeReturn -> m StateChangeReturn)
-> IO StateChangeReturn -> m StateChangeReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
let state' :: CUInt
state' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (State -> Int) -> State -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> Int
forall a. Enum a => a -> Int
fromEnum) State
state
CUInt
result <- Ptr Element -> CUInt -> IO CUInt
gst_element_set_state Ptr Element
element' CUInt
state'
let result' :: StateChangeReturn
result' = (Int -> StateChangeReturn
forall a. Enum a => Int -> a
toEnum (Int -> StateChangeReturn)
-> (CUInt -> Int) -> CUInt -> StateChangeReturn
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
element
StateChangeReturn -> IO StateChangeReturn
forall (m :: * -> *) a. Monad m => a -> m a
return StateChangeReturn
result'
#if defined(ENABLE_OVERLOADING)
data ElementSetStateMethodInfo
instance (signature ~ (Gst.Enums.State -> m Gst.Enums.StateChangeReturn), MonadIO m, IsElement a) => O.MethodInfo ElementSetStateMethodInfo a signature where
overloadedMethod = elementSetState
#endif
foreign import ccall "gst_element_sync_state_with_parent" gst_element_sync_state_with_parent ::
Ptr Element ->
IO CInt
elementSyncStateWithParent ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a) =>
a
-> m Bool
elementSyncStateWithParent :: a -> m Bool
elementSyncStateWithParent element :: a
element = 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 Element
element' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
element
CInt
result <- Ptr Element -> IO CInt
gst_element_sync_state_with_parent Ptr Element
element'
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
element
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ElementSyncStateWithParentMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsElement a) => O.MethodInfo ElementSyncStateWithParentMethodInfo a signature where
overloadedMethod = elementSyncStateWithParent
#endif
foreign import ccall "gst_element_unlink" gst_element_unlink ::
Ptr Element ->
Ptr Element ->
IO ()
elementUnlink ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, IsElement b) =>
a
-> b
-> m ()
elementUnlink :: a -> b -> m ()
elementUnlink src :: a
src dest :: b
dest = 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 Element
src' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Element
dest' <- b -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dest
Ptr Element -> Ptr Element -> IO ()
gst_element_unlink Ptr Element
src' Ptr Element
dest'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dest
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementUnlinkMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsElement a, IsElement b) => O.MethodInfo ElementUnlinkMethodInfo a signature where
overloadedMethod = elementUnlink
#endif
foreign import ccall "gst_element_unlink_pads" gst_element_unlink_pads ::
Ptr Element ->
CString ->
Ptr Element ->
CString ->
IO ()
elementUnlinkPads ::
(B.CallStack.HasCallStack, MonadIO m, IsElement a, IsElement b) =>
a
-> T.Text
-> b
-> T.Text
-> m ()
elementUnlinkPads :: a -> Text -> b -> Text -> m ()
elementUnlinkPads src :: a
src srcpadname :: Text
srcpadname dest :: b
dest destpadname :: Text
destpadname = 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 Element
src' <- a -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr CChar
srcpadname' <- Text -> IO (Ptr CChar)
textToCString Text
srcpadname
Ptr Element
dest' <- b -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dest
Ptr CChar
destpadname' <- Text -> IO (Ptr CChar)
textToCString Text
destpadname
Ptr Element -> Ptr CChar -> Ptr Element -> Ptr CChar -> IO ()
gst_element_unlink_pads Ptr Element
src' Ptr CChar
srcpadname' Ptr Element
dest' Ptr CChar
destpadname'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dest
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
srcpadname'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
destpadname'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ElementUnlinkPadsMethodInfo
instance (signature ~ (T.Text -> b -> T.Text -> m ()), MonadIO m, IsElement a, IsElement b) => O.MethodInfo ElementUnlinkPadsMethodInfo a signature where
overloadedMethod = elementUnlinkPads
#endif
foreign import ccall "gst_element_make_from_uri" gst_element_make_from_uri ::
CUInt ->
CString ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr Element)
elementMakeFromUri ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.URIType
-> T.Text
-> Maybe (T.Text)
-> m (Maybe Element)
elementMakeFromUri :: URIType -> Text -> Maybe Text -> m (Maybe Element)
elementMakeFromUri type_ :: URIType
type_ uri :: Text
uri elementname :: Maybe Text
elementname = IO (Maybe Element) -> m (Maybe Element)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Element) -> m (Maybe Element))
-> IO (Maybe Element) -> m (Maybe Element)
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (URIType -> Int) -> URIType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. URIType -> Int
forall a. Enum a => a -> Int
fromEnum) URIType
type_
Ptr CChar
uri' <- Text -> IO (Ptr CChar)
textToCString Text
uri
Ptr CChar
maybeElementname <- case Maybe Text
elementname of
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just jElementname :: Text
jElementname -> do
Ptr CChar
jElementname' <- Text -> IO (Ptr CChar)
textToCString Text
jElementname
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jElementname'
IO (Maybe Element) -> IO () -> IO (Maybe Element)
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Element
result <- (Ptr (Ptr GError) -> IO (Ptr Element)) -> IO (Ptr Element)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Element)) -> IO (Ptr Element))
-> (Ptr (Ptr GError) -> IO (Ptr Element)) -> IO (Ptr Element)
forall a b. (a -> b) -> a -> b
$ CUInt
-> Ptr CChar -> Ptr CChar -> Ptr (Ptr GError) -> IO (Ptr Element)
gst_element_make_from_uri CUInt
type_' Ptr CChar
uri' Ptr CChar
maybeElementname
Maybe Element
maybeResult <- Ptr Element -> (Ptr Element -> IO Element) -> IO (Maybe Element)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Element
result ((Ptr Element -> IO Element) -> IO (Maybe Element))
-> (Ptr Element -> IO Element) -> IO (Maybe Element)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Element
result' -> do
Element
result'' <- ((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
Element) Ptr Element
result'
Element -> IO Element
forall (m :: * -> *) a. Monad m => a -> m a
return Element
result''
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
uri'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeElementname
Maybe Element -> IO (Maybe Element)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Element
maybeResult
) (do
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
uri'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeElementname
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_element_register" gst_element_register ::
Ptr Gst.Plugin.Plugin ->
CString ->
Word32 ->
CGType ->
IO CInt
elementRegister ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Plugin.IsPlugin a) =>
Maybe (a)
-> T.Text
-> Word32
-> GType
-> m Bool
elementRegister :: Maybe a -> Text -> Word32 -> GType -> m Bool
elementRegister plugin :: Maybe a
plugin name :: Text
name rank :: Word32
rank type_ :: GType
type_ = 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 Plugin
maybePlugin <- case Maybe a
plugin of
Nothing -> Ptr Plugin -> IO (Ptr Plugin)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Plugin
forall a. Ptr a
nullPtr
Just jPlugin :: a
jPlugin -> do
Ptr Plugin
jPlugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jPlugin
Ptr Plugin -> IO (Ptr Plugin)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Plugin
jPlugin'
Ptr CChar
name' <- Text -> IO (Ptr CChar)
textToCString Text
name
let type_' :: Word64
type_' = GType -> Word64
gtypeToCGType GType
type_
CInt
result <- Ptr Plugin -> Ptr CChar -> Word32 -> Word64 -> IO CInt
gst_element_register Ptr Plugin
maybePlugin Ptr CChar
name' Word32
rank Word64
type_'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
plugin a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
name'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_element_state_change_return_get_name" gst_element_state_change_return_get_name ::
CUInt ->
IO CString
elementStateChangeReturnGetName ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.StateChangeReturn
-> m T.Text
elementStateChangeReturnGetName :: StateChangeReturn -> m Text
elementStateChangeReturnGetName stateRet :: StateChangeReturn
stateRet = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
let stateRet' :: CUInt
stateRet' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (StateChangeReturn -> Int) -> StateChangeReturn -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StateChangeReturn -> Int
forall a. Enum a => a -> Int
fromEnum) StateChangeReturn
stateRet
Ptr CChar
result <- CUInt -> IO (Ptr CChar)
gst_element_state_change_return_get_name CUInt
stateRet'
Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "elementStateChangeReturnGetName" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_element_state_get_name" gst_element_state_get_name ::
CUInt ->
IO CString
elementStateGetName ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.State
-> m T.Text
elementStateGetName :: State -> m Text
elementStateGetName state :: State
state = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
let state' :: CUInt
state' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (State -> Int) -> State -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> Int
forall a. Enum a => a -> Int
fromEnum) State
state
Ptr CChar
result <- CUInt -> IO (Ptr CChar)
gst_element_state_get_name CUInt
state'
Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "elementStateGetName" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
#endif