{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Objects.Stream
(
Stream(..) ,
IsStream ,
toStream ,
#if defined(ENABLE_OVERLOADING)
ResolveStreamMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
StreamGetCapsMethodInfo ,
#endif
streamGetCaps ,
#if defined(ENABLE_OVERLOADING)
StreamGetStreamFlagsMethodInfo ,
#endif
streamGetStreamFlags ,
#if defined(ENABLE_OVERLOADING)
StreamGetStreamIdMethodInfo ,
#endif
streamGetStreamId ,
#if defined(ENABLE_OVERLOADING)
StreamGetStreamTypeMethodInfo ,
#endif
streamGetStreamType ,
#if defined(ENABLE_OVERLOADING)
StreamGetTagsMethodInfo ,
#endif
streamGetTags ,
streamNew ,
#if defined(ENABLE_OVERLOADING)
StreamSetCapsMethodInfo ,
#endif
streamSetCaps ,
#if defined(ENABLE_OVERLOADING)
StreamSetStreamFlagsMethodInfo ,
#endif
streamSetStreamFlags ,
#if defined(ENABLE_OVERLOADING)
StreamSetStreamTypeMethodInfo ,
#endif
streamSetStreamType ,
#if defined(ENABLE_OVERLOADING)
StreamSetTagsMethodInfo ,
#endif
streamSetTags ,
#if defined(ENABLE_OVERLOADING)
StreamCapsPropertyInfo ,
#endif
clearStreamCaps ,
constructStreamCaps ,
getStreamCaps ,
setStreamCaps ,
#if defined(ENABLE_OVERLOADING)
streamCaps ,
#endif
#if defined(ENABLE_OVERLOADING)
StreamStreamFlagsPropertyInfo ,
#endif
constructStreamStreamFlags ,
getStreamStreamFlags ,
setStreamStreamFlags ,
#if defined(ENABLE_OVERLOADING)
streamStreamFlags ,
#endif
#if defined(ENABLE_OVERLOADING)
StreamStreamIdPropertyInfo ,
#endif
constructStreamStreamId ,
getStreamStreamId ,
#if defined(ENABLE_OVERLOADING)
streamStreamId ,
#endif
#if defined(ENABLE_OVERLOADING)
StreamStreamTypePropertyInfo ,
#endif
constructStreamStreamType ,
getStreamStreamType ,
setStreamStreamType ,
#if defined(ENABLE_OVERLOADING)
streamStreamType ,
#endif
#if defined(ENABLE_OVERLOADING)
StreamTagsPropertyInfo ,
#endif
clearStreamTags ,
constructStreamTags ,
getStreamTags ,
setStreamTags ,
#if defined(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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
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 GHC.Records as R
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 (SP.ManagedPtr Stream)
deriving (Stream -> Stream -> Bool
(Stream -> Stream -> Bool)
-> (Stream -> Stream -> Bool) -> Eq Stream
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Stream -> Stream -> Bool
== :: Stream -> Stream -> Bool
$c/= :: Stream -> Stream -> Bool
/= :: Stream -> Stream -> Bool
Eq)
instance SP.ManagedPtrNewtype Stream where
toManagedPtr :: Stream -> ManagedPtr Stream
toManagedPtr (Stream ManagedPtr Stream
p) = ManagedPtr Stream
p
foreign import ccall "gst_stream_get_type"
c_gst_stream_get_type :: IO B.Types.GType
instance B.Types.TypedObject Stream where
glibType :: IO GType
glibType = IO GType
c_gst_stream_get_type
instance B.Types.GObject Stream
class (SP.GObject o, O.IsDescendantOf Stream o) => IsStream o
instance (SP.GObject o, O.IsDescendantOf Stream o) => IsStream o
instance O.HasParentTypes Stream
type instance O.ParentTypes Stream = '[Gst.Object.Object, GObject.Object.Object]
toStream :: (MIO.MonadIO m, IsStream o) => o -> m Stream
toStream :: forall (m :: * -> *) o. (MonadIO m, IsStream o) => o -> m Stream
toStream = IO Stream -> m Stream
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Stream -> m Stream) -> (o -> IO Stream) -> o -> m Stream
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Stream -> Stream) -> o -> IO Stream
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Stream -> Stream
Stream
instance B.GValue.IsGValue (Maybe Stream) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_stream_get_type
gvalueSet_ :: Ptr GValue -> Maybe Stream -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Stream
P.Nothing = Ptr GValue -> Ptr Stream -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Stream
forall a. Ptr a
FP.nullPtr :: FP.Ptr Stream)
gvalueSet_ Ptr GValue
gv (P.Just Stream
obj) = Stream -> (Ptr Stream -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Stream
obj (Ptr GValue -> Ptr Stream -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Stream)
gvalueGet_ Ptr GValue
gv = do
Ptr Stream
ptr <- Ptr GValue -> IO (Ptr Stream)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Stream)
if Ptr Stream
ptr Ptr Stream -> Ptr Stream -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Stream
forall a. Ptr a
FP.nullPtr
then Stream -> Maybe Stream
forall a. a -> Maybe a
P.Just (Stream -> Maybe Stream) -> IO Stream -> IO (Maybe Stream)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Stream -> Stream) -> Ptr Stream -> IO Stream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Stream -> Stream
Stream Ptr Stream
ptr
else Maybe Stream -> IO (Maybe Stream)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Stream
forall a. Maybe a
P.Nothing
#if defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
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.OverloadedMethod info Stream p) => OL.IsLabel t (Stream -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveStreamMethod t Stream, O.OverloadedMethod info Stream p, R.HasField t Stream p) => R.HasField t Stream p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveStreamMethod t Stream, O.OverloadedMethodInfo info Stream) => OL.IsLabel t (O.MethodProxy info Stream) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getStreamCaps :: (MonadIO m, IsStream o) => o -> m (Maybe Gst.Caps.Caps)
getStreamCaps :: forall (m :: * -> *) o.
(MonadIO m, IsStream o) =>
o -> m (Maybe Caps)
getStreamCaps o
obj = IO (Maybe Caps) -> m (Maybe Caps)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Caps) -> m (Maybe Caps))
-> IO (Maybe Caps) -> m (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Caps -> Caps) -> IO (Maybe Caps)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"caps" ManagedPtr Caps -> Caps
Gst.Caps.Caps
setStreamCaps :: (MonadIO m, IsStream o) => o -> Gst.Caps.Caps -> m ()
setStreamCaps :: forall (m :: * -> *) o.
(MonadIO m, IsStream o) =>
o -> Caps -> m ()
setStreamCaps o
obj Caps
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe Caps -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"caps" (Caps -> Maybe Caps
forall a. a -> Maybe a
Just Caps
val)
constructStreamCaps :: (IsStream o, MIO.MonadIO m) => Gst.Caps.Caps -> m (GValueConstruct o)
constructStreamCaps :: forall o (m :: * -> *).
(IsStream o, MonadIO m) =>
Caps -> m (GValueConstruct o)
constructStreamCaps Caps
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Caps -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"caps" (Caps -> Maybe Caps
forall a. a -> Maybe a
P.Just Caps
val)
clearStreamCaps :: (MonadIO m, IsStream o) => o -> m ()
clearStreamCaps :: forall (m :: * -> *) o. (MonadIO m, IsStream o) => o -> m ()
clearStreamCaps o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Caps -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"caps" (Maybe Caps
forall a. Maybe a
Nothing :: Maybe Gst.Caps.Caps)
#if defined(ENABLE_OVERLOADING)
data StreamCapsPropertyInfo
instance AttrInfo StreamCapsPropertyInfo where
type AttrAllowedOps StreamCapsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint StreamCapsPropertyInfo = IsStream
type AttrSetTypeConstraint StreamCapsPropertyInfo = (~) Gst.Caps.Caps
type AttrTransferTypeConstraint StreamCapsPropertyInfo = (~) Gst.Caps.Caps
type AttrTransferType StreamCapsPropertyInfo = Gst.Caps.Caps
type AttrGetType StreamCapsPropertyInfo = (Maybe Gst.Caps.Caps)
type AttrLabel StreamCapsPropertyInfo = "caps"
type AttrOrigin StreamCapsPropertyInfo = Stream
attrGet = getStreamCaps
attrSet = setStreamCaps
attrTransfer _ v = do
return v
attrConstruct = constructStreamCaps
attrClear = clearStreamCaps
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.caps"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#g:attr:caps"
})
#endif
getStreamStreamFlags :: (MonadIO m, IsStream o) => o -> m [Gst.Flags.StreamFlags]
getStreamStreamFlags :: forall (m :: * -> *) o.
(MonadIO m, IsStream o) =>
o -> m [StreamFlags]
getStreamStreamFlags o
obj = IO [StreamFlags] -> m [StreamFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [StreamFlags] -> m [StreamFlags])
-> IO [StreamFlags] -> m [StreamFlags]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [StreamFlags]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"stream-flags"
setStreamStreamFlags :: (MonadIO m, IsStream o) => o -> [Gst.Flags.StreamFlags] -> m ()
setStreamStreamFlags :: forall (m :: * -> *) o.
(MonadIO m, IsStream o) =>
o -> [StreamFlags] -> m ()
setStreamStreamFlags o
obj [StreamFlags]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> [StreamFlags] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"stream-flags" [StreamFlags]
val
constructStreamStreamFlags :: (IsStream o, MIO.MonadIO m) => [Gst.Flags.StreamFlags] -> m (GValueConstruct o)
constructStreamStreamFlags :: forall o (m :: * -> *).
(IsStream o, MonadIO m) =>
[StreamFlags] -> m (GValueConstruct o)
constructStreamStreamFlags [StreamFlags]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> [StreamFlags] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"stream-flags" [StreamFlags]
val
#if defined(ENABLE_OVERLOADING)
data StreamStreamFlagsPropertyInfo
instance AttrInfo StreamStreamFlagsPropertyInfo where
type AttrAllowedOps StreamStreamFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint StreamStreamFlagsPropertyInfo = IsStream
type AttrSetTypeConstraint StreamStreamFlagsPropertyInfo = (~) [Gst.Flags.StreamFlags]
type AttrTransferTypeConstraint StreamStreamFlagsPropertyInfo = (~) [Gst.Flags.StreamFlags]
type AttrTransferType StreamStreamFlagsPropertyInfo = [Gst.Flags.StreamFlags]
type AttrGetType StreamStreamFlagsPropertyInfo = [Gst.Flags.StreamFlags]
type AttrLabel StreamStreamFlagsPropertyInfo = "stream-flags"
type AttrOrigin StreamStreamFlagsPropertyInfo = Stream
attrGet = getStreamStreamFlags
attrSet = setStreamStreamFlags
attrTransfer _ v = do
return v
attrConstruct = constructStreamStreamFlags
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.streamFlags"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#g:attr:streamFlags"
})
#endif
getStreamStreamId :: (MonadIO m, IsStream o) => o -> m (Maybe T.Text)
getStreamStreamId :: forall (m :: * -> *) o.
(MonadIO m, IsStream o) =>
o -> m (Maybe Text)
getStreamStreamId o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"stream-id"
constructStreamStreamId :: (IsStream o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructStreamStreamId :: forall o (m :: * -> *).
(IsStream o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructStreamStreamId Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"stream-id" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)
#if defined(ENABLE_OVERLOADING)
data StreamStreamIdPropertyInfo
instance AttrInfo StreamStreamIdPropertyInfo where
type AttrAllowedOps StreamStreamIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint StreamStreamIdPropertyInfo = IsStream
type AttrSetTypeConstraint StreamStreamIdPropertyInfo = (~) T.Text
type AttrTransferTypeConstraint StreamStreamIdPropertyInfo = (~) T.Text
type AttrTransferType StreamStreamIdPropertyInfo = T.Text
type AttrGetType StreamStreamIdPropertyInfo = (Maybe T.Text)
type AttrLabel StreamStreamIdPropertyInfo = "stream-id"
type AttrOrigin StreamStreamIdPropertyInfo = Stream
attrGet = getStreamStreamId
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructStreamStreamId
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.streamId"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#g:attr:streamId"
})
#endif
getStreamStreamType :: (MonadIO m, IsStream o) => o -> m [Gst.Flags.StreamType]
getStreamStreamType :: forall (m :: * -> *) o.
(MonadIO m, IsStream o) =>
o -> m [StreamType]
getStreamStreamType o
obj = IO [StreamType] -> m [StreamType]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [StreamType] -> m [StreamType])
-> IO [StreamType] -> m [StreamType]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [StreamType]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"stream-type"
setStreamStreamType :: (MonadIO m, IsStream o) => o -> [Gst.Flags.StreamType] -> m ()
setStreamStreamType :: forall (m :: * -> *) o.
(MonadIO m, IsStream o) =>
o -> [StreamType] -> m ()
setStreamStreamType o
obj [StreamType]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> [StreamType] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"stream-type" [StreamType]
val
constructStreamStreamType :: (IsStream o, MIO.MonadIO m) => [Gst.Flags.StreamType] -> m (GValueConstruct o)
constructStreamStreamType :: forall o (m :: * -> *).
(IsStream o, MonadIO m) =>
[StreamType] -> m (GValueConstruct o)
constructStreamStreamType [StreamType]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> [StreamType] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"stream-type" [StreamType]
val
#if defined(ENABLE_OVERLOADING)
data StreamStreamTypePropertyInfo
instance AttrInfo StreamStreamTypePropertyInfo where
type AttrAllowedOps StreamStreamTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint StreamStreamTypePropertyInfo = IsStream
type AttrSetTypeConstraint StreamStreamTypePropertyInfo = (~) [Gst.Flags.StreamType]
type AttrTransferTypeConstraint StreamStreamTypePropertyInfo = (~) [Gst.Flags.StreamType]
type AttrTransferType StreamStreamTypePropertyInfo = [Gst.Flags.StreamType]
type AttrGetType StreamStreamTypePropertyInfo = [Gst.Flags.StreamType]
type AttrLabel StreamStreamTypePropertyInfo = "stream-type"
type AttrOrigin StreamStreamTypePropertyInfo = Stream
attrGet = getStreamStreamType
attrSet = setStreamStreamType
attrTransfer _ v = do
return v
attrConstruct = constructStreamStreamType
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.streamType"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#g:attr:streamType"
})
#endif
getStreamTags :: (MonadIO m, IsStream o) => o -> m (Maybe Gst.TagList.TagList)
getStreamTags :: forall (m :: * -> *) o.
(MonadIO m, IsStream o) =>
o -> m (Maybe TagList)
getStreamTags o
obj = IO (Maybe TagList) -> m (Maybe TagList)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe TagList) -> m (Maybe TagList))
-> IO (Maybe TagList) -> m (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr TagList -> TagList) -> IO (Maybe TagList)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"tags" ManagedPtr TagList -> TagList
Gst.TagList.TagList
setStreamTags :: (MonadIO m, IsStream o) => o -> Gst.TagList.TagList -> m ()
setStreamTags :: forall (m :: * -> *) o.
(MonadIO m, IsStream o) =>
o -> TagList -> m ()
setStreamTags o
obj TagList
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe TagList -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"tags" (TagList -> Maybe TagList
forall a. a -> Maybe a
Just TagList
val)
constructStreamTags :: (IsStream o, MIO.MonadIO m) => Gst.TagList.TagList -> m (GValueConstruct o)
constructStreamTags :: forall o (m :: * -> *).
(IsStream o, MonadIO m) =>
TagList -> m (GValueConstruct o)
constructStreamTags TagList
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe TagList -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"tags" (TagList -> Maybe TagList
forall a. a -> Maybe a
P.Just TagList
val)
clearStreamTags :: (MonadIO m, IsStream o) => o -> m ()
clearStreamTags :: forall (m :: * -> *) o. (MonadIO m, IsStream o) => o -> m ()
clearStreamTags o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe TagList -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"tags" (Maybe TagList
forall a. Maybe a
Nothing :: Maybe Gst.TagList.TagList)
#if defined(ENABLE_OVERLOADING)
data StreamTagsPropertyInfo
instance AttrInfo StreamTagsPropertyInfo where
type AttrAllowedOps StreamTagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint StreamTagsPropertyInfo = IsStream
type AttrSetTypeConstraint StreamTagsPropertyInfo = (~) Gst.TagList.TagList
type AttrTransferTypeConstraint StreamTagsPropertyInfo = (~) Gst.TagList.TagList
type AttrTransferType StreamTagsPropertyInfo = Gst.TagList.TagList
type AttrGetType StreamTagsPropertyInfo = (Maybe Gst.TagList.TagList)
type AttrLabel StreamTagsPropertyInfo = "tags"
type AttrOrigin StreamTagsPropertyInfo = Stream
attrGet = getStreamTags
attrSet = setStreamTags
attrTransfer _ v = do
return v
attrConstruct = constructStreamTags
attrClear = clearStreamTags
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.tags"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#g:attr:tags"
})
#endif
#if defined(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 defined(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 defined(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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text
-> Maybe Caps -> [StreamType] -> [StreamFlags] -> m Stream
streamNew Maybe Text
streamId Maybe Caps
caps [StreamType]
type_ [StreamFlags]
flags = IO Stream -> m Stream
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Stream -> m Stream) -> IO Stream -> m Stream
forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
maybeStreamId <- case Maybe Text
streamId of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jStreamId -> do
Ptr CChar
jStreamId' <- Text -> IO (Ptr CChar)
textToCString Text
jStreamId
Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jStreamId'
Ptr Caps
maybeCaps <- case Maybe Caps
caps of
Maybe Caps
Nothing -> Ptr Caps -> IO (Ptr Caps)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
forall a. Ptr a
nullPtr
Just Caps
jCaps -> do
Ptr Caps
jCaps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
jCaps
Ptr Caps -> IO (Ptr Caps)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
jCaps'
let type_' :: CUInt
type_' = [StreamType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StreamType]
type_
let flags' :: CUInt
flags' = [StreamFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StreamFlags]
flags
Ptr Stream
result <- Ptr CChar -> Ptr Caps -> CUInt -> CUInt -> IO (Ptr Stream)
gst_stream_new Ptr CChar
maybeStreamId Ptr Caps
maybeCaps CUInt
type_' CUInt
flags'
Text -> Ptr Stream -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"streamNew" Ptr Stream
result
Stream
result' <- ((ManagedPtr Stream -> Stream) -> Ptr Stream -> IO Stream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Stream -> Stream
Stream) Ptr Stream
result
Maybe Caps -> (Caps -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Caps
caps Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeStreamId
Stream -> IO Stream
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Stream
result'
#if defined(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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStream a) =>
a -> m (Maybe Caps)
streamGetCaps a
stream = IO (Maybe Caps) -> m (Maybe Caps)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Caps) -> m (Maybe Caps))
-> IO (Maybe Caps) -> m (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ do
Ptr Stream
stream' <- a -> IO (Ptr Stream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Caps
result <- Ptr Stream -> IO (Ptr Caps)
gst_stream_get_caps Ptr Stream
stream'
Maybe Caps
maybeResult <- Ptr Caps -> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Caps
result ((Ptr Caps -> IO Caps) -> IO (Maybe Caps))
-> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ \Ptr Caps
result' -> do
Caps
result'' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result'
Caps -> IO Caps
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
Maybe Caps -> IO (Maybe Caps)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Caps
maybeResult
#if defined(ENABLE_OVERLOADING)
data StreamGetCapsMethodInfo
instance (signature ~ (m (Maybe Gst.Caps.Caps)), MonadIO m, IsStream a) => O.OverloadedMethod StreamGetCapsMethodInfo a signature where
overloadedMethod = streamGetCaps
instance O.OverloadedMethodInfo StreamGetCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.streamGetCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStream a) =>
a -> m [StreamFlags]
streamGetStreamFlags a
stream = IO [StreamFlags] -> m [StreamFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [StreamFlags] -> m [StreamFlags])
-> IO [StreamFlags] -> m [StreamFlags]
forall a b. (a -> b) -> a -> b
$ do
Ptr Stream
stream' <- a -> IO (Ptr Stream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
CUInt
result <- Ptr Stream -> IO CUInt
gst_stream_get_stream_flags Ptr Stream
stream'
let result' :: [StreamFlags]
result' = CUInt -> [StreamFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
[StreamFlags] -> IO [StreamFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [StreamFlags]
result'
#if defined(ENABLE_OVERLOADING)
data StreamGetStreamFlagsMethodInfo
instance (signature ~ (m [Gst.Flags.StreamFlags]), MonadIO m, IsStream a) => O.OverloadedMethod StreamGetStreamFlagsMethodInfo a signature where
overloadedMethod = streamGetStreamFlags
instance O.OverloadedMethodInfo StreamGetStreamFlagsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.streamGetStreamFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStream a) =>
a -> m (Maybe Text)
streamGetStreamId a
stream = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Stream
stream' <- a -> IO (Ptr Stream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr CChar
result <- Ptr Stream -> IO (Ptr CChar)
gst_stream_get_stream_id Ptr Stream
stream'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data StreamGetStreamIdMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsStream a) => O.OverloadedMethod StreamGetStreamIdMethodInfo a signature where
overloadedMethod = streamGetStreamId
instance O.OverloadedMethodInfo StreamGetStreamIdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.streamGetStreamId",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStream a) =>
a -> m [StreamType]
streamGetStreamType a
stream = IO [StreamType] -> m [StreamType]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [StreamType] -> m [StreamType])
-> IO [StreamType] -> m [StreamType]
forall a b. (a -> b) -> a -> b
$ do
Ptr Stream
stream' <- a -> IO (Ptr Stream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
CUInt
result <- Ptr Stream -> IO CUInt
gst_stream_get_stream_type Ptr Stream
stream'
let result' :: [StreamType]
result' = CUInt -> [StreamType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
[StreamType] -> IO [StreamType]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [StreamType]
result'
#if defined(ENABLE_OVERLOADING)
data StreamGetStreamTypeMethodInfo
instance (signature ~ (m [Gst.Flags.StreamType]), MonadIO m, IsStream a) => O.OverloadedMethod StreamGetStreamTypeMethodInfo a signature where
overloadedMethod = streamGetStreamType
instance O.OverloadedMethodInfo StreamGetStreamTypeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.streamGetStreamType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStream a) =>
a -> m (Maybe TagList)
streamGetTags a
stream = IO (Maybe TagList) -> m (Maybe TagList)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TagList) -> m (Maybe TagList))
-> IO (Maybe TagList) -> m (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ do
Ptr Stream
stream' <- a -> IO (Ptr Stream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr TagList
result <- Ptr Stream -> IO (Ptr TagList)
gst_stream_get_tags Ptr Stream
stream'
Maybe TagList
maybeResult <- Ptr TagList -> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TagList
result ((Ptr TagList -> IO TagList) -> IO (Maybe TagList))
-> (Ptr TagList -> IO TagList) -> IO (Maybe TagList)
forall a b. (a -> b) -> a -> b
$ \Ptr TagList
result' -> do
TagList
result'' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TagList -> TagList
Gst.TagList.TagList) Ptr TagList
result'
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
Maybe TagList -> IO (Maybe TagList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TagList
maybeResult
#if defined(ENABLE_OVERLOADING)
data StreamGetTagsMethodInfo
instance (signature ~ (m (Maybe Gst.TagList.TagList)), MonadIO m, IsStream a) => O.OverloadedMethod StreamGetTagsMethodInfo a signature where
overloadedMethod = streamGetTags
instance O.OverloadedMethodInfo StreamGetTagsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.streamGetTags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStream a) =>
a -> Maybe Caps -> m ()
streamSetCaps a
stream Maybe Caps
caps = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Stream
stream' <- a -> IO (Ptr Stream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Caps
maybeCaps <- case Maybe Caps
caps of
Maybe Caps
Nothing -> Ptr Caps -> IO (Ptr Caps)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
forall a. Ptr a
nullPtr
Just Caps
jCaps -> do
Ptr Caps
jCaps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
jCaps
Ptr Caps -> IO (Ptr Caps)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
jCaps'
Ptr Stream -> Ptr Caps -> IO ()
gst_stream_set_caps Ptr Stream
stream' Ptr Caps
maybeCaps
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
Maybe Caps -> (Caps -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Caps
caps Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data StreamSetCapsMethodInfo
instance (signature ~ (Maybe (Gst.Caps.Caps) -> m ()), MonadIO m, IsStream a) => O.OverloadedMethod StreamSetCapsMethodInfo a signature where
overloadedMethod = streamSetCaps
instance O.OverloadedMethodInfo StreamSetCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.streamSetCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStream a) =>
a -> [StreamFlags] -> m ()
streamSetStreamFlags a
stream [StreamFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Stream
stream' <- a -> IO (Ptr Stream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
let flags' :: CUInt
flags' = [StreamFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StreamFlags]
flags
Ptr Stream -> CUInt -> IO ()
gst_stream_set_stream_flags Ptr Stream
stream' CUInt
flags'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data StreamSetStreamFlagsMethodInfo
instance (signature ~ ([Gst.Flags.StreamFlags] -> m ()), MonadIO m, IsStream a) => O.OverloadedMethod StreamSetStreamFlagsMethodInfo a signature where
overloadedMethod = streamSetStreamFlags
instance O.OverloadedMethodInfo StreamSetStreamFlagsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.streamSetStreamFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStream a) =>
a -> [StreamType] -> m ()
streamSetStreamType a
stream [StreamType]
streamType = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Stream
stream' <- a -> IO (Ptr Stream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
let streamType' :: CUInt
streamType' = [StreamType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StreamType]
streamType
Ptr Stream -> CUInt -> IO ()
gst_stream_set_stream_type Ptr Stream
stream' CUInt
streamType'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data StreamSetStreamTypeMethodInfo
instance (signature ~ ([Gst.Flags.StreamType] -> m ()), MonadIO m, IsStream a) => O.OverloadedMethod StreamSetStreamTypeMethodInfo a signature where
overloadedMethod = streamSetStreamType
instance O.OverloadedMethodInfo StreamSetStreamTypeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.streamSetStreamType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStream a) =>
a -> Maybe TagList -> m ()
streamSetTags a
stream Maybe TagList
tags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Stream
stream' <- a -> IO (Ptr Stream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr TagList
maybeTags <- case Maybe TagList
tags of
Maybe TagList
Nothing -> Ptr TagList -> IO (Ptr TagList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TagList
forall a. Ptr a
nullPtr
Just TagList
jTags -> do
Ptr TagList
jTags' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TagList
jTags
Ptr TagList -> IO (Ptr TagList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TagList
jTags'
Ptr Stream -> Ptr TagList -> IO ()
gst_stream_set_tags Ptr Stream
stream' Ptr TagList
maybeTags
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
Maybe TagList -> (TagList -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe TagList
tags TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data StreamSetTagsMethodInfo
instance (signature ~ (Maybe (Gst.TagList.TagList) -> m ()), MonadIO m, IsStream a) => O.OverloadedMethod StreamSetTagsMethodInfo a signature where
overloadedMethod = streamSetTags
instance O.OverloadedMethodInfo StreamSetTagsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Stream.streamSetTags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Objects-Stream.html#v:streamSetTags"
})
#endif