{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) A 'GI.Gst.Objects.Element.Element' is linked to other elements via \"pads\", which are extremely light-weight generic link points. Pads have a 'GI.Gst.Enums.PadDirection', source pads produce data, sink pads consume data. Pads are typically created from a 'GI.Gst.Objects.PadTemplate.PadTemplate' with 'GI.Gst.Objects.Pad.padNewFromTemplate' and are then added to a 'GI.Gst.Objects.Element.Element'. This usually happens when the element is created but it can also happen dynamically based on the data that the element is processing or based on the pads that the application requests. Pads without pad templates can be created with 'GI.Gst.Objects.Pad.padNew', which takes a direction and a name as an argument. If the name is 'Nothing', then a guaranteed unique name will be assigned to it. A 'GI.Gst.Objects.Element.Element' creating a pad will typically use the various gst_pad_set_*@/_function()/@ calls to register callbacks for events, queries or dataflow on the pads. @/gst_pad_get_parent()/@ will retrieve the 'GI.Gst.Objects.Element.Element' that owns the pad. After two pads are retrieved from an element by 'GI.Gst.Objects.Element.elementGetStaticPad', the pads can be linked with 'GI.Gst.Objects.Pad.padLink'. (For quick links, you can also use 'GI.Gst.Objects.Element.elementLink', which will make the obvious link for you if it\'s straightforward.). Pads can be unlinked again with 'GI.Gst.Objects.Pad.padUnlink'. 'GI.Gst.Objects.Pad.padGetPeer' can be used to check what the pad is linked to. Before dataflow is possible on the pads, they need to be activated with 'GI.Gst.Objects.Pad.padSetActive'. 'GI.Gst.Objects.Pad.padQuery' and 'GI.Gst.Objects.Pad.padPeerQuery' can be used to query various properties of the pad and the stream. To send a 'GI.Gst.Structs.Event.Event' on a pad, use 'GI.Gst.Objects.Pad.padSendEvent' and 'GI.Gst.Objects.Pad.padPushEvent'. Some events will be sticky on the pad, meaning that after they pass on the pad they can be queried later with 'GI.Gst.Objects.Pad.padGetStickyEvent' and 'GI.Gst.Objects.Pad.padStickyEventsForeach'. 'GI.Gst.Objects.Pad.padGetCurrentCaps' and 'GI.Gst.Objects.Pad.padHasCurrentCaps' are convenience functions to query the current sticky CAPS event on a pad. GstElements will use 'GI.Gst.Objects.Pad.padPush' and 'GI.Gst.Objects.Pad.padPullRange' to push out or pull in a buffer. The dataflow, events and queries that happen on a pad can be monitored with probes that can be installed with 'GI.Gst.Objects.Pad.padAddProbe'. 'GI.Gst.Objects.Pad.padIsBlocked' can be used to check if a block probe is installed on the pad. 'GI.Gst.Objects.Pad.padIsBlocking' checks if the blocking probe is currently blocking the pad. 'GI.Gst.Objects.Pad.padRemoveProbe' is used to remove a previously installed probe and unblock blocking probes if any. Pad have an offset that can be retrieved with 'GI.Gst.Objects.Pad.padGetOffset'. This offset will be applied to the running_time of all data passing over the pad. 'GI.Gst.Objects.Pad.padSetOffset' can be used to change the offset. Convenience functions exist to start, pause and stop the task on a pad with 'GI.Gst.Objects.Pad.padStartTask', 'GI.Gst.Objects.Pad.padPauseTask' and 'GI.Gst.Objects.Pad.padStopTask' respectively. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gst.Objects.Pad ( -- * Exported types Pad(..) , IsPad , toPad , noPad , -- * Methods -- ** activateMode #method:activateMode# #if ENABLE_OVERLOADING PadActivateModeMethodInfo , #endif padActivateMode , -- ** addProbe #method:addProbe# #if ENABLE_OVERLOADING PadAddProbeMethodInfo , #endif padAddProbe , -- ** canLink #method:canLink# #if ENABLE_OVERLOADING PadCanLinkMethodInfo , #endif padCanLink , -- ** chain #method:chain# #if ENABLE_OVERLOADING PadChainMethodInfo , #endif padChain , -- ** chainList #method:chainList# #if ENABLE_OVERLOADING PadChainListMethodInfo , #endif padChainList , -- ** checkReconfigure #method:checkReconfigure# #if ENABLE_OVERLOADING PadCheckReconfigureMethodInfo , #endif padCheckReconfigure , -- ** createStreamId #method:createStreamId# #if ENABLE_OVERLOADING PadCreateStreamIdMethodInfo , #endif padCreateStreamId , -- ** eventDefault #method:eventDefault# #if ENABLE_OVERLOADING PadEventDefaultMethodInfo , #endif padEventDefault , -- ** forward #method:forward# #if ENABLE_OVERLOADING PadForwardMethodInfo , #endif padForward , -- ** getAllowedCaps #method:getAllowedCaps# #if ENABLE_OVERLOADING PadGetAllowedCapsMethodInfo , #endif padGetAllowedCaps , -- ** getCurrentCaps #method:getCurrentCaps# #if ENABLE_OVERLOADING PadGetCurrentCapsMethodInfo , #endif padGetCurrentCaps , -- ** getDirection #method:getDirection# #if ENABLE_OVERLOADING PadGetDirectionMethodInfo , #endif padGetDirection , -- ** getElementPrivate #method:getElementPrivate# #if ENABLE_OVERLOADING PadGetElementPrivateMethodInfo , #endif padGetElementPrivate , -- ** getLastFlowReturn #method:getLastFlowReturn# #if ENABLE_OVERLOADING PadGetLastFlowReturnMethodInfo , #endif padGetLastFlowReturn , -- ** getOffset #method:getOffset# #if ENABLE_OVERLOADING PadGetOffsetMethodInfo , #endif padGetOffset , -- ** getPadTemplate #method:getPadTemplate# #if ENABLE_OVERLOADING PadGetPadTemplateMethodInfo , #endif padGetPadTemplate , -- ** getPadTemplateCaps #method:getPadTemplateCaps# #if ENABLE_OVERLOADING PadGetPadTemplateCapsMethodInfo , #endif padGetPadTemplateCaps , -- ** getParentElement #method:getParentElement# #if ENABLE_OVERLOADING PadGetParentElementMethodInfo , #endif padGetParentElement , -- ** getPeer #method:getPeer# #if ENABLE_OVERLOADING PadGetPeerMethodInfo , #endif padGetPeer , -- ** getRange #method:getRange# #if ENABLE_OVERLOADING PadGetRangeMethodInfo , #endif padGetRange , -- ** getStickyEvent #method:getStickyEvent# #if ENABLE_OVERLOADING PadGetStickyEventMethodInfo , #endif padGetStickyEvent , -- ** getStream #method:getStream# #if ENABLE_OVERLOADING PadGetStreamMethodInfo , #endif padGetStream , -- ** getStreamId #method:getStreamId# #if ENABLE_OVERLOADING PadGetStreamIdMethodInfo , #endif padGetStreamId , -- ** getTaskState #method:getTaskState# #if ENABLE_OVERLOADING PadGetTaskStateMethodInfo , #endif padGetTaskState , -- ** hasCurrentCaps #method:hasCurrentCaps# #if ENABLE_OVERLOADING PadHasCurrentCapsMethodInfo , #endif padHasCurrentCaps , -- ** isActive #method:isActive# #if ENABLE_OVERLOADING PadIsActiveMethodInfo , #endif padIsActive , -- ** isBlocked #method:isBlocked# #if ENABLE_OVERLOADING PadIsBlockedMethodInfo , #endif padIsBlocked , -- ** isBlocking #method:isBlocking# #if ENABLE_OVERLOADING PadIsBlockingMethodInfo , #endif padIsBlocking , -- ** isLinked #method:isLinked# #if ENABLE_OVERLOADING PadIsLinkedMethodInfo , #endif padIsLinked , -- ** iterateInternalLinks #method:iterateInternalLinks# #if ENABLE_OVERLOADING PadIterateInternalLinksMethodInfo , #endif padIterateInternalLinks , -- ** iterateInternalLinksDefault #method:iterateInternalLinksDefault# #if ENABLE_OVERLOADING PadIterateInternalLinksDefaultMethodInfo, #endif padIterateInternalLinksDefault , -- ** link #method:link# #if ENABLE_OVERLOADING PadLinkMethodInfo , #endif padLink , -- ** linkFull #method:linkFull# #if ENABLE_OVERLOADING PadLinkFullMethodInfo , #endif padLinkFull , -- ** linkGetName #method:linkGetName# padLinkGetName , -- ** linkMaybeGhosting #method:linkMaybeGhosting# #if ENABLE_OVERLOADING PadLinkMaybeGhostingMethodInfo , #endif padLinkMaybeGhosting , -- ** linkMaybeGhostingFull #method:linkMaybeGhostingFull# #if ENABLE_OVERLOADING PadLinkMaybeGhostingFullMethodInfo , #endif padLinkMaybeGhostingFull , -- ** markReconfigure #method:markReconfigure# #if ENABLE_OVERLOADING PadMarkReconfigureMethodInfo , #endif padMarkReconfigure , -- ** needsReconfigure #method:needsReconfigure# #if ENABLE_OVERLOADING PadNeedsReconfigureMethodInfo , #endif padNeedsReconfigure , -- ** new #method:new# padNew , -- ** newFromStaticTemplate #method:newFromStaticTemplate# padNewFromStaticTemplate , -- ** newFromTemplate #method:newFromTemplate# padNewFromTemplate , -- ** pauseTask #method:pauseTask# #if ENABLE_OVERLOADING PadPauseTaskMethodInfo , #endif padPauseTask , -- ** peerQuery #method:peerQuery# #if ENABLE_OVERLOADING PadPeerQueryMethodInfo , #endif padPeerQuery , -- ** peerQueryAcceptCaps #method:peerQueryAcceptCaps# #if ENABLE_OVERLOADING PadPeerQueryAcceptCapsMethodInfo , #endif padPeerQueryAcceptCaps , -- ** peerQueryCaps #method:peerQueryCaps# #if ENABLE_OVERLOADING PadPeerQueryCapsMethodInfo , #endif padPeerQueryCaps , -- ** peerQueryConvert #method:peerQueryConvert# #if ENABLE_OVERLOADING PadPeerQueryConvertMethodInfo , #endif padPeerQueryConvert , -- ** peerQueryDuration #method:peerQueryDuration# #if ENABLE_OVERLOADING PadPeerQueryDurationMethodInfo , #endif padPeerQueryDuration , -- ** peerQueryPosition #method:peerQueryPosition# #if ENABLE_OVERLOADING PadPeerQueryPositionMethodInfo , #endif padPeerQueryPosition , -- ** proxyQueryAcceptCaps #method:proxyQueryAcceptCaps# #if ENABLE_OVERLOADING PadProxyQueryAcceptCapsMethodInfo , #endif padProxyQueryAcceptCaps , -- ** proxyQueryCaps #method:proxyQueryCaps# #if ENABLE_OVERLOADING PadProxyQueryCapsMethodInfo , #endif padProxyQueryCaps , -- ** pullRange #method:pullRange# #if ENABLE_OVERLOADING PadPullRangeMethodInfo , #endif padPullRange , -- ** push #method:push# #if ENABLE_OVERLOADING PadPushMethodInfo , #endif padPush , -- ** pushEvent #method:pushEvent# #if ENABLE_OVERLOADING PadPushEventMethodInfo , #endif padPushEvent , -- ** pushList #method:pushList# #if ENABLE_OVERLOADING PadPushListMethodInfo , #endif padPushList , -- ** query #method:query# #if ENABLE_OVERLOADING PadQueryMethodInfo , #endif padQuery , -- ** queryAcceptCaps #method:queryAcceptCaps# #if ENABLE_OVERLOADING PadQueryAcceptCapsMethodInfo , #endif padQueryAcceptCaps , -- ** queryCaps #method:queryCaps# #if ENABLE_OVERLOADING PadQueryCapsMethodInfo , #endif padQueryCaps , -- ** queryConvert #method:queryConvert# #if ENABLE_OVERLOADING PadQueryConvertMethodInfo , #endif padQueryConvert , -- ** queryDefault #method:queryDefault# #if ENABLE_OVERLOADING PadQueryDefaultMethodInfo , #endif padQueryDefault , -- ** queryDuration #method:queryDuration# #if ENABLE_OVERLOADING PadQueryDurationMethodInfo , #endif padQueryDuration , -- ** queryPosition #method:queryPosition# #if ENABLE_OVERLOADING PadQueryPositionMethodInfo , #endif padQueryPosition , -- ** removeProbe #method:removeProbe# #if ENABLE_OVERLOADING PadRemoveProbeMethodInfo , #endif padRemoveProbe , -- ** sendEvent #method:sendEvent# #if ENABLE_OVERLOADING PadSendEventMethodInfo , #endif padSendEvent , -- ** setActivateFunctionFull #method:setActivateFunctionFull# #if ENABLE_OVERLOADING PadSetActivateFunctionFullMethodInfo , #endif padSetActivateFunctionFull , -- ** setActivatemodeFunctionFull #method:setActivatemodeFunctionFull# #if ENABLE_OVERLOADING PadSetActivatemodeFunctionFullMethodInfo, #endif padSetActivatemodeFunctionFull , -- ** setActive #method:setActive# #if ENABLE_OVERLOADING PadSetActiveMethodInfo , #endif padSetActive , -- ** setChainFunctionFull #method:setChainFunctionFull# #if ENABLE_OVERLOADING PadSetChainFunctionFullMethodInfo , #endif padSetChainFunctionFull , -- ** setChainListFunctionFull #method:setChainListFunctionFull# #if ENABLE_OVERLOADING PadSetChainListFunctionFullMethodInfo , #endif padSetChainListFunctionFull , -- ** setElementPrivate #method:setElementPrivate# #if ENABLE_OVERLOADING PadSetElementPrivateMethodInfo , #endif padSetElementPrivate , -- ** setEventFullFunctionFull #method:setEventFullFunctionFull# #if ENABLE_OVERLOADING PadSetEventFullFunctionFullMethodInfo , #endif padSetEventFullFunctionFull , -- ** setEventFunctionFull #method:setEventFunctionFull# #if ENABLE_OVERLOADING PadSetEventFunctionFullMethodInfo , #endif padSetEventFunctionFull , -- ** setGetrangeFunctionFull #method:setGetrangeFunctionFull# #if ENABLE_OVERLOADING PadSetGetrangeFunctionFullMethodInfo , #endif padSetGetrangeFunctionFull , -- ** setIterateInternalLinksFunctionFull #method:setIterateInternalLinksFunctionFull# #if ENABLE_OVERLOADING PadSetIterateInternalLinksFunctionFullMethodInfo, #endif padSetIterateInternalLinksFunctionFull , -- ** setLinkFunctionFull #method:setLinkFunctionFull# #if ENABLE_OVERLOADING PadSetLinkFunctionFullMethodInfo , #endif padSetLinkFunctionFull , -- ** setOffset #method:setOffset# #if ENABLE_OVERLOADING PadSetOffsetMethodInfo , #endif padSetOffset , -- ** setQueryFunctionFull #method:setQueryFunctionFull# #if ENABLE_OVERLOADING PadSetQueryFunctionFullMethodInfo , #endif padSetQueryFunctionFull , -- ** setUnlinkFunctionFull #method:setUnlinkFunctionFull# #if ENABLE_OVERLOADING PadSetUnlinkFunctionFullMethodInfo , #endif padSetUnlinkFunctionFull , -- ** startTask #method:startTask# #if ENABLE_OVERLOADING PadStartTaskMethodInfo , #endif padStartTask , -- ** stickyEventsForeach #method:stickyEventsForeach# #if ENABLE_OVERLOADING PadStickyEventsForeachMethodInfo , #endif padStickyEventsForeach , -- ** stopTask #method:stopTask# #if ENABLE_OVERLOADING PadStopTaskMethodInfo , #endif padStopTask , -- ** storeStickyEvent #method:storeStickyEvent# #if ENABLE_OVERLOADING PadStoreStickyEventMethodInfo , #endif padStoreStickyEvent , -- ** unlink #method:unlink# #if ENABLE_OVERLOADING PadUnlinkMethodInfo , #endif padUnlink , -- ** useFixedCaps #method:useFixedCaps# #if ENABLE_OVERLOADING PadUseFixedCapsMethodInfo , #endif padUseFixedCaps , -- * Properties -- ** caps #attr:caps# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING PadCapsPropertyInfo , #endif getPadCaps , #if ENABLE_OVERLOADING padCaps , #endif -- ** direction #attr:direction# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING PadDirectionPropertyInfo , #endif constructPadDirection , getPadDirection , #if ENABLE_OVERLOADING padDirection , #endif -- ** offset #attr:offset# {- | The offset that will be applied to the running time of the pad. /Since: 1.6/ -} #if ENABLE_OVERLOADING PadOffsetPropertyInfo , #endif constructPadOffset , getPadOffset , #if ENABLE_OVERLOADING padOffset , #endif setPadOffset , -- ** template #attr:template# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING PadTemplatePropertyInfo , #endif clearPadTemplate , constructPadTemplate , getPadTemplate , #if ENABLE_OVERLOADING padTemplate , #endif setPadTemplate , -- * Signals -- ** linked #signal:linked# C_PadLinkedCallback , PadLinkedCallback , #if ENABLE_OVERLOADING PadLinkedSignalInfo , #endif afterPadLinked , genClosure_PadLinked , mk_PadLinkedCallback , noPadLinkedCallback , onPadLinked , wrap_PadLinkedCallback , -- ** unlinked #signal:unlinked# C_PadUnlinkedCallback , PadUnlinkedCallback , #if 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.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.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 -- | Memory-managed wrapper type. newtype Pad = Pad (ManagedPtr Pad) foreign import ccall "gst_pad_get_type" c_gst_pad_get_type :: IO GType instance GObject Pad where gobjectType = c_gst_pad_get_type -- | Type class for types which can be safely cast to `Pad`, for instance with `toPad`. class (GObject o, O.IsDescendantOf Pad o) => IsPad o instance (GObject o, O.IsDescendantOf Pad o) => IsPad o instance O.HasParentTypes Pad type instance O.ParentTypes Pad = '[Gst.Object.Object, GObject.Object.Object] -- | Cast to `Pad`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toPad :: (MonadIO m, IsPad o) => o -> m Pad toPad = liftIO . unsafeCastTo Pad -- | A convenience alias for `Nothing` :: `Maybe` `Pad`. noPad :: Maybe Pad noPad = Nothing #if 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 "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 (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- signal Pad::linked {- | Signals that a pad has been linked to the peer pad. -} type PadLinkedCallback = Pad {- ^ /@peer@/: the peer pad that has been connected -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `PadLinkedCallback`@. noPadLinkedCallback :: Maybe PadLinkedCallback noPadLinkedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_PadLinkedCallback = Ptr () -> -- object Ptr Pad -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_PadLinkedCallback`. foreign import ccall "wrapper" mk_PadLinkedCallback :: C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback) -- | Wrap the callback into a `GClosure`. genClosure_PadLinked :: MonadIO m => PadLinkedCallback -> m (GClosure C_PadLinkedCallback) genClosure_PadLinked cb = liftIO $ do let cb' = wrap_PadLinkedCallback cb mk_PadLinkedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `PadLinkedCallback` into a `C_PadLinkedCallback`. wrap_PadLinkedCallback :: PadLinkedCallback -> C_PadLinkedCallback wrap_PadLinkedCallback _cb _ peer _ = do peer' <- (newObject Pad) peer _cb peer' {- | Connect a signal handler for the “@linked@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' pad #linked callback @ -} onPadLinked :: (IsPad a, MonadIO m) => a -> PadLinkedCallback -> m SignalHandlerId onPadLinked obj cb = liftIO $ do let cb' = wrap_PadLinkedCallback cb cb'' <- mk_PadLinkedCallback cb' connectSignalFunPtr obj "linked" cb'' SignalConnectBefore {- | Connect a signal handler for the “@linked@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' pad #linked callback @ -} afterPadLinked :: (IsPad a, MonadIO m) => a -> PadLinkedCallback -> m SignalHandlerId afterPadLinked obj cb = liftIO $ do let cb' = wrap_PadLinkedCallback cb cb'' <- mk_PadLinkedCallback cb' connectSignalFunPtr obj "linked" cb'' SignalConnectAfter -- signal Pad::unlinked {- | Signals that a pad has been unlinked from the peer pad. -} type PadUnlinkedCallback = Pad {- ^ /@peer@/: the peer pad that has been disconnected -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `PadUnlinkedCallback`@. noPadUnlinkedCallback :: Maybe PadUnlinkedCallback noPadUnlinkedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_PadUnlinkedCallback = Ptr () -> -- object Ptr Pad -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_PadUnlinkedCallback`. foreign import ccall "wrapper" mk_PadUnlinkedCallback :: C_PadUnlinkedCallback -> IO (FunPtr C_PadUnlinkedCallback) -- | Wrap the callback into a `GClosure`. genClosure_PadUnlinked :: MonadIO m => PadUnlinkedCallback -> m (GClosure C_PadUnlinkedCallback) genClosure_PadUnlinked cb = liftIO $ do let cb' = wrap_PadUnlinkedCallback cb mk_PadUnlinkedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `PadUnlinkedCallback` into a `C_PadUnlinkedCallback`. wrap_PadUnlinkedCallback :: PadUnlinkedCallback -> C_PadUnlinkedCallback wrap_PadUnlinkedCallback _cb _ peer _ = do peer' <- (newObject Pad) peer _cb peer' {- | Connect a signal handler for the “@unlinked@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' pad #unlinked callback @ -} onPadUnlinked :: (IsPad a, MonadIO m) => a -> PadUnlinkedCallback -> m SignalHandlerId onPadUnlinked obj cb = liftIO $ do let cb' = wrap_PadUnlinkedCallback cb cb'' <- mk_PadUnlinkedCallback cb' connectSignalFunPtr obj "unlinked" cb'' SignalConnectBefore {- | Connect a signal handler for the “@unlinked@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' pad #unlinked callback @ -} afterPadUnlinked :: (IsPad a, MonadIO m) => a -> PadUnlinkedCallback -> m SignalHandlerId afterPadUnlinked obj cb = liftIO $ do let cb' = wrap_PadUnlinkedCallback cb cb'' <- mk_PadUnlinkedCallback cb' connectSignalFunPtr obj "unlinked" cb'' SignalConnectAfter -- VVV Prop "caps" -- Type: TInterface (Name {namespace = "Gst", name = "Caps"}) -- Flags: [PropertyReadable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@caps@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' pad #caps @ -} getPadCaps :: (MonadIO m, IsPad o) => o -> m (Maybe Gst.Caps.Caps) getPadCaps obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "caps" Gst.Caps.Caps #if ENABLE_OVERLOADING data PadCapsPropertyInfo instance AttrInfo PadCapsPropertyInfo where type AttrAllowedOps PadCapsPropertyInfo = '[ 'AttrGet, 'AttrClear] type AttrSetTypeConstraint PadCapsPropertyInfo = (~) () type AttrBaseTypeConstraint PadCapsPropertyInfo = IsPad type AttrGetType PadCapsPropertyInfo = (Maybe Gst.Caps.Caps) type AttrLabel PadCapsPropertyInfo = "caps" type AttrOrigin PadCapsPropertyInfo = Pad attrGet _ = getPadCaps attrSet _ = undefined attrConstruct _ = undefined attrClear _ = undefined #endif -- VVV Prop "direction" -- Type: TInterface (Name {namespace = "Gst", name = "PadDirection"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just False,Nothing) {- | Get the value of the “@direction@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' pad #direction @ -} getPadDirection :: (MonadIO m, IsPad o) => o -> m Gst.Enums.PadDirection getPadDirection obj = liftIO $ B.Properties.getObjectPropertyEnum obj "direction" {- | Construct a `GValueConstruct` with valid value for the “@direction@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructPadDirection :: (IsPad o) => Gst.Enums.PadDirection -> IO (GValueConstruct o) constructPadDirection val = B.Properties.constructObjectPropertyEnum "direction" val #if ENABLE_OVERLOADING data PadDirectionPropertyInfo instance AttrInfo PadDirectionPropertyInfo where type AttrAllowedOps PadDirectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint PadDirectionPropertyInfo = (~) Gst.Enums.PadDirection type AttrBaseTypeConstraint PadDirectionPropertyInfo = IsPad type AttrGetType PadDirectionPropertyInfo = Gst.Enums.PadDirection type AttrLabel PadDirectionPropertyInfo = "direction" type AttrOrigin PadDirectionPropertyInfo = Pad attrGet _ = getPadDirection attrSet _ = undefined attrConstruct _ = constructPadDirection attrClear _ = undefined #endif -- VVV Prop "offset" -- Type: TBasicType TInt64 -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Just False,Just False) {- | Get the value of the “@offset@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' pad #offset @ -} getPadOffset :: (MonadIO m, IsPad o) => o -> m Int64 getPadOffset obj = liftIO $ B.Properties.getObjectPropertyInt64 obj "offset" {- | Set the value of the “@offset@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' pad [ #offset 'Data.GI.Base.Attributes.:=' value ] @ -} setPadOffset :: (MonadIO m, IsPad o) => o -> Int64 -> m () setPadOffset obj val = liftIO $ B.Properties.setObjectPropertyInt64 obj "offset" val {- | Construct a `GValueConstruct` with valid value for the “@offset@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructPadOffset :: (IsPad o) => Int64 -> IO (GValueConstruct o) constructPadOffset val = B.Properties.constructObjectPropertyInt64 "offset" val #if ENABLE_OVERLOADING data PadOffsetPropertyInfo instance AttrInfo PadOffsetPropertyInfo where type AttrAllowedOps PadOffsetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint PadOffsetPropertyInfo = (~) Int64 type AttrBaseTypeConstraint PadOffsetPropertyInfo = IsPad type AttrGetType PadOffsetPropertyInfo = Int64 type AttrLabel PadOffsetPropertyInfo = "offset" type AttrOrigin PadOffsetPropertyInfo = Pad attrGet _ = getPadOffset attrSet _ = setPadOffset attrConstruct _ = constructPadOffset attrClear _ = undefined #endif -- VVV Prop "template" -- Type: TInterface (Name {namespace = "Gst", name = "PadTemplate"}) -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@template@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' pad #template @ -} getPadTemplate :: (MonadIO m, IsPad o) => o -> m (Maybe Gst.PadTemplate.PadTemplate) getPadTemplate obj = liftIO $ B.Properties.getObjectPropertyObject obj "template" Gst.PadTemplate.PadTemplate {- | Set the value of the “@template@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' pad [ #template 'Data.GI.Base.Attributes.:=' value ] @ -} setPadTemplate :: (MonadIO m, IsPad o, Gst.PadTemplate.IsPadTemplate a) => o -> a -> m () setPadTemplate obj val = liftIO $ B.Properties.setObjectPropertyObject obj "template" (Just val) {- | Construct a `GValueConstruct` with valid value for the “@template@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructPadTemplate :: (IsPad o, Gst.PadTemplate.IsPadTemplate a) => a -> IO (GValueConstruct o) constructPadTemplate val = B.Properties.constructObjectPropertyObject "template" (Just val) {- | Set the value of the “@template@” property to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #template @ -} clearPadTemplate :: (MonadIO m, IsPad o) => o -> m () clearPadTemplate obj = liftIO $ B.Properties.setObjectPropertyObject obj "template" (Nothing :: Maybe Gst.PadTemplate.PadTemplate) #if ENABLE_OVERLOADING data PadTemplatePropertyInfo instance AttrInfo PadTemplatePropertyInfo where type AttrAllowedOps PadTemplatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint PadTemplatePropertyInfo = Gst.PadTemplate.IsPadTemplate type AttrBaseTypeConstraint PadTemplatePropertyInfo = IsPad type AttrGetType PadTemplatePropertyInfo = (Maybe Gst.PadTemplate.PadTemplate) type AttrLabel PadTemplatePropertyInfo = "template" type AttrOrigin PadTemplatePropertyInfo = Pad attrGet _ = getPadTemplate attrSet _ = setPadTemplate attrConstruct _ = constructPadTemplate attrClear _ = clearPadTemplate #endif #if 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 ENABLE_OVERLOADING padCaps :: AttrLabelProxy "caps" padCaps = AttrLabelProxy padDirection :: AttrLabelProxy "direction" padDirection = AttrLabelProxy padOffset :: AttrLabelProxy "offset" padOffset = AttrLabelProxy padTemplate :: AttrLabelProxy "template" padTemplate = AttrLabelProxy #endif #if ENABLE_OVERLOADING data PadLinkedSignalInfo instance SignalInfo PadLinkedSignalInfo where type HaskellCallbackType PadLinkedSignalInfo = PadLinkedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_PadLinkedCallback cb cb'' <- mk_PadLinkedCallback cb' connectSignalFunPtr obj "linked" cb'' connectMode data PadUnlinkedSignalInfo instance SignalInfo PadUnlinkedSignalInfo where type HaskellCallbackType PadUnlinkedSignalInfo = PadUnlinkedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_PadUnlinkedCallback cb cb'' <- mk_PadUnlinkedCallback cb' connectSignalFunPtr obj "unlinked" cb'' connectMode type instance O.SignalList Pad = PadSignalList type PadSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("linked", PadLinkedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("unlinked", PadUnlinkedSignalInfo)] :: [(Symbol, *)]) #endif -- method Pad::new -- method type : Constructor -- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the name of the new pad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface (Name {namespace = "Gst", name = "PadDirection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPadDirection of the pad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Pad"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_new" gst_pad_new :: CString -> -- name : TBasicType TUTF8 CUInt -> -- direction : TInterface (Name {namespace = "Gst", name = "PadDirection"}) IO (Ptr Pad) {- | Creates a new pad with the given name in the given direction. If name is 'Nothing', a guaranteed unique name (across all pads) will be assigned. This function makes a copy of the name so you can safely free the name. -} padNew :: (B.CallStack.HasCallStack, MonadIO m) => Maybe (T.Text) {- ^ /@name@/: the name of the new pad. -} -> Gst.Enums.PadDirection {- ^ /@direction@/: the 'GI.Gst.Enums.PadDirection' of the pad. -} -> m (Maybe Pad) {- ^ __Returns:__ a new 'GI.Gst.Objects.Pad.Pad'. MT safe. -} padNew name direction = liftIO $ do maybeName <- case name of Nothing -> return nullPtr Just jName -> do jName' <- textToCString jName return jName' let direction' = (fromIntegral . fromEnum) direction result <- gst_pad_new maybeName direction' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newObject Pad) result' return result'' freeMem maybeName return maybeResult #if ENABLE_OVERLOADING #endif -- method Pad::new_from_static_template -- method type : Constructor -- Args : [Arg {argCName = "templ", argType = TInterface (Name {namespace = "Gst", name = "StaticPadTemplate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstStaticPadTemplate to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the pad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Pad"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_new_from_static_template" gst_pad_new_from_static_template :: Ptr Gst.StaticPadTemplate.StaticPadTemplate -> -- templ : TInterface (Name {namespace = "Gst", name = "StaticPadTemplate"}) CString -> -- name : TBasicType TUTF8 IO (Ptr Pad) {- | Creates a new pad with the given name from the given static template. If name is 'Nothing', a guaranteed unique name (across all pads) will be assigned. This function makes a copy of the name so you can safely free the name. -} padNewFromStaticTemplate :: (B.CallStack.HasCallStack, MonadIO m) => Gst.StaticPadTemplate.StaticPadTemplate {- ^ /@templ@/: the 'GI.Gst.Structs.StaticPadTemplate.StaticPadTemplate' to use -} -> T.Text {- ^ /@name@/: the name of the pad -} -> m (Maybe Pad) {- ^ __Returns:__ a new 'GI.Gst.Objects.Pad.Pad'. -} padNewFromStaticTemplate templ name = liftIO $ do templ' <- unsafeManagedPtrGetPtr templ name' <- textToCString name result <- gst_pad_new_from_static_template templ' name' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newObject Pad) result' return result'' touchManagedPtr templ freeMem name' return maybeResult #if ENABLE_OVERLOADING #endif -- method Pad::new_from_template -- method type : Constructor -- Args : [Arg {argCName = "templ", argType = TInterface (Name {namespace = "Gst", name = "PadTemplate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the pad template to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the name of the pad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Pad"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_new_from_template" gst_pad_new_from_template :: Ptr Gst.PadTemplate.PadTemplate -> -- templ : TInterface (Name {namespace = "Gst", name = "PadTemplate"}) CString -> -- name : TBasicType TUTF8 IO (Ptr Pad) {- | Creates a new pad with the given name from the given template. If name is 'Nothing', a guaranteed unique name (across all pads) will be assigned. This function makes a copy of the name so you can safely free the name. -} padNewFromTemplate :: (B.CallStack.HasCallStack, MonadIO m, Gst.PadTemplate.IsPadTemplate a) => a {- ^ /@templ@/: the pad template to use -} -> Maybe (T.Text) {- ^ /@name@/: the name of the pad -} -> m (Maybe Pad) {- ^ __Returns:__ a new 'GI.Gst.Objects.Pad.Pad'. -} padNewFromTemplate templ name = liftIO $ do templ' <- unsafeManagedPtrCastPtr templ maybeName <- case name of Nothing -> return nullPtr Just jName -> do jName' <- textToCString jName return jName' result <- gst_pad_new_from_template templ' maybeName maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newObject Pad) result' return result'' touchManagedPtr templ freeMem maybeName return maybeResult #if ENABLE_OVERLOADING #endif -- method Pad::activate_mode -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to activate or deactivate.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Gst", name = "PadMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the requested activation mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not the pad should be active.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_activate_mode" gst_pad_activate_mode :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) CUInt -> -- mode : TInterface (Name {namespace = "Gst", name = "PadMode"}) CInt -> -- active : TBasicType TBoolean IO CInt {- | Activates or deactivates the given pad in /@mode@/ via dispatching to the pad\'s activatemodefunc. For use from within pad activation functions only. If you don\'t know what this is, you probably don\'t want to call it. -} padActivateMode :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to activate or deactivate. -} -> Gst.Enums.PadMode {- ^ /@mode@/: the requested activation mode -} -> Bool {- ^ /@active@/: whether or not the pad should be active. -} -> m Bool {- ^ __Returns:__ 'True' if the operation was successful. MT safe. -} padActivateMode pad mode active = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad let mode' = (fromIntegral . fromEnum) mode let active' = (fromIntegral . fromEnum) active result <- gst_pad_activate_mode pad' mode' active' let result' = (/= 0) result touchManagedPtr pad return result' #if 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 -- method Pad::add_probe -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to add the probe to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mask", argType = TInterface (Name {namespace = "Gst", name = "PadProbeType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the probe mask", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gst", name = "PadProbeCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstPadProbeCallback that will be called with notifications of\n the pad state", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_data", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GDestroyNotify for user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TULong) -- throws : False -- Skip return : False foreign import ccall "gst_pad_add_probe" gst_pad_add_probe :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) CUInt -> -- mask : TInterface (Name {namespace = "Gst", name = "PadProbeType"}) FunPtr Gst.Callbacks.C_PadProbeCallback -> -- callback : TInterface (Name {namespace = "Gst", name = "PadProbeCallback"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_data : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO CULong {- | Be notified of different states of pads. The provided callback is called for every state that matches /@mask@/. Probes are called in groups: First GST_PAD_PROBE_TYPE_BLOCK probes are called, then others, then finally GST_PAD_PROBE_TYPE_IDLE. The only exception here are GST_PAD_PROBE_TYPE_IDLE probes that are called immediately if the pad is already idle while calling 'GI.Gst.Objects.Pad.padAddProbe'. In each of the groups, probes are called in the order in which they were added. -} padAddProbe :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to add the probe to -} -> [Gst.Flags.PadProbeType] {- ^ /@mask@/: the probe mask -} -> Gst.Callbacks.PadProbeCallback {- ^ /@callback@/: 'GI.Gst.Callbacks.PadProbeCallback' that will be called with notifications of the pad state -} -> m CULong {- ^ __Returns:__ an id or 0 if no probe is pending. The id can be used to remove the probe with 'GI.Gst.Objects.Pad.padRemoveProbe'. When using GST_PAD_PROBE_TYPE_IDLE it can happen that the probe can be run immediately and if the probe returns GST_PAD_PROBE_REMOVE this functions returns 0. MT safe. -} padAddProbe pad mask callback = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad let mask' = gflagsToWord mask callback' <- Gst.Callbacks.mk_PadProbeCallback (Gst.Callbacks.wrap_PadProbeCallback Nothing (Gst.Callbacks.drop_closures_PadProbeCallback callback)) let userData = castFunPtrToPtr callback' let destroyData = safeFreeFunPtrPtr result <- gst_pad_add_probe pad' mask' callback' userData destroyData touchManagedPtr pad return result #if 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 -- method Pad::can_link -- method type : OrdinaryMethod -- Args : [Arg {argCName = "srcpad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source #GstPad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sinkpad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the sink #GstPad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_can_link" gst_pad_can_link :: Ptr Pad -> -- srcpad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Pad -> -- sinkpad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Checks if the source pad and the sink pad are compatible so they can be linked. -} padCanLink :: (B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) => a {- ^ /@srcpad@/: the source 'GI.Gst.Objects.Pad.Pad'. -} -> b {- ^ /@sinkpad@/: the sink 'GI.Gst.Objects.Pad.Pad'. -} -> m Bool {- ^ __Returns:__ 'True' if the pads can be linked. -} padCanLink srcpad sinkpad = liftIO $ do srcpad' <- unsafeManagedPtrCastPtr srcpad sinkpad' <- unsafeManagedPtrCastPtr sinkpad result <- gst_pad_can_link srcpad' sinkpad' let result' = (/= 0) result touchManagedPtr srcpad touchManagedPtr sinkpad return result' #if ENABLE_OVERLOADING data PadCanLinkMethodInfo instance (signature ~ (b -> m Bool), MonadIO m, IsPad a, IsPad b) => O.MethodInfo PadCanLinkMethodInfo a signature where overloadedMethod _ = padCanLink #endif -- method Pad::chain -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a sink #GstPad, returns GST_FLOW_ERROR if not.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstBuffer to send, return GST_FLOW_ERROR\n if not.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_chain" gst_pad_chain :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) IO CInt {- | Chain a buffer to /@pad@/. The function returns @/GST_FLOW_FLUSHING/@ if the pad was flushing. If the buffer type is not acceptable for /@pad@/ (as negotiated with a preceding GST_EVENT_CAPS event), this function returns @/GST_FLOW_NOT_NEGOTIATED/@. The function proceeds calling the chain function installed on /@pad@/ (see @/gst_pad_set_chain_function()/@) and the return value of that function is returned to the caller. @/GST_FLOW_NOT_SUPPORTED/@ is returned if /@pad@/ has no chain function. In all cases, success or failure, the caller loses its reference to /@buffer@/ after calling this function. -} padChain :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a sink 'GI.Gst.Objects.Pad.Pad', returns GST_FLOW_ERROR if not. -} -> Gst.Buffer.Buffer {- ^ /@buffer@/: the 'GI.Gst.Structs.Buffer.Buffer' to send, return GST_FLOW_ERROR if not. -} -> m Gst.Enums.FlowReturn {- ^ __Returns:__ a 'GI.Gst.Enums.FlowReturn' from the pad. MT safe. -} padChain pad buffer = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad buffer' <- B.ManagedPtr.disownBoxed buffer result <- gst_pad_chain pad' buffer' let result' = (toEnum . fromIntegral) result touchManagedPtr pad touchManagedPtr buffer return result' #if 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 -- method Pad::chain_list -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a sink #GstPad, returns GST_FLOW_ERROR if not.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list", argType = TInterface (Name {namespace = "Gst", name = "BufferList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstBufferList to send, return GST_FLOW_ERROR\n if not.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_chain_list" gst_pad_chain_list :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.BufferList.BufferList -> -- list : TInterface (Name {namespace = "Gst", name = "BufferList"}) IO CInt {- | Chain a bufferlist to /@pad@/. The function returns @/GST_FLOW_FLUSHING/@ if the pad was flushing. If /@pad@/ was not negotiated properly with a CAPS event, this function returns @/GST_FLOW_NOT_NEGOTIATED/@. The function proceeds calling the chainlist function installed on /@pad@/ (see @/gst_pad_set_chain_list_function()/@) and the return value of that function is returned to the caller. @/GST_FLOW_NOT_SUPPORTED/@ is returned if /@pad@/ has no chainlist function. In all cases, success or failure, the caller loses its reference to /@list@/ after calling this function. MT safe. -} padChainList :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a sink 'GI.Gst.Objects.Pad.Pad', returns GST_FLOW_ERROR if not. -} -> Gst.BufferList.BufferList {- ^ /@list@/: the 'GI.Gst.Structs.BufferList.BufferList' to send, return GST_FLOW_ERROR if not. -} -> m Gst.Enums.FlowReturn {- ^ __Returns:__ a 'GI.Gst.Enums.FlowReturn' from the pad. -} padChainList pad list = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad list' <- B.ManagedPtr.disownBoxed list result <- gst_pad_chain_list pad' list' let result' = (toEnum . fromIntegral) result touchManagedPtr pad touchManagedPtr list return result' #if 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 -- method Pad::check_reconfigure -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_check_reconfigure" gst_pad_check_reconfigure :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Check and clear the @/GST_PAD_FLAG_NEED_RECONFIGURE/@ flag on /@pad@/ and return 'True' if the flag was set. -} padCheckReconfigure :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to check -} -> m Bool {- ^ __Returns:__ 'True' is the GST_PAD_FLAG_NEED_RECONFIGURE flag was set on /@pad@/. -} padCheckReconfigure pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_check_reconfigure pad' let result' = (/= 0) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadCheckReconfigureMethodInfo instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadCheckReconfigureMethodInfo a signature where overloadedMethod _ = padCheckReconfigure #endif -- method Pad::create_stream_id -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A source #GstPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface (Name {namespace = "Gst", name = "Element"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Parent #GstElement of @pad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The stream-id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "gst_pad_create_stream_id" gst_pad_create_stream_id :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Element.Element -> -- parent : TInterface (Name {namespace = "Gst", name = "Element"}) CString -> -- stream_id : TBasicType TUTF8 IO CString {- | Creates a stream-id for the source 'GI.Gst.Objects.Pad.Pad' /@pad@/ by combining the upstream information with the optional /@streamId@/ of the stream of /@pad@/. /@pad@/ must have a parent 'GI.Gst.Objects.Element.Element' and which must have zero or one sinkpad. /@streamId@/ can only be 'Nothing' if the parent element of /@pad@/ has only a single source pad. This function generates an unique stream-id by getting the upstream stream-start event stream ID and appending /@streamId@/ to it. If the element has no sinkpad it will generate an upstream stream-id by doing an URI query on the element and in the worst case just uses a random number. Source elements that don\'t implement the URI handler interface should ideally generate a unique, deterministic stream-id manually instead. Since stream IDs are sorted alphabetically, any numbers in the stream ID should be printed with a fixed number of characters, preceded by 0\'s, such as by using the format %03u instead of %u. -} padCreateStreamId :: (B.CallStack.HasCallStack, MonadIO m, IsPad a, Gst.Element.IsElement b) => a {- ^ /@pad@/: A source 'GI.Gst.Objects.Pad.Pad' -} -> b {- ^ /@parent@/: Parent 'GI.Gst.Objects.Element.Element' of /@pad@/ -} -> Maybe (T.Text) {- ^ /@streamId@/: The stream-id -} -> m T.Text {- ^ __Returns:__ A stream-id for /@pad@/. 'GI.GLib.Functions.free' after usage. -} padCreateStreamId pad parent streamId = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad parent' <- unsafeManagedPtrCastPtr parent maybeStreamId <- case streamId of Nothing -> return nullPtr Just jStreamId -> do jStreamId' <- textToCString jStreamId return jStreamId' result <- gst_pad_create_stream_id pad' parent' maybeStreamId checkUnexpectedReturnNULL "padCreateStreamId" result result' <- cstringToText result freeMem result touchManagedPtr pad touchManagedPtr parent freeMem maybeStreamId return result' #if 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 -- method Pad::event_default -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to call the default event handler on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the parent of @pad or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstEvent to handle.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_event_default" gst_pad_event_default :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Object.Object -> -- parent : TInterface (Name {namespace = "Gst", name = "Object"}) Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) IO CInt {- | Invokes the default event handler for the given pad. The EOS event will pause the task associated with /@pad@/ before it is forwarded to all internally linked pads, The event is sent to all pads internally linked to /@pad@/. This function takes ownership of /@event@/. -} padEventDefault :: (B.CallStack.HasCallStack, MonadIO m, IsPad a, Gst.Object.IsObject b) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to call the default event handler on. -} -> Maybe (b) {- ^ /@parent@/: the parent of /@pad@/ or 'Nothing' -} -> Gst.Event.Event {- ^ /@event@/: the 'GI.Gst.Structs.Event.Event' to handle. -} -> m Bool {- ^ __Returns:__ 'True' if the event was sent successfully. -} padEventDefault pad parent event = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad maybeParent <- case parent of Nothing -> return nullPtr Just jParent -> do jParent' <- unsafeManagedPtrCastPtr jParent return jParent' event' <- B.ManagedPtr.disownBoxed event result <- gst_pad_event_default pad' maybeParent event' let result' = (/= 0) result touchManagedPtr pad whenJust parent touchManagedPtr touchManagedPtr event return result' #if 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 -- method Pad::forward -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "forward", argType = TInterface (Name {namespace = "Gst", name = "PadForwardFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPadForwardFunction", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to @forward", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_forward" gst_pad_forward :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_PadForwardFunction -> -- forward : TInterface (Name {namespace = "Gst", name = "PadForwardFunction"}) Ptr () -> -- user_data : TBasicType TPtr IO CInt {- | Calls /@forward@/ for all internally linked pads of /@pad@/. This function deals with dynamically changing internal pads and will make sure that the /@forward@/ function is only called once for each pad. When /@forward@/ returns 'True', no further pads will be processed. -} padForward :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' -} -> Gst.Callbacks.PadForwardFunction {- ^ /@forward@/: a 'GI.Gst.Callbacks.PadForwardFunction' -} -> m Bool {- ^ __Returns:__ 'True' if one of the dispatcher functions returned 'True'. -} padForward pad forward = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad forward' <- Gst.Callbacks.mk_PadForwardFunction (Gst.Callbacks.wrap_PadForwardFunction Nothing (Gst.Callbacks.drop_closures_PadForwardFunction forward)) let userData = nullPtr result <- gst_pad_forward pad' forward' userData let result' = (/= 0) result safeFreeFunPtr $ castFunPtrToPtr forward' touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadForwardMethodInfo instance (signature ~ (Gst.Callbacks.PadForwardFunction -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadForwardMethodInfo a signature where overloadedMethod _ = padForward #endif -- method Pad::get_allowed_caps -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Caps"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_allowed_caps" gst_pad_get_allowed_caps :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO (Ptr Gst.Caps.Caps) {- | Gets the capabilities of the allowed media types that can flow through /@pad@/ and its peer. The allowed capabilities is calculated as the intersection of the results of calling 'GI.Gst.Objects.Pad.padQueryCaps' on /@pad@/ and its peer. The caller owns a reference on the resulting caps. -} padGetAllowedCaps :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad'. -} -> m (Maybe Gst.Caps.Caps) {- ^ __Returns:__ the allowed 'GI.Gst.Structs.Caps.Caps' of the pad link. Unref the caps when you no longer need it. This function returns 'Nothing' when /@pad@/ has no peer. MT safe. -} padGetAllowedCaps pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_get_allowed_caps pad' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Gst.Caps.Caps) result' return result'' touchManagedPtr pad return maybeResult #if ENABLE_OVERLOADING data PadGetAllowedCapsMethodInfo instance (signature ~ (m (Maybe Gst.Caps.Caps)), MonadIO m, IsPad a) => O.MethodInfo PadGetAllowedCapsMethodInfo a signature where overloadedMethod _ = padGetAllowedCaps #endif -- method Pad::get_current_caps -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to get the current capabilities of.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Caps"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_current_caps" gst_pad_get_current_caps :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO (Ptr Gst.Caps.Caps) {- | Gets the capabilities currently configured on /@pad@/ with the last @/GST_EVENT_CAPS/@ event. -} padGetCurrentCaps :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to get the current capabilities of. -} -> m (Maybe Gst.Caps.Caps) {- ^ __Returns:__ the current caps of the pad with incremented ref-count or 'Nothing' when pad has no caps. Unref after usage. -} padGetCurrentCaps pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_get_current_caps pad' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Gst.Caps.Caps) result' return result'' touchManagedPtr pad return maybeResult #if ENABLE_OVERLOADING data PadGetCurrentCapsMethodInfo instance (signature ~ (m (Maybe Gst.Caps.Caps)), MonadIO m, IsPad a) => O.MethodInfo PadGetCurrentCapsMethodInfo a signature where overloadedMethod _ = padGetCurrentCaps #endif -- method Pad::get_direction -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to get the direction of.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "PadDirection"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_direction" gst_pad_get_direction :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CUInt {- | Gets the direction of the pad. The direction of the pad is decided at construction time so this function does not take the LOCK. -} padGetDirection :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to get the direction of. -} -> m Gst.Enums.PadDirection {- ^ __Returns:__ the 'GI.Gst.Enums.PadDirection' of the pad. MT safe. -} padGetDirection pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_get_direction pad' let result' = (toEnum . fromIntegral) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadGetDirectionMethodInfo instance (signature ~ (m Gst.Enums.PadDirection), MonadIO m, IsPad a) => O.MethodInfo PadGetDirectionMethodInfo a signature where overloadedMethod _ = padGetDirection #endif -- method Pad::get_element_private -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to get the private data of.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TPtr) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_element_private" gst_pad_get_element_private :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO (Ptr ()) {- | Gets the private data of a pad. No locking is performed in this function. -} padGetElementPrivate :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to get the private data of. -} -> m (Ptr ()) {- ^ __Returns:__ a @/gpointer/@ to the private data. -} padGetElementPrivate pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_get_element_private pad' touchManagedPtr pad return result #if ENABLE_OVERLOADING data PadGetElementPrivateMethodInfo instance (signature ~ (m (Ptr ())), MonadIO m, IsPad a) => O.MethodInfo PadGetElementPrivateMethodInfo a signature where overloadedMethod _ = padGetElementPrivate #endif -- method Pad::get_last_flow_return -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_last_flow_return" gst_pad_get_last_flow_return :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Gets the 'GI.Gst.Enums.FlowReturn' return from the last data passed by this pad. /Since: 1.4/ -} padGetLastFlowReturn :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' -} -> m Gst.Enums.FlowReturn padGetLastFlowReturn pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_get_last_flow_return pad' let result' = (toEnum . fromIntegral) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadGetLastFlowReturnMethodInfo instance (signature ~ (m Gst.Enums.FlowReturn), MonadIO m, IsPad a) => O.MethodInfo PadGetLastFlowReturnMethodInfo a signature where overloadedMethod _ = padGetLastFlowReturn #endif -- method Pad::get_offset -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt64) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_offset" gst_pad_get_offset :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO Int64 {- | Get the offset applied to the running time of /@pad@/. /@pad@/ has to be a source pad. -} padGetOffset :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' -} -> m Int64 {- ^ __Returns:__ the offset. -} padGetOffset pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_get_offset pad' touchManagedPtr pad return result #if ENABLE_OVERLOADING data PadGetOffsetMethodInfo instance (signature ~ (m Int64), MonadIO m, IsPad a) => O.MethodInfo PadGetOffsetMethodInfo a signature where overloadedMethod _ = padGetOffset #endif -- method Pad::get_pad_template -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "PadTemplate"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_pad_template" gst_pad_get_pad_template :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO (Ptr Gst.PadTemplate.PadTemplate) {- | Gets the template for /@pad@/. -} padGetPadTemplate :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad'. -} -> m (Maybe Gst.PadTemplate.PadTemplate) {- ^ __Returns:__ the 'GI.Gst.Objects.PadTemplate.PadTemplate' from which this pad was instantiated, or 'Nothing' if this pad has no template. Unref after usage. -} padGetPadTemplate pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_get_pad_template pad' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapObject Gst.PadTemplate.PadTemplate) result' return result'' touchManagedPtr pad return maybeResult #if ENABLE_OVERLOADING data PadGetPadTemplateMethodInfo instance (signature ~ (m (Maybe Gst.PadTemplate.PadTemplate)), MonadIO m, IsPad a) => O.MethodInfo PadGetPadTemplateMethodInfo a signature where overloadedMethod _ = padGetPadTemplate #endif -- method Pad::get_pad_template_caps -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to get the template capabilities from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Caps"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_pad_template_caps" gst_pad_get_pad_template_caps :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO (Ptr Gst.Caps.Caps) {- | Gets the capabilities for /@pad@/\'s template. -} padGetPadTemplateCaps :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to get the template capabilities from. -} -> m Gst.Caps.Caps {- ^ __Returns:__ the 'GI.Gst.Structs.Caps.Caps' of this pad template. Unref after usage. -} padGetPadTemplateCaps pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_get_pad_template_caps pad' checkUnexpectedReturnNULL "padGetPadTemplateCaps" result result' <- (wrapBoxed Gst.Caps.Caps) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadGetPadTemplateCapsMethodInfo instance (signature ~ (m Gst.Caps.Caps), MonadIO m, IsPad a) => O.MethodInfo PadGetPadTemplateCapsMethodInfo a signature where overloadedMethod _ = padGetPadTemplateCaps #endif -- method Pad::get_parent_element -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Element"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_parent_element" gst_pad_get_parent_element :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO (Ptr Gst.Element.Element) {- | Gets the parent of /@pad@/, cast to a 'GI.Gst.Objects.Element.Element'. If a /@pad@/ has no parent or its parent is not an element, return 'Nothing'. -} padGetParentElement :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a pad -} -> m (Maybe Gst.Element.Element) {- ^ __Returns:__ the parent of the pad. The caller has a reference on the parent, so unref when you\'re finished with it. MT safe. -} padGetParentElement pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_get_parent_element pad' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapObject Gst.Element.Element) result' return result'' touchManagedPtr pad return maybeResult #if ENABLE_OVERLOADING data PadGetParentElementMethodInfo instance (signature ~ (m (Maybe Gst.Element.Element)), MonadIO m, IsPad a) => O.MethodInfo PadGetParentElementMethodInfo a signature where overloadedMethod _ = padGetParentElement #endif -- method Pad::get_peer -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to get the peer of.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Pad"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_peer" gst_pad_get_peer :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO (Ptr Pad) {- | Gets the peer of /@pad@/. This function refs the peer pad so you need to unref it after use. -} padGetPeer :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to get the peer of. -} -> m (Maybe Pad) {- ^ __Returns:__ the peer 'GI.Gst.Objects.Pad.Pad'. Unref after usage. MT safe. -} padGetPeer pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_get_peer pad' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapObject Pad) result' return result'' touchManagedPtr pad return maybeResult #if ENABLE_OVERLOADING data PadGetPeerMethodInfo instance (signature ~ (m (Maybe Pad)), MonadIO m, IsPad a) => O.MethodInfo PadGetPeerMethodInfo a signature where overloadedMethod _ = padGetPeer #endif -- method Pad::get_range -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a src #GstPad, returns #GST_FLOW_ERROR if not.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The start offset of the buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of the buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to hold the #GstBuffer,\n returns #GST_FLOW_ERROR if %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_range" gst_pad_get_range :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Word64 -> -- offset : TBasicType TUInt64 Word32 -> -- size : TBasicType TUInt Ptr (Ptr Gst.Buffer.Buffer) -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) IO CInt {- | When /@pad@/ is flushing this function returns @/GST_FLOW_FLUSHING/@ immediately and /@buffer@/ is 'Nothing'. Calls the getrange function of /@pad@/, see 'GI.Gst.Callbacks.PadGetRangeFunction' for a description of a getrange function. If /@pad@/ has no getrange function installed (see @/gst_pad_set_getrange_function()/@) this function returns @/GST_FLOW_NOT_SUPPORTED/@. If /@buffer@/ points to a variable holding 'Nothing', a valid new 'GI.Gst.Structs.Buffer.Buffer' will be placed in /@buffer@/ when this function returns @/GST_FLOW_OK/@. The new buffer must be freed with @/gst_buffer_unref()/@ after usage. When /@buffer@/ points to a variable that points to a valid 'GI.Gst.Structs.Buffer.Buffer', the buffer will be filled with the result data when this function returns @/GST_FLOW_OK/@. If the provided buffer is larger than /@size@/, only /@size@/ bytes will be filled in the result buffer and its size will be updated accordingly. Note that less than /@size@/ bytes can be returned in /@buffer@/ when, for example, an EOS condition is near or when /@buffer@/ is not large enough to hold /@size@/ bytes. The caller should check the result buffer size to get the result size. When this function returns any other result value than @/GST_FLOW_OK/@, /@buffer@/ will be unchanged. This is a lowlevel function. Usually 'GI.Gst.Objects.Pad.padPullRange' is used. -} padGetRange :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a src 'GI.Gst.Objects.Pad.Pad', returns @/GST_FLOW_ERROR/@ if not. -} -> Word64 {- ^ /@offset@/: The start offset of the buffer -} -> Word32 {- ^ /@size@/: The length of the buffer -} -> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer)) {- ^ __Returns:__ a 'GI.Gst.Enums.FlowReturn' from the pad. MT safe. -} padGetRange pad offset size = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad buffer <- allocMem :: IO (Ptr (Ptr Gst.Buffer.Buffer)) result <- gst_pad_get_range pad' offset size buffer let result' = (toEnum . fromIntegral) result buffer' <- peek buffer buffer'' <- (wrapBoxed Gst.Buffer.Buffer) buffer' touchManagedPtr pad freeMem buffer return (result', buffer'') #if 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 -- method Pad::get_sticky_event -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to get the event from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event_type", argType = TInterface (Name {namespace = "Gst", name = "EventType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstEventType that should be retrieved.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Event"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_sticky_event" gst_pad_get_sticky_event :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) CUInt -> -- event_type : TInterface (Name {namespace = "Gst", name = "EventType"}) Word32 -> -- idx : TBasicType TUInt IO (Ptr Gst.Event.Event) {- | Returns a new reference of the sticky event of type /@eventType@/ from the event. -} padGetStickyEvent :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to get the event from. -} -> Gst.Enums.EventType {- ^ /@eventType@/: the 'GI.Gst.Enums.EventType' that should be retrieved. -} -> Word32 {- ^ /@idx@/: the index of the event -} -> m (Maybe Gst.Event.Event) {- ^ __Returns:__ a 'GI.Gst.Structs.Event.Event' of type /@eventType@/ or 'Nothing' when no event of /@eventType@/ was on /@pad@/. Unref after usage. -} padGetStickyEvent pad eventType idx = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad let eventType' = (fromIntegral . fromEnum) eventType result <- gst_pad_get_sticky_event pad' eventType' idx maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Gst.Event.Event) result' return result'' touchManagedPtr pad return maybeResult #if 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 -- method Pad::get_stream -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A source #GstPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Stream"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_stream" gst_pad_get_stream :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO (Ptr Gst.Stream.Stream) {- | Returns the current 'GI.Gst.Objects.Stream.Stream' for the /@pad@/, or 'Nothing' if none has been set yet, i.e. the pad has not received a stream-start event yet. This is a convenience wrapper around 'GI.Gst.Objects.Pad.padGetStickyEvent' and 'GI.Gst.Structs.Event.eventParseStream'. /Since: 1.10/ -} padGetStream :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: A source 'GI.Gst.Objects.Pad.Pad' -} -> m (Maybe Gst.Stream.Stream) {- ^ __Returns:__ the current 'GI.Gst.Objects.Stream.Stream' for /@pad@/, or 'Nothing'. unref the returned stream when no longer needed. -} padGetStream pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_get_stream pad' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapObject Gst.Stream.Stream) result' return result'' touchManagedPtr pad return maybeResult #if ENABLE_OVERLOADING data PadGetStreamMethodInfo instance (signature ~ (m (Maybe Gst.Stream.Stream)), MonadIO m, IsPad a) => O.MethodInfo PadGetStreamMethodInfo a signature where overloadedMethod _ = padGetStream #endif -- method Pad::get_stream_id -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A source #GstPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_stream_id" gst_pad_get_stream_id :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CString {- | Returns the current stream-id for the /@pad@/, or 'Nothing' if none has been set yet, i.e. the pad has not received a stream-start event yet. This is a convenience wrapper around 'GI.Gst.Objects.Pad.padGetStickyEvent' and 'GI.Gst.Structs.Event.eventParseStreamStart'. The returned stream-id string should be treated as an opaque string, its contents should not be interpreted. /Since: 1.2/ -} padGetStreamId :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: A source 'GI.Gst.Objects.Pad.Pad' -} -> m (Maybe T.Text) {- ^ __Returns:__ a newly-allocated copy of the stream-id for /@pad@/, or 'Nothing'. 'GI.GLib.Functions.free' the returned string when no longer needed. -} padGetStreamId pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_get_stream_id pad' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- cstringToText result' freeMem result' return result'' touchManagedPtr pad return maybeResult #if ENABLE_OVERLOADING data PadGetStreamIdMethodInfo instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsPad a) => O.MethodInfo PadGetStreamIdMethodInfo a signature where overloadedMethod _ = padGetStreamId #endif -- method Pad::get_task_state -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to get task state from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "TaskState"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_get_task_state" gst_pad_get_task_state :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CUInt {- | Get /@pad@/ task state. If no task is currently set, @/GST_TASK_STOPPED/@ is returned. /Since: 1.12/ -} padGetTaskState :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to get task state from -} -> m Gst.Enums.TaskState {- ^ __Returns:__ The current state of /@pad@/\'s task. -} padGetTaskState pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_get_task_state pad' let result' = (toEnum . fromIntegral) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadGetTaskStateMethodInfo instance (signature ~ (m Gst.Enums.TaskState), MonadIO m, IsPad a) => O.MethodInfo PadGetTaskStateMethodInfo a signature where overloadedMethod _ = padGetTaskState #endif -- method Pad::has_current_caps -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_has_current_caps" gst_pad_has_current_caps :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Check if /@pad@/ has caps set on it with a @/GST_EVENT_CAPS/@ event. -} padHasCurrentCaps :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to check -} -> m Bool {- ^ __Returns:__ 'True' when /@pad@/ has caps associated with it. -} padHasCurrentCaps pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_has_current_caps pad' let result' = (/= 0) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadHasCurrentCapsMethodInfo instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadHasCurrentCapsMethodInfo a signature where overloadedMethod _ = padHasCurrentCaps #endif -- method Pad::is_active -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_is_active" gst_pad_is_active :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Query if a pad is active -} padIsActive :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to query -} -> m Bool {- ^ __Returns:__ 'True' if the pad is active. MT safe. -} padIsActive pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_is_active pad' let result' = (/= 0) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadIsActiveMethodInfo instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadIsActiveMethodInfo a signature where overloadedMethod _ = padIsActive #endif -- method Pad::is_blocked -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_is_blocked" gst_pad_is_blocked :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Checks if the pad is blocked or not. This function returns the last requested state of the pad. It is not certain that the pad is actually blocking at this point (see 'GI.Gst.Objects.Pad.padIsBlocking'). -} padIsBlocked :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to query -} -> m Bool {- ^ __Returns:__ 'True' if the pad is blocked. MT safe. -} padIsBlocked pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_is_blocked pad' let result' = (/= 0) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadIsBlockedMethodInfo instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadIsBlockedMethodInfo a signature where overloadedMethod _ = padIsBlocked #endif -- method Pad::is_blocking -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_is_blocking" gst_pad_is_blocking :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Checks if the pad is blocking or not. This is a guaranteed state of whether the pad is actually blocking on a 'GI.Gst.Structs.Buffer.Buffer' or a 'GI.Gst.Structs.Event.Event'. -} padIsBlocking :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to query -} -> m Bool {- ^ __Returns:__ 'True' if the pad is blocking. MT safe. -} padIsBlocking pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_is_blocking pad' let result' = (/= 0) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadIsBlockingMethodInfo instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadIsBlockingMethodInfo a signature where overloadedMethod _ = padIsBlocking #endif -- method Pad::is_linked -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pad to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_is_linked" gst_pad_is_linked :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Checks if a /@pad@/ is linked to another pad or not. -} padIsLinked :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: pad to check -} -> m Bool {- ^ __Returns:__ 'True' if the pad is linked, 'False' otherwise. MT safe. -} padIsLinked pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_is_linked pad' let result' = (/= 0) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadIsLinkedMethodInfo instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadIsLinkedMethodInfo a signature where overloadedMethod _ = padIsLinked #endif -- method Pad::iterate_internal_links -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the GstPad to get the internal links of.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Iterator"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_iterate_internal_links" gst_pad_iterate_internal_links :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO (Ptr Gst.Iterator.Iterator) {- | Gets an iterator for the pads to which the given pad is linked to inside of the parent element. Each 'GI.Gst.Objects.Pad.Pad' element yielded by the iterator will have its refcount increased, so unref after use. Free-function: gst_iterator_free -} padIterateInternalLinks :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the GstPad to get the internal links of. -} -> m (Maybe Gst.Iterator.Iterator) {- ^ __Returns:__ a new 'GI.Gst.Structs.Iterator.Iterator' of 'GI.Gst.Objects.Pad.Pad' or 'Nothing' when the pad does not have an iterator function configured. Use 'GI.Gst.Structs.Iterator.iteratorFree' after usage. -} padIterateInternalLinks pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_iterate_internal_links pad' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Gst.Iterator.Iterator) result' return result'' touchManagedPtr pad return maybeResult #if ENABLE_OVERLOADING data PadIterateInternalLinksMethodInfo instance (signature ~ (m (Maybe Gst.Iterator.Iterator)), MonadIO m, IsPad a) => O.MethodInfo PadIterateInternalLinksMethodInfo a signature where overloadedMethod _ = padIterateInternalLinks #endif -- method Pad::iterate_internal_links_default -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to get the internal links of.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the parent of @pad or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Iterator"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_iterate_internal_links_default" gst_pad_iterate_internal_links_default :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Object.Object -> -- parent : TInterface (Name {namespace = "Gst", name = "Object"}) IO (Ptr Gst.Iterator.Iterator) {- | Iterate the list of pads to which the given pad is linked to inside of the parent element. This is the default handler, and thus returns an iterator of all of the pads inside the parent element with opposite direction. The caller must free this iterator after use with 'GI.Gst.Structs.Iterator.iteratorFree'. -} padIterateInternalLinksDefault :: (B.CallStack.HasCallStack, MonadIO m, IsPad a, Gst.Object.IsObject b) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to get the internal links of. -} -> Maybe (b) {- ^ /@parent@/: the parent of /@pad@/ or 'Nothing' -} -> m (Maybe Gst.Iterator.Iterator) {- ^ __Returns:__ a 'GI.Gst.Structs.Iterator.Iterator' of 'GI.Gst.Objects.Pad.Pad', or 'Nothing' if /@pad@/ has no parent. Unref each returned pad with 'GI.Gst.Objects.Object.objectUnref'. -} padIterateInternalLinksDefault pad parent = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad maybeParent <- case parent of Nothing -> return nullPtr Just jParent -> do jParent' <- unsafeManagedPtrCastPtr jParent return jParent' result <- gst_pad_iterate_internal_links_default pad' maybeParent maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Gst.Iterator.Iterator) result' return result'' touchManagedPtr pad whenJust parent touchManagedPtr return maybeResult #if 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 -- method Pad::link -- method type : OrdinaryMethod -- Args : [Arg {argCName = "srcpad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source #GstPad to link.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sinkpad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the sink #GstPad to link.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "PadLinkReturn"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_link" gst_pad_link :: Ptr Pad -> -- srcpad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Pad -> -- sinkpad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Links the source pad and the sink pad. -} padLink :: (B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) => a {- ^ /@srcpad@/: the source 'GI.Gst.Objects.Pad.Pad' to link. -} -> b {- ^ /@sinkpad@/: the sink 'GI.Gst.Objects.Pad.Pad' to link. -} -> m Gst.Enums.PadLinkReturn {- ^ __Returns:__ A result code indicating if the connection worked or what went wrong. MT Safe. -} padLink srcpad sinkpad = liftIO $ do srcpad' <- unsafeManagedPtrCastPtr srcpad sinkpad' <- unsafeManagedPtrCastPtr sinkpad result <- gst_pad_link srcpad' sinkpad' let result' = (toEnum . fromIntegral) result touchManagedPtr srcpad touchManagedPtr sinkpad return result' #if 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 -- method Pad::link_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "srcpad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source #GstPad to link.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sinkpad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the sink #GstPad to link.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "PadLinkCheck"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the checks to validate when linking", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "PadLinkReturn"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_link_full" gst_pad_link_full :: Ptr Pad -> -- srcpad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Pad -> -- sinkpad : TInterface (Name {namespace = "Gst", name = "Pad"}) CUInt -> -- flags : TInterface (Name {namespace = "Gst", name = "PadLinkCheck"}) IO CInt {- | Links the source pad and the sink pad. This variant of @/gst_pad_link/@ provides a more granular control on the checks being done when linking. While providing some considerable speedups the caller of this method must be aware that wrong usage of those flags can cause severe issues. Refer to the documentation of 'GI.Gst.Flags.PadLinkCheck' for more information. MT Safe. -} padLinkFull :: (B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) => a {- ^ /@srcpad@/: the source 'GI.Gst.Objects.Pad.Pad' to link. -} -> b {- ^ /@sinkpad@/: the sink 'GI.Gst.Objects.Pad.Pad' to link. -} -> [Gst.Flags.PadLinkCheck] {- ^ /@flags@/: the checks to validate when linking -} -> m Gst.Enums.PadLinkReturn {- ^ __Returns:__ A result code indicating if the connection worked or what went wrong. -} padLinkFull srcpad sinkpad flags = liftIO $ do srcpad' <- unsafeManagedPtrCastPtr srcpad sinkpad' <- unsafeManagedPtrCastPtr sinkpad let flags' = gflagsToWord flags result <- gst_pad_link_full srcpad' sinkpad' flags' let result' = (toEnum . fromIntegral) result touchManagedPtr srcpad touchManagedPtr sinkpad return result' #if 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 -- method Pad::link_maybe_ghosting -- method type : OrdinaryMethod -- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sink", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_link_maybe_ghosting" gst_pad_link_maybe_ghosting :: Ptr Pad -> -- src : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Pad -> -- sink : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Links /@src@/ to /@sink@/, creating any 'GI.Gst.Objects.GhostPad.GhostPad'\'s in between as necessary. This is a convenience function to save having to create and add intermediate 'GI.Gst.Objects.GhostPad.GhostPad'\'s as required for linking across 'GI.Gst.Objects.Bin.Bin' boundaries. If /@src@/ or /@sink@/ pads don\'t have parent elements or do not share a common ancestor, the link will fail. /Since: 1.10/ -} padLinkMaybeGhosting :: (B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) => a {- ^ /@src@/: a 'GI.Gst.Objects.Pad.Pad' -} -> b {- ^ /@sink@/: a 'GI.Gst.Objects.Pad.Pad' -} -> m Bool {- ^ __Returns:__ whether the link succeeded. -} padLinkMaybeGhosting src sink = liftIO $ do src' <- unsafeManagedPtrCastPtr src sink' <- unsafeManagedPtrCastPtr sink result <- gst_pad_link_maybe_ghosting src' sink' let result' = (/= 0) result touchManagedPtr src touchManagedPtr sink return result' #if ENABLE_OVERLOADING data PadLinkMaybeGhostingMethodInfo instance (signature ~ (b -> m Bool), MonadIO m, IsPad a, IsPad b) => O.MethodInfo PadLinkMaybeGhostingMethodInfo a signature where overloadedMethod _ = padLinkMaybeGhosting #endif -- method Pad::link_maybe_ghosting_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sink", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "PadLinkCheck"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "some #GstPadLinkCheck flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_link_maybe_ghosting_full" gst_pad_link_maybe_ghosting_full :: Ptr Pad -> -- src : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Pad -> -- sink : TInterface (Name {namespace = "Gst", name = "Pad"}) CUInt -> -- flags : TInterface (Name {namespace = "Gst", name = "PadLinkCheck"}) IO CInt {- | Links /@src@/ to /@sink@/, creating any 'GI.Gst.Objects.GhostPad.GhostPad'\'s in between as necessary. This is a convenience function to save having to create and add intermediate 'GI.Gst.Objects.GhostPad.GhostPad'\'s as required for linking across 'GI.Gst.Objects.Bin.Bin' boundaries. If /@src@/ or /@sink@/ pads don\'t have parent elements or do not share a common ancestor, the link will fail. Calling 'GI.Gst.Objects.Pad.padLinkMaybeGhostingFull' with /@flags@/ == 'GI.Gst.Flags.PadLinkCheckDefault' is the recommended way of linking pads with safety checks applied. /Since: 1.10/ -} padLinkMaybeGhostingFull :: (B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) => a {- ^ /@src@/: a 'GI.Gst.Objects.Pad.Pad' -} -> b {- ^ /@sink@/: a 'GI.Gst.Objects.Pad.Pad' -} -> [Gst.Flags.PadLinkCheck] {- ^ /@flags@/: some 'GI.Gst.Flags.PadLinkCheck' flags -} -> m Bool {- ^ __Returns:__ whether the link succeeded. -} padLinkMaybeGhostingFull src sink flags = liftIO $ do src' <- unsafeManagedPtrCastPtr src sink' <- unsafeManagedPtrCastPtr sink let flags' = gflagsToWord flags result <- gst_pad_link_maybe_ghosting_full src' sink' flags' let result' = (/= 0) result touchManagedPtr src touchManagedPtr sink return result' #if 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 -- method Pad::mark_reconfigure -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to mark", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_mark_reconfigure" gst_pad_mark_reconfigure :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO () {- | Mark a pad for needing reconfiguration. The next call to 'GI.Gst.Objects.Pad.padCheckReconfigure' will return 'True' after this call. -} padMarkReconfigure :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to mark -} -> m () padMarkReconfigure pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad gst_pad_mark_reconfigure pad' touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadMarkReconfigureMethodInfo instance (signature ~ (m ()), MonadIO m, IsPad a) => O.MethodInfo PadMarkReconfigureMethodInfo a signature where overloadedMethod _ = padMarkReconfigure #endif -- method Pad::needs_reconfigure -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_needs_reconfigure" gst_pad_needs_reconfigure :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Check the @/GST_PAD_FLAG_NEED_RECONFIGURE/@ flag on /@pad@/ and return 'True' if the flag was set. -} padNeedsReconfigure :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to check -} -> m Bool {- ^ __Returns:__ 'True' is the GST_PAD_FLAG_NEED_RECONFIGURE flag is set on /@pad@/. -} padNeedsReconfigure pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_needs_reconfigure pad' let result' = (/= 0) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadNeedsReconfigureMethodInfo instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadNeedsReconfigureMethodInfo a signature where overloadedMethod _ = padNeedsReconfigure #endif -- method Pad::pause_task -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to pause the task of", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_pause_task" gst_pad_pause_task :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Pause the task of /@pad@/. This function will also wait until the function executed by the task is finished if this function is not called from the task function. -} padPauseTask :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to pause the task of -} -> m Bool {- ^ __Returns:__ a 'True' if the task could be paused or 'False' when the pad has no task. -} padPauseTask pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_pause_task pad' let result' = (/= 0) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadPauseTaskMethodInfo instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadPauseTaskMethodInfo a signature where overloadedMethod _ = padPauseTask #endif -- method Pad::peer_query -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to invoke the peer query on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstQuery to perform.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_peer_query" gst_pad_peer_query :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Query.Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"}) IO CInt {- | Performs 'GI.Gst.Objects.Pad.padQuery' on the peer of /@pad@/. The caller is responsible for both the allocation and deallocation of the query structure. -} padPeerQuery :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to invoke the peer query on. -} -> Gst.Query.Query {- ^ /@query@/: the 'GI.Gst.Structs.Query.Query' to perform. -} -> m Bool {- ^ __Returns:__ 'True' if the query could be performed. This function returns 'False' if /@pad@/ has no peer. -} padPeerQuery pad query = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad query' <- unsafeManagedPtrGetPtr query result <- gst_pad_peer_query pad' query' let result' = (/= 0) result touchManagedPtr pad touchManagedPtr query return result' #if ENABLE_OVERLOADING data PadPeerQueryMethodInfo instance (signature ~ (Gst.Query.Query -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadPeerQueryMethodInfo a signature where overloadedMethod _ = padPeerQuery #endif -- method Pad::peer_query_accept_caps -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to check the peer of", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstCaps to check on the pad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_peer_query_accept_caps" gst_pad_peer_query_accept_caps :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Caps.Caps -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"}) IO CInt {- | Check if the peer of /@pad@/ accepts /@caps@/. If /@pad@/ has no peer, this function returns 'True'. -} padPeerQueryAcceptCaps :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to check the peer of -} -> Gst.Caps.Caps {- ^ /@caps@/: a 'GI.Gst.Structs.Caps.Caps' to check on the pad -} -> m Bool {- ^ __Returns:__ 'True' if the peer of /@pad@/ can accept the caps or /@pad@/ has no peer. -} padPeerQueryAcceptCaps pad caps = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad caps' <- unsafeManagedPtrGetPtr caps result <- gst_pad_peer_query_accept_caps pad' caps' let result' = (/= 0) result touchManagedPtr pad touchManagedPtr caps return result' #if ENABLE_OVERLOADING data PadPeerQueryAcceptCapsMethodInfo instance (signature ~ (Gst.Caps.Caps -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadPeerQueryAcceptCapsMethodInfo a signature where overloadedMethod _ = padPeerQueryAcceptCaps #endif -- method Pad::peer_query_caps -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to get the capabilities of.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GstCaps filter, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Caps"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_peer_query_caps" gst_pad_peer_query_caps :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Caps.Caps -> -- filter : TInterface (Name {namespace = "Gst", name = "Caps"}) IO (Ptr Gst.Caps.Caps) {- | Gets the capabilities of the peer connected to this pad. Similar to 'GI.Gst.Objects.Pad.padQueryCaps'. When called on srcpads /@filter@/ contains the caps that upstream could produce in the order preferred by upstream. When called on sinkpads /@filter@/ contains the caps accepted by downstream in the preferred order. /@filter@/ might be 'Nothing' but if it is not 'Nothing' the returned caps will be a subset of /@filter@/. -} padPeerQueryCaps :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to get the capabilities of. -} -> Maybe (Gst.Caps.Caps) {- ^ /@filter@/: a 'GI.Gst.Structs.Caps.Caps' filter, or 'Nothing'. -} -> m Gst.Caps.Caps {- ^ __Returns:__ the caps of the peer pad with incremented ref-count. When there is no peer pad, this function returns /@filter@/ or, when /@filter@/ is 'Nothing', ANY caps. -} padPeerQueryCaps pad filter = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad maybeFilter <- case filter of Nothing -> return nullPtr Just jFilter -> do jFilter' <- unsafeManagedPtrGetPtr jFilter return jFilter' result <- gst_pad_peer_query_caps pad' maybeFilter checkUnexpectedReturnNULL "padPeerQueryCaps" result result' <- (wrapBoxed Gst.Caps.Caps) result touchManagedPtr pad whenJust filter touchManagedPtr return result' #if 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 -- method Pad::peer_query_convert -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad, on whose peer pad to invoke the convert query on.\n Must be a sink pad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstFormat to convert from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_val", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a value to convert.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstFormat to convert to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_val", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to the result.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_peer_query_convert" gst_pad_peer_query_convert :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) CUInt -> -- src_format : TInterface (Name {namespace = "Gst", name = "Format"}) Int64 -> -- src_val : TBasicType TInt64 CUInt -> -- dest_format : TInterface (Name {namespace = "Gst", name = "Format"}) Ptr Int64 -> -- dest_val : TBasicType TInt64 IO CInt {- | Queries the peer pad of a given sink pad to convert /@srcVal@/ in /@srcFormat@/ to /@destFormat@/. -} padPeerQueryConvert :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad', on whose peer pad to invoke the convert query on. Must be a sink pad. -} -> Gst.Enums.Format {- ^ /@srcFormat@/: a 'GI.Gst.Enums.Format' to convert from. -} -> Int64 {- ^ /@srcVal@/: a value to convert. -} -> Gst.Enums.Format {- ^ /@destFormat@/: the 'GI.Gst.Enums.Format' to convert to. -} -> m ((Bool, Int64)) {- ^ __Returns:__ 'True' if the query could be performed. -} padPeerQueryConvert pad srcFormat srcVal destFormat = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad let srcFormat' = (fromIntegral . fromEnum) srcFormat let destFormat' = (fromIntegral . fromEnum) destFormat destVal <- allocMem :: IO (Ptr Int64) result <- gst_pad_peer_query_convert pad' srcFormat' srcVal destFormat' destVal let result' = (/= 0) result destVal' <- peek destVal touchManagedPtr pad freeMem destVal return (result', destVal') #if 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 -- method Pad::peer_query_duration -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad on whose peer pad to invoke the duration query on.\n Must be a sink pad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstFormat requested", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location in which to store the total\n duration, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_peer_query_duration" gst_pad_peer_query_duration :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"}) Ptr Int64 -> -- duration : TBasicType TInt64 IO CInt {- | Queries the peer pad of a given sink pad for the total stream duration. -} padPeerQueryDuration :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' on whose peer pad to invoke the duration query on. Must be a sink pad. -} -> Gst.Enums.Format {- ^ /@format@/: the 'GI.Gst.Enums.Format' requested -} -> m ((Bool, Int64)) {- ^ __Returns:__ 'True' if the query could be performed. -} padPeerQueryDuration pad format = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad let format' = (fromIntegral . fromEnum) format duration <- allocMem :: IO (Ptr Int64) result <- gst_pad_peer_query_duration pad' format' duration let result' = (/= 0) result duration' <- peek duration touchManagedPtr pad freeMem duration return (result', duration') #if 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 -- method Pad::peer_query_position -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad on whose peer to invoke the position query on.\n Must be a sink pad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstFormat requested", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location in which to store the current\n position, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_peer_query_position" gst_pad_peer_query_position :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"}) Ptr Int64 -> -- cur : TBasicType TInt64 IO CInt {- | Queries the peer of a given sink pad for the stream position. -} padPeerQueryPosition :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' on whose peer to invoke the position query on. Must be a sink pad. -} -> Gst.Enums.Format {- ^ /@format@/: the 'GI.Gst.Enums.Format' requested -} -> m ((Bool, Int64)) {- ^ __Returns:__ 'True' if the query could be performed. -} padPeerQueryPosition pad format = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad let format' = (fromIntegral . fromEnum) format cur <- allocMem :: IO (Ptr Int64) result <- gst_pad_peer_query_position pad' format' cur let result' = (/= 0) result cur' <- peek cur touchManagedPtr pad freeMem cur return (result', cur') #if 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 -- method Pad::proxy_query_accept_caps -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to proxy.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an ACCEPT_CAPS #GstQuery.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_proxy_query_accept_caps" gst_pad_proxy_query_accept_caps :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Query.Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"}) IO CInt {- | Checks if all internally linked pads of /@pad@/ accepts the caps in /@query@/ and returns the intersection of the results. This function is useful as a default accept caps query function for an element that can handle any stream format, but requires caps that are acceptable for all opposite pads. -} padProxyQueryAcceptCaps :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to proxy. -} -> Gst.Query.Query {- ^ /@query@/: an ACCEPT_CAPS 'GI.Gst.Structs.Query.Query'. -} -> m Bool {- ^ __Returns:__ 'True' if /@query@/ could be executed -} padProxyQueryAcceptCaps pad query = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad query' <- unsafeManagedPtrGetPtr query result <- gst_pad_proxy_query_accept_caps pad' query' let result' = (/= 0) result touchManagedPtr pad touchManagedPtr query return result' #if ENABLE_OVERLOADING data PadProxyQueryAcceptCapsMethodInfo instance (signature ~ (Gst.Query.Query -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadProxyQueryAcceptCapsMethodInfo a signature where overloadedMethod _ = padProxyQueryAcceptCaps #endif -- method Pad::proxy_query_caps -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to proxy.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a CAPS #GstQuery.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_proxy_query_caps" gst_pad_proxy_query_caps :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Query.Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"}) IO CInt {- | Calls 'GI.Gst.Objects.Pad.padQueryCaps' for all internally linked pads of /@pad@/ and returns the intersection of the results. This function is useful as a default caps query function for an element that can handle any stream format, but requires all its pads to have the same caps. Two such elements are tee and adder. -} padProxyQueryCaps :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to proxy. -} -> Gst.Query.Query {- ^ /@query@/: a CAPS 'GI.Gst.Structs.Query.Query'. -} -> m Bool {- ^ __Returns:__ 'True' if /@query@/ could be executed -} padProxyQueryCaps pad query = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad query' <- unsafeManagedPtrGetPtr query result <- gst_pad_proxy_query_caps pad' query' let result' = (/= 0) result touchManagedPtr pad touchManagedPtr query return result' #if ENABLE_OVERLOADING data PadProxyQueryCapsMethodInfo instance (signature ~ (Gst.Query.Query -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadProxyQueryCapsMethodInfo a signature where overloadedMethod _ = padProxyQueryCaps #endif -- method Pad::pull_range -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a sink #GstPad, returns GST_FLOW_ERROR if not.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The start offset of the buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of the buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to hold the #GstBuffer, returns\n GST_FLOW_ERROR if %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_pull_range" gst_pad_pull_range :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Word64 -> -- offset : TBasicType TUInt64 Word32 -> -- size : TBasicType TUInt Ptr (Ptr Gst.Buffer.Buffer) -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) IO CInt {- | Pulls a /@buffer@/ from the peer pad or fills up a provided buffer. This function will first trigger the pad block signal if it was installed. When /@pad@/ is not linked @/GST_FLOW_NOT_LINKED/@ is returned else this function returns the result of 'GI.Gst.Objects.Pad.padGetRange' on the peer pad. See 'GI.Gst.Objects.Pad.padGetRange' for a list of return values and for the semantics of the arguments of this function. If /@buffer@/ points to a variable holding 'Nothing', a valid new 'GI.Gst.Structs.Buffer.Buffer' will be placed in /@buffer@/ when this function returns @/GST_FLOW_OK/@. The new buffer must be freed with @/gst_buffer_unref()/@ after usage. When this function returns any other result value, /@buffer@/ will still point to 'Nothing'. When /@buffer@/ points to a variable that points to a valid 'GI.Gst.Structs.Buffer.Buffer', the buffer will be filled with the result data when this function returns @/GST_FLOW_OK/@. When this function returns any other result value, /@buffer@/ will be unchanged. If the provided buffer is larger than /@size@/, only /@size@/ bytes will be filled in the result buffer and its size will be updated accordingly. Note that less than /@size@/ bytes can be returned in /@buffer@/ when, for example, an EOS condition is near or when /@buffer@/ is not large enough to hold /@size@/ bytes. The caller should check the result buffer size to get the result size. -} padPullRange :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a sink 'GI.Gst.Objects.Pad.Pad', returns GST_FLOW_ERROR if not. -} -> Word64 {- ^ /@offset@/: The start offset of the buffer -} -> Word32 {- ^ /@size@/: The length of the buffer -} -> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer)) {- ^ __Returns:__ a 'GI.Gst.Enums.FlowReturn' from the peer pad. MT safe. -} padPullRange pad offset size = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad buffer <- allocMem :: IO (Ptr (Ptr Gst.Buffer.Buffer)) result <- gst_pad_pull_range pad' offset size buffer let result' = (toEnum . fromIntegral) result buffer' <- peek buffer buffer'' <- (wrapBoxed Gst.Buffer.Buffer) buffer' touchManagedPtr pad freeMem buffer return (result', buffer'') #if 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 -- method Pad::push -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a source #GstPad, returns #GST_FLOW_ERROR if not.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstBuffer to push returns GST_FLOW_ERROR\n if not.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_push" gst_pad_push :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) IO CInt {- | Pushes a buffer to the peer of /@pad@/. This function will call installed block probes before triggering any installed data probes. The function proceeds calling 'GI.Gst.Objects.Pad.padChain' on the peer pad and returns the value from that function. If /@pad@/ has no peer, @/GST_FLOW_NOT_LINKED/@ will be returned. In all cases, success or failure, the caller loses its reference to /@buffer@/ after calling this function. -} padPush :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a source 'GI.Gst.Objects.Pad.Pad', returns @/GST_FLOW_ERROR/@ if not. -} -> Gst.Buffer.Buffer {- ^ /@buffer@/: the 'GI.Gst.Structs.Buffer.Buffer' to push returns GST_FLOW_ERROR if not. -} -> m Gst.Enums.FlowReturn {- ^ __Returns:__ a 'GI.Gst.Enums.FlowReturn' from the peer pad. MT safe. -} padPush pad buffer = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad buffer' <- B.ManagedPtr.disownBoxed buffer result <- gst_pad_push pad' buffer' let result' = (toEnum . fromIntegral) result touchManagedPtr pad touchManagedPtr buffer return result' #if 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 -- method Pad::push_event -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to push the event to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstEvent to send to the pad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_push_event" gst_pad_push_event :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) IO CInt {- | Sends the event to the peer of the given pad. This function is mainly used by elements to send events to their peer elements. This function takes ownership of the provided event so you should @/gst_event_ref()/@ it if you want to reuse the event after this call. -} padPushEvent :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to push the event to. -} -> Gst.Event.Event {- ^ /@event@/: the 'GI.Gst.Structs.Event.Event' to send to the pad. -} -> m Bool {- ^ __Returns:__ 'True' if the event was handled. MT safe. -} padPushEvent pad event = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad event' <- B.ManagedPtr.disownBoxed event result <- gst_pad_push_event pad' event' let result' = (/= 0) result touchManagedPtr pad touchManagedPtr event return result' #if ENABLE_OVERLOADING data PadPushEventMethodInfo instance (signature ~ (Gst.Event.Event -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadPushEventMethodInfo a signature where overloadedMethod _ = padPushEvent #endif -- method Pad::push_list -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a source #GstPad, returns #GST_FLOW_ERROR if not.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list", argType = TInterface (Name {namespace = "Gst", name = "BufferList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstBufferList to push returns GST_FLOW_ERROR\n if not.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_push_list" gst_pad_push_list :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.BufferList.BufferList -> -- list : TInterface (Name {namespace = "Gst", name = "BufferList"}) IO CInt {- | Pushes a buffer list to the peer of /@pad@/. This function will call installed block probes before triggering any installed data probes. The function proceeds calling the chain function on the peer pad and returns the value from that function. If /@pad@/ has no peer, @/GST_FLOW_NOT_LINKED/@ will be returned. If the peer pad does not have any installed chainlist function every group buffer of the list will be merged into a normal 'GI.Gst.Structs.Buffer.Buffer' and chained via 'GI.Gst.Objects.Pad.padChain'. In all cases, success or failure, the caller loses its reference to /@list@/ after calling this function. -} padPushList :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a source 'GI.Gst.Objects.Pad.Pad', returns @/GST_FLOW_ERROR/@ if not. -} -> Gst.BufferList.BufferList {- ^ /@list@/: the 'GI.Gst.Structs.BufferList.BufferList' to push returns GST_FLOW_ERROR if not. -} -> m Gst.Enums.FlowReturn {- ^ __Returns:__ a 'GI.Gst.Enums.FlowReturn' from the peer pad. MT safe. -} padPushList pad list = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad list' <- B.ManagedPtr.disownBoxed list result <- gst_pad_push_list pad' list' let result' = (toEnum . fromIntegral) result touchManagedPtr pad touchManagedPtr list return result' #if 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 -- method Pad::query -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to invoke the default query on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstQuery to perform.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_query" gst_pad_query :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Query.Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"}) IO CInt {- | Dispatches a query to a pad. The query should have been allocated by the caller via one of the type-specific allocation functions. The element that the pad belongs to is responsible for filling the query with an appropriate response, which should then be parsed with a type-specific query parsing function. Again, the caller is responsible for both the allocation and deallocation of the query structure. Please also note that some queries might need a running pipeline to work. -} padQuery :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to invoke the default query on. -} -> Gst.Query.Query {- ^ /@query@/: the 'GI.Gst.Structs.Query.Query' to perform. -} -> m Bool {- ^ __Returns:__ 'True' if the query could be performed. -} padQuery pad query = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad query' <- unsafeManagedPtrGetPtr query result <- gst_pad_query pad' query' let result' = (/= 0) result touchManagedPtr pad touchManagedPtr query return result' #if ENABLE_OVERLOADING data PadQueryMethodInfo instance (signature ~ (Gst.Query.Query -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadQueryMethodInfo a signature where overloadedMethod _ = padQuery #endif -- method Pad::query_accept_caps -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstCaps to check on the pad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_query_accept_caps" gst_pad_query_accept_caps :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Caps.Caps -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"}) IO CInt {- | Check if the given pad accepts the caps. -} padQueryAcceptCaps :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to check -} -> Gst.Caps.Caps {- ^ /@caps@/: a 'GI.Gst.Structs.Caps.Caps' to check on the pad -} -> m Bool {- ^ __Returns:__ 'True' if the pad can accept the caps. -} padQueryAcceptCaps pad caps = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad caps' <- unsafeManagedPtrGetPtr caps result <- gst_pad_query_accept_caps pad' caps' let result' = (/= 0) result touchManagedPtr pad touchManagedPtr caps return result' #if ENABLE_OVERLOADING data PadQueryAcceptCapsMethodInfo instance (signature ~ (Gst.Caps.Caps -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadQueryAcceptCapsMethodInfo a signature where overloadedMethod _ = padQueryAcceptCaps #endif -- method Pad::query_caps -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to get the capabilities of.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "suggested #GstCaps, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Caps"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_query_caps" gst_pad_query_caps :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Caps.Caps -> -- filter : TInterface (Name {namespace = "Gst", name = "Caps"}) IO (Ptr Gst.Caps.Caps) {- | Gets the capabilities this pad can produce or consume. Note that this method doesn\'t necessarily return the caps set by sending a 'GI.Gst.Structs.Event.eventNewCaps' - use 'GI.Gst.Objects.Pad.padGetCurrentCaps' for that instead. gst_pad_query_caps returns all possible caps a pad can operate with, using the pad\'s CAPS query function, If the query fails, this function will return /@filter@/, if not 'Nothing', otherwise ANY. When called on sinkpads /@filter@/ contains the caps that upstream could produce in the order preferred by upstream. When called on srcpads /@filter@/ contains the caps accepted by downstream in the preferred order. /@filter@/ might be 'Nothing' but if it is not 'Nothing' the returned caps will be a subset of /@filter@/. Note that this function does not return writable 'GI.Gst.Structs.Caps.Caps', use @/gst_caps_make_writable()/@ before modifying the caps. -} padQueryCaps :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to get the capabilities of. -} -> Maybe (Gst.Caps.Caps) {- ^ /@filter@/: suggested 'GI.Gst.Structs.Caps.Caps', or 'Nothing' -} -> m Gst.Caps.Caps {- ^ __Returns:__ the caps of the pad with incremented ref-count. -} padQueryCaps pad filter = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad maybeFilter <- case filter of Nothing -> return nullPtr Just jFilter -> do jFilter' <- unsafeManagedPtrGetPtr jFilter return jFilter' result <- gst_pad_query_caps pad' maybeFilter checkUnexpectedReturnNULL "padQueryCaps" result result' <- (wrapBoxed Gst.Caps.Caps) result touchManagedPtr pad whenJust filter touchManagedPtr return result' #if 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 -- method Pad::query_convert -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to invoke the convert query on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstFormat to convert from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_val", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a value to convert.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstFormat to convert to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_val", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to the result.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_query_convert" gst_pad_query_convert :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) CUInt -> -- src_format : TInterface (Name {namespace = "Gst", name = "Format"}) Int64 -> -- src_val : TBasicType TInt64 CUInt -> -- dest_format : TInterface (Name {namespace = "Gst", name = "Format"}) Ptr Int64 -> -- dest_val : TBasicType TInt64 IO CInt {- | Queries a pad to convert /@srcVal@/ in /@srcFormat@/ to /@destFormat@/. -} padQueryConvert :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to invoke the convert query on. -} -> Gst.Enums.Format {- ^ /@srcFormat@/: a 'GI.Gst.Enums.Format' to convert from. -} -> Int64 {- ^ /@srcVal@/: a value to convert. -} -> Gst.Enums.Format {- ^ /@destFormat@/: the 'GI.Gst.Enums.Format' to convert to. -} -> m ((Bool, Int64)) {- ^ __Returns:__ 'True' if the query could be performed. -} padQueryConvert pad srcFormat srcVal destFormat = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad let srcFormat' = (fromIntegral . fromEnum) srcFormat let destFormat' = (fromIntegral . fromEnum) destFormat destVal <- allocMem :: IO (Ptr Int64) result <- gst_pad_query_convert pad' srcFormat' srcVal destFormat' destVal let result' = (/= 0) result destVal' <- peek destVal touchManagedPtr pad freeMem destVal return (result', destVal') #if 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 -- method Pad::query_default -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to call the default query handler on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the parent of @pad or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstQuery to handle.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_query_default" gst_pad_query_default :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Object.Object -> -- parent : TInterface (Name {namespace = "Gst", name = "Object"}) Ptr Gst.Query.Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"}) IO CInt {- | Invokes the default query handler for the given pad. The query is sent to all pads internally linked to /@pad@/. Note that if there are many possible sink pads that are internally linked to /@pad@/, only one will be sent the query. Multi-sinkpad elements should implement custom query handlers. -} padQueryDefault :: (B.CallStack.HasCallStack, MonadIO m, IsPad a, Gst.Object.IsObject b) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to call the default query handler on. -} -> Maybe (b) {- ^ /@parent@/: the parent of /@pad@/ or 'Nothing' -} -> Gst.Query.Query {- ^ /@query@/: the 'GI.Gst.Structs.Query.Query' to handle. -} -> m Bool {- ^ __Returns:__ 'True' if the query was performed successfully. -} padQueryDefault pad parent query = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad maybeParent <- case parent of Nothing -> return nullPtr Just jParent -> do jParent' <- unsafeManagedPtrCastPtr jParent return jParent' query' <- unsafeManagedPtrGetPtr query result <- gst_pad_query_default pad' maybeParent query' let result' = (/= 0) result touchManagedPtr pad whenJust parent touchManagedPtr touchManagedPtr query return result' #if 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 -- method Pad::query_duration -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to invoke the duration query on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstFormat requested", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location in which to store the total\n duration, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_query_duration" gst_pad_query_duration :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"}) Ptr Int64 -> -- duration : TBasicType TInt64 IO CInt {- | Queries a pad for the total stream duration. -} padQueryDuration :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to invoke the duration query on. -} -> Gst.Enums.Format {- ^ /@format@/: the 'GI.Gst.Enums.Format' requested -} -> m ((Bool, Int64)) {- ^ __Returns:__ 'True' if the query could be performed. -} padQueryDuration pad format = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad let format' = (fromIntegral . fromEnum) format duration <- allocMem :: IO (Ptr Int64) result <- gst_pad_query_duration pad' format' duration let result' = (/= 0) result duration' <- peek duration touchManagedPtr pad freeMem duration return (result', duration') #if 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 -- method Pad::query_position -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to invoke the position query on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstFormat requested", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A location in which to store the current position, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_query_position" gst_pad_query_position :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) CUInt -> -- format : TInterface (Name {namespace = "Gst", name = "Format"}) Ptr Int64 -> -- cur : TBasicType TInt64 IO CInt {- | Queries a pad for the stream position. -} padQueryPosition :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to invoke the position query on. -} -> Gst.Enums.Format {- ^ /@format@/: the 'GI.Gst.Enums.Format' requested -} -> m ((Bool, Int64)) {- ^ __Returns:__ 'True' if the query could be performed. -} padQueryPosition pad format = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad let format' = (fromIntegral . fromEnum) format cur <- allocMem :: IO (Ptr Int64) result <- gst_pad_query_position pad' format' cur let result' = (/= 0) result cur' <- peek cur touchManagedPtr pad freeMem cur return (result', cur') #if 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 -- method Pad::remove_probe -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad with the probe", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the probe id to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_remove_probe" gst_pad_remove_probe :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) CULong -> -- id : TBasicType TULong IO () {- | Remove the probe with /@id@/ from /@pad@/. MT safe. -} padRemoveProbe :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' with the probe -} -> CULong {- ^ /@id@/: the probe id to remove -} -> m () padRemoveProbe pad id = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad gst_pad_remove_probe pad' id touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadRemoveProbeMethodInfo instance (signature ~ (CULong -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadRemoveProbeMethodInfo a signature where overloadedMethod _ = padRemoveProbe #endif -- method Pad::send_event -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad to send the event to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstEvent to send to the pad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_send_event" gst_pad_send_event :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) IO CInt {- | Sends the event to the pad. This function can be used by applications to send events in the pipeline. If /@pad@/ is a source pad, /@event@/ should be an upstream event. If /@pad@/ is a sink pad, /@event@/ should be a downstream event. For example, you would not send a @/GST_EVENT_EOS/@ on a src pad; EOS events only propagate downstream. Furthermore, some downstream events have to be serialized with data flow, like EOS, while some can travel out-of-band, like @/GST_EVENT_FLUSH_START/@. If the event needs to be serialized with data flow, this function will take the pad\'s stream lock while calling its event function. To find out whether an event type is upstream, downstream, or downstream and serialized, see 'GI.Gst.Flags.EventTypeFlags', 'GI.Gst.Functions.eventTypeGetFlags', @/GST_EVENT_IS_UPSTREAM/@, @/GST_EVENT_IS_DOWNSTREAM/@, and @/GST_EVENT_IS_SERIALIZED/@. Note that in practice that an application or plugin doesn\'t need to bother itself with this information; the core handles all necessary locks and checks. This function takes ownership of the provided event so you should @/gst_event_ref()/@ it if you want to reuse the event after this call. -} padSendEvent :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' to send the event to. -} -> Gst.Event.Event {- ^ /@event@/: the 'GI.Gst.Structs.Event.Event' to send to the pad. -} -> m Bool {- ^ __Returns:__ 'True' if the event was handled. -} padSendEvent pad event = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad event' <- B.ManagedPtr.disownBoxed event result <- gst_pad_send_event pad' event' let result' = (/= 0) result touchManagedPtr pad touchManagedPtr event return result' #if ENABLE_OVERLOADING data PadSendEventMethodInfo instance (signature ~ (Gst.Event.Event -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadSendEventMethodInfo a signature where overloadedMethod _ = padSendEvent #endif -- method Pad::set_activate_function_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "activate", argType = TInterface (Name {namespace = "Gst", name = "PadActivateFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPadActivateFunction to set.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data passed to @notify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "notify called when @activate will not be used anymore.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_activate_function_full" gst_pad_set_activate_function_full :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_PadActivateFunction -> -- activate : TInterface (Name {namespace = "Gst", name = "PadActivateFunction"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Sets the given activate function for /@pad@/. The activate function will dispatch to 'GI.Gst.Objects.Pad.padActivateMode' to perform the actual activation. Only makes sense to set on sink pads. Call this function if your sink pad can start a pull-based task. -} padSetActivateFunctionFull :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad'. -} -> Gst.Callbacks.PadActivateFunction {- ^ /@activate@/: the 'GI.Gst.Callbacks.PadActivateFunction' to set. -} -> m () padSetActivateFunctionFull pad activate = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad activate' <- Gst.Callbacks.mk_PadActivateFunction (Gst.Callbacks.wrap_PadActivateFunction Nothing activate) let userData = castFunPtrToPtr activate' let notify = safeFreeFunPtrPtr gst_pad_set_activate_function_full pad' activate' userData notify touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadSetActivateFunctionFullMethodInfo instance (signature ~ (Gst.Callbacks.PadActivateFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetActivateFunctionFullMethodInfo a signature where overloadedMethod _ = padSetActivateFunctionFull #endif -- method Pad::set_activatemode_function_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "activatemode", argType = TInterface (Name {namespace = "Gst", name = "PadActivateModeFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPadActivateModeFunction to set.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data passed to @notify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "notify called when @activatemode will not be used anymore.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_activatemode_function_full" gst_pad_set_activatemode_function_full :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_PadActivateModeFunction -> -- activatemode : TInterface (Name {namespace = "Gst", name = "PadActivateModeFunction"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Sets the given activate_mode function for the pad. An activate_mode function prepares the element for data passing. -} padSetActivatemodeFunctionFull :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad'. -} -> Gst.Callbacks.PadActivateModeFunction {- ^ /@activatemode@/: the 'GI.Gst.Callbacks.PadActivateModeFunction' to set. -} -> m () padSetActivatemodeFunctionFull pad activatemode = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad activatemode' <- Gst.Callbacks.mk_PadActivateModeFunction (Gst.Callbacks.wrap_PadActivateModeFunction Nothing activatemode) let userData = castFunPtrToPtr activatemode' let notify = safeFreeFunPtrPtr gst_pad_set_activatemode_function_full pad' activatemode' userData notify touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadSetActivatemodeFunctionFullMethodInfo instance (signature ~ (Gst.Callbacks.PadActivateModeFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetActivatemodeFunctionFullMethodInfo a signature where overloadedMethod _ = padSetActivatemodeFunctionFull #endif -- method Pad::set_active -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to activate or deactivate.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not the pad should be active.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_active" gst_pad_set_active :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) CInt -> -- active : TBasicType TBoolean IO CInt {- | Activates or deactivates the given pad. Normally called from within core state change functions. If /@active@/, makes sure the pad is active. If it is already active, either in push or pull mode, just return. Otherwise dispatches to the pad\'s activate function to perform the actual activation. If not /@active@/, calls 'GI.Gst.Objects.Pad.padActivateMode' with the pad\'s current mode and a 'False' argument. -} padSetActive :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to activate or deactivate. -} -> Bool {- ^ /@active@/: whether or not the pad should be active. -} -> m Bool {- ^ __Returns:__ 'True' if the operation was successful. MT safe. -} padSetActive pad active = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad let active' = (fromIntegral . fromEnum) active result <- gst_pad_set_active pad' active' let result' = (/= 0) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadSetActiveMethodInfo instance (signature ~ (Bool -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadSetActiveMethodInfo a signature where overloadedMethod _ = padSetActive #endif -- method Pad::set_chain_function_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a sink #GstPad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chain", argType = TInterface (Name {namespace = "Gst", name = "PadChainFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPadChainFunction to set.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data passed to @notify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "notify called when @chain will not be used anymore.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_chain_function_full" gst_pad_set_chain_function_full :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_PadChainFunction -> -- chain : TInterface (Name {namespace = "Gst", name = "PadChainFunction"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Sets the given chain function for the pad. The chain function is called to process a 'GI.Gst.Structs.Buffer.Buffer' input buffer. see 'GI.Gst.Callbacks.PadChainFunction' for more details. -} padSetChainFunctionFull :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a sink 'GI.Gst.Objects.Pad.Pad'. -} -> Gst.Callbacks.PadChainFunction {- ^ /@chain@/: the 'GI.Gst.Callbacks.PadChainFunction' to set. -} -> m () padSetChainFunctionFull pad chain = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad chain' <- Gst.Callbacks.mk_PadChainFunction (Gst.Callbacks.wrap_PadChainFunction Nothing chain) let userData = castFunPtrToPtr chain' let notify = safeFreeFunPtrPtr gst_pad_set_chain_function_full pad' chain' userData notify touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadSetChainFunctionFullMethodInfo instance (signature ~ (Gst.Callbacks.PadChainFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetChainFunctionFullMethodInfo a signature where overloadedMethod _ = padSetChainFunctionFull #endif -- method Pad::set_chain_list_function_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a sink #GstPad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chainlist", argType = TInterface (Name {namespace = "Gst", name = "PadChainListFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPadChainListFunction to set.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data passed to @notify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "notify called when @chainlist will not be used anymore.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_chain_list_function_full" gst_pad_set_chain_list_function_full :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_PadChainListFunction -> -- chainlist : TInterface (Name {namespace = "Gst", name = "PadChainListFunction"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Sets the given chain list function for the pad. The chainlist function is called to process a 'GI.Gst.Structs.BufferList.BufferList' input buffer list. See 'GI.Gst.Callbacks.PadChainListFunction' for more details. -} padSetChainListFunctionFull :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a sink 'GI.Gst.Objects.Pad.Pad'. -} -> Gst.Callbacks.PadChainListFunction {- ^ /@chainlist@/: the 'GI.Gst.Callbacks.PadChainListFunction' to set. -} -> m () padSetChainListFunctionFull pad chainlist = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad chainlist' <- Gst.Callbacks.mk_PadChainListFunction (Gst.Callbacks.wrap_PadChainListFunction Nothing chainlist) let userData = castFunPtrToPtr chainlist' let notify = safeFreeFunPtrPtr gst_pad_set_chain_list_function_full pad' chainlist' userData notify touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadSetChainListFunctionFullMethodInfo instance (signature ~ (Gst.Callbacks.PadChainListFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetChainListFunctionFullMethodInfo a signature where overloadedMethod _ = padSetChainListFunctionFull #endif -- method Pad::set_element_private -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to set the private data of.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "priv", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The private data to attach to the pad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_element_private" gst_pad_set_element_private :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr () -> -- priv : TBasicType TPtr IO () {- | Set the given private data gpointer on the pad. This function can only be used by the element that owns the pad. No locking is performed in this function. -} padSetElementPrivate :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to set the private data of. -} -> Ptr () {- ^ /@priv@/: The private data to attach to the pad. -} -> m () padSetElementPrivate pad priv = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad gst_pad_set_element_private pad' priv touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadSetElementPrivateMethodInfo instance (signature ~ (Ptr () -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetElementPrivateMethodInfo a signature where overloadedMethod _ = padSetElementPrivate #endif -- method Pad::set_event_full_function_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad of either direction.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "PadEventFullFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPadEventFullFunction to set.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data passed to @notify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "notify called when @event will not be used anymore.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_event_full_function_full" gst_pad_set_event_full_function_full :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_PadEventFullFunction -> -- event : TInterface (Name {namespace = "Gst", name = "PadEventFullFunction"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Sets the given event handler for the pad. /Since: 1.8/ -} padSetEventFullFunctionFull :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' of either direction. -} -> Gst.Callbacks.PadEventFullFunction {- ^ /@event@/: the 'GI.Gst.Callbacks.PadEventFullFunction' to set. -} -> m () padSetEventFullFunctionFull pad event = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad event' <- Gst.Callbacks.mk_PadEventFullFunction (Gst.Callbacks.wrap_PadEventFullFunction Nothing event) let userData = castFunPtrToPtr event' let notify = safeFreeFunPtrPtr gst_pad_set_event_full_function_full pad' event' userData notify touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadSetEventFullFunctionFullMethodInfo instance (signature ~ (Gst.Callbacks.PadEventFullFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetEventFullFunctionFullMethodInfo a signature where overloadedMethod _ = padSetEventFullFunctionFull #endif -- method Pad::set_event_function_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad of either direction.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "PadEventFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPadEventFunction to set.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data passed to @notify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "notify called when @event will not be used anymore.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_event_function_full" gst_pad_set_event_function_full :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_PadEventFunction -> -- event : TInterface (Name {namespace = "Gst", name = "PadEventFunction"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Sets the given event handler for the pad. -} padSetEventFunctionFull :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' of either direction. -} -> Gst.Callbacks.PadEventFunction {- ^ /@event@/: the 'GI.Gst.Callbacks.PadEventFunction' to set. -} -> m () padSetEventFunctionFull pad event = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad event' <- Gst.Callbacks.mk_PadEventFunction (Gst.Callbacks.wrap_PadEventFunction Nothing event) let userData = castFunPtrToPtr event' let notify = safeFreeFunPtrPtr gst_pad_set_event_function_full pad' event' userData notify touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadSetEventFunctionFullMethodInfo instance (signature ~ (Gst.Callbacks.PadEventFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetEventFunctionFullMethodInfo a signature where overloadedMethod _ = padSetEventFunctionFull #endif -- method Pad::set_getrange_function_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a source #GstPad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "get", argType = TInterface (Name {namespace = "Gst", name = "PadGetRangeFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPadGetRangeFunction to set.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data passed to @notify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "notify called when @get will not be used anymore.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_getrange_function_full" gst_pad_set_getrange_function_full :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_PadGetRangeFunction -> -- get : TInterface (Name {namespace = "Gst", name = "PadGetRangeFunction"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Sets the given getrange function for the pad. The getrange function is called to produce a new 'GI.Gst.Structs.Buffer.Buffer' to start the processing pipeline. see 'GI.Gst.Callbacks.PadGetRangeFunction' for a description of the getrange function. -} padSetGetrangeFunctionFull :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a source 'GI.Gst.Objects.Pad.Pad'. -} -> Gst.Callbacks.PadGetRangeFunction {- ^ /@get@/: the 'GI.Gst.Callbacks.PadGetRangeFunction' to set. -} -> m () padSetGetrangeFunctionFull pad get = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad get' <- Gst.Callbacks.mk_PadGetRangeFunction (Gst.Callbacks.wrap_PadGetRangeFunction Nothing get) let userData = castFunPtrToPtr get' let notify = safeFreeFunPtrPtr gst_pad_set_getrange_function_full pad' get' userData notify touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadSetGetrangeFunctionFullMethodInfo instance (signature ~ (Gst.Callbacks.PadGetRangeFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetGetrangeFunctionFullMethodInfo a signature where overloadedMethod _ = padSetGetrangeFunctionFull #endif -- method Pad::set_iterate_internal_links_function_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad of either direction.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iterintlink", argType = TInterface (Name {namespace = "Gst", name = "PadIterIntLinkFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPadIterIntLinkFunction to set.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data passed to @notify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "notify called when @iterintlink will not be used anymore.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_iterate_internal_links_function_full" gst_pad_set_iterate_internal_links_function_full :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_PadIterIntLinkFunction -> -- iterintlink : TInterface (Name {namespace = "Gst", name = "PadIterIntLinkFunction"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Sets the given internal link iterator function for the pad. -} padSetIterateInternalLinksFunctionFull :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' of either direction. -} -> Gst.Callbacks.PadIterIntLinkFunction {- ^ /@iterintlink@/: the 'GI.Gst.Callbacks.PadIterIntLinkFunction' to set. -} -> m () padSetIterateInternalLinksFunctionFull pad iterintlink = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad iterintlink' <- Gst.Callbacks.mk_PadIterIntLinkFunction (Gst.Callbacks.wrap_PadIterIntLinkFunction Nothing iterintlink) let userData = castFunPtrToPtr iterintlink' let notify = safeFreeFunPtrPtr gst_pad_set_iterate_internal_links_function_full pad' iterintlink' userData notify touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadSetIterateInternalLinksFunctionFullMethodInfo instance (signature ~ (Gst.Callbacks.PadIterIntLinkFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetIterateInternalLinksFunctionFullMethodInfo a signature where overloadedMethod _ = padSetIterateInternalLinksFunctionFull #endif -- method Pad::set_link_function_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "link", argType = TInterface (Name {namespace = "Gst", name = "PadLinkFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPadLinkFunction to set.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data passed to @notify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "notify called when @link will not be used anymore.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_link_function_full" gst_pad_set_link_function_full :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_PadLinkFunction -> -- link : TInterface (Name {namespace = "Gst", name = "PadLinkFunction"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Sets the given link function for the pad. It will be called when the pad is linked with another pad. The return value @/GST_PAD_LINK_OK/@ should be used when the connection can be made. The return value @/GST_PAD_LINK_REFUSED/@ should be used when the connection cannot be made for some reason. If /@link@/ is installed on a source pad, it should call the 'GI.Gst.Callbacks.PadLinkFunction' of the peer sink pad, if present. -} padSetLinkFunctionFull :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad'. -} -> Gst.Callbacks.PadLinkFunction {- ^ /@link@/: the 'GI.Gst.Callbacks.PadLinkFunction' to set. -} -> m () padSetLinkFunctionFull pad link = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad link' <- Gst.Callbacks.mk_PadLinkFunction (Gst.Callbacks.wrap_PadLinkFunction Nothing link) let userData = castFunPtrToPtr link' let notify = safeFreeFunPtrPtr gst_pad_set_link_function_full pad' link' userData notify touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadSetLinkFunctionFullMethodInfo instance (signature ~ (Gst.Callbacks.PadLinkFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetLinkFunctionFullMethodInfo a signature where overloadedMethod _ = padSetLinkFunctionFull #endif -- method Pad::set_offset -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_offset" gst_pad_set_offset :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Int64 -> -- offset : TBasicType TInt64 IO () {- | Set the offset that will be applied to the running time of /@pad@/. -} padSetOffset :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' -} -> Int64 {- ^ /@offset@/: the offset -} -> m () padSetOffset pad offset = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad gst_pad_set_offset pad' offset touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadSetOffsetMethodInfo instance (signature ~ (Int64 -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetOffsetMethodInfo a signature where overloadedMethod _ = padSetOffset #endif -- method Pad::set_query_function_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad of either direction.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "PadQueryFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPadQueryFunction to set.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data passed to @notify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "notify called when @query will not be used anymore.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_query_function_full" gst_pad_set_query_function_full :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_PadQueryFunction -> -- query : TInterface (Name {namespace = "Gst", name = "PadQueryFunction"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Set the given query function for the pad. -} padSetQueryFunctionFull :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' of either direction. -} -> Gst.Callbacks.PadQueryFunction {- ^ /@query@/: the 'GI.Gst.Callbacks.PadQueryFunction' to set. -} -> m () padSetQueryFunctionFull pad query = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad query' <- Gst.Callbacks.mk_PadQueryFunction (Gst.Callbacks.wrap_PadQueryFunction Nothing query) let userData = castFunPtrToPtr query' let notify = safeFreeFunPtrPtr gst_pad_set_query_function_full pad' query' userData notify touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadSetQueryFunctionFullMethodInfo instance (signature ~ (Gst.Callbacks.PadQueryFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetQueryFunctionFullMethodInfo a signature where overloadedMethod _ = padSetQueryFunctionFull #endif -- method Pad::set_unlink_function_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unlink", argType = TInterface (Name {namespace = "Gst", name = "PadUnlinkFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPadUnlinkFunction to set.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data passed to @notify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "notify called when @unlink will not be used anymore.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_set_unlink_function_full" gst_pad_set_unlink_function_full :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_PadUnlinkFunction -> -- unlink : TInterface (Name {namespace = "Gst", name = "PadUnlinkFunction"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Sets the given unlink function for the pad. It will be called when the pad is unlinked. Note that the pad\'s lock is already held when the unlink function is called, so most pad functions cannot be called from within the callback. -} padSetUnlinkFunctionFull :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad'. -} -> Gst.Callbacks.PadUnlinkFunction {- ^ /@unlink@/: the 'GI.Gst.Callbacks.PadUnlinkFunction' to set. -} -> m () padSetUnlinkFunctionFull pad unlink = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad unlink' <- Gst.Callbacks.mk_PadUnlinkFunction (Gst.Callbacks.wrap_PadUnlinkFunction Nothing unlink) let userData = castFunPtrToPtr unlink' let notify = safeFreeFunPtrPtr gst_pad_set_unlink_function_full pad' unlink' userData notify touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadSetUnlinkFunctionFullMethodInfo instance (signature ~ (Gst.Callbacks.PadUnlinkFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadSetUnlinkFunctionFullMethodInfo a signature where overloadedMethod _ = padSetUnlinkFunctionFull #endif -- method Pad::start_task -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to start the task of", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gst", name = "TaskFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the task function to call", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to the task function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "called when @user_data is no longer referenced", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_start_task" gst_pad_start_task :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_TaskFunction -> -- func : TInterface (Name {namespace = "Gst", name = "TaskFunction"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO CInt {- | Starts a task that repeatedly calls /@func@/ with /@userData@/. This function is mostly used in pad activation functions to start the dataflow. The @/GST_PAD_STREAM_LOCK/@ of /@pad@/ will automatically be acquired before /@func@/ is called. -} padStartTask :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to start the task of -} -> Gst.Callbacks.TaskFunction {- ^ /@func@/: the task function to call -} -> m Bool {- ^ __Returns:__ a 'True' if the task could be started. -} padStartTask pad func = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad func' <- Gst.Callbacks.mk_TaskFunction (Gst.Callbacks.wrap_TaskFunction Nothing (Gst.Callbacks.drop_closures_TaskFunction func)) let userData = castFunPtrToPtr func' let notify = safeFreeFunPtrPtr result <- gst_pad_start_task pad' func' userData notify let result' = (/= 0) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadStartTaskMethodInfo instance (signature ~ (Gst.Callbacks.TaskFunction -> m Bool), MonadIO m, IsPad a) => O.MethodInfo PadStartTaskMethodInfo a signature where overloadedMethod _ = padStartTask #endif -- method Pad::sticky_events_foreach -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad that should be used for iteration.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "foreach_func", argType = TInterface (Name {namespace = "Gst", name = "PadStickyEventsForeachFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPadStickyEventsForeachFunction that\n should be called for every event.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the optional user data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_sticky_events_foreach" gst_pad_sticky_events_foreach :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) FunPtr Gst.Callbacks.C_PadStickyEventsForeachFunction -> -- foreach_func : TInterface (Name {namespace = "Gst", name = "PadStickyEventsForeachFunction"}) Ptr () -> -- user_data : TBasicType TPtr IO () {- | Iterates all sticky events on /@pad@/ and calls /@foreachFunc@/ for every event. If /@foreachFunc@/ returns 'False' the iteration is immediately stopped. -} padStickyEventsForeach :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' that should be used for iteration. -} -> Gst.Callbacks.PadStickyEventsForeachFunction {- ^ /@foreachFunc@/: the 'GI.Gst.Callbacks.PadStickyEventsForeachFunction' that should be called for every event. -} -> m () padStickyEventsForeach pad foreachFunc = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad foreachFunc' <- Gst.Callbacks.mk_PadStickyEventsForeachFunction (Gst.Callbacks.wrap_PadStickyEventsForeachFunction Nothing (Gst.Callbacks.drop_closures_PadStickyEventsForeachFunction foreachFunc)) let userData = nullPtr gst_pad_sticky_events_foreach pad' foreachFunc' userData safeFreeFunPtr $ castFunPtrToPtr foreachFunc' touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadStickyEventsForeachMethodInfo instance (signature ~ (Gst.Callbacks.PadStickyEventsForeachFunction -> m ()), MonadIO m, IsPad a) => O.MethodInfo PadStickyEventsForeachMethodInfo a signature where overloadedMethod _ = padStickyEventsForeach #endif -- method Pad::stop_task -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstPad to stop the task of", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_stop_task" gst_pad_stop_task :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Stop the task of /@pad@/. This function will also make sure that the function executed by the task will effectively stop if not called from the GstTaskFunction. This function will deadlock if called from the GstTaskFunction of the task. Use 'GI.Gst.Objects.Task.taskPause' instead. Regardless of whether the pad has a task, the stream lock is acquired and released so as to ensure that streaming through this pad has finished. -} padStopTask :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the 'GI.Gst.Objects.Pad.Pad' to stop the task of -} -> m Bool {- ^ __Returns:__ a 'True' if the task could be stopped or 'False' on error. -} padStopTask pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad result <- gst_pad_stop_task pad' let result' = (/= 0) result touchManagedPtr pad return result' #if ENABLE_OVERLOADING data PadStopTaskMethodInfo instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.MethodInfo PadStopTaskMethodInfo a signature where overloadedMethod _ = padStopTask #endif -- method Pad::store_sticky_event -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstEvent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) -- throws : False -- Skip return : False foreign import ccall "gst_pad_store_sticky_event" gst_pad_store_sticky_event :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) IO CInt {- | Store the sticky /@event@/ on /@pad@/ /Since: 1.2/ -} padStoreStickyEvent :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: a 'GI.Gst.Objects.Pad.Pad' -} -> Gst.Event.Event {- ^ /@event@/: a 'GI.Gst.Structs.Event.Event' -} -> m Gst.Enums.FlowReturn {- ^ __Returns:__ @/GST_FLOW_OK/@ on success, @/GST_FLOW_FLUSHING/@ when the pad was flushing or @/GST_FLOW_EOS/@ when the pad was EOS. -} padStoreStickyEvent pad event = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad event' <- unsafeManagedPtrGetPtr event result <- gst_pad_store_sticky_event pad' event' let result' = (toEnum . fromIntegral) result touchManagedPtr pad touchManagedPtr event return result' #if 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 -- method Pad::unlink -- method type : OrdinaryMethod -- Args : [Arg {argCName = "srcpad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source #GstPad to unlink.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sinkpad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the sink #GstPad to unlink.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_pad_unlink" gst_pad_unlink :: Ptr Pad -> -- srcpad : TInterface (Name {namespace = "Gst", name = "Pad"}) Ptr Pad -> -- sinkpad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO CInt {- | Unlinks the source pad from the sink pad. Will emit the 'GI.Gst.Objects.Pad.Pad'::@/unlinked/@ signal on both pads. -} padUnlink :: (B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) => a {- ^ /@srcpad@/: the source 'GI.Gst.Objects.Pad.Pad' to unlink. -} -> b {- ^ /@sinkpad@/: the sink 'GI.Gst.Objects.Pad.Pad' to unlink. -} -> m Bool {- ^ __Returns:__ 'True' if the pads were unlinked. This function returns 'False' if the pads were not linked together. MT safe. -} padUnlink srcpad sinkpad = liftIO $ do srcpad' <- unsafeManagedPtrCastPtr srcpad sinkpad' <- unsafeManagedPtrCastPtr sinkpad result <- gst_pad_unlink srcpad' sinkpad' let result' = (/= 0) result touchManagedPtr srcpad touchManagedPtr sinkpad return result' #if ENABLE_OVERLOADING data PadUnlinkMethodInfo instance (signature ~ (b -> m Bool), MonadIO m, IsPad a, IsPad b) => O.MethodInfo PadUnlinkMethodInfo a signature where overloadedMethod _ = padUnlink #endif -- method Pad::use_fixed_caps -- method type : OrdinaryMethod -- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "Gst", name = "Pad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the pad to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_pad_use_fixed_caps" gst_pad_use_fixed_caps :: Ptr Pad -> -- pad : TInterface (Name {namespace = "Gst", name = "Pad"}) IO () {- | A helper function you can use that sets the FIXED_CAPS flag This way the default CAPS query will always return the negotiated caps or in case the pad is not negotiated, the padtemplate caps. The negotiated caps are the caps of the last CAPS event that passed on the pad. Use this function on a pad that, once it negotiated to a CAPS, cannot be renegotiated to something else. -} padUseFixedCaps :: (B.CallStack.HasCallStack, MonadIO m, IsPad a) => a {- ^ /@pad@/: the pad to use -} -> m () padUseFixedCaps pad = liftIO $ do pad' <- unsafeManagedPtrCastPtr pad gst_pad_use_fixed_caps pad' touchManagedPtr pad return () #if ENABLE_OVERLOADING data PadUseFixedCapsMethodInfo instance (signature ~ (m ()), MonadIO m, IsPad a) => O.MethodInfo PadUseFixedCapsMethodInfo a signature where overloadedMethod _ = padUseFixedCaps #endif -- method Pad::link_get_name -- method type : MemberFunction -- Args : [Arg {argCName = "ret", argType = TInterface (Name {namespace = "Gst", name = "PadLinkReturn"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstPadLinkReturn to get the name of.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "gst_pad_link_get_name" gst_pad_link_get_name :: CInt -> -- ret : TInterface (Name {namespace = "Gst", name = "PadLinkReturn"}) IO CString {- | Gets a string representing the given pad-link return. /Since: 1.4/ -} padLinkGetName :: (B.CallStack.HasCallStack, MonadIO m) => Gst.Enums.PadLinkReturn {- ^ /@ret@/: a 'GI.Gst.Enums.PadLinkReturn' to get the name of. -} -> m T.Text {- ^ __Returns:__ a static string with the name of the pad-link return. -} padLinkGetName ret = liftIO $ do let ret' = (fromIntegral . fromEnum) ret result <- gst_pad_link_get_name ret' checkUnexpectedReturnNULL "padLinkGetName" result result' <- cstringToText result return result' #if ENABLE_OVERLOADING #endif