#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Gst.Objects.Stream
(
Stream(..) ,
IsStream ,
toStream ,
noStream ,
#if ENABLE_OVERLOADING
StreamGetCapsMethodInfo ,
#endif
streamGetCaps ,
#if ENABLE_OVERLOADING
StreamGetStreamFlagsMethodInfo ,
#endif
streamGetStreamFlags ,
#if ENABLE_OVERLOADING
StreamGetStreamIdMethodInfo ,
#endif
streamGetStreamId ,
#if ENABLE_OVERLOADING
StreamGetStreamTypeMethodInfo ,
#endif
streamGetStreamType ,
#if ENABLE_OVERLOADING
StreamGetTagsMethodInfo ,
#endif
streamGetTags ,
streamNew ,
#if ENABLE_OVERLOADING
StreamSetCapsMethodInfo ,
#endif
streamSetCaps ,
#if ENABLE_OVERLOADING
StreamSetStreamFlagsMethodInfo ,
#endif
streamSetStreamFlags ,
#if ENABLE_OVERLOADING
StreamSetStreamTypeMethodInfo ,
#endif
streamSetStreamType ,
#if ENABLE_OVERLOADING
StreamSetTagsMethodInfo ,
#endif
streamSetTags ,
#if ENABLE_OVERLOADING
StreamCapsPropertyInfo ,
#endif
clearStreamCaps ,
constructStreamCaps ,
getStreamCaps ,
setStreamCaps ,
#if ENABLE_OVERLOADING
streamCaps ,
#endif
#if ENABLE_OVERLOADING
StreamStreamFlagsPropertyInfo ,
#endif
constructStreamStreamFlags ,
getStreamStreamFlags ,
setStreamStreamFlags ,
#if ENABLE_OVERLOADING
streamStreamFlags ,
#endif
#if ENABLE_OVERLOADING
StreamStreamIdPropertyInfo ,
#endif
constructStreamStreamId ,
getStreamStreamId ,
#if ENABLE_OVERLOADING
streamStreamId ,
#endif
#if ENABLE_OVERLOADING
StreamStreamTypePropertyInfo ,
#endif
constructStreamStreamType ,
getStreamStreamType ,
setStreamStreamType ,
#if ENABLE_OVERLOADING
streamStreamType ,
#endif
#if ENABLE_OVERLOADING
StreamTagsPropertyInfo ,
#endif
clearStreamTags ,
constructStreamTags ,
getStreamTags ,
setStreamTags ,
#if ENABLE_OVERLOADING
streamTags ,
#endif
) 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.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.Gst.Structs.TagList as Gst.TagList
newtype Stream = Stream (ManagedPtr Stream)
foreign import ccall "gst_stream_get_type"
c_gst_stream_get_type :: IO GType
instance GObject Stream where
gobjectType = c_gst_stream_get_type
class (GObject o, O.IsDescendantOf Stream o) => IsStream o
instance (GObject o, O.IsDescendantOf Stream o) => IsStream o
instance O.HasParentTypes Stream
type instance O.ParentTypes Stream = '[Gst.Object.Object, GObject.Object.Object]
toStream :: (MonadIO m, IsStream o) => o -> m Stream
toStream = liftIO . unsafeCastTo Stream
noStream :: Maybe Stream
noStream = Nothing
#if ENABLE_OVERLOADING
type family ResolveStreamMethod (t :: Symbol) (o :: *) :: * where
ResolveStreamMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolveStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveStreamMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolveStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveStreamMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolveStreamMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolveStreamMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolveStreamMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolveStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveStreamMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolveStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveStreamMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolveStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveStreamMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolveStreamMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolveStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveStreamMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolveStreamMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolveStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveStreamMethod "getCaps" o = StreamGetCapsMethodInfo
ResolveStreamMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolveStreamMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolveStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveStreamMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolveStreamMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
ResolveStreamMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolveStreamMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolveStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveStreamMethod "getStreamFlags" o = StreamGetStreamFlagsMethodInfo
ResolveStreamMethod "getStreamId" o = StreamGetStreamIdMethodInfo
ResolveStreamMethod "getStreamType" o = StreamGetStreamTypeMethodInfo
ResolveStreamMethod "getTags" o = StreamGetTagsMethodInfo
ResolveStreamMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolveStreamMethod "setCaps" o = StreamSetCapsMethodInfo
ResolveStreamMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolveStreamMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolveStreamMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolveStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveStreamMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolveStreamMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolveStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveStreamMethod "setStreamFlags" o = StreamSetStreamFlagsMethodInfo
ResolveStreamMethod "setStreamType" o = StreamSetStreamTypeMethodInfo
ResolveStreamMethod "setTags" o = StreamSetTagsMethodInfo
ResolveStreamMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveStreamMethod t Stream, O.MethodInfo info Stream p) => OL.IsLabel t (Stream -> 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
getStreamCaps :: (MonadIO m, IsStream o) => o -> m (Maybe Gst.Caps.Caps)
getStreamCaps obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "caps" Gst.Caps.Caps
setStreamCaps :: (MonadIO m, IsStream o) => o -> Gst.Caps.Caps -> m ()
setStreamCaps obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "caps" (Just val)
constructStreamCaps :: (IsStream o) => Gst.Caps.Caps -> IO (GValueConstruct o)
constructStreamCaps val = B.Properties.constructObjectPropertyBoxed "caps" (Just val)
clearStreamCaps :: (MonadIO m, IsStream o) => o -> m ()
clearStreamCaps obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "caps" (Nothing :: Maybe Gst.Caps.Caps)
#if ENABLE_OVERLOADING
data StreamCapsPropertyInfo
instance AttrInfo StreamCapsPropertyInfo where
type AttrAllowedOps StreamCapsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint StreamCapsPropertyInfo = (~) Gst.Caps.Caps
type AttrBaseTypeConstraint StreamCapsPropertyInfo = IsStream
type AttrGetType StreamCapsPropertyInfo = (Maybe Gst.Caps.Caps)
type AttrLabel StreamCapsPropertyInfo = "caps"
type AttrOrigin StreamCapsPropertyInfo = Stream
attrGet _ = getStreamCaps
attrSet _ = setStreamCaps
attrConstruct _ = constructStreamCaps
attrClear _ = clearStreamCaps
#endif
getStreamStreamFlags :: (MonadIO m, IsStream o) => o -> m [Gst.Flags.StreamFlags]
getStreamStreamFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "stream-flags"
setStreamStreamFlags :: (MonadIO m, IsStream o) => o -> [Gst.Flags.StreamFlags] -> m ()
setStreamStreamFlags obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "stream-flags" val
constructStreamStreamFlags :: (IsStream o) => [Gst.Flags.StreamFlags] -> IO (GValueConstruct o)
constructStreamStreamFlags val = B.Properties.constructObjectPropertyFlags "stream-flags" val
#if ENABLE_OVERLOADING
data StreamStreamFlagsPropertyInfo
instance AttrInfo StreamStreamFlagsPropertyInfo where
type AttrAllowedOps StreamStreamFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint StreamStreamFlagsPropertyInfo = (~) [Gst.Flags.StreamFlags]
type AttrBaseTypeConstraint StreamStreamFlagsPropertyInfo = IsStream
type AttrGetType StreamStreamFlagsPropertyInfo = [Gst.Flags.StreamFlags]
type AttrLabel StreamStreamFlagsPropertyInfo = "stream-flags"
type AttrOrigin StreamStreamFlagsPropertyInfo = Stream
attrGet _ = getStreamStreamFlags
attrSet _ = setStreamStreamFlags
attrConstruct _ = constructStreamStreamFlags
attrClear _ = undefined
#endif
getStreamStreamId :: (MonadIO m, IsStream o) => o -> m (Maybe T.Text)
getStreamStreamId obj = liftIO $ B.Properties.getObjectPropertyString obj "stream-id"
constructStreamStreamId :: (IsStream o) => T.Text -> IO (GValueConstruct o)
constructStreamStreamId val = B.Properties.constructObjectPropertyString "stream-id" (Just val)
#if ENABLE_OVERLOADING
data StreamStreamIdPropertyInfo
instance AttrInfo StreamStreamIdPropertyInfo where
type AttrAllowedOps StreamStreamIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint StreamStreamIdPropertyInfo = (~) T.Text
type AttrBaseTypeConstraint StreamStreamIdPropertyInfo = IsStream
type AttrGetType StreamStreamIdPropertyInfo = (Maybe T.Text)
type AttrLabel StreamStreamIdPropertyInfo = "stream-id"
type AttrOrigin StreamStreamIdPropertyInfo = Stream
attrGet _ = getStreamStreamId
attrSet _ = undefined
attrConstruct _ = constructStreamStreamId
attrClear _ = undefined
#endif
getStreamStreamType :: (MonadIO m, IsStream o) => o -> m [Gst.Flags.StreamType]
getStreamStreamType obj = liftIO $ B.Properties.getObjectPropertyFlags obj "stream-type"
setStreamStreamType :: (MonadIO m, IsStream o) => o -> [Gst.Flags.StreamType] -> m ()
setStreamStreamType obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "stream-type" val
constructStreamStreamType :: (IsStream o) => [Gst.Flags.StreamType] -> IO (GValueConstruct o)
constructStreamStreamType val = B.Properties.constructObjectPropertyFlags "stream-type" val
#if ENABLE_OVERLOADING
data StreamStreamTypePropertyInfo
instance AttrInfo StreamStreamTypePropertyInfo where
type AttrAllowedOps StreamStreamTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint StreamStreamTypePropertyInfo = (~) [Gst.Flags.StreamType]
type AttrBaseTypeConstraint StreamStreamTypePropertyInfo = IsStream
type AttrGetType StreamStreamTypePropertyInfo = [Gst.Flags.StreamType]
type AttrLabel StreamStreamTypePropertyInfo = "stream-type"
type AttrOrigin StreamStreamTypePropertyInfo = Stream
attrGet _ = getStreamStreamType
attrSet _ = setStreamStreamType
attrConstruct _ = constructStreamStreamType
attrClear _ = undefined
#endif
getStreamTags :: (MonadIO m, IsStream o) => o -> m (Maybe Gst.TagList.TagList)
getStreamTags obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "tags" Gst.TagList.TagList
setStreamTags :: (MonadIO m, IsStream o) => o -> Gst.TagList.TagList -> m ()
setStreamTags obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "tags" (Just val)
constructStreamTags :: (IsStream o) => Gst.TagList.TagList -> IO (GValueConstruct o)
constructStreamTags val = B.Properties.constructObjectPropertyBoxed "tags" (Just val)
clearStreamTags :: (MonadIO m, IsStream o) => o -> m ()
clearStreamTags obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "tags" (Nothing :: Maybe Gst.TagList.TagList)
#if ENABLE_OVERLOADING
data StreamTagsPropertyInfo
instance AttrInfo StreamTagsPropertyInfo where
type AttrAllowedOps StreamTagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint StreamTagsPropertyInfo = (~) Gst.TagList.TagList
type AttrBaseTypeConstraint StreamTagsPropertyInfo = IsStream
type AttrGetType StreamTagsPropertyInfo = (Maybe Gst.TagList.TagList)
type AttrLabel StreamTagsPropertyInfo = "tags"
type AttrOrigin StreamTagsPropertyInfo = Stream
attrGet _ = getStreamTags
attrSet _ = setStreamTags
attrConstruct _ = constructStreamTags
attrClear _ = clearStreamTags
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList Stream
type instance O.AttributeList Stream = StreamAttributeList
type StreamAttributeList = ('[ '("caps", StreamCapsPropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("streamFlags", StreamStreamFlagsPropertyInfo), '("streamId", StreamStreamIdPropertyInfo), '("streamType", StreamStreamTypePropertyInfo), '("tags", StreamTagsPropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
streamCaps :: AttrLabelProxy "caps"
streamCaps = AttrLabelProxy
streamStreamFlags :: AttrLabelProxy "streamFlags"
streamStreamFlags = AttrLabelProxy
streamStreamId :: AttrLabelProxy "streamId"
streamStreamId = AttrLabelProxy
streamStreamType :: AttrLabelProxy "streamType"
streamStreamType = AttrLabelProxy
streamTags :: AttrLabelProxy "tags"
streamTags = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
type instance O.SignalList Stream = StreamSignalList
type StreamSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_stream_new" gst_stream_new ::
CString ->
Ptr Gst.Caps.Caps ->
CUInt ->
CUInt ->
IO (Ptr Stream)
streamNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> Maybe (Gst.Caps.Caps)
-> [Gst.Flags.StreamType]
-> [Gst.Flags.StreamFlags]
-> m Stream
streamNew streamId caps type_ flags = liftIO $ do
maybeStreamId <- case streamId of
Nothing -> return nullPtr
Just jStreamId -> do
jStreamId' <- textToCString jStreamId
return jStreamId'
maybeCaps <- case caps of
Nothing -> return nullPtr
Just jCaps -> do
jCaps' <- unsafeManagedPtrGetPtr jCaps
return jCaps'
let type_' = gflagsToWord type_
let flags' = gflagsToWord flags
result <- gst_stream_new maybeStreamId maybeCaps type_' flags'
checkUnexpectedReturnNULL "streamNew" result
result' <- (wrapObject Stream) result
whenJust caps touchManagedPtr
freeMem maybeStreamId
return result'
#if ENABLE_OVERLOADING
#endif
foreign import ccall "gst_stream_get_caps" gst_stream_get_caps ::
Ptr Stream ->
IO (Ptr Gst.Caps.Caps)
streamGetCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsStream a) =>
a
-> m (Maybe Gst.Caps.Caps)
streamGetCaps stream = liftIO $ do
stream' <- unsafeManagedPtrCastPtr stream
result <- gst_stream_get_caps stream'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Gst.Caps.Caps) result'
return result''
touchManagedPtr stream
return maybeResult
#if ENABLE_OVERLOADING
data StreamGetCapsMethodInfo
instance (signature ~ (m (Maybe Gst.Caps.Caps)), MonadIO m, IsStream a) => O.MethodInfo StreamGetCapsMethodInfo a signature where
overloadedMethod _ = streamGetCaps
#endif
foreign import ccall "gst_stream_get_stream_flags" gst_stream_get_stream_flags ::
Ptr Stream ->
IO CUInt
streamGetStreamFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsStream a) =>
a
-> m [Gst.Flags.StreamFlags]
streamGetStreamFlags stream = liftIO $ do
stream' <- unsafeManagedPtrCastPtr stream
result <- gst_stream_get_stream_flags stream'
let result' = wordToGFlags result
touchManagedPtr stream
return result'
#if ENABLE_OVERLOADING
data StreamGetStreamFlagsMethodInfo
instance (signature ~ (m [Gst.Flags.StreamFlags]), MonadIO m, IsStream a) => O.MethodInfo StreamGetStreamFlagsMethodInfo a signature where
overloadedMethod _ = streamGetStreamFlags
#endif
foreign import ccall "gst_stream_get_stream_id" gst_stream_get_stream_id ::
Ptr Stream ->
IO CString
streamGetStreamId ::
(B.CallStack.HasCallStack, MonadIO m, IsStream a) =>
a
-> m (Maybe T.Text)
streamGetStreamId stream = liftIO $ do
stream' <- unsafeManagedPtrCastPtr stream
result <- gst_stream_get_stream_id stream'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- cstringToText result'
return result''
touchManagedPtr stream
return maybeResult
#if ENABLE_OVERLOADING
data StreamGetStreamIdMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsStream a) => O.MethodInfo StreamGetStreamIdMethodInfo a signature where
overloadedMethod _ = streamGetStreamId
#endif
foreign import ccall "gst_stream_get_stream_type" gst_stream_get_stream_type ::
Ptr Stream ->
IO CUInt
streamGetStreamType ::
(B.CallStack.HasCallStack, MonadIO m, IsStream a) =>
a
-> m [Gst.Flags.StreamType]
streamGetStreamType stream = liftIO $ do
stream' <- unsafeManagedPtrCastPtr stream
result <- gst_stream_get_stream_type stream'
let result' = wordToGFlags result
touchManagedPtr stream
return result'
#if ENABLE_OVERLOADING
data StreamGetStreamTypeMethodInfo
instance (signature ~ (m [Gst.Flags.StreamType]), MonadIO m, IsStream a) => O.MethodInfo StreamGetStreamTypeMethodInfo a signature where
overloadedMethod _ = streamGetStreamType
#endif
foreign import ccall "gst_stream_get_tags" gst_stream_get_tags ::
Ptr Stream ->
IO (Ptr Gst.TagList.TagList)
streamGetTags ::
(B.CallStack.HasCallStack, MonadIO m, IsStream a) =>
a
-> m (Maybe Gst.TagList.TagList)
streamGetTags stream = liftIO $ do
stream' <- unsafeManagedPtrCastPtr stream
result <- gst_stream_get_tags stream'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Gst.TagList.TagList) result'
return result''
touchManagedPtr stream
return maybeResult
#if ENABLE_OVERLOADING
data StreamGetTagsMethodInfo
instance (signature ~ (m (Maybe Gst.TagList.TagList)), MonadIO m, IsStream a) => O.MethodInfo StreamGetTagsMethodInfo a signature where
overloadedMethod _ = streamGetTags
#endif
foreign import ccall "gst_stream_set_caps" gst_stream_set_caps ::
Ptr Stream ->
Ptr Gst.Caps.Caps ->
IO ()
streamSetCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsStream a) =>
a
-> Maybe (Gst.Caps.Caps)
-> m ()
streamSetCaps stream caps = liftIO $ do
stream' <- unsafeManagedPtrCastPtr stream
maybeCaps <- case caps of
Nothing -> return nullPtr
Just jCaps -> do
jCaps' <- unsafeManagedPtrGetPtr jCaps
return jCaps'
gst_stream_set_caps stream' maybeCaps
touchManagedPtr stream
whenJust caps touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data StreamSetCapsMethodInfo
instance (signature ~ (Maybe (Gst.Caps.Caps) -> m ()), MonadIO m, IsStream a) => O.MethodInfo StreamSetCapsMethodInfo a signature where
overloadedMethod _ = streamSetCaps
#endif
foreign import ccall "gst_stream_set_stream_flags" gst_stream_set_stream_flags ::
Ptr Stream ->
CUInt ->
IO ()
streamSetStreamFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsStream a) =>
a
-> [Gst.Flags.StreamFlags]
-> m ()
streamSetStreamFlags stream flags = liftIO $ do
stream' <- unsafeManagedPtrCastPtr stream
let flags' = gflagsToWord flags
gst_stream_set_stream_flags stream' flags'
touchManagedPtr stream
return ()
#if ENABLE_OVERLOADING
data StreamSetStreamFlagsMethodInfo
instance (signature ~ ([Gst.Flags.StreamFlags] -> m ()), MonadIO m, IsStream a) => O.MethodInfo StreamSetStreamFlagsMethodInfo a signature where
overloadedMethod _ = streamSetStreamFlags
#endif
foreign import ccall "gst_stream_set_stream_type" gst_stream_set_stream_type ::
Ptr Stream ->
CUInt ->
IO ()
streamSetStreamType ::
(B.CallStack.HasCallStack, MonadIO m, IsStream a) =>
a
-> [Gst.Flags.StreamType]
-> m ()
streamSetStreamType stream streamType = liftIO $ do
stream' <- unsafeManagedPtrCastPtr stream
let streamType' = gflagsToWord streamType
gst_stream_set_stream_type stream' streamType'
touchManagedPtr stream
return ()
#if ENABLE_OVERLOADING
data StreamSetStreamTypeMethodInfo
instance (signature ~ ([Gst.Flags.StreamType] -> m ()), MonadIO m, IsStream a) => O.MethodInfo StreamSetStreamTypeMethodInfo a signature where
overloadedMethod _ = streamSetStreamType
#endif
foreign import ccall "gst_stream_set_tags" gst_stream_set_tags ::
Ptr Stream ->
Ptr Gst.TagList.TagList ->
IO ()
streamSetTags ::
(B.CallStack.HasCallStack, MonadIO m, IsStream a) =>
a
-> Maybe (Gst.TagList.TagList)
-> m ()
streamSetTags stream tags = liftIO $ do
stream' <- unsafeManagedPtrCastPtr stream
maybeTags <- case tags of
Nothing -> return nullPtr
Just jTags -> do
jTags' <- unsafeManagedPtrGetPtr jTags
return jTags'
gst_stream_set_tags stream' maybeTags
touchManagedPtr stream
whenJust tags touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data StreamSetTagsMethodInfo
instance (signature ~ (Maybe (Gst.TagList.TagList) -> m ()), MonadIO m, IsStream a) => O.MethodInfo StreamSetTagsMethodInfo a signature where
overloadedMethod _ = streamSetTags
#endif