{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Objects.Pad
(
Pad(..) ,
IsPad ,
toPad ,
#if defined(ENABLE_OVERLOADING)
ResolvePadMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
PadActivateModeMethodInfo ,
#endif
padActivateMode ,
#if defined(ENABLE_OVERLOADING)
PadAddProbeMethodInfo ,
#endif
padAddProbe ,
#if defined(ENABLE_OVERLOADING)
PadCanLinkMethodInfo ,
#endif
padCanLink ,
#if defined(ENABLE_OVERLOADING)
PadChainMethodInfo ,
#endif
padChain ,
#if defined(ENABLE_OVERLOADING)
PadChainListMethodInfo ,
#endif
padChainList ,
#if defined(ENABLE_OVERLOADING)
PadCheckReconfigureMethodInfo ,
#endif
padCheckReconfigure ,
#if defined(ENABLE_OVERLOADING)
PadCreateStreamIdMethodInfo ,
#endif
padCreateStreamId ,
#if defined(ENABLE_OVERLOADING)
PadEventDefaultMethodInfo ,
#endif
padEventDefault ,
#if defined(ENABLE_OVERLOADING)
PadForwardMethodInfo ,
#endif
padForward ,
#if defined(ENABLE_OVERLOADING)
PadGetAllowedCapsMethodInfo ,
#endif
padGetAllowedCaps ,
#if defined(ENABLE_OVERLOADING)
PadGetCurrentCapsMethodInfo ,
#endif
padGetCurrentCaps ,
#if defined(ENABLE_OVERLOADING)
PadGetDirectionMethodInfo ,
#endif
padGetDirection ,
#if defined(ENABLE_OVERLOADING)
PadGetElementPrivateMethodInfo ,
#endif
padGetElementPrivate ,
#if defined(ENABLE_OVERLOADING)
PadGetLastFlowReturnMethodInfo ,
#endif
padGetLastFlowReturn ,
#if defined(ENABLE_OVERLOADING)
PadGetOffsetMethodInfo ,
#endif
padGetOffset ,
#if defined(ENABLE_OVERLOADING)
PadGetPadTemplateMethodInfo ,
#endif
padGetPadTemplate ,
#if defined(ENABLE_OVERLOADING)
PadGetPadTemplateCapsMethodInfo ,
#endif
padGetPadTemplateCaps ,
#if defined(ENABLE_OVERLOADING)
PadGetParentElementMethodInfo ,
#endif
padGetParentElement ,
#if defined(ENABLE_OVERLOADING)
PadGetPeerMethodInfo ,
#endif
padGetPeer ,
#if defined(ENABLE_OVERLOADING)
PadGetRangeMethodInfo ,
#endif
padGetRange ,
#if defined(ENABLE_OVERLOADING)
PadGetStickyEventMethodInfo ,
#endif
padGetStickyEvent ,
#if defined(ENABLE_OVERLOADING)
PadGetStreamMethodInfo ,
#endif
padGetStream ,
#if defined(ENABLE_OVERLOADING)
PadGetStreamIdMethodInfo ,
#endif
padGetStreamId ,
#if defined(ENABLE_OVERLOADING)
PadGetTaskStateMethodInfo ,
#endif
padGetTaskState ,
#if defined(ENABLE_OVERLOADING)
PadHasCurrentCapsMethodInfo ,
#endif
padHasCurrentCaps ,
#if defined(ENABLE_OVERLOADING)
PadIsActiveMethodInfo ,
#endif
padIsActive ,
#if defined(ENABLE_OVERLOADING)
PadIsBlockedMethodInfo ,
#endif
padIsBlocked ,
#if defined(ENABLE_OVERLOADING)
PadIsBlockingMethodInfo ,
#endif
padIsBlocking ,
#if defined(ENABLE_OVERLOADING)
PadIsLinkedMethodInfo ,
#endif
padIsLinked ,
#if defined(ENABLE_OVERLOADING)
PadIterateInternalLinksMethodInfo ,
#endif
padIterateInternalLinks ,
#if defined(ENABLE_OVERLOADING)
PadIterateInternalLinksDefaultMethodInfo,
#endif
padIterateInternalLinksDefault ,
#if defined(ENABLE_OVERLOADING)
PadLinkMethodInfo ,
#endif
padLink ,
#if defined(ENABLE_OVERLOADING)
PadLinkFullMethodInfo ,
#endif
padLinkFull ,
padLinkGetName ,
#if defined(ENABLE_OVERLOADING)
PadLinkMaybeGhostingMethodInfo ,
#endif
padLinkMaybeGhosting ,
#if defined(ENABLE_OVERLOADING)
PadLinkMaybeGhostingFullMethodInfo ,
#endif
padLinkMaybeGhostingFull ,
#if defined(ENABLE_OVERLOADING)
PadMarkReconfigureMethodInfo ,
#endif
padMarkReconfigure ,
#if defined(ENABLE_OVERLOADING)
PadNeedsReconfigureMethodInfo ,
#endif
padNeedsReconfigure ,
padNew ,
padNewFromStaticTemplate ,
padNewFromTemplate ,
#if defined(ENABLE_OVERLOADING)
PadPauseTaskMethodInfo ,
#endif
padPauseTask ,
#if defined(ENABLE_OVERLOADING)
PadPeerQueryMethodInfo ,
#endif
padPeerQuery ,
#if defined(ENABLE_OVERLOADING)
PadPeerQueryAcceptCapsMethodInfo ,
#endif
padPeerQueryAcceptCaps ,
#if defined(ENABLE_OVERLOADING)
PadPeerQueryCapsMethodInfo ,
#endif
padPeerQueryCaps ,
#if defined(ENABLE_OVERLOADING)
PadPeerQueryConvertMethodInfo ,
#endif
padPeerQueryConvert ,
#if defined(ENABLE_OVERLOADING)
PadPeerQueryDurationMethodInfo ,
#endif
padPeerQueryDuration ,
#if defined(ENABLE_OVERLOADING)
PadPeerQueryPositionMethodInfo ,
#endif
padPeerQueryPosition ,
#if defined(ENABLE_OVERLOADING)
PadProxyQueryAcceptCapsMethodInfo ,
#endif
padProxyQueryAcceptCaps ,
#if defined(ENABLE_OVERLOADING)
PadProxyQueryCapsMethodInfo ,
#endif
padProxyQueryCaps ,
#if defined(ENABLE_OVERLOADING)
PadPullRangeMethodInfo ,
#endif
padPullRange ,
#if defined(ENABLE_OVERLOADING)
PadPushMethodInfo ,
#endif
padPush ,
#if defined(ENABLE_OVERLOADING)
PadPushEventMethodInfo ,
#endif
padPushEvent ,
#if defined(ENABLE_OVERLOADING)
PadPushListMethodInfo ,
#endif
padPushList ,
#if defined(ENABLE_OVERLOADING)
PadQueryMethodInfo ,
#endif
padQuery ,
#if defined(ENABLE_OVERLOADING)
PadQueryAcceptCapsMethodInfo ,
#endif
padQueryAcceptCaps ,
#if defined(ENABLE_OVERLOADING)
PadQueryCapsMethodInfo ,
#endif
padQueryCaps ,
#if defined(ENABLE_OVERLOADING)
PadQueryConvertMethodInfo ,
#endif
padQueryConvert ,
#if defined(ENABLE_OVERLOADING)
PadQueryDefaultMethodInfo ,
#endif
padQueryDefault ,
#if defined(ENABLE_OVERLOADING)
PadQueryDurationMethodInfo ,
#endif
padQueryDuration ,
#if defined(ENABLE_OVERLOADING)
PadQueryPositionMethodInfo ,
#endif
padQueryPosition ,
#if defined(ENABLE_OVERLOADING)
PadRemoveProbeMethodInfo ,
#endif
padRemoveProbe ,
#if defined(ENABLE_OVERLOADING)
PadSendEventMethodInfo ,
#endif
padSendEvent ,
#if defined(ENABLE_OVERLOADING)
PadSetActivateFunctionFullMethodInfo ,
#endif
padSetActivateFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetActivatemodeFunctionFullMethodInfo,
#endif
padSetActivatemodeFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetActiveMethodInfo ,
#endif
padSetActive ,
#if defined(ENABLE_OVERLOADING)
PadSetChainFunctionFullMethodInfo ,
#endif
padSetChainFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetChainListFunctionFullMethodInfo ,
#endif
padSetChainListFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetElementPrivateMethodInfo ,
#endif
padSetElementPrivate ,
#if defined(ENABLE_OVERLOADING)
PadSetEventFullFunctionFullMethodInfo ,
#endif
padSetEventFullFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetEventFunctionFullMethodInfo ,
#endif
padSetEventFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetGetrangeFunctionFullMethodInfo ,
#endif
padSetGetrangeFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetIterateInternalLinksFunctionFullMethodInfo,
#endif
padSetIterateInternalLinksFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetLinkFunctionFullMethodInfo ,
#endif
padSetLinkFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetOffsetMethodInfo ,
#endif
padSetOffset ,
#if defined(ENABLE_OVERLOADING)
PadSetQueryFunctionFullMethodInfo ,
#endif
padSetQueryFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetUnlinkFunctionFullMethodInfo ,
#endif
padSetUnlinkFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadStartTaskMethodInfo ,
#endif
padStartTask ,
#if defined(ENABLE_OVERLOADING)
PadStickyEventsForeachMethodInfo ,
#endif
padStickyEventsForeach ,
#if defined(ENABLE_OVERLOADING)
PadStopTaskMethodInfo ,
#endif
padStopTask ,
#if defined(ENABLE_OVERLOADING)
PadStoreStickyEventMethodInfo ,
#endif
padStoreStickyEvent ,
#if defined(ENABLE_OVERLOADING)
PadUnlinkMethodInfo ,
#endif
padUnlink ,
#if defined(ENABLE_OVERLOADING)
PadUseFixedCapsMethodInfo ,
#endif
padUseFixedCaps ,
#if defined(ENABLE_OVERLOADING)
PadCapsPropertyInfo ,
#endif
getPadCaps ,
#if defined(ENABLE_OVERLOADING)
padCaps ,
#endif
#if defined(ENABLE_OVERLOADING)
PadDirectionPropertyInfo ,
#endif
constructPadDirection ,
getPadDirection ,
#if defined(ENABLE_OVERLOADING)
padDirection ,
#endif
#if defined(ENABLE_OVERLOADING)
PadOffsetPropertyInfo ,
#endif
constructPadOffset ,
getPadOffset ,
#if defined(ENABLE_OVERLOADING)
padOffset ,
#endif
setPadOffset ,
#if defined(ENABLE_OVERLOADING)
PadTemplatePropertyInfo ,
#endif
clearPadTemplate ,
constructPadTemplate ,
getPadTemplate ,
#if defined(ENABLE_OVERLOADING)
padTemplate ,
#endif
setPadTemplate ,
C_PadLinkedCallback ,
PadLinkedCallback ,
#if defined(ENABLE_OVERLOADING)
PadLinkedSignalInfo ,
#endif
afterPadLinked ,
genClosure_PadLinked ,
mk_PadLinkedCallback ,
noPadLinkedCallback ,
onPadLinked ,
wrap_PadLinkedCallback ,
C_PadUnlinkedCallback ,
PadUnlinkedCallback ,
#if defined(ENABLE_OVERLOADING)
PadUnlinkedSignalInfo ,
#endif
afterPadUnlinked ,
genClosure_PadUnlinked ,
mk_PadUnlinkedCallback ,
noPadUnlinkedCallback ,
onPadUnlinked ,
wrap_PadUnlinkedCallback ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.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 Control.Monad.IO.Class as MIO
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.Element as Gst.Element
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.PadTemplate as Gst.PadTemplate
import {-# SOURCE #-} qualified GI.Gst.Objects.Stream as Gst.Stream
import {-# SOURCE #-} qualified GI.Gst.Structs.Buffer as Gst.Buffer
import {-# SOURCE #-} qualified GI.Gst.Structs.BufferList as Gst.BufferList
import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps
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.Query as Gst.Query
import {-# SOURCE #-} qualified GI.Gst.Structs.StaticPadTemplate as Gst.StaticPadTemplate
newtype Pad = Pad (SP.ManagedPtr Pad)
deriving (Pad -> Pad -> Bool
(Pad -> Pad -> Bool) -> (Pad -> Pad -> Bool) -> Eq Pad
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pad -> Pad -> Bool
$c/= :: Pad -> Pad -> Bool
== :: Pad -> Pad -> Bool
$c== :: Pad -> Pad -> Bool
Eq)
instance SP.ManagedPtrNewtype Pad where
toManagedPtr :: Pad -> ManagedPtr Pad
toManagedPtr (Pad ManagedPtr Pad
p) = ManagedPtr Pad
p
foreign import ccall "gst_pad_get_type"
c_gst_pad_get_type :: IO B.Types.GType
instance B.Types.TypedObject Pad where
glibType :: IO GType
glibType = IO GType
c_gst_pad_get_type
instance B.Types.GObject Pad
instance B.GValue.IsGValue Pad where
toGValue :: Pad -> IO GValue
toGValue Pad
o = do
GType
gtype <- IO GType
c_gst_pad_get_type
Pad -> (Ptr Pad -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Pad
o (GType -> (GValue -> Ptr Pad -> IO ()) -> Ptr Pad -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Pad -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO Pad
fromGValue GValue
gv = do
Ptr Pad
ptr <- GValue -> IO (Ptr Pad)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Pad)
(ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Pad -> Pad
Pad Ptr Pad
ptr
class (SP.GObject o, O.IsDescendantOf Pad o) => IsPad o
instance (SP.GObject o, O.IsDescendantOf Pad o) => IsPad o
instance O.HasParentTypes Pad
type instance O.ParentTypes Pad = '[Gst.Object.Object, GObject.Object.Object]
toPad :: (MonadIO m, IsPad o) => o -> m Pad
toPad :: o -> m Pad
toPad = IO Pad -> m Pad
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Pad -> m Pad) -> (o -> IO Pad) -> o -> m Pad
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Pad -> Pad) -> o -> IO Pad
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Pad -> Pad
Pad
#if defined(ENABLE_OVERLOADING)
type family ResolvePadMethod (t :: Symbol) (o :: *) :: * where
ResolvePadMethod "activateMode" o = PadActivateModeMethodInfo
ResolvePadMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolvePadMethod "addProbe" o = PadAddProbeMethodInfo
ResolvePadMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolvePadMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolvePadMethod "canLink" o = PadCanLinkMethodInfo
ResolvePadMethod "chain" o = PadChainMethodInfo
ResolvePadMethod "chainList" o = PadChainListMethodInfo
ResolvePadMethod "checkReconfigure" o = PadCheckReconfigureMethodInfo
ResolvePadMethod "createStreamId" o = PadCreateStreamIdMethodInfo
ResolvePadMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolvePadMethod "eventDefault" o = PadEventDefaultMethodInfo
ResolvePadMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolvePadMethod "forward" o = PadForwardMethodInfo
ResolvePadMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolvePadMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolvePadMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolvePadMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolvePadMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolvePadMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolvePadMethod "hasCurrentCaps" o = PadHasCurrentCapsMethodInfo
ResolvePadMethod "isActive" o = PadIsActiveMethodInfo
ResolvePadMethod "isBlocked" o = PadIsBlockedMethodInfo
ResolvePadMethod "isBlocking" o = PadIsBlockingMethodInfo
ResolvePadMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolvePadMethod "isLinked" o = PadIsLinkedMethodInfo
ResolvePadMethod "iterateInternalLinks" o = PadIterateInternalLinksMethodInfo
ResolvePadMethod "iterateInternalLinksDefault" o = PadIterateInternalLinksDefaultMethodInfo
ResolvePadMethod "link" o = PadLinkMethodInfo
ResolvePadMethod "linkFull" o = PadLinkFullMethodInfo
ResolvePadMethod "linkMaybeGhosting" o = PadLinkMaybeGhostingMethodInfo
ResolvePadMethod "linkMaybeGhostingFull" o = PadLinkMaybeGhostingFullMethodInfo
ResolvePadMethod "markReconfigure" o = PadMarkReconfigureMethodInfo
ResolvePadMethod "needsReconfigure" o = PadNeedsReconfigureMethodInfo
ResolvePadMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolvePadMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolvePadMethod "pauseTask" o = PadPauseTaskMethodInfo
ResolvePadMethod "peerQuery" o = PadPeerQueryMethodInfo
ResolvePadMethod "peerQueryAcceptCaps" o = PadPeerQueryAcceptCapsMethodInfo
ResolvePadMethod "peerQueryCaps" o = PadPeerQueryCapsMethodInfo
ResolvePadMethod "peerQueryConvert" o = PadPeerQueryConvertMethodInfo
ResolvePadMethod "peerQueryDuration" o = PadPeerQueryDurationMethodInfo
ResolvePadMethod "peerQueryPosition" o = PadPeerQueryPositionMethodInfo
ResolvePadMethod "proxyQueryAcceptCaps" o = PadProxyQueryAcceptCapsMethodInfo
ResolvePadMethod "proxyQueryCaps" o = PadProxyQueryCapsMethodInfo
ResolvePadMethod "pullRange" o = PadPullRangeMethodInfo
ResolvePadMethod "push" o = PadPushMethodInfo
ResolvePadMethod "pushEvent" o = PadPushEventMethodInfo
ResolvePadMethod "pushList" o = PadPushListMethodInfo
ResolvePadMethod "query" o = PadQueryMethodInfo
ResolvePadMethod "queryAcceptCaps" o = PadQueryAcceptCapsMethodInfo
ResolvePadMethod "queryCaps" o = PadQueryCapsMethodInfo
ResolvePadMethod "queryConvert" o = PadQueryConvertMethodInfo
ResolvePadMethod "queryDefault" o = PadQueryDefaultMethodInfo
ResolvePadMethod "queryDuration" o = PadQueryDurationMethodInfo
ResolvePadMethod "queryPosition" o = PadQueryPositionMethodInfo
ResolvePadMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolvePadMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolvePadMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolvePadMethod "removeProbe" o = PadRemoveProbeMethodInfo
ResolvePadMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolvePadMethod "sendEvent" o = PadSendEventMethodInfo
ResolvePadMethod "startTask" o = PadStartTaskMethodInfo
ResolvePadMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolvePadMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolvePadMethod "stickyEventsForeach" o = PadStickyEventsForeachMethodInfo
ResolvePadMethod "stopTask" o = PadStopTaskMethodInfo
ResolvePadMethod "storeStickyEvent" o = PadStoreStickyEventMethodInfo
ResolvePadMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolvePadMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolvePadMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolvePadMethod "unlink" o = PadUnlinkMethodInfo
ResolvePadMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolvePadMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolvePadMethod "useFixedCaps" o = PadUseFixedCapsMethodInfo
ResolvePadMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolvePadMethod "getAllowedCaps" o = PadGetAllowedCapsMethodInfo
ResolvePadMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolvePadMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolvePadMethod "getCurrentCaps" o = PadGetCurrentCapsMethodInfo
ResolvePadMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolvePadMethod "getDirection" o = PadGetDirectionMethodInfo
ResolvePadMethod "getElementPrivate" o = PadGetElementPrivateMethodInfo
ResolvePadMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolvePadMethod "getLastFlowReturn" o = PadGetLastFlowReturnMethodInfo
ResolvePadMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
ResolvePadMethod "getOffset" o = PadGetOffsetMethodInfo
ResolvePadMethod "getPadTemplate" o = PadGetPadTemplateMethodInfo
ResolvePadMethod "getPadTemplateCaps" o = PadGetPadTemplateCapsMethodInfo
ResolvePadMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolvePadMethod "getParentElement" o = PadGetParentElementMethodInfo
ResolvePadMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolvePadMethod "getPeer" o = PadGetPeerMethodInfo
ResolvePadMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolvePadMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolvePadMethod "getRange" o = PadGetRangeMethodInfo
ResolvePadMethod "getStickyEvent" o = PadGetStickyEventMethodInfo
ResolvePadMethod "getStream" o = PadGetStreamMethodInfo
ResolvePadMethod "getStreamId" o = PadGetStreamIdMethodInfo
ResolvePadMethod "getTaskState" o = PadGetTaskStateMethodInfo
ResolvePadMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolvePadMethod "setActivateFunctionFull" o = PadSetActivateFunctionFullMethodInfo
ResolvePadMethod "setActivatemodeFunctionFull" o = PadSetActivatemodeFunctionFullMethodInfo
ResolvePadMethod "setActive" o = PadSetActiveMethodInfo
ResolvePadMethod "setChainFunctionFull" o = PadSetChainFunctionFullMethodInfo
ResolvePadMethod "setChainListFunctionFull" o = PadSetChainListFunctionFullMethodInfo
ResolvePadMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolvePadMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolvePadMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolvePadMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolvePadMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolvePadMethod "setElementPrivate" o = PadSetElementPrivateMethodInfo
ResolvePadMethod "setEventFullFunctionFull" o = PadSetEventFullFunctionFullMethodInfo
ResolvePadMethod "setEventFunctionFull" o = PadSetEventFunctionFullMethodInfo
ResolvePadMethod "setGetrangeFunctionFull" o = PadSetGetrangeFunctionFullMethodInfo
ResolvePadMethod "setIterateInternalLinksFunctionFull" o = PadSetIterateInternalLinksFunctionFullMethodInfo
ResolvePadMethod "setLinkFunctionFull" o = PadSetLinkFunctionFullMethodInfo
ResolvePadMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolvePadMethod "setOffset" o = PadSetOffsetMethodInfo
ResolvePadMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolvePadMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolvePadMethod "setQueryFunctionFull" o = PadSetQueryFunctionFullMethodInfo
ResolvePadMethod "setUnlinkFunctionFull" o = PadSetUnlinkFunctionFullMethodInfo
ResolvePadMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolvePadMethod t Pad, O.MethodInfo info Pad p) => OL.IsLabel t (Pad -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
type PadLinkedCallback =
Pad
-> IO ()
noPadLinkedCallback :: Maybe PadLinkedCallback
noPadLinkedCallback :: Maybe PadLinkedCallback
noPadLinkedCallback = Maybe PadLinkedCallback
forall a. Maybe a
Nothing
type C_PadLinkedCallback =
Ptr () ->
Ptr Pad ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_PadLinkedCallback :: C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback)
genClosure_PadLinked :: MonadIO m => PadLinkedCallback -> m (GClosure C_PadLinkedCallback)
genClosure_PadLinked :: PadLinkedCallback -> m (GClosure C_PadLinkedCallback)
genClosure_PadLinked PadLinkedCallback
cb = IO (GClosure C_PadLinkedCallback)
-> m (GClosure C_PadLinkedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PadLinkedCallback)
-> m (GClosure C_PadLinkedCallback))
-> IO (GClosure C_PadLinkedCallback)
-> m (GClosure C_PadLinkedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_PadLinkedCallback
cb' = PadLinkedCallback -> C_PadLinkedCallback
wrap_PadLinkedCallback PadLinkedCallback
cb
C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback)
mk_PadLinkedCallback C_PadLinkedCallback
cb' IO (FunPtr C_PadLinkedCallback)
-> (FunPtr C_PadLinkedCallback
-> IO (GClosure C_PadLinkedCallback))
-> IO (GClosure C_PadLinkedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PadLinkedCallback -> IO (GClosure C_PadLinkedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_PadLinkedCallback ::
PadLinkedCallback ->
C_PadLinkedCallback
wrap_PadLinkedCallback :: PadLinkedCallback -> C_PadLinkedCallback
wrap_PadLinkedCallback PadLinkedCallback
_cb Ptr ()
_ Ptr Pad
peer Ptr ()
_ = do
Pad
peer' <- ((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
Pad) Ptr Pad
peer
PadLinkedCallback
_cb Pad
peer'
onPadLinked :: (IsPad a, MonadIO m) => a -> PadLinkedCallback -> m SignalHandlerId
onPadLinked :: a -> PadLinkedCallback -> m SignalHandlerId
onPadLinked a
obj PadLinkedCallback
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_PadLinkedCallback
cb' = PadLinkedCallback -> C_PadLinkedCallback
wrap_PadLinkedCallback PadLinkedCallback
cb
FunPtr C_PadLinkedCallback
cb'' <- C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback)
mk_PadLinkedCallback C_PadLinkedCallback
cb'
a
-> Text
-> FunPtr C_PadLinkedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"linked" FunPtr C_PadLinkedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterPadLinked :: (IsPad a, MonadIO m) => a -> PadLinkedCallback -> m SignalHandlerId
afterPadLinked :: a -> PadLinkedCallback -> m SignalHandlerId
afterPadLinked a
obj PadLinkedCallback
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_PadLinkedCallback
cb' = PadLinkedCallback -> C_PadLinkedCallback
wrap_PadLinkedCallback PadLinkedCallback
cb
FunPtr C_PadLinkedCallback
cb'' <- C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback)
mk_PadLinkedCallback C_PadLinkedCallback
cb'
a
-> Text
-> FunPtr C_PadLinkedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"linked" FunPtr C_PadLinkedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data PadLinkedSignalInfo
instance SignalInfo PadLinkedSignalInfo where
type HaskellCallbackType PadLinkedSignalInfo = PadLinkedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_PadLinkedCallback cb
cb'' <- mk_PadLinkedCallback cb'
connectSignalFunPtr obj "linked" cb'' connectMode detail
#endif
type PadUnlinkedCallback =
Pad
-> IO ()
noPadUnlinkedCallback :: Maybe PadUnlinkedCallback
noPadUnlinkedCallback :: Maybe PadLinkedCallback
noPadUnlinkedCallback = Maybe PadLinkedCallback
forall a. Maybe a
Nothing
type C_PadUnlinkedCallback =
Ptr () ->
Ptr Pad ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_PadUnlinkedCallback :: C_PadUnlinkedCallback -> IO (FunPtr C_PadUnlinkedCallback)
genClosure_PadUnlinked :: MonadIO m => PadUnlinkedCallback -> m (GClosure C_PadUnlinkedCallback)
genClosure_PadUnlinked :: PadLinkedCallback -> m (GClosure C_PadLinkedCallback)
genClosure_PadUnlinked PadLinkedCallback
cb = IO (GClosure C_PadLinkedCallback)
-> m (GClosure C_PadLinkedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PadLinkedCallback)
-> m (GClosure C_PadLinkedCallback))
-> IO (GClosure C_PadLinkedCallback)
-> m (GClosure C_PadLinkedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_PadLinkedCallback
cb' = PadLinkedCallback -> C_PadLinkedCallback
wrap_PadUnlinkedCallback PadLinkedCallback
cb
C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback)
mk_PadUnlinkedCallback C_PadLinkedCallback
cb' IO (FunPtr C_PadLinkedCallback)
-> (FunPtr C_PadLinkedCallback
-> IO (GClosure C_PadLinkedCallback))
-> IO (GClosure C_PadLinkedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PadLinkedCallback -> IO (GClosure C_PadLinkedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_PadUnlinkedCallback ::
PadUnlinkedCallback ->
C_PadUnlinkedCallback
wrap_PadUnlinkedCallback :: PadLinkedCallback -> C_PadLinkedCallback
wrap_PadUnlinkedCallback PadLinkedCallback
_cb Ptr ()
_ Ptr Pad
peer Ptr ()
_ = do
Pad
peer' <- ((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
Pad) Ptr Pad
peer
PadLinkedCallback
_cb Pad
peer'
onPadUnlinked :: (IsPad a, MonadIO m) => a -> PadUnlinkedCallback -> m SignalHandlerId
onPadUnlinked :: a -> PadLinkedCallback -> m SignalHandlerId
onPadUnlinked a
obj PadLinkedCallback
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_PadLinkedCallback
cb' = PadLinkedCallback -> C_PadLinkedCallback
wrap_PadUnlinkedCallback PadLinkedCallback
cb
FunPtr C_PadLinkedCallback
cb'' <- C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback)
mk_PadUnlinkedCallback C_PadLinkedCallback
cb'
a
-> Text
-> FunPtr C_PadLinkedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"unlinked" FunPtr C_PadLinkedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterPadUnlinked :: (IsPad a, MonadIO m) => a -> PadUnlinkedCallback -> m SignalHandlerId
afterPadUnlinked :: a -> PadLinkedCallback -> m SignalHandlerId
afterPadUnlinked a
obj PadLinkedCallback
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_PadLinkedCallback
cb' = PadLinkedCallback -> C_PadLinkedCallback
wrap_PadUnlinkedCallback PadLinkedCallback
cb
FunPtr C_PadLinkedCallback
cb'' <- C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback)
mk_PadUnlinkedCallback C_PadLinkedCallback
cb'
a
-> Text
-> FunPtr C_PadLinkedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"unlinked" FunPtr C_PadLinkedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data PadUnlinkedSignalInfo
instance SignalInfo PadUnlinkedSignalInfo where
type HaskellCallbackType PadUnlinkedSignalInfo = PadUnlinkedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_PadUnlinkedCallback cb
cb'' <- mk_PadUnlinkedCallback cb'
connectSignalFunPtr obj "unlinked" cb'' connectMode detail
#endif
getPadCaps :: (MonadIO m, IsPad o) => o -> m (Maybe Gst.Caps.Caps)
getPadCaps :: o -> m (Maybe Caps)
getPadCaps o
obj = IO (Maybe Caps) -> m (Maybe Caps)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Caps) -> m (Maybe Caps))
-> IO (Maybe Caps) -> m (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Caps -> Caps) -> IO (Maybe Caps)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"caps" ManagedPtr Caps -> Caps
Gst.Caps.Caps
#if defined(ENABLE_OVERLOADING)
data PadCapsPropertyInfo
instance AttrInfo PadCapsPropertyInfo where
type AttrAllowedOps PadCapsPropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint PadCapsPropertyInfo = IsPad
type AttrSetTypeConstraint PadCapsPropertyInfo = (~) ()
type AttrTransferTypeConstraint PadCapsPropertyInfo = (~) ()
type AttrTransferType PadCapsPropertyInfo = ()
type AttrGetType PadCapsPropertyInfo = (Maybe Gst.Caps.Caps)
type AttrLabel PadCapsPropertyInfo = "caps"
type AttrOrigin PadCapsPropertyInfo = Pad
attrGet = getPadCaps
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
#endif
getPadDirection :: (MonadIO m, IsPad o) => o -> m Gst.Enums.PadDirection
getPadDirection :: o -> m PadDirection
getPadDirection o
obj = IO PadDirection -> m PadDirection
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadDirection -> m PadDirection)
-> IO PadDirection -> m PadDirection
forall a b. (a -> b) -> a -> b
$ o -> String -> IO PadDirection
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"direction"
constructPadDirection :: (IsPad o, MIO.MonadIO m) => Gst.Enums.PadDirection -> m (GValueConstruct o)
constructPadDirection :: PadDirection -> m (GValueConstruct o)
constructPadDirection PadDirection
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> PadDirection -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"direction" PadDirection
val
#if defined(ENABLE_OVERLOADING)
data PadDirectionPropertyInfo
instance AttrInfo PadDirectionPropertyInfo where
type AttrAllowedOps PadDirectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint PadDirectionPropertyInfo = IsPad
type AttrSetTypeConstraint PadDirectionPropertyInfo = (~) Gst.Enums.PadDirection
type AttrTransferTypeConstraint PadDirectionPropertyInfo = (~) Gst.Enums.PadDirection
type AttrTransferType PadDirectionPropertyInfo = Gst.Enums.PadDirection
type AttrGetType PadDirectionPropertyInfo = Gst.Enums.PadDirection
type AttrLabel PadDirectionPropertyInfo = "direction"
type AttrOrigin PadDirectionPropertyInfo = Pad
attrGet = getPadDirection
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructPadDirection
attrClear = undefined
#endif
getPadOffset :: (MonadIO m, IsPad o) => o -> m Int64
getPadOffset :: o -> m Int64
getPadOffset o
obj = IO Int64 -> m Int64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int64
forall a. GObject a => a -> String -> IO Int64
B.Properties.getObjectPropertyInt64 o
obj String
"offset"
setPadOffset :: (MonadIO m, IsPad o) => o -> Int64 -> m ()
setPadOffset :: o -> Int64 -> m ()
setPadOffset o
obj Int64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Int64 -> IO ()
forall a. GObject a => a -> String -> Int64 -> IO ()
B.Properties.setObjectPropertyInt64 o
obj String
"offset" Int64
val
constructPadOffset :: (IsPad o, MIO.MonadIO m) => Int64 -> m (GValueConstruct o)
constructPadOffset :: Int64 -> m (GValueConstruct o)
constructPadOffset Int64
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int64 -> IO (GValueConstruct o)
forall o. String -> Int64 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt64 String
"offset" Int64
val
#if defined(ENABLE_OVERLOADING)
data PadOffsetPropertyInfo
instance AttrInfo PadOffsetPropertyInfo where
type AttrAllowedOps PadOffsetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint PadOffsetPropertyInfo = IsPad
type AttrSetTypeConstraint PadOffsetPropertyInfo = (~) Int64
type AttrTransferTypeConstraint PadOffsetPropertyInfo = (~) Int64
type AttrTransferType PadOffsetPropertyInfo = Int64
type AttrGetType PadOffsetPropertyInfo = Int64
type AttrLabel PadOffsetPropertyInfo = "offset"
type AttrOrigin PadOffsetPropertyInfo = Pad
attrGet = getPadOffset
attrSet = setPadOffset
attrTransfer _ v = do
return v
attrConstruct = constructPadOffset
attrClear = undefined
#endif
getPadTemplate :: (MonadIO m, IsPad o) => o -> m (Maybe Gst.PadTemplate.PadTemplate)
getPadTemplate :: o -> m (Maybe PadTemplate)
getPadTemplate o
obj = 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
$ o
-> String
-> (ManagedPtr PadTemplate -> PadTemplate)
-> IO (Maybe PadTemplate)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"template" ManagedPtr PadTemplate -> PadTemplate
Gst.PadTemplate.PadTemplate
setPadTemplate :: (MonadIO m, IsPad o, Gst.PadTemplate.IsPadTemplate a) => o -> a -> m ()
setPadTemplate :: o -> a -> m ()
setPadTemplate o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"template" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)
constructPadTemplate :: (IsPad o, MIO.MonadIO m, Gst.PadTemplate.IsPadTemplate a) => a -> m (GValueConstruct o)
constructPadTemplate :: a -> m (GValueConstruct o)
constructPadTemplate a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"template" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
clearPadTemplate :: (MonadIO m, IsPad o) => o -> m ()
clearPadTemplate :: o -> m ()
clearPadTemplate o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe PadTemplate -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"template" (Maybe PadTemplate
forall a. Maybe a
Nothing :: Maybe Gst.PadTemplate.PadTemplate)
#if defined(ENABLE_OVERLOADING)
data PadTemplatePropertyInfo
instance AttrInfo PadTemplatePropertyInfo where
type AttrAllowedOps PadTemplatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint PadTemplatePropertyInfo = IsPad
type AttrSetTypeConstraint PadTemplatePropertyInfo = Gst.PadTemplate.IsPadTemplate
type AttrTransferTypeConstraint PadTemplatePropertyInfo = Gst.PadTemplate.IsPadTemplate
type AttrTransferType PadTemplatePropertyInfo = Gst.PadTemplate.PadTemplate
type AttrGetType PadTemplatePropertyInfo = (Maybe Gst.PadTemplate.PadTemplate)
type AttrLabel PadTemplatePropertyInfo = "template"
type AttrOrigin PadTemplatePropertyInfo = Pad
attrGet = getPadTemplate
attrSet = setPadTemplate
attrTransfer _ v = do
unsafeCastTo Gst.PadTemplate.PadTemplate v
attrConstruct = constructPadTemplate
attrClear = clearPadTemplate
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Pad
type instance O.AttributeList Pad = PadAttributeList
type PadAttributeList = ('[ '("caps", PadCapsPropertyInfo), '("direction", PadDirectionPropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("offset", PadOffsetPropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("template", PadTemplatePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
padCaps :: AttrLabelProxy "caps"
padCaps = AttrLabelProxy
padDirection :: AttrLabelProxy "direction"
padDirection = AttrLabelProxy
padOffset :: AttrLabelProxy "offset"
padOffset = AttrLabelProxy
padTemplate :: AttrLabelProxy "template"
padTemplate = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Pad = PadSignalList
type PadSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("linked", PadLinkedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("unlinked", PadUnlinkedSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_pad_new" gst_pad_new ::
CString ->
CUInt ->
IO (Ptr Pad)
padNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> Gst.Enums.PadDirection
-> m (Maybe Pad)
padNew :: Maybe Text -> PadDirection -> m (Maybe Pad)
padNew Maybe Text
name PadDirection
direction = 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 CChar
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just 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'
let direction' :: CUInt
direction' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PadDirection -> Int) -> PadDirection -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PadDirection -> Int
forall a. Enum a => a -> Int
fromEnum) PadDirection
direction
Ptr Pad
result <- Ptr CChar -> CUInt -> IO (Ptr Pad)
gst_pad_new Ptr CChar
maybeName CUInt
direction'
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
$ \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
newObject ManagedPtr Pad -> Pad
Pad) Ptr Pad
result'
Pad -> IO Pad
forall (m :: * -> *) a. Monad m => a -> m a
return Pad
result''
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)
#endif
foreign import ccall "gst_pad_new_from_static_template" gst_pad_new_from_static_template ::
Ptr Gst.StaticPadTemplate.StaticPadTemplate ->
CString ->
IO (Ptr Pad)
padNewFromStaticTemplate ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.StaticPadTemplate.StaticPadTemplate
-> T.Text
-> m (Maybe Pad)
padNewFromStaticTemplate :: StaticPadTemplate -> Text -> m (Maybe Pad)
padNewFromStaticTemplate StaticPadTemplate
templ 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 StaticPadTemplate
templ' <- StaticPadTemplate -> IO (Ptr StaticPadTemplate)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StaticPadTemplate
templ
Ptr CChar
name' <- Text -> IO (Ptr CChar)
textToCString Text
name
Ptr Pad
result <- Ptr StaticPadTemplate -> Ptr CChar -> IO (Ptr Pad)
gst_pad_new_from_static_template Ptr StaticPadTemplate
templ' 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
$ \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
newObject ManagedPtr Pad -> Pad
Pad) Ptr Pad
result'
Pad -> IO Pad
forall (m :: * -> *) a. Monad m => a -> m a
return Pad
result''
StaticPadTemplate -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StaticPadTemplate
templ
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)
#endif
foreign import ccall "gst_pad_new_from_template" gst_pad_new_from_template ::
Ptr Gst.PadTemplate.PadTemplate ->
CString ->
IO (Ptr Pad)
padNewFromTemplate ::
(B.CallStack.HasCallStack, MonadIO m, Gst.PadTemplate.IsPadTemplate a) =>
a
-> Maybe (T.Text)
-> m (Maybe Pad)
padNewFromTemplate :: a -> Maybe Text -> m (Maybe Pad)
padNewFromTemplate a
templ Maybe 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 PadTemplate
templ' <- a -> IO (Ptr PadTemplate)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
templ
Ptr CChar
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just 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 Pad
result <- Ptr PadTemplate -> Ptr CChar -> IO (Ptr Pad)
gst_pad_new_from_template Ptr PadTemplate
templ' Ptr CChar
maybeName
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
$ \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
newObject ManagedPtr Pad -> 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
templ
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)
#endif
foreign import ccall "gst_pad_activate_mode" gst_pad_activate_mode ::
Ptr Pad ->
CUInt ->
CInt ->
IO CInt
padActivateMode ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.PadMode
-> Bool
-> m Bool
padActivateMode :: a -> PadMode -> Bool -> m Bool
padActivateMode a
pad PadMode
mode Bool
active = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PadMode -> Int) -> PadMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PadMode -> Int
forall a. Enum a => a -> Int
fromEnum) PadMode
mode
let active' :: CInt
active' = (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
active
CInt
result <- Ptr Pad -> CUInt -> CInt -> IO CInt
gst_pad_activate_mode Ptr Pad
pad' CUInt
mode' CInt
active'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadActivateModeMethodInfo
instance (signature ~ (Gst.Enums.PadMode -> Bool -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadActivateModeMethodInfo a signature where
overloadedMethod = padActivateMode
#endif
foreign import ccall "gst_pad_add_probe" gst_pad_add_probe ::
Ptr Pad ->
CUInt ->
FunPtr Gst.Callbacks.C_PadProbeCallback ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO CULong
padAddProbe ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> [Gst.Flags.PadProbeType]
-> Gst.Callbacks.PadProbeCallback
-> m CULong
padAddProbe :: a -> [PadProbeType] -> PadProbeCallback -> m SignalHandlerId
padAddProbe a
pad [PadProbeType]
mask PadProbeCallback
callback = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let mask' :: CUInt
mask' = [PadProbeType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PadProbeType]
mask
FunPtr C_PadProbeCallback
callback' <- C_PadProbeCallback -> IO (FunPtr C_PadProbeCallback)
Gst.Callbacks.mk_PadProbeCallback (Maybe (Ptr (FunPtr C_PadProbeCallback))
-> PadProbeCallback_WithClosures -> C_PadProbeCallback
Gst.Callbacks.wrap_PadProbeCallback Maybe (Ptr (FunPtr C_PadProbeCallback))
forall a. Maybe a
Nothing (PadProbeCallback -> PadProbeCallback_WithClosures
Gst.Callbacks.drop_closures_PadProbeCallback PadProbeCallback
callback))
let userData :: Ptr ()
userData = FunPtr C_PadProbeCallback -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadProbeCallback
callback'
let destroyData :: FunPtr (Ptr a -> IO ())
destroyData = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
SignalHandlerId
result <- Ptr Pad
-> CUInt
-> FunPtr C_PadProbeCallback
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO SignalHandlerId
gst_pad_add_probe Ptr Pad
pad' CUInt
mask' FunPtr C_PadProbeCallback
callback' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroyData
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
SignalHandlerId -> IO SignalHandlerId
forall (m :: * -> *) a. Monad m => a -> m a
return SignalHandlerId
result
#if defined(ENABLE_OVERLOADING)
data PadAddProbeMethodInfo
instance (signature ~ ([Gst.Flags.PadProbeType] -> Gst.Callbacks.PadProbeCallback -> m CULong), MonadIO m, IsPad a) => O.MethodInfo PadAddProbeMethodInfo a signature where
overloadedMethod = padAddProbe
#endif
foreign import ccall "gst_pad_can_link" gst_pad_can_link ::
Ptr Pad ->
Ptr Pad ->
IO CInt
padCanLink ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a
-> b
-> m Bool
padCanLink :: a -> b -> m Bool
padCanLink a
srcpad b
sinkpad = 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 Pad
srcpad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
srcpad
Ptr Pad
sinkpad' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sinkpad
CInt
result <- Ptr Pad -> Ptr Pad -> IO CInt
gst_pad_can_link Ptr Pad
srcpad' Ptr Pad
sinkpad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
srcpad
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sinkpad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadCanLinkMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsPad a, IsPad b) => O.MethodInfo PadCanLinkMethodInfo a signature where
overloadedMethod = padCanLink
#endif
foreign import ccall "gst_pad_chain" gst_pad_chain ::
Ptr Pad ->
Ptr Gst.Buffer.Buffer ->
IO CInt
padChain ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Buffer.Buffer
-> m Gst.Enums.FlowReturn
padChain :: a -> Buffer -> m FlowReturn
padChain a
pad Buffer
buffer = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
buffer
CInt
result <- Ptr Pad -> Ptr Buffer -> IO CInt
gst_pad_chain Ptr Pad
pad' Ptr Buffer
buffer'
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadChainMethodInfo
instance (signature ~ (Gst.Buffer.Buffer -> m Gst.Enums.FlowReturn), MonadIO m, IsPad a) => O.MethodInfo PadChainMethodInfo a signature where
overloadedMethod = padChain
#endif
foreign import ccall "gst_pad_chain_list" gst_pad_chain_list ::
Ptr Pad ->
Ptr Gst.BufferList.BufferList ->
IO CInt
padChainList ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.BufferList.BufferList
-> m Gst.Enums.FlowReturn
padChainList :: a -> BufferList -> m FlowReturn
padChainList a
pad BufferList
list = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr BufferList
list' <- BufferList -> IO (Ptr BufferList)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed BufferList
list
CInt
result <- Ptr Pad -> Ptr BufferList -> IO CInt
gst_pad_chain_list Ptr Pad
pad' Ptr BufferList
list'
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
BufferList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BufferList
list
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadChainListMethodInfo
instance (signature ~ (Gst.BufferList.BufferList -> m Gst.Enums.FlowReturn), MonadIO m, IsPad a) => O.MethodInfo PadChainListMethodInfo a signature where
overloadedMethod = padChainList
#endif
foreign import ccall "gst_pad_check_reconfigure" gst_pad_check_reconfigure ::
Ptr Pad ->
IO CInt
padCheckReconfigure ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padCheckReconfigure :: a -> m Bool
padCheckReconfigure a
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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_check_reconfigure Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadCheckReconfigureMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadCheckReconfigureMethodInfo a signature where
overloadedMethod = padCheckReconfigure
#endif
foreign import ccall "gst_pad_create_stream_id" gst_pad_create_stream_id ::
Ptr Pad ->
Ptr Gst.Element.Element ->
CString ->
IO CString
padCreateStreamId ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, Gst.Element.IsElement b) =>
a
-> b
-> Maybe (T.Text)
-> m T.Text
padCreateStreamId :: a -> b -> Maybe Text -> m Text
padCreateStreamId a
pad b
parent Maybe Text
streamId = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Element
parent' <- b -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
parent
Ptr CChar
maybeStreamId <- case Maybe Text
streamId of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jStreamId -> do
Ptr CChar
jStreamId' <- Text -> IO (Ptr CChar)
textToCString Text
jStreamId
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jStreamId'
Ptr CChar
result <- Ptr Pad -> Ptr Element -> Ptr CChar -> IO (Ptr CChar)
gst_pad_create_stream_id Ptr Pad
pad' Ptr Element
parent' Ptr CChar
maybeStreamId
Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"padCreateStreamId" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
parent
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeStreamId
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data PadCreateStreamIdMethodInfo
instance (signature ~ (b -> Maybe (T.Text) -> m T.Text), MonadIO m, IsPad a, Gst.Element.IsElement b) => O.MethodInfo PadCreateStreamIdMethodInfo a signature where
overloadedMethod = padCreateStreamId
#endif
foreign import ccall "gst_pad_event_default" gst_pad_event_default ::
Ptr Pad ->
Ptr Gst.Object.Object ->
Ptr Gst.Event.Event ->
IO CInt
padEventDefault ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, Gst.Object.IsObject b) =>
a
-> Maybe (b)
-> Gst.Event.Event
-> m Bool
padEventDefault :: a -> Maybe b -> Event -> m Bool
padEventDefault a
pad Maybe b
parent 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Object
maybeParent <- case Maybe b
parent of
Maybe b
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just b
jParent -> do
Ptr Object
jParent' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jParent
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jParent'
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Event
event
CInt
result <- Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt
gst_pad_event_default Ptr Pad
pad' Ptr Object
maybeParent Ptr Event
event'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
parent b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
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 PadEventDefaultMethodInfo
instance (signature ~ (Maybe (b) -> Gst.Event.Event -> m Bool), MonadIO m, IsPad a, Gst.Object.IsObject b) => O.MethodInfo PadEventDefaultMethodInfo a signature where
overloadedMethod = padEventDefault
#endif
foreign import ccall "gst_pad_forward" gst_pad_forward ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadForwardFunction ->
Ptr () ->
IO CInt
padForward ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadForwardFunction
-> m Bool
padForward :: a -> PadForwardFunction -> m Bool
padForward a
pad PadForwardFunction
forward = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadForwardFunction
forward' <- C_PadForwardFunction -> IO (FunPtr C_PadForwardFunction)
Gst.Callbacks.mk_PadForwardFunction (Maybe (Ptr (FunPtr C_PadForwardFunction))
-> PadForwardFunction_WithClosures -> C_PadForwardFunction
Gst.Callbacks.wrap_PadForwardFunction Maybe (Ptr (FunPtr C_PadForwardFunction))
forall a. Maybe a
Nothing (PadForwardFunction -> PadForwardFunction_WithClosures
Gst.Callbacks.drop_closures_PadForwardFunction PadForwardFunction
forward))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
CInt
result <- Ptr Pad -> FunPtr C_PadForwardFunction -> Ptr () -> IO CInt
gst_pad_forward Ptr Pad
pad' FunPtr C_PadForwardFunction
forward' Ptr ()
forall a. Ptr a
userData
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
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_PadForwardFunction -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadForwardFunction
forward'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadForwardMethodInfo
instance (signature ~ (Gst.Callbacks.PadForwardFunction -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadForwardMethodInfo a signature where
overloadedMethod = padForward
#endif
foreign import ccall "gst_pad_get_allowed_caps" gst_pad_get_allowed_caps ::
Ptr Pad ->
IO (Ptr Gst.Caps.Caps)
padGetAllowedCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Gst.Caps.Caps)
padGetAllowedCaps :: a -> m (Maybe Caps)
padGetAllowedCaps a
pad = IO (Maybe Caps) -> m (Maybe Caps)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Caps) -> m (Maybe Caps))
-> IO (Maybe Caps) -> m (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
result <- Ptr Pad -> IO (Ptr Caps)
gst_pad_get_allowed_caps Ptr Pad
pad'
Maybe Caps
maybeResult <- Ptr Caps -> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Caps
result ((Ptr Caps -> IO Caps) -> IO (Maybe Caps))
-> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ \Ptr Caps
result' -> do
Caps
result'' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result'
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Caps -> IO (Maybe Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Caps
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetAllowedCapsMethodInfo
instance (signature ~ (m (Maybe Gst.Caps.Caps)), MonadIO m, IsPad a) => O.MethodInfo PadGetAllowedCapsMethodInfo a signature where
overloadedMethod = padGetAllowedCaps
#endif
foreign import ccall "gst_pad_get_current_caps" gst_pad_get_current_caps ::
Ptr Pad ->
IO (Ptr Gst.Caps.Caps)
padGetCurrentCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Gst.Caps.Caps)
padGetCurrentCaps :: a -> m (Maybe Caps)
padGetCurrentCaps a
pad = IO (Maybe Caps) -> m (Maybe Caps)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Caps) -> m (Maybe Caps))
-> IO (Maybe Caps) -> m (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
result <- Ptr Pad -> IO (Ptr Caps)
gst_pad_get_current_caps Ptr Pad
pad'
Maybe Caps
maybeResult <- Ptr Caps -> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Caps
result ((Ptr Caps -> IO Caps) -> IO (Maybe Caps))
-> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ \Ptr Caps
result' -> do
Caps
result'' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result'
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Caps -> IO (Maybe Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Caps
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetCurrentCapsMethodInfo
instance (signature ~ (m (Maybe Gst.Caps.Caps)), MonadIO m, IsPad a) => O.MethodInfo PadGetCurrentCapsMethodInfo a signature where
overloadedMethod = padGetCurrentCaps
#endif
foreign import ccall "gst_pad_get_direction" gst_pad_get_direction ::
Ptr Pad ->
IO CUInt
padGetDirection ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Gst.Enums.PadDirection
padGetDirection :: a -> m PadDirection
padGetDirection a
pad = IO PadDirection -> m PadDirection
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadDirection -> m PadDirection)
-> IO PadDirection -> m PadDirection
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CUInt
result <- Ptr Pad -> IO CUInt
gst_pad_get_direction Ptr Pad
pad'
let result' :: PadDirection
result' = (Int -> PadDirection
forall a. Enum a => Int -> a
toEnum (Int -> PadDirection) -> (CUInt -> Int) -> CUInt -> PadDirection
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
pad
PadDirection -> IO PadDirection
forall (m :: * -> *) a. Monad m => a -> m a
return PadDirection
result'
#if defined(ENABLE_OVERLOADING)
data PadGetDirectionMethodInfo
instance (signature ~ (m Gst.Enums.PadDirection), MonadIO m, IsPad a) => O.MethodInfo PadGetDirectionMethodInfo a signature where
overloadedMethod = padGetDirection
#endif
foreign import ccall "gst_pad_get_element_private" gst_pad_get_element_private ::
Ptr Pad ->
IO (Ptr ())
padGetElementPrivate ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Ptr ())
padGetElementPrivate :: a -> m (Ptr ())
padGetElementPrivate a
pad = IO (Ptr ()) -> m (Ptr ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr ()
result <- Ptr Pad -> IO (Ptr ())
gst_pad_get_element_private Ptr Pad
pad'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data PadGetElementPrivateMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsPad a) => O.MethodInfo PadGetElementPrivateMethodInfo a signature where
overloadedMethod = padGetElementPrivate
#endif
foreign import ccall "gst_pad_get_last_flow_return" gst_pad_get_last_flow_return ::
Ptr Pad ->
IO CInt
padGetLastFlowReturn ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Gst.Enums.FlowReturn
padGetLastFlowReturn :: a -> m FlowReturn
padGetLastFlowReturn a
pad = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_get_last_flow_return Ptr Pad
pad'
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadGetLastFlowReturnMethodInfo
instance (signature ~ (m Gst.Enums.FlowReturn), MonadIO m, IsPad a) => O.MethodInfo PadGetLastFlowReturnMethodInfo a signature where
overloadedMethod = padGetLastFlowReturn
#endif
foreign import ccall "gst_pad_get_offset" gst_pad_get_offset ::
Ptr Pad ->
IO Int64
padGetOffset ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Int64
padGetOffset :: a -> m Int64
padGetOffset a
pad = IO Int64 -> m Int64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Int64
result <- Ptr Pad -> IO Int64
gst_pad_get_offset Ptr Pad
pad'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Int64 -> IO Int64
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
result
#if defined(ENABLE_OVERLOADING)
data PadGetOffsetMethodInfo
instance (signature ~ (m Int64), MonadIO m, IsPad a) => O.MethodInfo PadGetOffsetMethodInfo a signature where
overloadedMethod = padGetOffset
#endif
foreign import ccall "gst_pad_get_pad_template" gst_pad_get_pad_template ::
Ptr Pad ->
IO (Ptr Gst.PadTemplate.PadTemplate)
padGetPadTemplate ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Gst.PadTemplate.PadTemplate)
padGetPadTemplate :: a -> m (Maybe PadTemplate)
padGetPadTemplate a
pad = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr PadTemplate
result <- Ptr Pad -> IO (Ptr PadTemplate)
gst_pad_get_pad_template Ptr Pad
pad'
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
$ \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
wrapObject 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
pad
Maybe PadTemplate -> IO (Maybe PadTemplate)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PadTemplate
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetPadTemplateMethodInfo
instance (signature ~ (m (Maybe Gst.PadTemplate.PadTemplate)), MonadIO m, IsPad a) => O.MethodInfo PadGetPadTemplateMethodInfo a signature where
overloadedMethod = padGetPadTemplate
#endif
foreign import ccall "gst_pad_get_pad_template_caps" gst_pad_get_pad_template_caps ::
Ptr Pad ->
IO (Ptr Gst.Caps.Caps)
padGetPadTemplateCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Gst.Caps.Caps
padGetPadTemplateCaps :: a -> m Caps
padGetPadTemplateCaps a
pad = IO Caps -> m Caps
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Caps -> m Caps) -> IO Caps -> m Caps
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
result <- Ptr Pad -> IO (Ptr Caps)
gst_pad_get_pad_template_caps Ptr Pad
pad'
Text -> Ptr Caps -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"padGetPadTemplateCaps" Ptr Caps
result
Caps
result' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result'
#if defined(ENABLE_OVERLOADING)
data PadGetPadTemplateCapsMethodInfo
instance (signature ~ (m Gst.Caps.Caps), MonadIO m, IsPad a) => O.MethodInfo PadGetPadTemplateCapsMethodInfo a signature where
overloadedMethod = padGetPadTemplateCaps
#endif
foreign import ccall "gst_pad_get_parent_element" gst_pad_get_parent_element ::
Ptr Pad ->
IO (Ptr Gst.Element.Element)
padGetParentElement ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Gst.Element.Element)
padGetParentElement :: a -> m (Maybe Element)
padGetParentElement a
pad = 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
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Element
result <- Ptr Pad -> IO (Ptr Element)
gst_pad_get_parent_element Ptr Pad
pad'
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
$ \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
wrapObject ManagedPtr Element -> Element
Gst.Element.Element) Ptr Element
result'
Element -> IO Element
forall (m :: * -> *) a. Monad m => a -> m a
return Element
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Element -> IO (Maybe Element)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Element
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetParentElementMethodInfo
instance (signature ~ (m (Maybe Gst.Element.Element)), MonadIO m, IsPad a) => O.MethodInfo PadGetParentElementMethodInfo a signature where
overloadedMethod = padGetParentElement
#endif
foreign import ccall "gst_pad_get_peer" gst_pad_get_peer ::
Ptr Pad ->
IO (Ptr Pad)
padGetPeer ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Pad)
padGetPeer :: a -> m (Maybe Pad)
padGetPeer a
pad = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Pad
result <- Ptr Pad -> IO (Ptr Pad)
gst_pad_get_peer Ptr Pad
pad'
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
$ \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
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
pad
Maybe Pad -> IO (Maybe Pad)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pad
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetPeerMethodInfo
instance (signature ~ (m (Maybe Pad)), MonadIO m, IsPad a) => O.MethodInfo PadGetPeerMethodInfo a signature where
overloadedMethod = padGetPeer
#endif
foreign import ccall "gst_pad_get_range" gst_pad_get_range ::
Ptr Pad ->
Word64 ->
Word32 ->
Ptr (Ptr Gst.Buffer.Buffer) ->
IO CInt
padGetRange ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Word64
-> Word32
-> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))
padGetRange :: a -> Word64 -> Word32 -> m (FlowReturn, Buffer)
padGetRange a
pad Word64
offset Word32
size = IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer))
-> IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr (Ptr Buffer)
buffer <- IO (Ptr (Ptr Buffer))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Buffer.Buffer))
CInt
result <- Ptr Pad -> Word64 -> Word32 -> Ptr (Ptr Buffer) -> IO CInt
gst_pad_get_range Ptr Pad
pad' Word64
offset Word32
size Ptr (Ptr Buffer)
buffer
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
Ptr Buffer
buffer' <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Buffer)
buffer
Buffer
buffer'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
buffer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Ptr (Ptr Buffer) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Buffer)
buffer
(FlowReturn, Buffer) -> IO (FlowReturn, Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return (FlowReturn
result', Buffer
buffer'')
#if defined(ENABLE_OVERLOADING)
data PadGetRangeMethodInfo
instance (signature ~ (Word64 -> Word32 -> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))), MonadIO m, IsPad a) => O.MethodInfo PadGetRangeMethodInfo a signature where
overloadedMethod = padGetRange
#endif
foreign import ccall "gst_pad_get_sticky_event" gst_pad_get_sticky_event ::
Ptr Pad ->
CUInt ->
Word32 ->
IO (Ptr Gst.Event.Event)
padGetStickyEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.EventType
-> Word32
-> m (Maybe Gst.Event.Event)
padGetStickyEvent :: a -> EventType -> Word32 -> m (Maybe Event)
padGetStickyEvent a
pad EventType
eventType Word32
idx = IO (Maybe Event) -> m (Maybe Event)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Event) -> m (Maybe Event))
-> IO (Maybe Event) -> m (Maybe Event)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let eventType' :: CUInt
eventType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (EventType -> Int) -> EventType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EventType -> Int
forall a. Enum a => a -> Int
fromEnum) EventType
eventType
Ptr Event
result <- Ptr Pad -> CUInt -> Word32 -> IO (Ptr Event)
gst_pad_get_sticky_event Ptr Pad
pad' CUInt
eventType' Word32
idx
Maybe Event
maybeResult <- Ptr Event -> (Ptr Event -> IO Event) -> IO (Maybe Event)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Event
result ((Ptr Event -> IO Event) -> IO (Maybe Event))
-> (Ptr Event -> IO Event) -> IO (Maybe Event)
forall a b. (a -> b) -> a -> b
$ \Ptr Event
result' -> do
Event
result'' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Gst.Event.Event) Ptr Event
result'
Event -> IO Event
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Event -> IO (Maybe Event)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Event
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetStickyEventMethodInfo
instance (signature ~ (Gst.Enums.EventType -> Word32 -> m (Maybe Gst.Event.Event)), MonadIO m, IsPad a) => O.MethodInfo PadGetStickyEventMethodInfo a signature where
overloadedMethod = padGetStickyEvent
#endif
foreign import ccall "gst_pad_get_stream" gst_pad_get_stream ::
Ptr Pad ->
IO (Ptr Gst.Stream.Stream)
padGetStream ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Gst.Stream.Stream)
padGetStream :: a -> m (Maybe Stream)
padGetStream a
pad = IO (Maybe Stream) -> m (Maybe Stream)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Stream) -> m (Maybe Stream))
-> IO (Maybe Stream) -> m (Maybe Stream)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Stream
result <- Ptr Pad -> IO (Ptr Stream)
gst_pad_get_stream Ptr Pad
pad'
Maybe Stream
maybeResult <- Ptr Stream -> (Ptr Stream -> IO Stream) -> IO (Maybe Stream)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Stream
result ((Ptr Stream -> IO Stream) -> IO (Maybe Stream))
-> (Ptr Stream -> IO Stream) -> IO (Maybe Stream)
forall a b. (a -> b) -> a -> b
$ \Ptr Stream
result' -> do
Stream
result'' <- ((ManagedPtr Stream -> Stream) -> Ptr Stream -> IO Stream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Stream -> Stream
Gst.Stream.Stream) Ptr Stream
result'
Stream -> IO Stream
forall (m :: * -> *) a. Monad m => a -> m a
return Stream
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Stream -> IO (Maybe Stream)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Stream
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetStreamMethodInfo
instance (signature ~ (m (Maybe Gst.Stream.Stream)), MonadIO m, IsPad a) => O.MethodInfo PadGetStreamMethodInfo a signature where
overloadedMethod = padGetStream
#endif
foreign import ccall "gst_pad_get_stream_id" gst_pad_get_stream_id ::
Ptr Pad ->
IO CString
padGetStreamId ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe T.Text)
padGetStreamId :: a -> m (Maybe Text)
padGetStreamId a
pad = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr CChar
result <- Ptr Pad -> IO (Ptr CChar)
gst_pad_get_stream_id Ptr Pad
pad'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetStreamIdMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsPad a) => O.MethodInfo PadGetStreamIdMethodInfo a signature where
overloadedMethod = padGetStreamId
#endif
foreign import ccall "gst_pad_get_task_state" gst_pad_get_task_state ::
Ptr Pad ->
IO CUInt
padGetTaskState ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Gst.Enums.TaskState
padGetTaskState :: a -> m TaskState
padGetTaskState a
pad = IO TaskState -> m TaskState
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TaskState -> m TaskState) -> IO TaskState -> m TaskState
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CUInt
result <- Ptr Pad -> IO CUInt
gst_pad_get_task_state Ptr Pad
pad'
let result' :: TaskState
result' = (Int -> TaskState
forall a. Enum a => Int -> a
toEnum (Int -> TaskState) -> (CUInt -> Int) -> CUInt -> TaskState
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
TaskState -> IO TaskState
forall (m :: * -> *) a. Monad m => a -> m a
return TaskState
result'
#if defined(ENABLE_OVERLOADING)
data PadGetTaskStateMethodInfo
instance (signature ~ (m Gst.Enums.TaskState), MonadIO m, IsPad a) => O.MethodInfo PadGetTaskStateMethodInfo a signature where
overloadedMethod = padGetTaskState
#endif
foreign import ccall "gst_pad_has_current_caps" gst_pad_has_current_caps ::
Ptr Pad ->
IO CInt
padHasCurrentCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padHasCurrentCaps :: a -> m Bool
padHasCurrentCaps a
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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_has_current_caps Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadHasCurrentCapsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadHasCurrentCapsMethodInfo a signature where
overloadedMethod = padHasCurrentCaps
#endif
foreign import ccall "gst_pad_is_active" gst_pad_is_active ::
Ptr Pad ->
IO CInt
padIsActive ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padIsActive :: a -> m Bool
padIsActive a
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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_is_active Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadIsActiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadIsActiveMethodInfo a signature where
overloadedMethod = padIsActive
#endif
foreign import ccall "gst_pad_is_blocked" gst_pad_is_blocked ::
Ptr Pad ->
IO CInt
padIsBlocked ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padIsBlocked :: a -> m Bool
padIsBlocked a
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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_is_blocked Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadIsBlockedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadIsBlockedMethodInfo a signature where
overloadedMethod = padIsBlocked
#endif
foreign import ccall "gst_pad_is_blocking" gst_pad_is_blocking ::
Ptr Pad ->
IO CInt
padIsBlocking ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padIsBlocking :: a -> m Bool
padIsBlocking a
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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_is_blocking Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadIsBlockingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadIsBlockingMethodInfo a signature where
overloadedMethod = padIsBlocking
#endif
foreign import ccall "gst_pad_is_linked" gst_pad_is_linked ::
Ptr Pad ->
IO CInt
padIsLinked ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padIsLinked :: a -> m Bool
padIsLinked a
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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_is_linked Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadIsLinkedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadIsLinkedMethodInfo a signature where
overloadedMethod = padIsLinked
#endif
foreign import ccall "gst_pad_iterate_internal_links" gst_pad_iterate_internal_links ::
Ptr Pad ->
IO (Ptr Gst.Iterator.Iterator)
padIterateInternalLinks ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Gst.Iterator.Iterator)
padIterateInternalLinks :: a -> m (Maybe Iterator)
padIterateInternalLinks a
pad = IO (Maybe Iterator) -> m (Maybe Iterator)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Iterator) -> m (Maybe Iterator))
-> IO (Maybe Iterator) -> m (Maybe Iterator)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Iterator
result <- Ptr Pad -> IO (Ptr Iterator)
gst_pad_iterate_internal_links Ptr Pad
pad'
Maybe Iterator
maybeResult <- Ptr Iterator
-> (Ptr Iterator -> IO Iterator) -> IO (Maybe Iterator)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Iterator
result ((Ptr Iterator -> IO Iterator) -> IO (Maybe Iterator))
-> (Ptr Iterator -> IO Iterator) -> IO (Maybe Iterator)
forall a b. (a -> b) -> a -> b
$ \Ptr Iterator
result' -> do
Iterator
result'' <- ((ManagedPtr Iterator -> Iterator) -> Ptr Iterator -> IO Iterator
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Iterator -> Iterator
Gst.Iterator.Iterator) Ptr Iterator
result'
Iterator -> IO Iterator
forall (m :: * -> *) a. Monad m => a -> m a
return Iterator
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Iterator -> IO (Maybe Iterator)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Iterator
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadIterateInternalLinksMethodInfo
instance (signature ~ (m (Maybe Gst.Iterator.Iterator)), MonadIO m, IsPad a) => O.MethodInfo PadIterateInternalLinksMethodInfo a signature where
overloadedMethod = padIterateInternalLinks
#endif
foreign import ccall "gst_pad_iterate_internal_links_default" gst_pad_iterate_internal_links_default ::
Ptr Pad ->
Ptr Gst.Object.Object ->
IO (Ptr Gst.Iterator.Iterator)
padIterateInternalLinksDefault ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, Gst.Object.IsObject b) =>
a
-> Maybe (b)
-> m (Maybe Gst.Iterator.Iterator)
padIterateInternalLinksDefault :: a -> Maybe b -> m (Maybe Iterator)
padIterateInternalLinksDefault a
pad Maybe b
parent = IO (Maybe Iterator) -> m (Maybe Iterator)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Iterator) -> m (Maybe Iterator))
-> IO (Maybe Iterator) -> m (Maybe Iterator)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Object
maybeParent <- case Maybe b
parent of
Maybe b
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just b
jParent -> do
Ptr Object
jParent' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jParent
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jParent'
Ptr Iterator
result <- Ptr Pad -> Ptr Object -> IO (Ptr Iterator)
gst_pad_iterate_internal_links_default Ptr Pad
pad' Ptr Object
maybeParent
Maybe Iterator
maybeResult <- Ptr Iterator
-> (Ptr Iterator -> IO Iterator) -> IO (Maybe Iterator)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Iterator
result ((Ptr Iterator -> IO Iterator) -> IO (Maybe Iterator))
-> (Ptr Iterator -> IO Iterator) -> IO (Maybe Iterator)
forall a b. (a -> b) -> a -> b
$ \Ptr Iterator
result' -> do
Iterator
result'' <- ((ManagedPtr Iterator -> Iterator) -> Ptr Iterator -> IO Iterator
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Iterator -> Iterator
Gst.Iterator.Iterator) Ptr Iterator
result'
Iterator -> IO Iterator
forall (m :: * -> *) a. Monad m => a -> m a
return Iterator
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
parent b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Iterator -> IO (Maybe Iterator)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Iterator
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadIterateInternalLinksDefaultMethodInfo
instance (signature ~ (Maybe (b) -> m (Maybe Gst.Iterator.Iterator)), MonadIO m, IsPad a, Gst.Object.IsObject b) => O.MethodInfo PadIterateInternalLinksDefaultMethodInfo a signature where
overloadedMethod = padIterateInternalLinksDefault
#endif
foreign import ccall "gst_pad_link" gst_pad_link ::
Ptr Pad ->
Ptr Pad ->
IO CInt
padLink ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a
-> b
-> m Gst.Enums.PadLinkReturn
padLink :: a -> b -> m PadLinkReturn
padLink a
srcpad b
sinkpad = IO PadLinkReturn -> m PadLinkReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadLinkReturn -> m PadLinkReturn)
-> IO PadLinkReturn -> m PadLinkReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
srcpad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
srcpad
Ptr Pad
sinkpad' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sinkpad
CInt
result <- Ptr Pad -> Ptr Pad -> IO CInt
gst_pad_link Ptr Pad
srcpad' Ptr Pad
sinkpad'
let result' :: PadLinkReturn
result' = (Int -> PadLinkReturn
forall a. Enum a => Int -> a
toEnum (Int -> PadLinkReturn) -> (CInt -> Int) -> CInt -> PadLinkReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
srcpad
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sinkpad
PadLinkReturn -> IO PadLinkReturn
forall (m :: * -> *) a. Monad m => a -> m a
return PadLinkReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadLinkMethodInfo
instance (signature ~ (b -> m Gst.Enums.PadLinkReturn), MonadIO m, IsPad a, IsPad b) => O.MethodInfo PadLinkMethodInfo a signature where
overloadedMethod = padLink
#endif
foreign import ccall "gst_pad_link_full" gst_pad_link_full ::
Ptr Pad ->
Ptr Pad ->
CUInt ->
IO CInt
padLinkFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a
-> b
-> [Gst.Flags.PadLinkCheck]
-> m Gst.Enums.PadLinkReturn
padLinkFull :: a -> b -> [PadLinkCheck] -> m PadLinkReturn
padLinkFull a
srcpad b
sinkpad [PadLinkCheck]
flags = IO PadLinkReturn -> m PadLinkReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadLinkReturn -> m PadLinkReturn)
-> IO PadLinkReturn -> m PadLinkReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
srcpad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
srcpad
Ptr Pad
sinkpad' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sinkpad
let flags' :: CUInt
flags' = [PadLinkCheck] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PadLinkCheck]
flags
CInt
result <- Ptr Pad -> Ptr Pad -> CUInt -> IO CInt
gst_pad_link_full Ptr Pad
srcpad' Ptr Pad
sinkpad' CUInt
flags'
let result' :: PadLinkReturn
result' = (Int -> PadLinkReturn
forall a. Enum a => Int -> a
toEnum (Int -> PadLinkReturn) -> (CInt -> Int) -> CInt -> PadLinkReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
srcpad
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sinkpad
PadLinkReturn -> IO PadLinkReturn
forall (m :: * -> *) a. Monad m => a -> m a
return PadLinkReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadLinkFullMethodInfo
instance (signature ~ (b -> [Gst.Flags.PadLinkCheck] -> m Gst.Enums.PadLinkReturn), MonadIO m, IsPad a, IsPad b) => O.MethodInfo PadLinkFullMethodInfo a signature where
overloadedMethod = padLinkFull
#endif
foreign import ccall "gst_pad_link_maybe_ghosting" gst_pad_link_maybe_ghosting ::
Ptr Pad ->
Ptr Pad ->
IO CInt
padLinkMaybeGhosting ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a
-> b
-> m Bool
padLinkMaybeGhosting :: a -> b -> m Bool
padLinkMaybeGhosting a
src b
sink = 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 Pad
src' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Pad
sink' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sink
CInt
result <- Ptr Pad -> Ptr Pad -> IO CInt
gst_pad_link_maybe_ghosting Ptr Pad
src' Ptr Pad
sink'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sink
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadLinkMaybeGhostingMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsPad a, IsPad b) => O.MethodInfo PadLinkMaybeGhostingMethodInfo a signature where
overloadedMethod = padLinkMaybeGhosting
#endif
foreign import ccall "gst_pad_link_maybe_ghosting_full" gst_pad_link_maybe_ghosting_full ::
Ptr Pad ->
Ptr Pad ->
CUInt ->
IO CInt
padLinkMaybeGhostingFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a
-> b
-> [Gst.Flags.PadLinkCheck]
-> m Bool
padLinkMaybeGhostingFull :: a -> b -> [PadLinkCheck] -> m Bool
padLinkMaybeGhostingFull a
src b
sink [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 Pad
src' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Pad
sink' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sink
let flags' :: CUInt
flags' = [PadLinkCheck] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PadLinkCheck]
flags
CInt
result <- Ptr Pad -> Ptr Pad -> CUInt -> IO CInt
gst_pad_link_maybe_ghosting_full Ptr Pad
src' Ptr Pad
sink' CUInt
flags'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sink
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadLinkMaybeGhostingFullMethodInfo
instance (signature ~ (b -> [Gst.Flags.PadLinkCheck] -> m Bool), MonadIO m, IsPad a, IsPad b) => O.MethodInfo PadLinkMaybeGhostingFullMethodInfo a signature where
overloadedMethod = padLinkMaybeGhostingFull
#endif
foreign import ccall "gst_pad_mark_reconfigure" gst_pad_mark_reconfigure ::
Ptr Pad ->
IO ()
padMarkReconfigure ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m ()
padMarkReconfigure :: a -> m ()
padMarkReconfigure a
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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Pad -> IO ()
gst_pad_mark_reconfigure Ptr Pad
pad'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadMarkReconfigureMethodInfo
instance (signature ~ (m ()), MonadIO m, IsPad a) => O.MethodInfo PadMarkReconfigureMethodInfo a signature where
overloadedMethod = padMarkReconfigure
#endif
foreign import ccall "gst_pad_needs_reconfigure" gst_pad_needs_reconfigure ::
Ptr Pad ->
IO CInt
padNeedsReconfigure ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padNeedsReconfigure :: a -> m Bool
padNeedsReconfigure a
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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_needs_reconfigure Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadNeedsReconfigureMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadNeedsReconfigureMethodInfo a signature where
overloadedMethod = padNeedsReconfigure
#endif
foreign import ccall "gst_pad_pause_task" gst_pad_pause_task ::
Ptr Pad ->
IO CInt
padPauseTask ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padPauseTask :: a -> m Bool
padPauseTask a
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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_pause_task Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadPauseTaskMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadPauseTaskMethodInfo a signature where
overloadedMethod = padPauseTask
#endif
foreign import ccall "gst_pad_peer_query" gst_pad_peer_query ::
Ptr Pad ->
Ptr Gst.Query.Query ->
IO CInt
padPeerQuery ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Query.Query
-> m Bool
padPeerQuery :: a -> Query -> m Bool
padPeerQuery a
pad 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
CInt
result <- Ptr Pad -> Ptr Query -> IO CInt
gst_pad_peer_query Ptr Pad
pad' Ptr Query
query'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
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 PadPeerQueryMethodInfo
instance (signature ~ (Gst.Query.Query -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadPeerQueryMethodInfo a signature where
overloadedMethod = padPeerQuery
#endif
foreign import ccall "gst_pad_peer_query_accept_caps" gst_pad_peer_query_accept_caps ::
Ptr Pad ->
Ptr Gst.Caps.Caps ->
IO CInt
padPeerQueryAcceptCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Caps.Caps
-> m Bool
padPeerQueryAcceptCaps :: a -> Caps -> m Bool
padPeerQueryAcceptCaps a
pad Caps
caps = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
caps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
CInt
result <- Ptr Pad -> Ptr Caps -> IO CInt
gst_pad_peer_query_accept_caps Ptr Pad
pad' Ptr Caps
caps'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadPeerQueryAcceptCapsMethodInfo
instance (signature ~ (Gst.Caps.Caps -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadPeerQueryAcceptCapsMethodInfo a signature where
overloadedMethod = padPeerQueryAcceptCaps
#endif
foreign import ccall "gst_pad_peer_query_caps" gst_pad_peer_query_caps ::
Ptr Pad ->
Ptr Gst.Caps.Caps ->
IO (Ptr Gst.Caps.Caps)
padPeerQueryCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Maybe (Gst.Caps.Caps)
-> m Gst.Caps.Caps
padPeerQueryCaps :: a -> Maybe Caps -> m Caps
padPeerQueryCaps a
pad Maybe Caps
filter = IO Caps -> m Caps
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Caps -> m Caps) -> IO Caps -> m Caps
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
maybeFilter <- case Maybe Caps
filter of
Maybe Caps
Nothing -> Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
forall a. Ptr a
nullPtr
Just 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'
Ptr Caps
result <- Ptr Pad -> Ptr Caps -> IO (Ptr Caps)
gst_pad_peer_query_caps Ptr Pad
pad' Ptr Caps
maybeFilter
Text -> Ptr Caps -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"padPeerQueryCaps" Ptr Caps
result
Caps
result' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
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
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result'
#if defined(ENABLE_OVERLOADING)
data PadPeerQueryCapsMethodInfo
instance (signature ~ (Maybe (Gst.Caps.Caps) -> m Gst.Caps.Caps), MonadIO m, IsPad a) => O.MethodInfo PadPeerQueryCapsMethodInfo a signature where
overloadedMethod = padPeerQueryCaps
#endif
foreign import ccall "gst_pad_peer_query_convert" gst_pad_peer_query_convert ::
Ptr Pad ->
CUInt ->
Int64 ->
CUInt ->
Ptr Int64 ->
IO CInt
padPeerQueryConvert ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.Format
-> Int64
-> Gst.Enums.Format
-> m ((Bool, Int64))
padPeerQueryConvert :: a -> Format -> Int64 -> Format -> m (Bool, Int64)
padPeerQueryConvert a
pad Format
srcFormat Int64
srcVal 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
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 Pad -> CUInt -> Int64 -> CUInt -> Ptr Int64 -> IO CInt
gst_pad_peer_query_convert Ptr Pad
pad' CUInt
srcFormat' Int64
srcVal CUInt
destFormat' Ptr Int64
destVal
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
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
pad
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 PadPeerQueryConvertMethodInfo
instance (signature ~ (Gst.Enums.Format -> Int64 -> Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsPad a) => O.MethodInfo PadPeerQueryConvertMethodInfo a signature where
overloadedMethod = padPeerQueryConvert
#endif
foreign import ccall "gst_pad_peer_query_duration" gst_pad_peer_query_duration ::
Ptr Pad ->
CUInt ->
Ptr Int64 ->
IO CInt
padPeerQueryDuration ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.Format
-> m ((Bool, Int64))
padPeerQueryDuration :: a -> Format -> m (Bool, Int64)
padPeerQueryDuration a
pad 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
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 Pad -> CUInt -> Ptr Int64 -> IO CInt
gst_pad_peer_query_duration Ptr Pad
pad' CUInt
format' Ptr Int64
duration
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
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
pad
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 PadPeerQueryDurationMethodInfo
instance (signature ~ (Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsPad a) => O.MethodInfo PadPeerQueryDurationMethodInfo a signature where
overloadedMethod = padPeerQueryDuration
#endif
foreign import ccall "gst_pad_peer_query_position" gst_pad_peer_query_position ::
Ptr Pad ->
CUInt ->
Ptr Int64 ->
IO CInt
padPeerQueryPosition ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.Format
-> m ((Bool, Int64))
padPeerQueryPosition :: a -> Format -> m (Bool, Int64)
padPeerQueryPosition a
pad 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
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 Pad -> CUInt -> Ptr Int64 -> IO CInt
gst_pad_peer_query_position Ptr Pad
pad' CUInt
format' Ptr Int64
cur
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
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
pad
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 PadPeerQueryPositionMethodInfo
instance (signature ~ (Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsPad a) => O.MethodInfo PadPeerQueryPositionMethodInfo a signature where
overloadedMethod = padPeerQueryPosition
#endif
foreign import ccall "gst_pad_proxy_query_accept_caps" gst_pad_proxy_query_accept_caps ::
Ptr Pad ->
Ptr Gst.Query.Query ->
IO CInt
padProxyQueryAcceptCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Query.Query
-> m Bool
padProxyQueryAcceptCaps :: a -> Query -> m Bool
padProxyQueryAcceptCaps a
pad 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
CInt
result <- Ptr Pad -> Ptr Query -> IO CInt
gst_pad_proxy_query_accept_caps Ptr Pad
pad' Ptr Query
query'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
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 PadProxyQueryAcceptCapsMethodInfo
instance (signature ~ (Gst.Query.Query -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadProxyQueryAcceptCapsMethodInfo a signature where
overloadedMethod = padProxyQueryAcceptCaps
#endif
foreign import ccall "gst_pad_proxy_query_caps" gst_pad_proxy_query_caps ::
Ptr Pad ->
Ptr Gst.Query.Query ->
IO CInt
padProxyQueryCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Query.Query
-> m Bool
padProxyQueryCaps :: a -> Query -> m Bool
padProxyQueryCaps a
pad 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
CInt
result <- Ptr Pad -> Ptr Query -> IO CInt
gst_pad_proxy_query_caps Ptr Pad
pad' Ptr Query
query'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
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 PadProxyQueryCapsMethodInfo
instance (signature ~ (Gst.Query.Query -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadProxyQueryCapsMethodInfo a signature where
overloadedMethod = padProxyQueryCaps
#endif
foreign import ccall "gst_pad_pull_range" gst_pad_pull_range ::
Ptr Pad ->
Word64 ->
Word32 ->
Ptr (Ptr Gst.Buffer.Buffer) ->
IO CInt
padPullRange ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Word64
-> Word32
-> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))
padPullRange :: a -> Word64 -> Word32 -> m (FlowReturn, Buffer)
padPullRange a
pad Word64
offset Word32
size = IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer))
-> IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr (Ptr Buffer)
buffer <- IO (Ptr (Ptr Buffer))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Buffer.Buffer))
CInt
result <- Ptr Pad -> Word64 -> Word32 -> Ptr (Ptr Buffer) -> IO CInt
gst_pad_pull_range Ptr Pad
pad' Word64
offset Word32
size Ptr (Ptr Buffer)
buffer
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
Ptr Buffer
buffer' <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Buffer)
buffer
Buffer
buffer'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
buffer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Ptr (Ptr Buffer) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Buffer)
buffer
(FlowReturn, Buffer) -> IO (FlowReturn, Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return (FlowReturn
result', Buffer
buffer'')
#if defined(ENABLE_OVERLOADING)
data PadPullRangeMethodInfo
instance (signature ~ (Word64 -> Word32 -> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))), MonadIO m, IsPad a) => O.MethodInfo PadPullRangeMethodInfo a signature where
overloadedMethod = padPullRange
#endif
foreign import ccall "gst_pad_push" gst_pad_push ::
Ptr Pad ->
Ptr Gst.Buffer.Buffer ->
IO CInt
padPush ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Buffer.Buffer
-> m Gst.Enums.FlowReturn
padPush :: a -> Buffer -> m FlowReturn
padPush a
pad Buffer
buffer = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
buffer
CInt
result <- Ptr Pad -> Ptr Buffer -> IO CInt
gst_pad_push Ptr Pad
pad' Ptr Buffer
buffer'
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadPushMethodInfo
instance (signature ~ (Gst.Buffer.Buffer -> m Gst.Enums.FlowReturn), MonadIO m, IsPad a) => O.MethodInfo PadPushMethodInfo a signature where
overloadedMethod = padPush
#endif
foreign import ccall "gst_pad_push_event" gst_pad_push_event ::
Ptr Pad ->
Ptr Gst.Event.Event ->
IO CInt
padPushEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Event.Event
-> m Bool
padPushEvent :: a -> Event -> m Bool
padPushEvent a
pad 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Event
event
CInt
result <- Ptr Pad -> Ptr Event -> IO CInt
gst_pad_push_event Ptr Pad
pad' Ptr Event
event'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
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 PadPushEventMethodInfo
instance (signature ~ (Gst.Event.Event -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadPushEventMethodInfo a signature where
overloadedMethod = padPushEvent
#endif
foreign import ccall "gst_pad_push_list" gst_pad_push_list ::
Ptr Pad ->
Ptr Gst.BufferList.BufferList ->
IO CInt
padPushList ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.BufferList.BufferList
-> m Gst.Enums.FlowReturn
padPushList :: a -> BufferList -> m FlowReturn
padPushList a
pad BufferList
list = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr BufferList
list' <- BufferList -> IO (Ptr BufferList)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed BufferList
list
CInt
result <- Ptr Pad -> Ptr BufferList -> IO CInt
gst_pad_push_list Ptr Pad
pad' Ptr BufferList
list'
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
BufferList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BufferList
list
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadPushListMethodInfo
instance (signature ~ (Gst.BufferList.BufferList -> m Gst.Enums.FlowReturn), MonadIO m, IsPad a) => O.MethodInfo PadPushListMethodInfo a signature where
overloadedMethod = padPushList
#endif
foreign import ccall "gst_pad_query" gst_pad_query ::
Ptr Pad ->
Ptr Gst.Query.Query ->
IO CInt
padQuery ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Query.Query
-> m Bool
padQuery :: a -> Query -> m Bool
padQuery a
pad 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
CInt
result <- Ptr Pad -> Ptr Query -> IO CInt
gst_pad_query Ptr Pad
pad' Ptr Query
query'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
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 PadQueryMethodInfo
instance (signature ~ (Gst.Query.Query -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadQueryMethodInfo a signature where
overloadedMethod = padQuery
#endif
foreign import ccall "gst_pad_query_accept_caps" gst_pad_query_accept_caps ::
Ptr Pad ->
Ptr Gst.Caps.Caps ->
IO CInt
padQueryAcceptCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Caps.Caps
-> m Bool
padQueryAcceptCaps :: a -> Caps -> m Bool
padQueryAcceptCaps a
pad Caps
caps = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
caps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
CInt
result <- Ptr Pad -> Ptr Caps -> IO CInt
gst_pad_query_accept_caps Ptr Pad
pad' Ptr Caps
caps'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadQueryAcceptCapsMethodInfo
instance (signature ~ (Gst.Caps.Caps -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadQueryAcceptCapsMethodInfo a signature where
overloadedMethod = padQueryAcceptCaps
#endif
foreign import ccall "gst_pad_query_caps" gst_pad_query_caps ::
Ptr Pad ->
Ptr Gst.Caps.Caps ->
IO (Ptr Gst.Caps.Caps)
padQueryCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Maybe (Gst.Caps.Caps)
-> m Gst.Caps.Caps
padQueryCaps :: a -> Maybe Caps -> m Caps
padQueryCaps a
pad Maybe Caps
filter = IO Caps -> m Caps
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Caps -> m Caps) -> IO Caps -> m Caps
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
maybeFilter <- case Maybe Caps
filter of
Maybe Caps
Nothing -> Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
forall a. Ptr a
nullPtr
Just 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'
Ptr Caps
result <- Ptr Pad -> Ptr Caps -> IO (Ptr Caps)
gst_pad_query_caps Ptr Pad
pad' Ptr Caps
maybeFilter
Text -> Ptr Caps -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"padQueryCaps" Ptr Caps
result
Caps
result' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
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
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result'
#if defined(ENABLE_OVERLOADING)
data PadQueryCapsMethodInfo
instance (signature ~ (Maybe (Gst.Caps.Caps) -> m Gst.Caps.Caps), MonadIO m, IsPad a) => O.MethodInfo PadQueryCapsMethodInfo a signature where
overloadedMethod = padQueryCaps
#endif
foreign import ccall "gst_pad_query_convert" gst_pad_query_convert ::
Ptr Pad ->
CUInt ->
Int64 ->
CUInt ->
Ptr Int64 ->
IO CInt
padQueryConvert ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.Format
-> Int64
-> Gst.Enums.Format
-> m ((Bool, Int64))
padQueryConvert :: a -> Format -> Int64 -> Format -> m (Bool, Int64)
padQueryConvert a
pad Format
srcFormat Int64
srcVal 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
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 Pad -> CUInt -> Int64 -> CUInt -> Ptr Int64 -> IO CInt
gst_pad_query_convert Ptr Pad
pad' CUInt
srcFormat' Int64
srcVal CUInt
destFormat' Ptr Int64
destVal
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
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
pad
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 PadQueryConvertMethodInfo
instance (signature ~ (Gst.Enums.Format -> Int64 -> Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsPad a) => O.MethodInfo PadQueryConvertMethodInfo a signature where
overloadedMethod = padQueryConvert
#endif
foreign import ccall "gst_pad_query_default" gst_pad_query_default ::
Ptr Pad ->
Ptr Gst.Object.Object ->
Ptr Gst.Query.Query ->
IO CInt
padQueryDefault ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, Gst.Object.IsObject b) =>
a
-> Maybe (b)
-> Gst.Query.Query
-> m Bool
padQueryDefault :: a -> Maybe b -> Query -> m Bool
padQueryDefault a
pad Maybe b
parent 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Object
maybeParent <- case Maybe b
parent of
Maybe b
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just b
jParent -> do
Ptr Object
jParent' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jParent
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jParent'
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
CInt
result <- Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt
gst_pad_query_default Ptr Pad
pad' Ptr Object
maybeParent Ptr Query
query'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
parent b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
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 PadQueryDefaultMethodInfo
instance (signature ~ (Maybe (b) -> Gst.Query.Query -> m Bool), MonadIO m, IsPad a, Gst.Object.IsObject b) => O.MethodInfo PadQueryDefaultMethodInfo a signature where
overloadedMethod = padQueryDefault
#endif
foreign import ccall "gst_pad_query_duration" gst_pad_query_duration ::
Ptr Pad ->
CUInt ->
Ptr Int64 ->
IO CInt
padQueryDuration ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.Format
-> m ((Bool, Int64))
padQueryDuration :: a -> Format -> m (Bool, Int64)
padQueryDuration a
pad 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
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 Pad -> CUInt -> Ptr Int64 -> IO CInt
gst_pad_query_duration Ptr Pad
pad' CUInt
format' Ptr Int64
duration
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
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
pad
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 PadQueryDurationMethodInfo
instance (signature ~ (Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsPad a) => O.MethodInfo PadQueryDurationMethodInfo a signature where
overloadedMethod = padQueryDuration
#endif
foreign import ccall "gst_pad_query_position" gst_pad_query_position ::
Ptr Pad ->
CUInt ->
Ptr Int64 ->
IO CInt
padQueryPosition ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.Format
-> m ((Bool, Int64))
padQueryPosition :: a -> Format -> m (Bool, Int64)
padQueryPosition a
pad 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
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 Pad -> CUInt -> Ptr Int64 -> IO CInt
gst_pad_query_position Ptr Pad
pad' CUInt
format' Ptr Int64
cur
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
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
pad
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 PadQueryPositionMethodInfo
instance (signature ~ (Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsPad a) => O.MethodInfo PadQueryPositionMethodInfo a signature where
overloadedMethod = padQueryPosition
#endif
foreign import ccall "gst_pad_remove_probe" gst_pad_remove_probe ::
Ptr Pad ->
CULong ->
IO ()
padRemoveProbe ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> CULong
-> m ()
padRemoveProbe :: a -> SignalHandlerId -> m ()
padRemoveProbe a
pad SignalHandlerId
id = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Pad -> SignalHandlerId -> IO ()
gst_pad_remove_probe Ptr Pad
pad' SignalHandlerId
id
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadRemoveProbeMethodInfo
instance (signature ~ (CULong -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadRemoveProbeMethodInfo a signature where
overloadedMethod = padRemoveProbe
#endif
foreign import ccall "gst_pad_send_event" gst_pad_send_event ::
Ptr Pad ->
Ptr Gst.Event.Event ->
IO CInt
padSendEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Event.Event
-> m Bool
padSendEvent :: a -> Event -> m Bool
padSendEvent a
pad 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Event
event
CInt
result <- Ptr Pad -> Ptr Event -> IO CInt
gst_pad_send_event Ptr Pad
pad' Ptr Event
event'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
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 PadSendEventMethodInfo
instance (signature ~ (Gst.Event.Event -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadSendEventMethodInfo a signature where
overloadedMethod = padSendEvent
#endif
foreign import ccall "gst_pad_set_activate_function_full" gst_pad_set_activate_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadActivateFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetActivateFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadActivateFunction
-> m ()
padSetActivateFunctionFull :: a -> PadActivateFunction -> m ()
padSetActivateFunctionFull a
pad PadActivateFunction
activate = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadActivateFunction
activate' <- C_PadActivateFunction -> IO (FunPtr C_PadActivateFunction)
Gst.Callbacks.mk_PadActivateFunction (Maybe (Ptr (FunPtr C_PadActivateFunction))
-> PadActivateFunction -> C_PadActivateFunction
Gst.Callbacks.wrap_PadActivateFunction Maybe (Ptr (FunPtr C_PadActivateFunction))
forall a. Maybe a
Nothing PadActivateFunction
activate)
let userData :: Ptr ()
userData = FunPtr C_PadActivateFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadActivateFunction
activate'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadActivateFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_activate_function_full Ptr Pad
pad' FunPtr C_PadActivateFunction
activate' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetActivateFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadActivateFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetActivateFunctionFullMethodInfo a signature where
overloadedMethod = padSetActivateFunctionFull
#endif
foreign import ccall "gst_pad_set_activatemode_function_full" gst_pad_set_activatemode_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadActivateModeFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetActivatemodeFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadActivateModeFunction
-> m ()
padSetActivatemodeFunctionFull :: a -> PadActivateModeFunction -> m ()
padSetActivatemodeFunctionFull a
pad PadActivateModeFunction
activatemode = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadActivateModeFunction
activatemode' <- C_PadActivateModeFunction -> IO (FunPtr C_PadActivateModeFunction)
Gst.Callbacks.mk_PadActivateModeFunction (Maybe (Ptr (FunPtr C_PadActivateModeFunction))
-> PadActivateModeFunction -> C_PadActivateModeFunction
Gst.Callbacks.wrap_PadActivateModeFunction Maybe (Ptr (FunPtr C_PadActivateModeFunction))
forall a. Maybe a
Nothing PadActivateModeFunction
activatemode)
let userData :: Ptr ()
userData = FunPtr C_PadActivateModeFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadActivateModeFunction
activatemode'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadActivateModeFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_activatemode_function_full Ptr Pad
pad' FunPtr C_PadActivateModeFunction
activatemode' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetActivatemodeFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadActivateModeFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetActivatemodeFunctionFullMethodInfo a signature where
overloadedMethod = padSetActivatemodeFunctionFull
#endif
foreign import ccall "gst_pad_set_active" gst_pad_set_active ::
Ptr Pad ->
CInt ->
IO CInt
padSetActive ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Bool
-> m Bool
padSetActive :: a -> Bool -> m Bool
padSetActive a
pad Bool
active = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let active' :: CInt
active' = (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
active
CInt
result <- Ptr Pad -> CInt -> IO CInt
gst_pad_set_active Ptr Pad
pad' CInt
active'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadSetActiveMethodInfo
instance (signature ~ (Bool -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadSetActiveMethodInfo a signature where
overloadedMethod = padSetActive
#endif
foreign import ccall "gst_pad_set_chain_function_full" gst_pad_set_chain_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadChainFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetChainFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadChainFunction
-> m ()
padSetChainFunctionFull :: a -> PadChainFunction -> m ()
padSetChainFunctionFull a
pad PadChainFunction
chain = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadChainFunction
chain' <- C_PadChainFunction -> IO (FunPtr C_PadChainFunction)
Gst.Callbacks.mk_PadChainFunction (Maybe (Ptr (FunPtr C_PadChainFunction))
-> PadChainFunction -> C_PadChainFunction
Gst.Callbacks.wrap_PadChainFunction Maybe (Ptr (FunPtr C_PadChainFunction))
forall a. Maybe a
Nothing PadChainFunction
chain)
let userData :: Ptr ()
userData = FunPtr C_PadChainFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadChainFunction
chain'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadChainFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_chain_function_full Ptr Pad
pad' FunPtr C_PadChainFunction
chain' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetChainFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadChainFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetChainFunctionFullMethodInfo a signature where
overloadedMethod = padSetChainFunctionFull
#endif
foreign import ccall "gst_pad_set_chain_list_function_full" gst_pad_set_chain_list_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadChainListFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetChainListFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadChainListFunction
-> m ()
padSetChainListFunctionFull :: a -> PadChainListFunction -> m ()
padSetChainListFunctionFull a
pad PadChainListFunction
chainlist = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadChainListFunction
chainlist' <- C_PadChainListFunction -> IO (FunPtr C_PadChainListFunction)
Gst.Callbacks.mk_PadChainListFunction (Maybe (Ptr (FunPtr C_PadChainListFunction))
-> PadChainListFunction -> C_PadChainListFunction
Gst.Callbacks.wrap_PadChainListFunction Maybe (Ptr (FunPtr C_PadChainListFunction))
forall a. Maybe a
Nothing PadChainListFunction
chainlist)
let userData :: Ptr ()
userData = FunPtr C_PadChainListFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadChainListFunction
chainlist'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadChainListFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_chain_list_function_full Ptr Pad
pad' FunPtr C_PadChainListFunction
chainlist' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetChainListFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadChainListFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetChainListFunctionFullMethodInfo a signature where
overloadedMethod = padSetChainListFunctionFull
#endif
foreign import ccall "gst_pad_set_element_private" gst_pad_set_element_private ::
Ptr Pad ->
Ptr () ->
IO ()
padSetElementPrivate ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Ptr ()
-> m ()
padSetElementPrivate :: a -> Ptr () -> m ()
padSetElementPrivate a
pad Ptr ()
priv = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Pad -> C_DestroyNotify
gst_pad_set_element_private Ptr Pad
pad' Ptr ()
priv
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetElementPrivateMethodInfo
instance (signature ~ (Ptr () -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetElementPrivateMethodInfo a signature where
overloadedMethod = padSetElementPrivate
#endif
foreign import ccall "gst_pad_set_event_full_function_full" gst_pad_set_event_full_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadEventFullFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetEventFullFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadEventFullFunction
-> m ()
padSetEventFullFunctionFull :: a -> PadEventFullFunction -> m ()
padSetEventFullFunctionFull a
pad PadEventFullFunction
event = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
event' <- (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
-> IO (FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt))
Gst.Callbacks.mk_PadEventFullFunction (Maybe
(Ptr (FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)))
-> PadEventFullFunction
-> Ptr Pad
-> Ptr Object
-> Ptr Event
-> IO CInt
Gst.Callbacks.wrap_PadEventFullFunction Maybe
(Ptr (FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)))
forall a. Maybe a
Nothing PadEventFullFunction
event)
let userData :: Ptr ()
userData = FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
event'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Pad
-> FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_event_full_function_full Ptr Pad
pad' FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
event' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetEventFullFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadEventFullFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetEventFullFunctionFullMethodInfo a signature where
overloadedMethod = padSetEventFullFunctionFull
#endif
foreign import ccall "gst_pad_set_event_function_full" gst_pad_set_event_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadEventFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetEventFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadEventFunction
-> m ()
padSetEventFunctionFull :: a -> PadEventFunction -> m ()
padSetEventFunctionFull a
pad PadEventFunction
event = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
event' <- (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
-> IO (FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt))
Gst.Callbacks.mk_PadEventFunction (Maybe
(Ptr (FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)))
-> PadEventFunction
-> Ptr Pad
-> Ptr Object
-> Ptr Event
-> IO CInt
Gst.Callbacks.wrap_PadEventFunction Maybe
(Ptr (FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)))
forall a. Maybe a
Nothing PadEventFunction
event)
let userData :: Ptr ()
userData = FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
event'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Pad
-> FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_event_function_full Ptr Pad
pad' FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
event' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetEventFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadEventFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetEventFunctionFullMethodInfo a signature where
overloadedMethod = padSetEventFunctionFull
#endif
foreign import ccall "gst_pad_set_getrange_function_full" gst_pad_set_getrange_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadGetRangeFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetGetrangeFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadGetRangeFunction
-> m ()
padSetGetrangeFunctionFull :: a -> PadGetRangeFunction -> m ()
padSetGetrangeFunctionFull a
pad PadGetRangeFunction
get = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadGetRangeFunction
get' <- C_PadGetRangeFunction -> IO (FunPtr C_PadGetRangeFunction)
Gst.Callbacks.mk_PadGetRangeFunction (Maybe (Ptr (FunPtr C_PadGetRangeFunction))
-> PadGetRangeFunction -> C_PadGetRangeFunction
Gst.Callbacks.wrap_PadGetRangeFunction Maybe (Ptr (FunPtr C_PadGetRangeFunction))
forall a. Maybe a
Nothing PadGetRangeFunction
get)
let userData :: Ptr ()
userData = FunPtr C_PadGetRangeFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadGetRangeFunction
get'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadGetRangeFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_getrange_function_full Ptr Pad
pad' FunPtr C_PadGetRangeFunction
get' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetGetrangeFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadGetRangeFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetGetrangeFunctionFullMethodInfo a signature where
overloadedMethod = padSetGetrangeFunctionFull
#endif
foreign import ccall "gst_pad_set_iterate_internal_links_function_full" gst_pad_set_iterate_internal_links_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadIterIntLinkFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetIterateInternalLinksFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadIterIntLinkFunction
-> m ()
padSetIterateInternalLinksFunctionFull :: a -> PadIterIntLinkFunction -> m ()
padSetIterateInternalLinksFunctionFull a
pad PadIterIntLinkFunction
iterintlink = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))
iterintlink' <- (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))
-> IO (FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator)))
Gst.Callbacks.mk_PadIterIntLinkFunction (Maybe (Ptr (FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))))
-> PadIterIntLinkFunction
-> Ptr Pad
-> Ptr Object
-> IO (Ptr Iterator)
Gst.Callbacks.wrap_PadIterIntLinkFunction Maybe (Ptr (FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))))
forall a. Maybe a
Nothing PadIterIntLinkFunction
iterintlink)
let userData :: Ptr ()
userData = FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator)) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))
iterintlink'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Pad
-> FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_iterate_internal_links_function_full Ptr Pad
pad' FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))
iterintlink' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetIterateInternalLinksFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadIterIntLinkFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetIterateInternalLinksFunctionFullMethodInfo a signature where
overloadedMethod = padSetIterateInternalLinksFunctionFull
#endif
foreign import ccall "gst_pad_set_link_function_full" gst_pad_set_link_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadLinkFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetLinkFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadLinkFunction
-> m ()
padSetLinkFunctionFull :: a -> PadLinkFunction -> m ()
padSetLinkFunctionFull a
pad PadLinkFunction
link = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadLinkFunction
link' <- C_PadLinkFunction -> IO (FunPtr C_PadLinkFunction)
Gst.Callbacks.mk_PadLinkFunction (Maybe (Ptr (FunPtr C_PadLinkFunction))
-> PadLinkFunction -> C_PadLinkFunction
Gst.Callbacks.wrap_PadLinkFunction Maybe (Ptr (FunPtr C_PadLinkFunction))
forall a. Maybe a
Nothing PadLinkFunction
link)
let userData :: Ptr ()
userData = FunPtr C_PadLinkFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadLinkFunction
link'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadLinkFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_link_function_full Ptr Pad
pad' FunPtr C_PadLinkFunction
link' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetLinkFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadLinkFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetLinkFunctionFullMethodInfo a signature where
overloadedMethod = padSetLinkFunctionFull
#endif
foreign import ccall "gst_pad_set_offset" gst_pad_set_offset ::
Ptr Pad ->
Int64 ->
IO ()
padSetOffset ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Int64
-> m ()
padSetOffset :: a -> Int64 -> m ()
padSetOffset a
pad Int64
offset = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Pad -> Int64 -> IO ()
gst_pad_set_offset Ptr Pad
pad' Int64
offset
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetOffsetMethodInfo
instance (signature ~ (Int64 -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetOffsetMethodInfo a signature where
overloadedMethod = padSetOffset
#endif
foreign import ccall "gst_pad_set_query_function_full" gst_pad_set_query_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadQueryFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetQueryFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadQueryFunction
-> m ()
padSetQueryFunctionFull :: a -> PadQueryFunction -> m ()
padSetQueryFunctionFull a
pad PadQueryFunction
query = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)
query' <- (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)
-> IO (FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt))
Gst.Callbacks.mk_PadQueryFunction (Maybe
(Ptr (FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)))
-> PadQueryFunction
-> Ptr Pad
-> Ptr Object
-> Ptr Query
-> IO CInt
Gst.Callbacks.wrap_PadQueryFunction Maybe
(Ptr (FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)))
forall a. Maybe a
Nothing PadQueryFunction
query)
let userData :: Ptr ()
userData = FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)
query'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Pad
-> FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_query_function_full Ptr Pad
pad' FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)
query' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetQueryFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadQueryFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetQueryFunctionFullMethodInfo a signature where
overloadedMethod = padSetQueryFunctionFull
#endif
foreign import ccall "gst_pad_set_unlink_function_full" gst_pad_set_unlink_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadUnlinkFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetUnlinkFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadUnlinkFunction
-> m ()
padSetUnlinkFunctionFull :: a -> PadUnlinkFunction -> m ()
padSetUnlinkFunctionFull a
pad PadUnlinkFunction
unlink = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadUnlinkFunction
unlink' <- C_PadUnlinkFunction -> IO (FunPtr C_PadUnlinkFunction)
Gst.Callbacks.mk_PadUnlinkFunction (Maybe (Ptr (FunPtr C_PadUnlinkFunction))
-> PadUnlinkFunction -> C_PadUnlinkFunction
Gst.Callbacks.wrap_PadUnlinkFunction Maybe (Ptr (FunPtr C_PadUnlinkFunction))
forall a. Maybe a
Nothing PadUnlinkFunction
unlink)
let userData :: Ptr ()
userData = FunPtr C_PadUnlinkFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadUnlinkFunction
unlink'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadUnlinkFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_unlink_function_full Ptr Pad
pad' FunPtr C_PadUnlinkFunction
unlink' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetUnlinkFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadUnlinkFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetUnlinkFunctionFullMethodInfo a signature where
overloadedMethod = padSetUnlinkFunctionFull
#endif
foreign import ccall "gst_pad_start_task" gst_pad_start_task ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_TaskFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO CInt
padStartTask ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.TaskFunction
-> m Bool
padStartTask :: a -> IO () -> m Bool
padStartTask a
pad IO ()
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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_DestroyNotify
func' <- C_DestroyNotify -> IO (FunPtr C_DestroyNotify)
Gst.Callbacks.mk_TaskFunction (Maybe (Ptr (FunPtr C_DestroyNotify))
-> C_DestroyNotify -> C_DestroyNotify
Gst.Callbacks.wrap_TaskFunction Maybe (Ptr (FunPtr C_DestroyNotify))
forall a. Maybe a
Nothing (IO () -> C_DestroyNotify
Gst.Callbacks.drop_closures_TaskFunction IO ()
func))
let userData :: Ptr ()
userData = FunPtr C_DestroyNotify -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_DestroyNotify
func'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
CInt
result <- Ptr Pad
-> FunPtr C_DestroyNotify
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO CInt
gst_pad_start_task Ptr Pad
pad' FunPtr C_DestroyNotify
func' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadStartTaskMethodInfo
instance (signature ~ (Gst.Callbacks.TaskFunction -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadStartTaskMethodInfo a signature where
overloadedMethod = padStartTask
#endif
foreign import ccall "gst_pad_sticky_events_foreach" gst_pad_sticky_events_foreach ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadStickyEventsForeachFunction ->
Ptr () ->
IO ()
padStickyEventsForeach ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadStickyEventsForeachFunction
-> m ()
padStickyEventsForeach :: a -> PadStickyEventsForeachFunction -> m ()
padStickyEventsForeach a
pad PadStickyEventsForeachFunction
foreachFunc = 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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadStickyEventsForeachFunction
foreachFunc' <- C_PadStickyEventsForeachFunction
-> IO (FunPtr C_PadStickyEventsForeachFunction)
Gst.Callbacks.mk_PadStickyEventsForeachFunction (Maybe (Ptr (FunPtr C_PadStickyEventsForeachFunction))
-> PadStickyEventsForeachFunction_WithClosures
-> C_PadStickyEventsForeachFunction
Gst.Callbacks.wrap_PadStickyEventsForeachFunction Maybe (Ptr (FunPtr C_PadStickyEventsForeachFunction))
forall a. Maybe a
Nothing (PadStickyEventsForeachFunction
-> PadStickyEventsForeachFunction_WithClosures
Gst.Callbacks.drop_closures_PadStickyEventsForeachFunction PadStickyEventsForeachFunction
foreachFunc))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
Ptr Pad
-> FunPtr C_PadStickyEventsForeachFunction -> C_DestroyNotify
gst_pad_sticky_events_foreach Ptr Pad
pad' FunPtr C_PadStickyEventsForeachFunction
foreachFunc' Ptr ()
forall a. Ptr a
userData
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_PadStickyEventsForeachFunction -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadStickyEventsForeachFunction
foreachFunc'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadStickyEventsForeachMethodInfo
instance (signature ~ (Gst.Callbacks.PadStickyEventsForeachFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadStickyEventsForeachMethodInfo a signature where
overloadedMethod = padStickyEventsForeach
#endif
foreign import ccall "gst_pad_stop_task" gst_pad_stop_task ::
Ptr Pad ->
IO CInt
padStopTask ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padStopTask :: a -> m Bool
padStopTask a
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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_stop_task Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadStopTaskMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadStopTaskMethodInfo a signature where
overloadedMethod = padStopTask
#endif
foreign import ccall "gst_pad_store_sticky_event" gst_pad_store_sticky_event ::
Ptr Pad ->
Ptr Gst.Event.Event ->
IO CInt
padStoreStickyEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Event.Event
-> m Gst.Enums.FlowReturn
padStoreStickyEvent :: a -> Event -> m FlowReturn
padStoreStickyEvent a
pad Event
event = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CInt
result <- Ptr Pad -> Ptr Event -> IO CInt
gst_pad_store_sticky_event Ptr Pad
pad' Ptr Event
event'
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadStoreStickyEventMethodInfo
instance (signature ~ (Gst.Event.Event -> m Gst.Enums.FlowReturn), MonadIO m, IsPad a) => O.MethodInfo PadStoreStickyEventMethodInfo a signature where
overloadedMethod = padStoreStickyEvent
#endif
foreign import ccall "gst_pad_unlink" gst_pad_unlink ::
Ptr Pad ->
Ptr Pad ->
IO CInt
padUnlink ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a
-> b
-> m Bool
padUnlink :: a -> b -> m Bool
padUnlink a
srcpad b
sinkpad = 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 Pad
srcpad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
srcpad
Ptr Pad
sinkpad' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sinkpad
CInt
result <- Ptr Pad -> Ptr Pad -> IO CInt
gst_pad_unlink Ptr Pad
srcpad' Ptr Pad
sinkpad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
srcpad
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sinkpad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadUnlinkMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsPad a, IsPad b) => O.MethodInfo PadUnlinkMethodInfo a signature where
overloadedMethod = padUnlink
#endif
foreign import ccall "gst_pad_use_fixed_caps" gst_pad_use_fixed_caps ::
Ptr Pad ->
IO ()
padUseFixedCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m ()
padUseFixedCaps :: a -> m ()
padUseFixedCaps a
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 Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Pad -> IO ()
gst_pad_use_fixed_caps Ptr Pad
pad'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadUseFixedCapsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsPad a) => O.MethodInfo PadUseFixedCapsMethodInfo a signature where
overloadedMethod = padUseFixedCaps
#endif
foreign import ccall "gst_pad_link_get_name" gst_pad_link_get_name ::
CInt ->
IO CString
padLinkGetName ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.PadLinkReturn
-> m T.Text
padLinkGetName :: PadLinkReturn -> m Text
padLinkGetName PadLinkReturn
ret = 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 ret' :: CInt
ret' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (PadLinkReturn -> Int) -> PadLinkReturn -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PadLinkReturn -> Int
forall a. Enum a => a -> Int
fromEnum) PadLinkReturn
ret
Ptr CChar
result <- CInt -> IO (Ptr CChar)
gst_pad_link_get_name CInt
ret'
Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"padLinkGetName" 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