{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.Message
(
Message(..) ,
newZeroMessage ,
#if defined(ENABLE_OVERLOADING)
ResolveMessageMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
MessageAddRedirectEntryMethodInfo ,
#endif
messageAddRedirectEntry ,
#if defined(ENABLE_OVERLOADING)
MessageGetNumRedirectEntriesMethodInfo ,
#endif
messageGetNumRedirectEntries ,
#if defined(ENABLE_OVERLOADING)
MessageGetSeqnumMethodInfo ,
#endif
messageGetSeqnum ,
#if defined(ENABLE_OVERLOADING)
MessageGetStreamStatusObjectMethodInfo ,
#endif
messageGetStreamStatusObject ,
#if defined(ENABLE_OVERLOADING)
MessageGetStructureMethodInfo ,
#endif
messageGetStructure ,
#if defined(ENABLE_OVERLOADING)
MessageHasNameMethodInfo ,
#endif
messageHasName ,
messageNewApplication ,
messageNewAsyncDone ,
messageNewAsyncStart ,
messageNewBuffering ,
messageNewClockLost ,
messageNewClockProvide ,
messageNewCustom ,
messageNewDeviceAdded ,
messageNewDeviceChanged ,
messageNewDeviceRemoved ,
messageNewDurationChanged ,
messageNewElement ,
messageNewEos ,
messageNewError ,
messageNewErrorWithDetails ,
messageNewHaveContext ,
messageNewInfo ,
messageNewInfoWithDetails ,
messageNewLatency ,
messageNewNeedContext ,
messageNewNewClock ,
messageNewProgress ,
messageNewPropertyNotify ,
messageNewQos ,
messageNewRedirect ,
messageNewRequestState ,
messageNewResetTime ,
messageNewSegmentDone ,
messageNewSegmentStart ,
messageNewStateChanged ,
messageNewStateDirty ,
messageNewStepDone ,
messageNewStepStart ,
messageNewStreamCollection ,
messageNewStreamStart ,
messageNewStreamStatus ,
messageNewStreamsSelected ,
messageNewStructureChange ,
messageNewTag ,
messageNewToc ,
messageNewWarning ,
messageNewWarningWithDetails ,
#if defined(ENABLE_OVERLOADING)
MessageParseAsyncDoneMethodInfo ,
#endif
messageParseAsyncDone ,
#if defined(ENABLE_OVERLOADING)
MessageParseBufferingMethodInfo ,
#endif
messageParseBuffering ,
#if defined(ENABLE_OVERLOADING)
MessageParseBufferingStatsMethodInfo ,
#endif
messageParseBufferingStats ,
#if defined(ENABLE_OVERLOADING)
MessageParseClockLostMethodInfo ,
#endif
messageParseClockLost ,
#if defined(ENABLE_OVERLOADING)
MessageParseClockProvideMethodInfo ,
#endif
messageParseClockProvide ,
#if defined(ENABLE_OVERLOADING)
MessageParseContextTypeMethodInfo ,
#endif
messageParseContextType ,
#if defined(ENABLE_OVERLOADING)
MessageParseDeviceAddedMethodInfo ,
#endif
messageParseDeviceAdded ,
#if defined(ENABLE_OVERLOADING)
MessageParseDeviceChangedMethodInfo ,
#endif
messageParseDeviceChanged ,
#if defined(ENABLE_OVERLOADING)
MessageParseDeviceRemovedMethodInfo ,
#endif
messageParseDeviceRemoved ,
#if defined(ENABLE_OVERLOADING)
MessageParseErrorMethodInfo ,
#endif
messageParseError ,
#if defined(ENABLE_OVERLOADING)
MessageParseErrorDetailsMethodInfo ,
#endif
messageParseErrorDetails ,
#if defined(ENABLE_OVERLOADING)
MessageParseGroupIdMethodInfo ,
#endif
messageParseGroupId ,
#if defined(ENABLE_OVERLOADING)
MessageParseHaveContextMethodInfo ,
#endif
messageParseHaveContext ,
#if defined(ENABLE_OVERLOADING)
MessageParseInfoMethodInfo ,
#endif
messageParseInfo ,
#if defined(ENABLE_OVERLOADING)
MessageParseInfoDetailsMethodInfo ,
#endif
messageParseInfoDetails ,
#if defined(ENABLE_OVERLOADING)
MessageParseNewClockMethodInfo ,
#endif
messageParseNewClock ,
#if defined(ENABLE_OVERLOADING)
MessageParseProgressMethodInfo ,
#endif
messageParseProgress ,
#if defined(ENABLE_OVERLOADING)
MessageParsePropertyNotifyMethodInfo ,
#endif
messageParsePropertyNotify ,
#if defined(ENABLE_OVERLOADING)
MessageParseQosMethodInfo ,
#endif
messageParseQos ,
#if defined(ENABLE_OVERLOADING)
MessageParseQosStatsMethodInfo ,
#endif
messageParseQosStats ,
#if defined(ENABLE_OVERLOADING)
MessageParseQosValuesMethodInfo ,
#endif
messageParseQosValues ,
#if defined(ENABLE_OVERLOADING)
MessageParseRedirectEntryMethodInfo ,
#endif
messageParseRedirectEntry ,
#if defined(ENABLE_OVERLOADING)
MessageParseRequestStateMethodInfo ,
#endif
messageParseRequestState ,
#if defined(ENABLE_OVERLOADING)
MessageParseResetTimeMethodInfo ,
#endif
messageParseResetTime ,
#if defined(ENABLE_OVERLOADING)
MessageParseSegmentDoneMethodInfo ,
#endif
messageParseSegmentDone ,
#if defined(ENABLE_OVERLOADING)
MessageParseSegmentStartMethodInfo ,
#endif
messageParseSegmentStart ,
#if defined(ENABLE_OVERLOADING)
MessageParseStateChangedMethodInfo ,
#endif
messageParseStateChanged ,
#if defined(ENABLE_OVERLOADING)
MessageParseStepDoneMethodInfo ,
#endif
messageParseStepDone ,
#if defined(ENABLE_OVERLOADING)
MessageParseStepStartMethodInfo ,
#endif
messageParseStepStart ,
#if defined(ENABLE_OVERLOADING)
MessageParseStreamCollectionMethodInfo ,
#endif
messageParseStreamCollection ,
#if defined(ENABLE_OVERLOADING)
MessageParseStreamStatusMethodInfo ,
#endif
messageParseStreamStatus ,
#if defined(ENABLE_OVERLOADING)
MessageParseStreamsSelectedMethodInfo ,
#endif
messageParseStreamsSelected ,
#if defined(ENABLE_OVERLOADING)
MessageParseStructureChangeMethodInfo ,
#endif
messageParseStructureChange ,
#if defined(ENABLE_OVERLOADING)
MessageParseTagMethodInfo ,
#endif
messageParseTag ,
#if defined(ENABLE_OVERLOADING)
MessageParseTocMethodInfo ,
#endif
messageParseToc ,
#if defined(ENABLE_OVERLOADING)
MessageParseWarningMethodInfo ,
#endif
messageParseWarning ,
#if defined(ENABLE_OVERLOADING)
MessageParseWarningDetailsMethodInfo ,
#endif
messageParseWarningDetails ,
#if defined(ENABLE_OVERLOADING)
MessageSetBufferingStatsMethodInfo ,
#endif
messageSetBufferingStats ,
#if defined(ENABLE_OVERLOADING)
MessageSetGroupIdMethodInfo ,
#endif
messageSetGroupId ,
#if defined(ENABLE_OVERLOADING)
MessageSetQosStatsMethodInfo ,
#endif
messageSetQosStats ,
#if defined(ENABLE_OVERLOADING)
MessageSetQosValuesMethodInfo ,
#endif
messageSetQosValues ,
#if defined(ENABLE_OVERLOADING)
MessageSetSeqnumMethodInfo ,
#endif
messageSetSeqnum ,
#if defined(ENABLE_OVERLOADING)
MessageSetStreamStatusObjectMethodInfo ,
#endif
messageSetStreamStatusObject ,
#if defined(ENABLE_OVERLOADING)
MessageStreamsSelectedAddMethodInfo ,
#endif
messageStreamsSelectedAdd ,
#if defined(ENABLE_OVERLOADING)
MessageStreamsSelectedGetSizeMethodInfo ,
#endif
messageStreamsSelectedGetSize ,
#if defined(ENABLE_OVERLOADING)
MessageStreamsSelectedGetStreamMethodInfo,
#endif
messageStreamsSelectedGetStream ,
#if defined(ENABLE_OVERLOADING)
MessageWritableStructureMethodInfo ,
#endif
messageWritableStructure ,
getMessageMiniObject ,
#if defined(ENABLE_OVERLOADING)
message_miniObject ,
#endif
getMessageSeqnum ,
#if defined(ENABLE_OVERLOADING)
message_seqnum ,
#endif
setMessageSeqnum ,
clearMessageSrc ,
getMessageSrc ,
#if defined(ENABLE_OVERLOADING)
message_src ,
#endif
setMessageSrc ,
getMessageTimestamp ,
#if defined(ENABLE_OVERLOADING)
message_timestamp ,
#endif
setMessageTimestamp ,
getMessageType ,
#if defined(ENABLE_OVERLOADING)
message_type ,
#endif
setMessageType ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
import {-# SOURCE #-} qualified GI.Gst.Objects.Clock as Gst.Clock
import {-# SOURCE #-} qualified GI.Gst.Objects.Device as Gst.Device
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.Stream as Gst.Stream
import {-# SOURCE #-} qualified GI.Gst.Objects.StreamCollection as Gst.StreamCollection
import {-# SOURCE #-} qualified GI.Gst.Structs.Context as Gst.Context
import {-# SOURCE #-} qualified GI.Gst.Structs.MiniObject as Gst.MiniObject
import {-# SOURCE #-} qualified GI.Gst.Structs.Structure as Gst.Structure
import {-# SOURCE #-} qualified GI.Gst.Structs.TagList as Gst.TagList
import {-# SOURCE #-} qualified GI.Gst.Structs.Toc as Gst.Toc
newtype Message = Message (SP.ManagedPtr Message)
deriving (Message -> Message -> Bool
(Message -> Message -> Bool)
-> (Message -> Message -> Bool) -> Eq Message
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Message -> Message -> Bool
$c/= :: Message -> Message -> Bool
== :: Message -> Message -> Bool
$c== :: Message -> Message -> Bool
Eq)
instance SP.ManagedPtrNewtype Message where
toManagedPtr :: Message -> ManagedPtr Message
toManagedPtr (Message ManagedPtr Message
p) = ManagedPtr Message
p
foreign import ccall "gst_message_get_type" c_gst_message_get_type ::
IO GType
type instance O.ParentTypes Message = '[]
instance O.HasParentTypes Message
instance B.Types.TypedObject Message where
glibType :: IO GType
glibType = IO GType
c_gst_message_get_type
instance B.Types.GBoxed Message
instance B.GValue.IsGValue Message where
toGValue :: Message -> IO GValue
toGValue Message
o = do
GType
gtype <- IO GType
c_gst_message_get_type
Message -> (Ptr Message -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Message
o (GType
-> (GValue -> Ptr Message -> IO ()) -> Ptr Message -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Message -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO Message
fromGValue GValue
gv = do
Ptr Message
ptr <- GValue -> IO (Ptr Message)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr Message)
(ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Message -> Message
Message Ptr Message
ptr
newZeroMessage :: MonadIO m => m Message
newZeroMessage :: m Message
newZeroMessage = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Message)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
120 IO (Ptr Message) -> (Ptr Message -> IO Message) -> IO Message
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message
instance tag ~ 'AttrSet => Constructible Message tag where
new :: (ManagedPtr Message -> Message)
-> [AttrOp Message tag] -> m Message
new ManagedPtr Message -> Message
_ [AttrOp Message tag]
attrs = do
Message
o <- m Message
forall (m :: * -> *). MonadIO m => m Message
newZeroMessage
Message -> [AttrOp Message 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Message
o [AttrOp Message tag]
[AttrOp Message 'AttrSet]
attrs
Message -> m Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
o
getMessageMiniObject :: MonadIO m => Message -> m Gst.MiniObject.MiniObject
getMessageMiniObject :: Message -> m MiniObject
getMessageMiniObject Message
s = IO MiniObject -> m MiniObject
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MiniObject -> m MiniObject) -> IO MiniObject -> m MiniObject
forall a b. (a -> b) -> a -> b
$ Message -> (Ptr Message -> IO MiniObject) -> IO MiniObject
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Message
s ((Ptr Message -> IO MiniObject) -> IO MiniObject)
-> (Ptr Message -> IO MiniObject) -> IO MiniObject
forall a b. (a -> b) -> a -> b
$ \Ptr Message
ptr -> do
let val :: Ptr MiniObject
val = Ptr Message
ptr Ptr Message -> Int -> Ptr MiniObject
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Gst.MiniObject.MiniObject)
MiniObject
val' <- ((ManagedPtr MiniObject -> MiniObject)
-> Ptr MiniObject -> IO MiniObject
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr MiniObject -> MiniObject
Gst.MiniObject.MiniObject) Ptr MiniObject
val
MiniObject -> IO MiniObject
forall (m :: * -> *) a. Monad m => a -> m a
return MiniObject
val'
#if defined(ENABLE_OVERLOADING)
data MessageMiniObjectFieldInfo
instance AttrInfo MessageMiniObjectFieldInfo where
type AttrBaseTypeConstraint MessageMiniObjectFieldInfo = (~) Message
type AttrAllowedOps MessageMiniObjectFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint MessageMiniObjectFieldInfo = (~) (Ptr Gst.MiniObject.MiniObject)
type AttrTransferTypeConstraint MessageMiniObjectFieldInfo = (~)(Ptr Gst.MiniObject.MiniObject)
type AttrTransferType MessageMiniObjectFieldInfo = (Ptr Gst.MiniObject.MiniObject)
type AttrGetType MessageMiniObjectFieldInfo = Gst.MiniObject.MiniObject
type AttrLabel MessageMiniObjectFieldInfo = "mini_object"
type AttrOrigin MessageMiniObjectFieldInfo = Message
attrGet = getMessageMiniObject
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
message_miniObject :: AttrLabelProxy "miniObject"
message_miniObject = AttrLabelProxy
#endif
getMessageType :: MonadIO m => Message -> m [Gst.Flags.MessageType]
getMessageType :: Message -> m [MessageType]
getMessageType Message
s = IO [MessageType] -> m [MessageType]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [MessageType] -> m [MessageType])
-> IO [MessageType] -> m [MessageType]
forall a b. (a -> b) -> a -> b
$ Message -> (Ptr Message -> IO [MessageType]) -> IO [MessageType]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Message
s ((Ptr Message -> IO [MessageType]) -> IO [MessageType])
-> (Ptr Message -> IO [MessageType]) -> IO [MessageType]
forall a b. (a -> b) -> a -> b
$ \Ptr Message
ptr -> do
CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr Message
ptr Ptr Message -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) :: IO CUInt
let val' :: [MessageType]
val' = CUInt -> [MessageType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
[MessageType] -> IO [MessageType]
forall (m :: * -> *) a. Monad m => a -> m a
return [MessageType]
val'
setMessageType :: MonadIO m => Message -> [Gst.Flags.MessageType] -> m ()
setMessageType :: Message -> [MessageType] -> m ()
setMessageType Message
s [MessageType]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Message -> (Ptr Message -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Message
s ((Ptr Message -> IO ()) -> IO ())
-> (Ptr Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Message
ptr -> do
let val' :: CUInt
val' = [MessageType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MessageType]
val
Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Message
ptr Ptr Message -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data MessageTypeFieldInfo
instance AttrInfo MessageTypeFieldInfo where
type AttrBaseTypeConstraint MessageTypeFieldInfo = (~) Message
type AttrAllowedOps MessageTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint MessageTypeFieldInfo = (~) [Gst.Flags.MessageType]
type AttrTransferTypeConstraint MessageTypeFieldInfo = (~)[Gst.Flags.MessageType]
type AttrTransferType MessageTypeFieldInfo = [Gst.Flags.MessageType]
type AttrGetType MessageTypeFieldInfo = [Gst.Flags.MessageType]
type AttrLabel MessageTypeFieldInfo = "type"
type AttrOrigin MessageTypeFieldInfo = Message
attrGet = getMessageType
attrSet = setMessageType
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
message_type :: AttrLabelProxy "type"
message_type = AttrLabelProxy
#endif
getMessageTimestamp :: MonadIO m => Message -> m Word64
getMessageTimestamp :: Message -> m Word64
getMessageTimestamp Message
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Message -> (Ptr Message -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Message
s ((Ptr Message -> IO Word64) -> IO Word64)
-> (Ptr Message -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Message
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Message
ptr Ptr Message -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setMessageTimestamp :: MonadIO m => Message -> Word64 -> m ()
setMessageTimestamp :: Message -> Word64 -> m ()
setMessageTimestamp Message
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Message -> (Ptr Message -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Message
s ((Ptr Message -> IO ()) -> IO ())
-> (Ptr Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Message
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Message
ptr Ptr Message -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data MessageTimestampFieldInfo
instance AttrInfo MessageTimestampFieldInfo where
type AttrBaseTypeConstraint MessageTimestampFieldInfo = (~) Message
type AttrAllowedOps MessageTimestampFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint MessageTimestampFieldInfo = (~) Word64
type AttrTransferTypeConstraint MessageTimestampFieldInfo = (~)Word64
type AttrTransferType MessageTimestampFieldInfo = Word64
type AttrGetType MessageTimestampFieldInfo = Word64
type AttrLabel MessageTimestampFieldInfo = "timestamp"
type AttrOrigin MessageTimestampFieldInfo = Message
attrGet = getMessageTimestamp
attrSet = setMessageTimestamp
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
message_timestamp :: AttrLabelProxy "timestamp"
message_timestamp = AttrLabelProxy
#endif
getMessageSrc :: MonadIO m => Message -> m (Maybe Gst.Object.Object)
getMessageSrc :: Message -> m (Maybe Object)
getMessageSrc Message
s = IO (Maybe Object) -> m (Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ Message -> (Ptr Message -> IO (Maybe Object)) -> IO (Maybe Object)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Message
s ((Ptr Message -> IO (Maybe Object)) -> IO (Maybe Object))
-> (Ptr Message -> IO (Maybe Object)) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Message
ptr -> do
Ptr Object
val <- Ptr (Ptr Object) -> IO (Ptr Object)
forall a. Storable a => Ptr a -> IO a
peek (Ptr Message
ptr Ptr Message -> Int -> Ptr (Ptr Object)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) :: IO (Ptr Gst.Object.Object)
Maybe Object
result <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Object
val ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
val' -> do
Object
val'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Gst.Object.Object) Ptr Object
val'
Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
val''
Maybe Object -> IO (Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
result
setMessageSrc :: MonadIO m => Message -> Ptr Gst.Object.Object -> m ()
setMessageSrc :: Message -> Ptr Object -> m ()
setMessageSrc Message
s Ptr Object
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Message -> (Ptr Message -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Message
s ((Ptr Message -> IO ()) -> IO ())
-> (Ptr Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Message
ptr -> do
Ptr (Ptr Object) -> Ptr Object -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Message
ptr Ptr Message -> Int -> Ptr (Ptr Object)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) (Ptr Object
val :: Ptr Gst.Object.Object)
clearMessageSrc :: MonadIO m => Message -> m ()
clearMessageSrc :: Message -> m ()
clearMessageSrc Message
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Message -> (Ptr Message -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Message
s ((Ptr Message -> IO ()) -> IO ())
-> (Ptr Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Message
ptr -> do
Ptr (Ptr Object) -> Ptr Object -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Message
ptr Ptr Message -> Int -> Ptr (Ptr Object)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) (Ptr Object
forall a. Ptr a
FP.nullPtr :: Ptr Gst.Object.Object)
#if defined(ENABLE_OVERLOADING)
data MessageSrcFieldInfo
instance AttrInfo MessageSrcFieldInfo where
type AttrBaseTypeConstraint MessageSrcFieldInfo = (~) Message
type AttrAllowedOps MessageSrcFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MessageSrcFieldInfo = (~) (Ptr Gst.Object.Object)
type AttrTransferTypeConstraint MessageSrcFieldInfo = (~)(Ptr Gst.Object.Object)
type AttrTransferType MessageSrcFieldInfo = (Ptr Gst.Object.Object)
type AttrGetType MessageSrcFieldInfo = Maybe Gst.Object.Object
type AttrLabel MessageSrcFieldInfo = "src"
type AttrOrigin MessageSrcFieldInfo = Message
attrGet = getMessageSrc
attrSet = setMessageSrc
attrConstruct = undefined
attrClear = clearMessageSrc
attrTransfer _ v = do
return v
message_src :: AttrLabelProxy "src"
message_src = AttrLabelProxy
#endif
getMessageSeqnum :: MonadIO m => Message -> m Word32
getMessageSeqnum :: Message -> m Word32
getMessageSeqnum Message
s = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ Message -> (Ptr Message -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Message
s ((Ptr Message -> IO Word32) -> IO Word32)
-> (Ptr Message -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr Message
ptr -> do
Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Message
ptr Ptr Message -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
88) :: IO Word32
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setMessageSeqnum :: MonadIO m => Message -> Word32 -> m ()
setMessageSeqnum :: Message -> Word32 -> m ()
setMessageSeqnum Message
s Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Message -> (Ptr Message -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Message
s ((Ptr Message -> IO ()) -> IO ())
-> (Ptr Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Message
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Message
ptr Ptr Message -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
88) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data MessageSeqnumFieldInfo
instance AttrInfo MessageSeqnumFieldInfo where
type AttrBaseTypeConstraint MessageSeqnumFieldInfo = (~) Message
type AttrAllowedOps MessageSeqnumFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint MessageSeqnumFieldInfo = (~) Word32
type AttrTransferTypeConstraint MessageSeqnumFieldInfo = (~)Word32
type AttrTransferType MessageSeqnumFieldInfo = Word32
type AttrGetType MessageSeqnumFieldInfo = Word32
type AttrLabel MessageSeqnumFieldInfo = "seqnum"
type AttrOrigin MessageSeqnumFieldInfo = Message
attrGet = getMessageSeqnum
attrSet = setMessageSeqnum
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
message_seqnum :: AttrLabelProxy "seqnum"
message_seqnum = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Message
type instance O.AttributeList Message = MessageAttributeList
type MessageAttributeList = ('[ '("miniObject", MessageMiniObjectFieldInfo), '("type", MessageTypeFieldInfo), '("timestamp", MessageTimestampFieldInfo), '("src", MessageSrcFieldInfo), '("seqnum", MessageSeqnumFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_message_new_application" gst_message_new_application ::
Ptr Gst.Object.Object ->
Ptr Gst.Structure.Structure ->
IO (Ptr Message)
messageNewApplication ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> Gst.Structure.Structure
-> m (Maybe Message)
messageNewApplication :: Maybe a -> Structure -> m (Maybe Message)
messageNewApplication Maybe a
src Structure
structure = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Structure
structure' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
structure
Ptr Message
result <- Ptr Object -> Ptr Structure -> IO (Ptr Message)
gst_message_new_application Ptr Object
maybeSrc Ptr Structure
structure'
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Structure
structure
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_async_done" gst_message_new_async_done ::
Ptr Gst.Object.Object ->
Word64 ->
IO (Ptr Message)
messageNewAsyncDone ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> Word64
-> m Message
messageNewAsyncDone :: Maybe a -> Word64 -> m Message
messageNewAsyncDone Maybe a
src Word64
runningTime = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Message
result <- Ptr Object -> Word64 -> IO (Ptr Message)
gst_message_new_async_done Ptr Object
maybeSrc Word64
runningTime
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewAsyncDone" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_async_start" gst_message_new_async_start ::
Ptr Gst.Object.Object ->
IO (Ptr Message)
messageNewAsyncStart ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> m Message
messageNewAsyncStart :: Maybe a -> m Message
messageNewAsyncStart Maybe a
src = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Message
result <- Ptr Object -> IO (Ptr Message)
gst_message_new_async_start Ptr Object
maybeSrc
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewAsyncStart" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_buffering" gst_message_new_buffering ::
Ptr Gst.Object.Object ->
Int32 ->
IO (Ptr Message)
messageNewBuffering ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> Int32
-> m (Maybe Message)
messageNewBuffering :: Maybe a -> Int32 -> m (Maybe Message)
messageNewBuffering Maybe a
src Int32
percent = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Message
result <- Ptr Object -> Int32 -> IO (Ptr Message)
gst_message_new_buffering Ptr Object
maybeSrc Int32
percent
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_clock_lost" gst_message_new_clock_lost ::
Ptr Gst.Object.Object ->
Ptr Gst.Clock.Clock ->
IO (Ptr Message)
messageNewClockLost ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a, Gst.Clock.IsClock b) =>
Maybe (a)
-> b
-> m Message
messageNewClockLost :: Maybe a -> b -> m Message
messageNewClockLost Maybe a
src b
clock = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Clock
clock' <- b -> IO (Ptr Clock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
clock
Ptr Message
result <- Ptr Object -> Ptr Clock -> IO (Ptr Message)
gst_message_new_clock_lost Ptr Object
maybeSrc Ptr Clock
clock'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewClockLost" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
clock
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_clock_provide" gst_message_new_clock_provide ::
Ptr Gst.Object.Object ->
Ptr Gst.Clock.Clock ->
CInt ->
IO (Ptr Message)
messageNewClockProvide ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a, Gst.Clock.IsClock b) =>
Maybe (a)
-> b
-> Bool
-> m Message
messageNewClockProvide :: Maybe a -> b -> Bool -> m Message
messageNewClockProvide Maybe a
src b
clock Bool
ready = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Clock
clock' <- b -> IO (Ptr Clock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
clock
let ready' :: CInt
ready' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
ready
Ptr Message
result <- Ptr Object -> Ptr Clock -> CInt -> IO (Ptr Message)
gst_message_new_clock_provide Ptr Object
maybeSrc Ptr Clock
clock' CInt
ready'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewClockProvide" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
clock
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_custom" gst_message_new_custom ::
CUInt ->
Ptr Gst.Object.Object ->
Ptr Gst.Structure.Structure ->
IO (Ptr Message)
messageNewCustom ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
[Gst.Flags.MessageType]
-> Maybe (a)
-> Maybe (Gst.Structure.Structure)
-> m (Maybe Message)
messageNewCustom :: [MessageType] -> Maybe a -> Maybe Structure -> m (Maybe Message)
messageNewCustom [MessageType]
type_ Maybe a
src Maybe Structure
structure = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CUInt
type_' = [MessageType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MessageType]
type_
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Structure
maybeStructure <- case Maybe Structure
structure of
Maybe Structure
Nothing -> Ptr Structure -> IO (Ptr Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
forall a. Ptr a
nullPtr
Just Structure
jStructure -> do
Ptr Structure
jStructure' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
jStructure
Ptr Structure -> IO (Ptr Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
jStructure'
Ptr Message
result <- CUInt -> Ptr Object -> Ptr Structure -> IO (Ptr Message)
gst_message_new_custom CUInt
type_' Ptr Object
maybeSrc Ptr Structure
maybeStructure
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Structure -> (Structure -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Structure
structure Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_device_added" gst_message_new_device_added ::
Ptr Gst.Object.Object ->
Ptr Gst.Device.Device ->
IO (Ptr Message)
messageNewDeviceAdded ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a, Gst.Device.IsDevice b) =>
a
-> b
-> m Message
messageNewDeviceAdded :: a -> b -> m Message
messageNewDeviceAdded a
src b
device = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Device
device' <- b -> IO (Ptr Device)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
device
Ptr Message
result <- Ptr Object -> Ptr Device -> IO (Ptr Message)
gst_message_new_device_added Ptr Object
src' Ptr Device
device'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewDeviceAdded" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
device
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_device_changed" gst_message_new_device_changed ::
Ptr Gst.Object.Object ->
Ptr Gst.Device.Device ->
Ptr Gst.Device.Device ->
IO (Ptr Message)
messageNewDeviceChanged ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a, Gst.Device.IsDevice b, Gst.Device.IsDevice c) =>
a
-> b
-> c
-> m Message
messageNewDeviceChanged :: a -> b -> c -> m Message
messageNewDeviceChanged a
src b
device c
changedDevice = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Device
device' <- b -> IO (Ptr Device)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
device
Ptr Device
changedDevice' <- c -> IO (Ptr Device)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
changedDevice
Ptr Message
result <- Ptr Object -> Ptr Device -> Ptr Device -> IO (Ptr Message)
gst_message_new_device_changed Ptr Object
src' Ptr Device
device' Ptr Device
changedDevice'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewDeviceChanged" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
device
c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
changedDevice
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_device_removed" gst_message_new_device_removed ::
Ptr Gst.Object.Object ->
Ptr Gst.Device.Device ->
IO (Ptr Message)
messageNewDeviceRemoved ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a, Gst.Device.IsDevice b) =>
a
-> b
-> m Message
messageNewDeviceRemoved :: a -> b -> m Message
messageNewDeviceRemoved a
src b
device = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Device
device' <- b -> IO (Ptr Device)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
device
Ptr Message
result <- Ptr Object -> Ptr Device -> IO (Ptr Message)
gst_message_new_device_removed Ptr Object
src' Ptr Device
device'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewDeviceRemoved" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
device
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_duration_changed" gst_message_new_duration_changed ::
Ptr Gst.Object.Object ->
IO (Ptr Message)
messageNewDurationChanged ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> m Message
messageNewDurationChanged :: Maybe a -> m Message
messageNewDurationChanged Maybe a
src = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Message
result <- Ptr Object -> IO (Ptr Message)
gst_message_new_duration_changed Ptr Object
maybeSrc
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewDurationChanged" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_element" gst_message_new_element ::
Ptr Gst.Object.Object ->
Ptr Gst.Structure.Structure ->
IO (Ptr Message)
messageNewElement ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> Gst.Structure.Structure
-> m (Maybe Message)
messageNewElement :: Maybe a -> Structure -> m (Maybe Message)
messageNewElement Maybe a
src Structure
structure = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Structure
structure' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
structure
Ptr Message
result <- Ptr Object -> Ptr Structure -> IO (Ptr Message)
gst_message_new_element Ptr Object
maybeSrc Ptr Structure
structure'
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Structure
structure
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_eos" gst_message_new_eos ::
Ptr Gst.Object.Object ->
IO (Ptr Message)
messageNewEos ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> m Message
messageNewEos :: Maybe a -> m Message
messageNewEos Maybe a
src = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Message
result <- Ptr Object -> IO (Ptr Message)
gst_message_new_eos Ptr Object
maybeSrc
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewEos" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_error" gst_message_new_error ::
Ptr Gst.Object.Object ->
Ptr GError ->
CString ->
IO (Ptr Message)
messageNewError ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> GError
-> T.Text
-> m Message
messageNewError :: Maybe a -> GError -> Text -> m Message
messageNewError Maybe a
src GError
error_ Text
debug = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr GError
error_' <- GError -> IO (Ptr GError)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GError
error_
CString
debug' <- Text -> IO CString
textToCString Text
debug
Ptr Message
result <- Ptr Object -> Ptr GError -> CString -> IO (Ptr Message)
gst_message_new_error Ptr Object
maybeSrc Ptr GError
error_' CString
debug'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewError" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
GError -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GError
error_
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
debug'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_error_with_details" gst_message_new_error_with_details ::
Ptr Gst.Object.Object ->
Ptr GError ->
CString ->
Ptr Gst.Structure.Structure ->
IO (Ptr Message)
messageNewErrorWithDetails ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> GError
-> T.Text
-> Maybe (Gst.Structure.Structure)
-> m (Maybe Message)
messageNewErrorWithDetails :: Maybe a -> GError -> Text -> Maybe Structure -> m (Maybe Message)
messageNewErrorWithDetails Maybe a
src GError
error_ Text
debug Maybe Structure
details = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr GError
error_' <- GError -> IO (Ptr GError)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GError
error_
CString
debug' <- Text -> IO CString
textToCString Text
debug
Ptr Structure
maybeDetails <- case Maybe Structure
details of
Maybe Structure
Nothing -> Ptr Structure -> IO (Ptr Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
forall a. Ptr a
nullPtr
Just Structure
jDetails -> do
Ptr Structure
jDetails' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
jDetails
Ptr Structure -> IO (Ptr Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
jDetails'
Ptr Message
result <- Ptr Object
-> Ptr GError -> CString -> Ptr Structure -> IO (Ptr Message)
gst_message_new_error_with_details Ptr Object
maybeSrc Ptr GError
error_' CString
debug' Ptr Structure
maybeDetails
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
GError -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GError
error_
Maybe Structure -> (Structure -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Structure
details Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
debug'
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_have_context" gst_message_new_have_context ::
Ptr Gst.Object.Object ->
Ptr Gst.Context.Context ->
IO (Ptr Message)
messageNewHaveContext ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> Gst.Context.Context
-> m Message
messageNewHaveContext :: Maybe a -> Context -> m Message
messageNewHaveContext Maybe a
src Context
context = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Context
context' <- Context -> IO (Ptr Context)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Context
context
Ptr Message
result <- Ptr Object -> Ptr Context -> IO (Ptr Message)
gst_message_new_have_context Ptr Object
maybeSrc Ptr Context
context'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewHaveContext" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Context -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Context
context
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_info" gst_message_new_info ::
Ptr Gst.Object.Object ->
Ptr GError ->
CString ->
IO (Ptr Message)
messageNewInfo ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> GError
-> T.Text
-> m Message
messageNewInfo :: Maybe a -> GError -> Text -> m Message
messageNewInfo Maybe a
src GError
error_ Text
debug = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr GError
error_' <- GError -> IO (Ptr GError)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GError
error_
CString
debug' <- Text -> IO CString
textToCString Text
debug
Ptr Message
result <- Ptr Object -> Ptr GError -> CString -> IO (Ptr Message)
gst_message_new_info Ptr Object
maybeSrc Ptr GError
error_' CString
debug'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewInfo" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
GError -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GError
error_
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
debug'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_info_with_details" gst_message_new_info_with_details ::
Ptr Gst.Object.Object ->
Ptr GError ->
CString ->
Ptr Gst.Structure.Structure ->
IO (Ptr Message)
messageNewInfoWithDetails ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> GError
-> T.Text
-> Maybe (Gst.Structure.Structure)
-> m (Maybe Message)
messageNewInfoWithDetails :: Maybe a -> GError -> Text -> Maybe Structure -> m (Maybe Message)
messageNewInfoWithDetails Maybe a
src GError
error_ Text
debug Maybe Structure
details = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr GError
error_' <- GError -> IO (Ptr GError)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GError
error_
CString
debug' <- Text -> IO CString
textToCString Text
debug
Ptr Structure
maybeDetails <- case Maybe Structure
details of
Maybe Structure
Nothing -> Ptr Structure -> IO (Ptr Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
forall a. Ptr a
nullPtr
Just Structure
jDetails -> do
Ptr Structure
jDetails' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
jDetails
Ptr Structure -> IO (Ptr Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
jDetails'
Ptr Message
result <- Ptr Object
-> Ptr GError -> CString -> Ptr Structure -> IO (Ptr Message)
gst_message_new_info_with_details Ptr Object
maybeSrc Ptr GError
error_' CString
debug' Ptr Structure
maybeDetails
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
GError -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GError
error_
Maybe Structure -> (Structure -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Structure
details Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
debug'
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_latency" gst_message_new_latency ::
Ptr Gst.Object.Object ->
IO (Ptr Message)
messageNewLatency ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> m Message
messageNewLatency :: Maybe a -> m Message
messageNewLatency Maybe a
src = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Message
result <- Ptr Object -> IO (Ptr Message)
gst_message_new_latency Ptr Object
maybeSrc
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewLatency" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_need_context" gst_message_new_need_context ::
Ptr Gst.Object.Object ->
CString ->
IO (Ptr Message)
messageNewNeedContext ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> T.Text
-> m Message
messageNewNeedContext :: Maybe a -> Text -> m Message
messageNewNeedContext Maybe a
src Text
contextType = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
CString
contextType' <- Text -> IO CString
textToCString Text
contextType
Ptr Message
result <- Ptr Object -> CString -> IO (Ptr Message)
gst_message_new_need_context Ptr Object
maybeSrc CString
contextType'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewNeedContext" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
contextType'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_new_clock" gst_message_new_new_clock ::
Ptr Gst.Object.Object ->
Ptr Gst.Clock.Clock ->
IO (Ptr Message)
messageNewNewClock ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a, Gst.Clock.IsClock b) =>
Maybe (a)
-> b
-> m Message
messageNewNewClock :: Maybe a -> b -> m Message
messageNewNewClock Maybe a
src b
clock = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Clock
clock' <- b -> IO (Ptr Clock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
clock
Ptr Message
result <- Ptr Object -> Ptr Clock -> IO (Ptr Message)
gst_message_new_new_clock Ptr Object
maybeSrc Ptr Clock
clock'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewNewClock" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
clock
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_progress" gst_message_new_progress ::
Ptr Gst.Object.Object ->
CUInt ->
CString ->
CString ->
IO (Ptr Message)
messageNewProgress ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
a
-> Gst.Enums.ProgressType
-> T.Text
-> T.Text
-> m (Maybe Message)
messageNewProgress :: a -> ProgressType -> Text -> Text -> m (Maybe Message)
messageNewProgress a
src ProgressType
type_ Text
code Text
text = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ProgressType -> Int) -> ProgressType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ProgressType -> Int
forall a. Enum a => a -> Int
fromEnum) ProgressType
type_
CString
code' <- Text -> IO CString
textToCString Text
code
CString
text' <- Text -> IO CString
textToCString Text
text
Ptr Message
result <- Ptr Object -> CUInt -> CString -> CString -> IO (Ptr Message)
gst_message_new_progress Ptr Object
src' CUInt
type_' CString
code' CString
text'
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
code'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
text'
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_property_notify" gst_message_new_property_notify ::
Ptr Gst.Object.Object ->
CString ->
Ptr GValue ->
IO (Ptr Message)
messageNewPropertyNotify ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
a
-> T.Text
-> Maybe (GValue)
-> m Message
messageNewPropertyNotify :: a -> Text -> Maybe GValue -> m Message
messageNewPropertyNotify a
src Text
propertyName Maybe GValue
val = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
Ptr GValue
maybeVal <- case Maybe GValue
val of
Maybe GValue
Nothing -> Ptr GValue -> IO (Ptr GValue)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GValue
forall a. Ptr a
nullPtr
Just GValue
jVal -> do
Ptr GValue
jVal' <- GValue -> IO (Ptr GValue)
B.GValue.disownGValue GValue
jVal
Ptr GValue -> IO (Ptr GValue)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GValue
jVal'
Ptr Message
result <- Ptr Object -> CString -> Ptr GValue -> IO (Ptr Message)
gst_message_new_property_notify Ptr Object
src' CString
propertyName' Ptr GValue
maybeVal
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewPropertyNotify" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
Maybe GValue -> (GValue -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GValue
val GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_qos" gst_message_new_qos ::
Ptr Gst.Object.Object ->
CInt ->
Word64 ->
Word64 ->
Word64 ->
Word64 ->
IO (Ptr Message)
messageNewQos ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
a
-> Bool
-> Word64
-> Word64
-> Word64
-> Word64
-> m Message
messageNewQos :: a -> Bool -> Word64 -> Word64 -> Word64 -> Word64 -> m Message
messageNewQos a
src Bool
live Word64
runningTime Word64
streamTime Word64
timestamp Word64
duration = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
let live' :: CInt
live' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
live
Ptr Message
result <- Ptr Object
-> CInt -> Word64 -> Word64 -> Word64 -> Word64 -> IO (Ptr Message)
gst_message_new_qos Ptr Object
src' CInt
live' Word64
runningTime Word64
streamTime Word64
timestamp Word64
duration
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewQos" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_redirect" gst_message_new_redirect ::
Ptr Gst.Object.Object ->
CString ->
Ptr Gst.TagList.TagList ->
Ptr Gst.Structure.Structure ->
IO (Ptr Message)
messageNewRedirect ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
a
-> T.Text
-> Maybe (Gst.TagList.TagList)
-> Maybe (Gst.Structure.Structure)
-> m Message
messageNewRedirect :: a -> Text -> Maybe TagList -> Maybe Structure -> m Message
messageNewRedirect a
src Text
location Maybe TagList
tagList Maybe Structure
entryStruct = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
CString
location' <- Text -> IO CString
textToCString Text
location
Ptr TagList
maybeTagList <- case Maybe TagList
tagList of
Maybe TagList
Nothing -> Ptr TagList -> IO (Ptr TagList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TagList
forall a. Ptr a
nullPtr
Just TagList
jTagList -> do
Ptr TagList
jTagList' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed TagList
jTagList
Ptr TagList -> IO (Ptr TagList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TagList
jTagList'
Ptr Structure
maybeEntryStruct <- case Maybe Structure
entryStruct of
Maybe Structure
Nothing -> Ptr Structure -> IO (Ptr Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
forall a. Ptr a
nullPtr
Just Structure
jEntryStruct -> do
Ptr Structure
jEntryStruct' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
jEntryStruct
Ptr Structure -> IO (Ptr Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
jEntryStruct'
Ptr Message
result <- Ptr Object
-> CString -> Ptr TagList -> Ptr Structure -> IO (Ptr Message)
gst_message_new_redirect Ptr Object
src' CString
location' Ptr TagList
maybeTagList Ptr Structure
maybeEntryStruct
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewRedirect" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
Maybe TagList -> (TagList -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe TagList
tagList TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Structure -> (Structure -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Structure
entryStruct Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
location'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_request_state" gst_message_new_request_state ::
Ptr Gst.Object.Object ->
CUInt ->
IO (Ptr Message)
messageNewRequestState ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> Gst.Enums.State
-> m Message
messageNewRequestState :: Maybe a -> State -> m Message
messageNewRequestState Maybe a
src State
state = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
let state' :: CUInt
state' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (State -> Int) -> State -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> Int
forall a. Enum a => a -> Int
fromEnum) State
state
Ptr Message
result <- Ptr Object -> CUInt -> IO (Ptr Message)
gst_message_new_request_state Ptr Object
maybeSrc CUInt
state'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewRequestState" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_reset_time" gst_message_new_reset_time ::
Ptr Gst.Object.Object ->
Word64 ->
IO (Ptr Message)
messageNewResetTime ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> Word64
-> m Message
messageNewResetTime :: Maybe a -> Word64 -> m Message
messageNewResetTime Maybe a
src Word64
runningTime = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Message
result <- Ptr Object -> Word64 -> IO (Ptr Message)
gst_message_new_reset_time Ptr Object
maybeSrc Word64
runningTime
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewResetTime" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_segment_done" gst_message_new_segment_done ::
Ptr Gst.Object.Object ->
CUInt ->
Int64 ->
IO (Ptr Message)
messageNewSegmentDone ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> Gst.Enums.Format
-> Int64
-> m Message
messageNewSegmentDone :: Maybe a -> Format -> Int64 -> m Message
messageNewSegmentDone Maybe a
src Format
format Int64
position = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
Ptr Message
result <- Ptr Object -> CUInt -> Int64 -> IO (Ptr Message)
gst_message_new_segment_done Ptr Object
maybeSrc CUInt
format' Int64
position
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewSegmentDone" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_segment_start" gst_message_new_segment_start ::
Ptr Gst.Object.Object ->
CUInt ->
Int64 ->
IO (Ptr Message)
messageNewSegmentStart ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> Gst.Enums.Format
-> Int64
-> m Message
messageNewSegmentStart :: Maybe a -> Format -> Int64 -> m Message
messageNewSegmentStart Maybe a
src Format
format Int64
position = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
Ptr Message
result <- Ptr Object -> CUInt -> Int64 -> IO (Ptr Message)
gst_message_new_segment_start Ptr Object
maybeSrc CUInt
format' Int64
position
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewSegmentStart" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_state_changed" gst_message_new_state_changed ::
Ptr Gst.Object.Object ->
CUInt ->
CUInt ->
CUInt ->
IO (Ptr Message)
messageNewStateChanged ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> Gst.Enums.State
-> Gst.Enums.State
-> Gst.Enums.State
-> m Message
messageNewStateChanged :: Maybe a -> State -> State -> State -> m Message
messageNewStateChanged Maybe a
src State
oldstate State
newstate State
pending = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
let oldstate' :: CUInt
oldstate' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (State -> Int) -> State -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> Int
forall a. Enum a => a -> Int
fromEnum) State
oldstate
let newstate' :: CUInt
newstate' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (State -> Int) -> State -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> Int
forall a. Enum a => a -> Int
fromEnum) State
newstate
let pending' :: CUInt
pending' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (State -> Int) -> State -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> Int
forall a. Enum a => a -> Int
fromEnum) State
pending
Ptr Message
result <- Ptr Object -> CUInt -> CUInt -> CUInt -> IO (Ptr Message)
gst_message_new_state_changed Ptr Object
maybeSrc CUInt
oldstate' CUInt
newstate' CUInt
pending'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewStateChanged" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_state_dirty" gst_message_new_state_dirty ::
Ptr Gst.Object.Object ->
IO (Ptr Message)
messageNewStateDirty ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> m Message
messageNewStateDirty :: Maybe a -> m Message
messageNewStateDirty Maybe a
src = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Message
result <- Ptr Object -> IO (Ptr Message)
gst_message_new_state_dirty Ptr Object
maybeSrc
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewStateDirty" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_step_done" gst_message_new_step_done ::
Ptr Gst.Object.Object ->
CUInt ->
Word64 ->
CDouble ->
CInt ->
CInt ->
Word64 ->
CInt ->
IO (Ptr Message)
messageNewStepDone ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
a
-> Gst.Enums.Format
-> Word64
-> Double
-> Bool
-> Bool
-> Word64
-> Bool
-> m Message
messageNewStepDone :: a
-> Format
-> Word64
-> Double
-> Bool
-> Bool
-> Word64
-> Bool
-> m Message
messageNewStepDone a
src Format
format Word64
amount Double
rate Bool
flush Bool
intermediate Word64
duration Bool
eos = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
let rate' :: CDouble
rate' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
rate
let flush' :: CInt
flush' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
flush
let intermediate' :: CInt
intermediate' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
intermediate
let eos' :: CInt
eos' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
eos
Ptr Message
result <- Ptr Object
-> CUInt
-> Word64
-> CDouble
-> CInt
-> CInt
-> Word64
-> CInt
-> IO (Ptr Message)
gst_message_new_step_done Ptr Object
src' CUInt
format' Word64
amount CDouble
rate' CInt
flush' CInt
intermediate' Word64
duration CInt
eos'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewStepDone" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_step_start" gst_message_new_step_start ::
Ptr Gst.Object.Object ->
CInt ->
CUInt ->
Word64 ->
CDouble ->
CInt ->
CInt ->
IO (Ptr Message)
messageNewStepStart ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
a
-> Bool
-> Gst.Enums.Format
-> Word64
-> Double
-> Bool
-> Bool
-> m Message
messageNewStepStart :: a
-> Bool -> Format -> Word64 -> Double -> Bool -> Bool -> m Message
messageNewStepStart a
src Bool
active Format
format Word64
amount Double
rate Bool
flush Bool
intermediate = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
let active' :: CInt
active' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
active
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
let rate' :: CDouble
rate' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
rate
let flush' :: CInt
flush' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
flush
let intermediate' :: CInt
intermediate' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
intermediate
Ptr Message
result <- Ptr Object
-> CInt
-> CUInt
-> Word64
-> CDouble
-> CInt
-> CInt
-> IO (Ptr Message)
gst_message_new_step_start Ptr Object
src' CInt
active' CUInt
format' Word64
amount CDouble
rate' CInt
flush' CInt
intermediate'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewStepStart" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_stream_collection" gst_message_new_stream_collection ::
Ptr Gst.Object.Object ->
Ptr Gst.StreamCollection.StreamCollection ->
IO (Ptr Message)
messageNewStreamCollection ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a, Gst.StreamCollection.IsStreamCollection b) =>
a
-> b
-> m Message
messageNewStreamCollection :: a -> b -> m Message
messageNewStreamCollection a
src b
collection = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr StreamCollection
collection' <- b -> IO (Ptr StreamCollection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
collection
Ptr Message
result <- Ptr Object -> Ptr StreamCollection -> IO (Ptr Message)
gst_message_new_stream_collection Ptr Object
src' Ptr StreamCollection
collection'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewStreamCollection" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
collection
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_stream_start" gst_message_new_stream_start ::
Ptr Gst.Object.Object ->
IO (Ptr Message)
messageNewStreamStart ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> m Message
messageNewStreamStart :: Maybe a -> m Message
messageNewStreamStart Maybe a
src = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr Message
result <- Ptr Object -> IO (Ptr Message)
gst_message_new_stream_start Ptr Object
maybeSrc
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewStreamStart" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_stream_status" gst_message_new_stream_status ::
Ptr Gst.Object.Object ->
CUInt ->
Ptr Gst.Element.Element ->
IO (Ptr Message)
messageNewStreamStatus ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a, Gst.Element.IsElement b) =>
a
-> Gst.Enums.StreamStatusType
-> b
-> m Message
messageNewStreamStatus :: a -> StreamStatusType -> b -> m Message
messageNewStreamStatus a
src StreamStatusType
type_ b
owner = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (StreamStatusType -> Int) -> StreamStatusType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StreamStatusType -> Int
forall a. Enum a => a -> Int
fromEnum) StreamStatusType
type_
Ptr Element
owner' <- b -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
owner
Ptr Message
result <- Ptr Object -> CUInt -> Ptr Element -> IO (Ptr Message)
gst_message_new_stream_status Ptr Object
src' CUInt
type_' Ptr Element
owner'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewStreamStatus" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
owner
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_streams_selected" gst_message_new_streams_selected ::
Ptr Gst.Object.Object ->
Ptr Gst.StreamCollection.StreamCollection ->
IO (Ptr Message)
messageNewStreamsSelected ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a, Gst.StreamCollection.IsStreamCollection b) =>
a
-> b
-> m Message
messageNewStreamsSelected :: a -> b -> m Message
messageNewStreamsSelected a
src b
collection = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr StreamCollection
collection' <- b -> IO (Ptr StreamCollection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
collection
Ptr Message
result <- Ptr Object -> Ptr StreamCollection -> IO (Ptr Message)
gst_message_new_streams_selected Ptr Object
src' Ptr StreamCollection
collection'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewStreamsSelected" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
collection
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_structure_change" gst_message_new_structure_change ::
Ptr Gst.Object.Object ->
CUInt ->
Ptr Gst.Element.Element ->
CInt ->
IO (Ptr Message)
messageNewStructureChange ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a, Gst.Element.IsElement b) =>
Maybe (a)
-> Gst.Enums.StructureChangeType
-> b
-> Bool
-> m Message
messageNewStructureChange :: Maybe a -> StructureChangeType -> b -> Bool -> m Message
messageNewStructureChange Maybe a
src StructureChangeType
type_ b
owner Bool
busy = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (StructureChangeType -> Int) -> StructureChangeType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StructureChangeType -> Int
forall a. Enum a => a -> Int
fromEnum) StructureChangeType
type_
Ptr Element
owner' <- b -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
owner
let busy' :: CInt
busy' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
busy
Ptr Message
result <- Ptr Object -> CUInt -> Ptr Element -> CInt -> IO (Ptr Message)
gst_message_new_structure_change Ptr Object
maybeSrc CUInt
type_' Ptr Element
owner' CInt
busy'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewStructureChange" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
owner
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_tag" gst_message_new_tag ::
Ptr Gst.Object.Object ->
Ptr Gst.TagList.TagList ->
IO (Ptr Message)
messageNewTag ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> Gst.TagList.TagList
-> m Message
messageNewTag :: Maybe a -> TagList -> m Message
messageNewTag Maybe a
src TagList
tagList = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr TagList
tagList' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed TagList
tagList
Ptr Message
result <- Ptr Object -> Ptr TagList -> IO (Ptr Message)
gst_message_new_tag Ptr Object
maybeSrc Ptr TagList
tagList'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewTag" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
tagList
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_toc" gst_message_new_toc ::
Ptr Gst.Object.Object ->
Ptr Gst.Toc.Toc ->
CInt ->
IO (Ptr Message)
messageNewToc ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
a
-> Gst.Toc.Toc
-> Bool
-> m Message
messageNewToc :: a -> Toc -> Bool -> m Message
messageNewToc a
src Toc
toc Bool
updated = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Toc
toc' <- Toc -> IO (Ptr Toc)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Toc
toc
let updated' :: CInt
updated' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
updated
Ptr Message
result <- Ptr Object -> Ptr Toc -> CInt -> IO (Ptr Message)
gst_message_new_toc Ptr Object
src' Ptr Toc
toc' CInt
updated'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewToc" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
Toc -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Toc
toc
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_warning" gst_message_new_warning ::
Ptr Gst.Object.Object ->
Ptr GError ->
CString ->
IO (Ptr Message)
messageNewWarning ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> GError
-> T.Text
-> m Message
messageNewWarning :: Maybe a -> GError -> Text -> m Message
messageNewWarning Maybe a
src GError
error_ Text
debug = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr GError
error_' <- GError -> IO (Ptr GError)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GError
error_
CString
debug' <- Text -> IO CString
textToCString Text
debug
Ptr Message
result <- Ptr Object -> Ptr GError -> CString -> IO (Ptr Message)
gst_message_new_warning Ptr Object
maybeSrc Ptr GError
error_' CString
debug'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewWarning" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
GError -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GError
error_
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
debug'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_new_warning_with_details" gst_message_new_warning_with_details ::
Ptr Gst.Object.Object ->
Ptr GError ->
CString ->
Ptr Gst.Structure.Structure ->
IO (Ptr Message)
messageNewWarningWithDetails ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
Maybe (a)
-> GError
-> T.Text
-> Maybe (Gst.Structure.Structure)
-> m (Maybe Message)
messageNewWarningWithDetails :: Maybe a -> GError -> Text -> Maybe Structure -> m (Maybe Message)
messageNewWarningWithDetails Maybe a
src GError
error_ Text
debug Maybe Structure
details = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
maybeSrc <- case Maybe a
src of
Maybe a
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just a
jSrc -> do
Ptr Object
jSrc' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jSrc
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jSrc'
Ptr GError
error_' <- GError -> IO (Ptr GError)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GError
error_
CString
debug' <- Text -> IO CString
textToCString Text
debug
Ptr Structure
maybeDetails <- case Maybe Structure
details of
Maybe Structure
Nothing -> Ptr Structure -> IO (Ptr Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
forall a. Ptr a
nullPtr
Just Structure
jDetails -> do
Ptr Structure
jDetails' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
jDetails
Ptr Structure -> IO (Ptr Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
jDetails'
Ptr Message
result <- Ptr Object
-> Ptr GError -> CString -> Ptr Structure -> IO (Ptr Message)
gst_message_new_warning_with_details Ptr Object
maybeSrc Ptr GError
error_' CString
debug' Ptr Structure
maybeDetails
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
src a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
GError -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GError
error_
Maybe Structure -> (Structure -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Structure
details Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
debug'
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_message_add_redirect_entry" gst_message_add_redirect_entry ::
Ptr Message ->
CString ->
Ptr Gst.TagList.TagList ->
Ptr Gst.Structure.Structure ->
IO ()
messageAddRedirectEntry ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> T.Text
-> Maybe (Gst.TagList.TagList)
-> Maybe (Gst.Structure.Structure)
-> m ()
messageAddRedirectEntry :: Message -> Text -> Maybe TagList -> Maybe Structure -> m ()
messageAddRedirectEntry Message
message Text
location Maybe TagList
tagList Maybe Structure
entryStruct = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
CString
location' <- Text -> IO CString
textToCString Text
location
Ptr TagList
maybeTagList <- case Maybe TagList
tagList of
Maybe TagList
Nothing -> Ptr TagList -> IO (Ptr TagList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TagList
forall a. Ptr a
nullPtr
Just TagList
jTagList -> do
Ptr TagList
jTagList' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed TagList
jTagList
Ptr TagList -> IO (Ptr TagList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TagList
jTagList'
Ptr Structure
maybeEntryStruct <- case Maybe Structure
entryStruct of
Maybe Structure
Nothing -> Ptr Structure -> IO (Ptr Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
forall a. Ptr a
nullPtr
Just Structure
jEntryStruct -> do
Ptr Structure
jEntryStruct' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
jEntryStruct
Ptr Structure -> IO (Ptr Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
jEntryStruct'
Ptr Message -> CString -> Ptr TagList -> Ptr Structure -> IO ()
gst_message_add_redirect_entry Ptr Message
message' CString
location' Ptr TagList
maybeTagList Ptr Structure
maybeEntryStruct
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Maybe TagList -> (TagList -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe TagList
tagList TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Structure -> (Structure -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Structure
entryStruct Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
location'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageAddRedirectEntryMethodInfo
instance (signature ~ (T.Text -> Maybe (Gst.TagList.TagList) -> Maybe (Gst.Structure.Structure) -> m ()), MonadIO m) => O.MethodInfo MessageAddRedirectEntryMethodInfo Message signature where
overloadedMethod = messageAddRedirectEntry
#endif
foreign import ccall "gst_message_get_num_redirect_entries" gst_message_get_num_redirect_entries ::
Ptr Message ->
IO Word64
messageGetNumRedirectEntries ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m Word64
messageGetNumRedirectEntries :: Message -> m Word64
messageGetNumRedirectEntries Message
message = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Word64
result <- Ptr Message -> IO Word64
gst_message_get_num_redirect_entries Ptr Message
message'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data MessageGetNumRedirectEntriesMethodInfo
instance (signature ~ (m Word64), MonadIO m) => O.MethodInfo MessageGetNumRedirectEntriesMethodInfo Message signature where
overloadedMethod = messageGetNumRedirectEntries
#endif
foreign import ccall "gst_message_get_seqnum" gst_message_get_seqnum ::
Ptr Message ->
IO Word32
messageGetSeqnum ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m Word32
messageGetSeqnum :: Message -> m Word32
messageGetSeqnum Message
message = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Word32
result <- Ptr Message -> IO Word32
gst_message_get_seqnum Ptr Message
message'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data MessageGetSeqnumMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo MessageGetSeqnumMethodInfo Message signature where
overloadedMethod = messageGetSeqnum
#endif
foreign import ccall "gst_message_get_stream_status_object" gst_message_get_stream_status_object ::
Ptr Message ->
IO (Ptr GValue)
messageGetStreamStatusObject ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Maybe GValue)
messageGetStreamStatusObject :: Message -> m (Maybe GValue)
messageGetStreamStatusObject Message
message = IO (Maybe GValue) -> m (Maybe GValue)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GValue) -> m (Maybe GValue))
-> IO (Maybe GValue) -> m (Maybe GValue)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr GValue
result <- Ptr Message -> IO (Ptr GValue)
gst_message_get_stream_status_object Ptr Message
message'
Maybe GValue
maybeResult <- Ptr GValue -> (Ptr GValue -> IO GValue) -> IO (Maybe GValue)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GValue
result ((Ptr GValue -> IO GValue) -> IO (Maybe GValue))
-> (Ptr GValue -> IO GValue) -> IO (Maybe GValue)
forall a b. (a -> b) -> a -> b
$ \Ptr GValue
result' -> do
GValue
result'' <- Ptr GValue -> IO GValue
B.GValue.newGValueFromPtr Ptr GValue
result'
GValue -> IO GValue
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
result''
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Maybe GValue -> IO (Maybe GValue)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GValue
maybeResult
#if defined(ENABLE_OVERLOADING)
data MessageGetStreamStatusObjectMethodInfo
instance (signature ~ (m (Maybe GValue)), MonadIO m) => O.MethodInfo MessageGetStreamStatusObjectMethodInfo Message signature where
overloadedMethod = messageGetStreamStatusObject
#endif
foreign import ccall "gst_message_get_structure" gst_message_get_structure ::
Ptr Message ->
IO (Ptr Gst.Structure.Structure)
messageGetStructure ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Maybe Gst.Structure.Structure)
messageGetStructure :: Message -> m (Maybe Structure)
messageGetStructure Message
message = IO (Maybe Structure) -> m (Maybe Structure)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Structure) -> m (Maybe Structure))
-> IO (Maybe Structure) -> m (Maybe Structure)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr Structure
result <- Ptr Message -> IO (Ptr Structure)
gst_message_get_structure Ptr Message
message'
Maybe Structure
maybeResult <- Ptr Structure
-> (Ptr Structure -> IO Structure) -> IO (Maybe Structure)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Structure
result ((Ptr Structure -> IO Structure) -> IO (Maybe Structure))
-> (Ptr Structure -> IO Structure) -> IO (Maybe Structure)
forall a b. (a -> b) -> a -> b
$ \Ptr Structure
result' -> do
Structure
result'' <- ((ManagedPtr Structure -> Structure)
-> Ptr Structure -> IO Structure
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Structure -> Structure
Gst.Structure.Structure) Ptr Structure
result'
Structure -> IO Structure
forall (m :: * -> *) a. Monad m => a -> m a
return Structure
result''
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Maybe Structure -> IO (Maybe Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Structure
maybeResult
#if defined(ENABLE_OVERLOADING)
data MessageGetStructureMethodInfo
instance (signature ~ (m (Maybe Gst.Structure.Structure)), MonadIO m) => O.MethodInfo MessageGetStructureMethodInfo Message signature where
overloadedMethod = messageGetStructure
#endif
foreign import ccall "gst_message_has_name" gst_message_has_name ::
Ptr Message ->
CString ->
IO CInt
messageHasName ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> T.Text
-> m Bool
messageHasName :: Message -> Text -> m Bool
messageHasName Message
message Text
name = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
CString
name' <- Text -> IO CString
textToCString Text
name
CInt
result <- Ptr Message -> CString -> IO CInt
gst_message_has_name Ptr Message
message' CString
name'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data MessageHasNameMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo MessageHasNameMethodInfo Message signature where
overloadedMethod = messageHasName
#endif
foreign import ccall "gst_message_parse_async_done" gst_message_parse_async_done ::
Ptr Message ->
Ptr Word64 ->
IO ()
messageParseAsyncDone ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Word64)
messageParseAsyncDone :: Message -> m Word64
messageParseAsyncDone Message
message = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr Word64
runningTime <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Message -> Ptr Word64 -> IO ()
gst_message_parse_async_done Ptr Message
message' Ptr Word64
runningTime
Word64
runningTime' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
runningTime
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
runningTime
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
runningTime'
#if defined(ENABLE_OVERLOADING)
data MessageParseAsyncDoneMethodInfo
instance (signature ~ (m (Word64)), MonadIO m) => O.MethodInfo MessageParseAsyncDoneMethodInfo Message signature where
overloadedMethod = messageParseAsyncDone
#endif
foreign import ccall "gst_message_parse_buffering" gst_message_parse_buffering ::
Ptr Message ->
Ptr Int32 ->
IO ()
messageParseBuffering ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Int32)
messageParseBuffering :: Message -> m Int32
messageParseBuffering Message
message = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr Int32
percent <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Message -> Ptr Int32 -> IO ()
gst_message_parse_buffering Ptr Message
message' Ptr Int32
percent
Int32
percent' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
percent
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
percent
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
percent'
#if defined(ENABLE_OVERLOADING)
data MessageParseBufferingMethodInfo
instance (signature ~ (m (Int32)), MonadIO m) => O.MethodInfo MessageParseBufferingMethodInfo Message signature where
overloadedMethod = messageParseBuffering
#endif
foreign import ccall "gst_message_parse_buffering_stats" gst_message_parse_buffering_stats ::
Ptr Message ->
Ptr CUInt ->
Ptr Int32 ->
Ptr Int32 ->
Ptr Int64 ->
IO ()
messageParseBufferingStats ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Gst.Enums.BufferingMode, Int32, Int32, Int64))
messageParseBufferingStats :: Message -> m (BufferingMode, Int32, Int32, Int64)
messageParseBufferingStats Message
message = IO (BufferingMode, Int32, Int32, Int64)
-> m (BufferingMode, Int32, Int32, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (BufferingMode, Int32, Int32, Int64)
-> m (BufferingMode, Int32, Int32, Int64))
-> IO (BufferingMode, Int32, Int32, Int64)
-> m (BufferingMode, Int32, Int32, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CUInt
mode <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Int32
avgIn <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
avgOut <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int64
bufferingLeft <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
Ptr Message
-> Ptr CUInt -> Ptr Int32 -> Ptr Int32 -> Ptr Int64 -> IO ()
gst_message_parse_buffering_stats Ptr Message
message' Ptr CUInt
mode Ptr Int32
avgIn Ptr Int32
avgOut Ptr Int64
bufferingLeft
CUInt
mode' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
mode
let mode'' :: BufferingMode
mode'' = (Int -> BufferingMode
forall a. Enum a => Int -> a
toEnum (Int -> BufferingMode) -> (CUInt -> Int) -> CUInt -> BufferingMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
mode'
Int32
avgIn' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
avgIn
Int32
avgOut' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
avgOut
Int64
bufferingLeft' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
bufferingLeft
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
mode
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
avgIn
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
avgOut
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
bufferingLeft
(BufferingMode, Int32, Int32, Int64)
-> IO (BufferingMode, Int32, Int32, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (BufferingMode
mode'', Int32
avgIn', Int32
avgOut', Int64
bufferingLeft')
#if defined(ENABLE_OVERLOADING)
data MessageParseBufferingStatsMethodInfo
instance (signature ~ (m ((Gst.Enums.BufferingMode, Int32, Int32, Int64))), MonadIO m) => O.MethodInfo MessageParseBufferingStatsMethodInfo Message signature where
overloadedMethod = messageParseBufferingStats
#endif
foreign import ccall "gst_message_parse_clock_lost" gst_message_parse_clock_lost ::
Ptr Message ->
Ptr (Ptr Gst.Clock.Clock) ->
IO ()
messageParseClockLost ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Gst.Clock.Clock)
messageParseClockLost :: Message -> m Clock
messageParseClockLost Message
message = IO Clock -> m Clock
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Clock -> m Clock) -> IO Clock -> m Clock
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr Clock)
clock <- IO (Ptr (Ptr Clock))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Clock.Clock))
Ptr Message -> Ptr (Ptr Clock) -> IO ()
gst_message_parse_clock_lost Ptr Message
message' Ptr (Ptr Clock)
clock
Ptr Clock
clock' <- Ptr (Ptr Clock) -> IO (Ptr Clock)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Clock)
clock
Clock
clock'' <- ((ManagedPtr Clock -> Clock) -> Ptr Clock -> IO Clock
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Clock -> Clock
Gst.Clock.Clock) Ptr Clock
clock'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr Clock) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Clock)
clock
Clock -> IO Clock
forall (m :: * -> *) a. Monad m => a -> m a
return Clock
clock''
#if defined(ENABLE_OVERLOADING)
data MessageParseClockLostMethodInfo
instance (signature ~ (m (Gst.Clock.Clock)), MonadIO m) => O.MethodInfo MessageParseClockLostMethodInfo Message signature where
overloadedMethod = messageParseClockLost
#endif
foreign import ccall "gst_message_parse_clock_provide" gst_message_parse_clock_provide ::
Ptr Message ->
Ptr (Ptr Gst.Clock.Clock) ->
Ptr CInt ->
IO ()
messageParseClockProvide ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Gst.Clock.Clock, Bool))
messageParseClockProvide :: Message -> m (Clock, Bool)
messageParseClockProvide Message
message = IO (Clock, Bool) -> m (Clock, Bool)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Clock, Bool) -> m (Clock, Bool))
-> IO (Clock, Bool) -> m (Clock, Bool)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr Clock)
clock <- IO (Ptr (Ptr Clock))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Clock.Clock))
Ptr CInt
ready <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
Ptr Message -> Ptr (Ptr Clock) -> Ptr CInt -> IO ()
gst_message_parse_clock_provide Ptr Message
message' Ptr (Ptr Clock)
clock Ptr CInt
ready
Ptr Clock
clock' <- Ptr (Ptr Clock) -> IO (Ptr Clock)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Clock)
clock
Clock
clock'' <- ((ManagedPtr Clock -> Clock) -> Ptr Clock -> IO Clock
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Clock -> Clock
Gst.Clock.Clock) Ptr Clock
clock'
CInt
ready' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
ready
let ready'' :: Bool
ready'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
ready'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr Clock) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Clock)
clock
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
ready
(Clock, Bool) -> IO (Clock, Bool)
forall (m :: * -> *) a. Monad m => a -> m a
return (Clock
clock'', Bool
ready'')
#if defined(ENABLE_OVERLOADING)
data MessageParseClockProvideMethodInfo
instance (signature ~ (m ((Gst.Clock.Clock, Bool))), MonadIO m) => O.MethodInfo MessageParseClockProvideMethodInfo Message signature where
overloadedMethod = messageParseClockProvide
#endif
foreign import ccall "gst_message_parse_context_type" gst_message_parse_context_type ::
Ptr Message ->
Ptr CString ->
IO CInt
messageParseContextType ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Bool, T.Text))
messageParseContextType :: Message -> m (Bool, Text)
messageParseContextType Message
message = IO (Bool, Text) -> m (Bool, Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text) -> m (Bool, Text))
-> IO (Bool, Text) -> m (Bool, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CString
contextType <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
CInt
result <- Ptr Message -> Ptr CString -> IO CInt
gst_message_parse_context_type Ptr Message
message' Ptr CString
contextType
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString
contextType' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
contextType
Text
contextType'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
contextType'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
contextType
(Bool, Text) -> IO (Bool, Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
contextType'')
#if defined(ENABLE_OVERLOADING)
data MessageParseContextTypeMethodInfo
instance (signature ~ (m ((Bool, T.Text))), MonadIO m) => O.MethodInfo MessageParseContextTypeMethodInfo Message signature where
overloadedMethod = messageParseContextType
#endif
foreign import ccall "gst_message_parse_device_added" gst_message_parse_device_added ::
Ptr Message ->
Ptr (Ptr Gst.Device.Device) ->
IO ()
messageParseDeviceAdded ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Gst.Device.Device)
messageParseDeviceAdded :: Message -> m Device
messageParseDeviceAdded Message
message = IO Device -> m Device
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Device -> m Device) -> IO Device -> m Device
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr Device)
device <- IO (Ptr (Ptr Device))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Device.Device))
Ptr Message -> Ptr (Ptr Device) -> IO ()
gst_message_parse_device_added Ptr Message
message' Ptr (Ptr Device)
device
Ptr Device
device' <- Ptr (Ptr Device) -> IO (Ptr Device)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Device)
device
Device
device'' <- ((ManagedPtr Device -> Device) -> Ptr Device -> IO Device
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Device -> Device
Gst.Device.Device) Ptr Device
device'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr Device) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Device)
device
Device -> IO Device
forall (m :: * -> *) a. Monad m => a -> m a
return Device
device''
#if defined(ENABLE_OVERLOADING)
data MessageParseDeviceAddedMethodInfo
instance (signature ~ (m (Gst.Device.Device)), MonadIO m) => O.MethodInfo MessageParseDeviceAddedMethodInfo Message signature where
overloadedMethod = messageParseDeviceAdded
#endif
foreign import ccall "gst_message_parse_device_changed" gst_message_parse_device_changed ::
Ptr Message ->
Ptr (Ptr Gst.Device.Device) ->
Ptr (Ptr Gst.Device.Device) ->
IO ()
messageParseDeviceChanged ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Gst.Device.Device, Gst.Device.Device))
messageParseDeviceChanged :: Message -> m (Device, Device)
messageParseDeviceChanged Message
message = IO (Device, Device) -> m (Device, Device)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Device, Device) -> m (Device, Device))
-> IO (Device, Device) -> m (Device, Device)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr Device)
device <- IO (Ptr (Ptr Device))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Device.Device))
Ptr (Ptr Device)
changedDevice <- IO (Ptr (Ptr Device))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Device.Device))
Ptr Message -> Ptr (Ptr Device) -> Ptr (Ptr Device) -> IO ()
gst_message_parse_device_changed Ptr Message
message' Ptr (Ptr Device)
device Ptr (Ptr Device)
changedDevice
Ptr Device
device' <- Ptr (Ptr Device) -> IO (Ptr Device)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Device)
device
Device
device'' <- ((ManagedPtr Device -> Device) -> Ptr Device -> IO Device
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Device -> Device
Gst.Device.Device) Ptr Device
device'
Ptr Device
changedDevice' <- Ptr (Ptr Device) -> IO (Ptr Device)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Device)
changedDevice
Device
changedDevice'' <- ((ManagedPtr Device -> Device) -> Ptr Device -> IO Device
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Device -> Device
Gst.Device.Device) Ptr Device
changedDevice'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr Device) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Device)
device
Ptr (Ptr Device) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Device)
changedDevice
(Device, Device) -> IO (Device, Device)
forall (m :: * -> *) a. Monad m => a -> m a
return (Device
device'', Device
changedDevice'')
#if defined(ENABLE_OVERLOADING)
data MessageParseDeviceChangedMethodInfo
instance (signature ~ (m ((Gst.Device.Device, Gst.Device.Device))), MonadIO m) => O.MethodInfo MessageParseDeviceChangedMethodInfo Message signature where
overloadedMethod = messageParseDeviceChanged
#endif
foreign import ccall "gst_message_parse_device_removed" gst_message_parse_device_removed ::
Ptr Message ->
Ptr (Ptr Gst.Device.Device) ->
IO ()
messageParseDeviceRemoved ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Gst.Device.Device)
messageParseDeviceRemoved :: Message -> m Device
messageParseDeviceRemoved Message
message = IO Device -> m Device
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Device -> m Device) -> IO Device -> m Device
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr Device)
device <- IO (Ptr (Ptr Device))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Device.Device))
Ptr Message -> Ptr (Ptr Device) -> IO ()
gst_message_parse_device_removed Ptr Message
message' Ptr (Ptr Device)
device
Ptr Device
device' <- Ptr (Ptr Device) -> IO (Ptr Device)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Device)
device
Device
device'' <- ((ManagedPtr Device -> Device) -> Ptr Device -> IO Device
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Device -> Device
Gst.Device.Device) Ptr Device
device'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr Device) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Device)
device
Device -> IO Device
forall (m :: * -> *) a. Monad m => a -> m a
return Device
device''
#if defined(ENABLE_OVERLOADING)
data MessageParseDeviceRemovedMethodInfo
instance (signature ~ (m (Gst.Device.Device)), MonadIO m) => O.MethodInfo MessageParseDeviceRemovedMethodInfo Message signature where
overloadedMethod = messageParseDeviceRemoved
#endif
foreign import ccall "gst_message_parse_error" gst_message_parse_error ::
Ptr Message ->
Ptr (Ptr GError) ->
Ptr CString ->
IO ()
messageParseError ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((GError, T.Text))
messageParseError :: Message -> m (GError, Text)
messageParseError Message
message = IO (GError, Text) -> m (GError, Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GError, Text) -> m (GError, Text))
-> IO (GError, Text) -> m (GError, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr GError)
gerror <- IO (Ptr (Ptr GError))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GError))
Ptr CString
debug <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr Message -> Ptr (Ptr GError) -> Ptr CString -> IO ()
gst_message_parse_error Ptr Message
message' Ptr (Ptr GError)
gerror Ptr CString
debug
Ptr GError
gerror' <- Ptr (Ptr GError) -> IO (Ptr GError)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GError)
gerror
GError
gerror'' <- ((ManagedPtr GError -> GError) -> Ptr GError -> IO GError
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr GError -> GError
GError) Ptr GError
gerror'
CString
debug' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
debug
Text
debug'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
debug'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
debug'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr GError) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GError)
gerror
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
debug
(GError, Text) -> IO (GError, Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (GError
gerror'', Text
debug'')
#if defined(ENABLE_OVERLOADING)
data MessageParseErrorMethodInfo
instance (signature ~ (m ((GError, T.Text))), MonadIO m) => O.MethodInfo MessageParseErrorMethodInfo Message signature where
overloadedMethod = messageParseError
#endif
foreign import ccall "gst_message_parse_error_details" gst_message_parse_error_details ::
Ptr Message ->
Ptr (Ptr Gst.Structure.Structure) ->
IO ()
messageParseErrorDetails ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Gst.Structure.Structure)
messageParseErrorDetails :: Message -> m Structure
messageParseErrorDetails Message
message = IO Structure -> m Structure
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Structure -> m Structure) -> IO Structure -> m Structure
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr Structure)
structure <- IO (Ptr (Ptr Structure))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Structure.Structure))
Ptr Message -> Ptr (Ptr Structure) -> IO ()
gst_message_parse_error_details Ptr Message
message' Ptr (Ptr Structure)
structure
Ptr Structure
structure' <- Ptr (Ptr Structure) -> IO (Ptr Structure)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Structure)
structure
Structure
structure'' <- ((ManagedPtr Structure -> Structure)
-> Ptr Structure -> IO Structure
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Structure -> Structure
Gst.Structure.Structure) Ptr Structure
structure'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr Structure) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Structure)
structure
Structure -> IO Structure
forall (m :: * -> *) a. Monad m => a -> m a
return Structure
structure''
#if defined(ENABLE_OVERLOADING)
data MessageParseErrorDetailsMethodInfo
instance (signature ~ (m (Gst.Structure.Structure)), MonadIO m) => O.MethodInfo MessageParseErrorDetailsMethodInfo Message signature where
overloadedMethod = messageParseErrorDetails
#endif
foreign import ccall "gst_message_parse_group_id" gst_message_parse_group_id ::
Ptr Message ->
Ptr Word32 ->
IO CInt
messageParseGroupId ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Bool, Word32))
messageParseGroupId :: Message -> m (Bool, Word32)
messageParseGroupId Message
message = IO (Bool, Word32) -> m (Bool, Word32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word32) -> m (Bool, Word32))
-> IO (Bool, Word32) -> m (Bool, Word32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr Word32
groupId <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
CInt
result <- Ptr Message -> Ptr Word32 -> IO CInt
gst_message_parse_group_id Ptr Message
message' Ptr Word32
groupId
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Word32
groupId' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
groupId
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
groupId
(Bool, Word32) -> IO (Bool, Word32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word32
groupId')
#if defined(ENABLE_OVERLOADING)
data MessageParseGroupIdMethodInfo
instance (signature ~ (m ((Bool, Word32))), MonadIO m) => O.MethodInfo MessageParseGroupIdMethodInfo Message signature where
overloadedMethod = messageParseGroupId
#endif
foreign import ccall "gst_message_parse_have_context" gst_message_parse_have_context ::
Ptr Message ->
Ptr (Ptr Gst.Context.Context) ->
IO ()
messageParseHaveContext ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Gst.Context.Context)
messageParseHaveContext :: Message -> m Context
messageParseHaveContext Message
message = IO Context -> m Context
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Context -> m Context) -> IO Context -> m Context
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr Context)
context <- IO (Ptr (Ptr Context))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Context.Context))
Ptr Message -> Ptr (Ptr Context) -> IO ()
gst_message_parse_have_context Ptr Message
message' Ptr (Ptr Context)
context
Ptr Context
context' <- Ptr (Ptr Context) -> IO (Ptr Context)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Context)
context
Context
context'' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Context -> Context
Gst.Context.Context) Ptr Context
context'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr Context) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Context)
context
Context -> IO Context
forall (m :: * -> *) a. Monad m => a -> m a
return Context
context''
#if defined(ENABLE_OVERLOADING)
data MessageParseHaveContextMethodInfo
instance (signature ~ (m (Gst.Context.Context)), MonadIO m) => O.MethodInfo MessageParseHaveContextMethodInfo Message signature where
overloadedMethod = messageParseHaveContext
#endif
foreign import ccall "gst_message_parse_info" gst_message_parse_info ::
Ptr Message ->
Ptr (Ptr GError) ->
Ptr CString ->
IO ()
messageParseInfo ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((GError, T.Text))
messageParseInfo :: Message -> m (GError, Text)
messageParseInfo Message
message = IO (GError, Text) -> m (GError, Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GError, Text) -> m (GError, Text))
-> IO (GError, Text) -> m (GError, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr GError)
gerror <- IO (Ptr (Ptr GError))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GError))
Ptr CString
debug <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr Message -> Ptr (Ptr GError) -> Ptr CString -> IO ()
gst_message_parse_info Ptr Message
message' Ptr (Ptr GError)
gerror Ptr CString
debug
Ptr GError
gerror' <- Ptr (Ptr GError) -> IO (Ptr GError)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GError)
gerror
GError
gerror'' <- ((ManagedPtr GError -> GError) -> Ptr GError -> IO GError
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr GError -> GError
GError) Ptr GError
gerror'
CString
debug' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
debug
Text
debug'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
debug'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
debug'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr GError) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GError)
gerror
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
debug
(GError, Text) -> IO (GError, Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (GError
gerror'', Text
debug'')
#if defined(ENABLE_OVERLOADING)
data MessageParseInfoMethodInfo
instance (signature ~ (m ((GError, T.Text))), MonadIO m) => O.MethodInfo MessageParseInfoMethodInfo Message signature where
overloadedMethod = messageParseInfo
#endif
foreign import ccall "gst_message_parse_info_details" gst_message_parse_info_details ::
Ptr Message ->
Ptr (Ptr Gst.Structure.Structure) ->
IO ()
messageParseInfoDetails ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Gst.Structure.Structure)
messageParseInfoDetails :: Message -> m Structure
messageParseInfoDetails Message
message = IO Structure -> m Structure
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Structure -> m Structure) -> IO Structure -> m Structure
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr Structure)
structure <- IO (Ptr (Ptr Structure))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Structure.Structure))
Ptr Message -> Ptr (Ptr Structure) -> IO ()
gst_message_parse_info_details Ptr Message
message' Ptr (Ptr Structure)
structure
Ptr Structure
structure' <- Ptr (Ptr Structure) -> IO (Ptr Structure)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Structure)
structure
Structure
structure'' <- ((ManagedPtr Structure -> Structure)
-> Ptr Structure -> IO Structure
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Structure -> Structure
Gst.Structure.Structure) Ptr Structure
structure'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr Structure) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Structure)
structure
Structure -> IO Structure
forall (m :: * -> *) a. Monad m => a -> m a
return Structure
structure''
#if defined(ENABLE_OVERLOADING)
data MessageParseInfoDetailsMethodInfo
instance (signature ~ (m (Gst.Structure.Structure)), MonadIO m) => O.MethodInfo MessageParseInfoDetailsMethodInfo Message signature where
overloadedMethod = messageParseInfoDetails
#endif
foreign import ccall "gst_message_parse_new_clock" gst_message_parse_new_clock ::
Ptr Message ->
Ptr (Ptr Gst.Clock.Clock) ->
IO ()
messageParseNewClock ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Gst.Clock.Clock)
messageParseNewClock :: Message -> m Clock
messageParseNewClock Message
message = IO Clock -> m Clock
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Clock -> m Clock) -> IO Clock -> m Clock
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr Clock)
clock <- IO (Ptr (Ptr Clock))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Clock.Clock))
Ptr Message -> Ptr (Ptr Clock) -> IO ()
gst_message_parse_new_clock Ptr Message
message' Ptr (Ptr Clock)
clock
Ptr Clock
clock' <- Ptr (Ptr Clock) -> IO (Ptr Clock)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Clock)
clock
Clock
clock'' <- ((ManagedPtr Clock -> Clock) -> Ptr Clock -> IO Clock
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Clock -> Clock
Gst.Clock.Clock) Ptr Clock
clock'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr Clock) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Clock)
clock
Clock -> IO Clock
forall (m :: * -> *) a. Monad m => a -> m a
return Clock
clock''
#if defined(ENABLE_OVERLOADING)
data MessageParseNewClockMethodInfo
instance (signature ~ (m (Gst.Clock.Clock)), MonadIO m) => O.MethodInfo MessageParseNewClockMethodInfo Message signature where
overloadedMethod = messageParseNewClock
#endif
foreign import ccall "gst_message_parse_progress" gst_message_parse_progress ::
Ptr Message ->
Ptr CUInt ->
Ptr CString ->
Ptr CString ->
IO ()
messageParseProgress ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Gst.Enums.ProgressType, T.Text, T.Text))
messageParseProgress :: Message -> m (ProgressType, Text, Text)
messageParseProgress Message
message = IO (ProgressType, Text, Text) -> m (ProgressType, Text, Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (ProgressType, Text, Text) -> m (ProgressType, Text, Text))
-> IO (ProgressType, Text, Text) -> m (ProgressType, Text, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CUInt
type_ <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr CString
code <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CString
text <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr Message -> Ptr CUInt -> Ptr CString -> Ptr CString -> IO ()
gst_message_parse_progress Ptr Message
message' Ptr CUInt
type_ Ptr CString
code Ptr CString
text
CUInt
type_' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
type_
let type_'' :: ProgressType
type_'' = (Int -> ProgressType
forall a. Enum a => Int -> a
toEnum (Int -> ProgressType) -> (CUInt -> Int) -> CUInt -> ProgressType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
type_'
CString
code' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
code
Text
code'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
code'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
code'
CString
text' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
text
Text
text'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
text'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
text'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
type_
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
code
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
text
(ProgressType, Text, Text) -> IO (ProgressType, Text, Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (ProgressType
type_'', Text
code'', Text
text'')
#if defined(ENABLE_OVERLOADING)
data MessageParseProgressMethodInfo
instance (signature ~ (m ((Gst.Enums.ProgressType, T.Text, T.Text))), MonadIO m) => O.MethodInfo MessageParseProgressMethodInfo Message signature where
overloadedMethod = messageParseProgress
#endif
foreign import ccall "gst_message_parse_property_notify" gst_message_parse_property_notify ::
Ptr Message ->
Ptr (Ptr Gst.Object.Object) ->
Ptr CString ->
Ptr (Ptr GValue) ->
IO ()
messageParsePropertyNotify ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Gst.Object.Object, T.Text, GValue))
messageParsePropertyNotify :: Message -> m (Object, Text, GValue)
messageParsePropertyNotify Message
message = IO (Object, Text, GValue) -> m (Object, Text, GValue)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Object, Text, GValue) -> m (Object, Text, GValue))
-> IO (Object, Text, GValue) -> m (Object, Text, GValue)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr Object)
object <- IO (Ptr (Ptr Object))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Object.Object))
Ptr CString
propertyName <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr (Ptr GValue)
propertyValue <- IO (Ptr (Ptr GValue))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GValue))
Ptr Message
-> Ptr (Ptr Object) -> Ptr CString -> Ptr (Ptr GValue) -> IO ()
gst_message_parse_property_notify Ptr Message
message' Ptr (Ptr Object)
object Ptr CString
propertyName Ptr (Ptr GValue)
propertyValue
Ptr Object
object' <- Ptr (Ptr Object) -> IO (Ptr Object)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Object)
object
Object
object'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Gst.Object.Object) Ptr Object
object'
CString
propertyName' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
propertyName
Text
propertyName'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
propertyName'
Ptr GValue
propertyValue' <- Ptr (Ptr GValue) -> IO (Ptr GValue)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GValue)
propertyValue
GValue
propertyValue'' <- Ptr GValue -> IO GValue
B.GValue.newGValueFromPtr Ptr GValue
propertyValue'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr Object) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Object)
object
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
propertyName
Ptr (Ptr GValue) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GValue)
propertyValue
(Object, Text, GValue) -> IO (Object, Text, GValue)
forall (m :: * -> *) a. Monad m => a -> m a
return (Object
object'', Text
propertyName'', GValue
propertyValue'')
#if defined(ENABLE_OVERLOADING)
data MessageParsePropertyNotifyMethodInfo
instance (signature ~ (m ((Gst.Object.Object, T.Text, GValue))), MonadIO m) => O.MethodInfo MessageParsePropertyNotifyMethodInfo Message signature where
overloadedMethod = messageParsePropertyNotify
#endif
foreign import ccall "gst_message_parse_qos" gst_message_parse_qos ::
Ptr Message ->
Ptr CInt ->
Ptr Word64 ->
Ptr Word64 ->
Ptr Word64 ->
Ptr Word64 ->
IO ()
messageParseQos ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Bool, Word64, Word64, Word64, Word64))
messageParseQos :: Message -> m (Bool, Word64, Word64, Word64, Word64)
messageParseQos Message
message = IO (Bool, Word64, Word64, Word64, Word64)
-> m (Bool, Word64, Word64, Word64, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word64, Word64, Word64, Word64)
-> m (Bool, Word64, Word64, Word64, Word64))
-> IO (Bool, Word64, Word64, Word64, Word64)
-> m (Bool, Word64, Word64, Word64, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CInt
live <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
Ptr Word64
runningTime <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Word64
streamTime <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Word64
timestamp <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Word64
duration <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Message
-> Ptr CInt
-> Ptr Word64
-> Ptr Word64
-> Ptr Word64
-> Ptr Word64
-> IO ()
gst_message_parse_qos Ptr Message
message' Ptr CInt
live Ptr Word64
runningTime Ptr Word64
streamTime Ptr Word64
timestamp Ptr Word64
duration
CInt
live' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
live
let live'' :: Bool
live'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
live'
Word64
runningTime' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
runningTime
Word64
streamTime' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
streamTime
Word64
timestamp' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
timestamp
Word64
duration' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
duration
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
live
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
runningTime
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
streamTime
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
timestamp
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
duration
(Bool, Word64, Word64, Word64, Word64)
-> IO (Bool, Word64, Word64, Word64, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
live'', Word64
runningTime', Word64
streamTime', Word64
timestamp', Word64
duration')
#if defined(ENABLE_OVERLOADING)
data MessageParseQosMethodInfo
instance (signature ~ (m ((Bool, Word64, Word64, Word64, Word64))), MonadIO m) => O.MethodInfo MessageParseQosMethodInfo Message signature where
overloadedMethod = messageParseQos
#endif
foreign import ccall "gst_message_parse_qos_stats" gst_message_parse_qos_stats ::
Ptr Message ->
Ptr CUInt ->
Ptr Word64 ->
Ptr Word64 ->
IO ()
messageParseQosStats ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Gst.Enums.Format, Word64, Word64))
messageParseQosStats :: Message -> m (Format, Word64, Word64)
messageParseQosStats Message
message = IO (Format, Word64, Word64) -> m (Format, Word64, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Format, Word64, Word64) -> m (Format, Word64, Word64))
-> IO (Format, Word64, Word64) -> m (Format, Word64, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CUInt
format <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Word64
processed <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Word64
dropped <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Message -> Ptr CUInt -> Ptr Word64 -> Ptr Word64 -> IO ()
gst_message_parse_qos_stats Ptr Message
message' Ptr CUInt
format Ptr Word64
processed Ptr Word64
dropped
CUInt
format' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
format
let format'' :: Format
format'' = (Int -> Format
forall a. Enum a => Int -> a
toEnum (Int -> Format) -> (CUInt -> Int) -> CUInt -> Format
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
format'
Word64
processed' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
processed
Word64
dropped' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
dropped
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
format
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
processed
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
dropped
(Format, Word64, Word64) -> IO (Format, Word64, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Format
format'', Word64
processed', Word64
dropped')
#if defined(ENABLE_OVERLOADING)
data MessageParseQosStatsMethodInfo
instance (signature ~ (m ((Gst.Enums.Format, Word64, Word64))), MonadIO m) => O.MethodInfo MessageParseQosStatsMethodInfo Message signature where
overloadedMethod = messageParseQosStats
#endif
foreign import ccall "gst_message_parse_qos_values" gst_message_parse_qos_values ::
Ptr Message ->
Ptr Int64 ->
Ptr CDouble ->
Ptr Int32 ->
IO ()
messageParseQosValues ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Int64, Double, Int32))
messageParseQosValues :: Message -> m (Int64, Double, Int32)
messageParseQosValues Message
message = IO (Int64, Double, Int32) -> m (Int64, Double, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int64, Double, Int32) -> m (Int64, Double, Int32))
-> IO (Int64, Double, Int32) -> m (Int64, Double, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr Int64
jitter <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
Ptr CDouble
proportion <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr Int32
quality <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Message -> Ptr Int64 -> Ptr CDouble -> Ptr Int32 -> IO ()
gst_message_parse_qos_values Ptr Message
message' Ptr Int64
jitter Ptr CDouble
proportion Ptr Int32
quality
Int64
jitter' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
jitter
CDouble
proportion' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
proportion
let proportion'' :: Double
proportion'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
proportion'
Int32
quality' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
quality
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
jitter
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
proportion
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
quality
(Int64, Double, Int32) -> IO (Int64, Double, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int64
jitter', Double
proportion'', Int32
quality')
#if defined(ENABLE_OVERLOADING)
data MessageParseQosValuesMethodInfo
instance (signature ~ (m ((Int64, Double, Int32))), MonadIO m) => O.MethodInfo MessageParseQosValuesMethodInfo Message signature where
overloadedMethod = messageParseQosValues
#endif
foreign import ccall "gst_message_parse_redirect_entry" gst_message_parse_redirect_entry ::
Ptr Message ->
Word64 ->
Ptr CString ->
Ptr (Ptr Gst.TagList.TagList) ->
Ptr (Ptr Gst.Structure.Structure) ->
IO ()
messageParseRedirectEntry ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> Word64
-> m ((T.Text, Gst.TagList.TagList, Gst.Structure.Structure))
messageParseRedirectEntry :: Message -> Word64 -> m (Text, TagList, Structure)
messageParseRedirectEntry Message
message Word64
entryIndex = IO (Text, TagList, Structure) -> m (Text, TagList, Structure)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, TagList, Structure) -> m (Text, TagList, Structure))
-> IO (Text, TagList, Structure) -> m (Text, TagList, Structure)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CString
location <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr (Ptr TagList)
tagList <- IO (Ptr (Ptr TagList))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.TagList.TagList))
Ptr (Ptr Structure)
entryStruct <- IO (Ptr (Ptr Structure))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Structure.Structure))
Ptr Message
-> Word64
-> Ptr CString
-> Ptr (Ptr TagList)
-> Ptr (Ptr Structure)
-> IO ()
gst_message_parse_redirect_entry Ptr Message
message' Word64
entryIndex Ptr CString
location Ptr (Ptr TagList)
tagList Ptr (Ptr Structure)
entryStruct
CString
location' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
location
Text
location'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
location'
Ptr TagList
tagList' <- Ptr (Ptr TagList) -> IO (Ptr TagList)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr TagList)
tagList
TagList
tagList'' <- ((ManagedPtr TagList -> TagList) -> Ptr TagList -> IO TagList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr TagList -> TagList
Gst.TagList.TagList) Ptr TagList
tagList'
Ptr Structure
entryStruct' <- Ptr (Ptr Structure) -> IO (Ptr Structure)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Structure)
entryStruct
Structure
entryStruct'' <- ((ManagedPtr Structure -> Structure)
-> Ptr Structure -> IO Structure
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Structure -> Structure
Gst.Structure.Structure) Ptr Structure
entryStruct'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
location
Ptr (Ptr TagList) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr TagList)
tagList
Ptr (Ptr Structure) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Structure)
entryStruct
(Text, TagList, Structure) -> IO (Text, TagList, Structure)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
location'', TagList
tagList'', Structure
entryStruct'')
#if defined(ENABLE_OVERLOADING)
data MessageParseRedirectEntryMethodInfo
instance (signature ~ (Word64 -> m ((T.Text, Gst.TagList.TagList, Gst.Structure.Structure))), MonadIO m) => O.MethodInfo MessageParseRedirectEntryMethodInfo Message signature where
overloadedMethod = messageParseRedirectEntry
#endif
foreign import ccall "gst_message_parse_request_state" gst_message_parse_request_state ::
Ptr Message ->
Ptr CUInt ->
IO ()
messageParseRequestState ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Gst.Enums.State)
messageParseRequestState :: Message -> m State
messageParseRequestState Message
message = IO State -> m State
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO State -> m State) -> IO State -> m State
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CUInt
state <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Message -> Ptr CUInt -> IO ()
gst_message_parse_request_state Ptr Message
message' Ptr CUInt
state
CUInt
state' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
state
let state'' :: State
state'' = (Int -> State
forall a. Enum a => Int -> a
toEnum (Int -> State) -> (CUInt -> Int) -> CUInt -> State
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
state'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
state
State -> IO State
forall (m :: * -> *) a. Monad m => a -> m a
return State
state''
#if defined(ENABLE_OVERLOADING)
data MessageParseRequestStateMethodInfo
instance (signature ~ (m (Gst.Enums.State)), MonadIO m) => O.MethodInfo MessageParseRequestStateMethodInfo Message signature where
overloadedMethod = messageParseRequestState
#endif
foreign import ccall "gst_message_parse_reset_time" gst_message_parse_reset_time ::
Ptr Message ->
Ptr Word64 ->
IO ()
messageParseResetTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Word64)
messageParseResetTime :: Message -> m Word64
messageParseResetTime Message
message = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr Word64
runningTime <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Message -> Ptr Word64 -> IO ()
gst_message_parse_reset_time Ptr Message
message' Ptr Word64
runningTime
Word64
runningTime' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
runningTime
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
runningTime
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
runningTime'
#if defined(ENABLE_OVERLOADING)
data MessageParseResetTimeMethodInfo
instance (signature ~ (m (Word64)), MonadIO m) => O.MethodInfo MessageParseResetTimeMethodInfo Message signature where
overloadedMethod = messageParseResetTime
#endif
foreign import ccall "gst_message_parse_segment_done" gst_message_parse_segment_done ::
Ptr Message ->
Ptr CUInt ->
Ptr Int64 ->
IO ()
messageParseSegmentDone ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Gst.Enums.Format, Int64))
messageParseSegmentDone :: Message -> m (Format, Int64)
messageParseSegmentDone Message
message = IO (Format, Int64) -> m (Format, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Format, Int64) -> m (Format, Int64))
-> IO (Format, Int64) -> m (Format, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CUInt
format <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Int64
position <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
Ptr Message -> Ptr CUInt -> Ptr Int64 -> IO ()
gst_message_parse_segment_done Ptr Message
message' Ptr CUInt
format Ptr Int64
position
CUInt
format' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
format
let format'' :: Format
format'' = (Int -> Format
forall a. Enum a => Int -> a
toEnum (Int -> Format) -> (CUInt -> Int) -> CUInt -> Format
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
format'
Int64
position' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
position
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
format
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
position
(Format, Int64) -> IO (Format, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Format
format'', Int64
position')
#if defined(ENABLE_OVERLOADING)
data MessageParseSegmentDoneMethodInfo
instance (signature ~ (m ((Gst.Enums.Format, Int64))), MonadIO m) => O.MethodInfo MessageParseSegmentDoneMethodInfo Message signature where
overloadedMethod = messageParseSegmentDone
#endif
foreign import ccall "gst_message_parse_segment_start" gst_message_parse_segment_start ::
Ptr Message ->
Ptr CUInt ->
Ptr Int64 ->
IO ()
messageParseSegmentStart ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Gst.Enums.Format, Int64))
messageParseSegmentStart :: Message -> m (Format, Int64)
messageParseSegmentStart Message
message = IO (Format, Int64) -> m (Format, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Format, Int64) -> m (Format, Int64))
-> IO (Format, Int64) -> m (Format, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CUInt
format <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Int64
position <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
Ptr Message -> Ptr CUInt -> Ptr Int64 -> IO ()
gst_message_parse_segment_start Ptr Message
message' Ptr CUInt
format Ptr Int64
position
CUInt
format' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
format
let format'' :: Format
format'' = (Int -> Format
forall a. Enum a => Int -> a
toEnum (Int -> Format) -> (CUInt -> Int) -> CUInt -> Format
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
format'
Int64
position' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
position
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
format
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
position
(Format, Int64) -> IO (Format, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Format
format'', Int64
position')
#if defined(ENABLE_OVERLOADING)
data MessageParseSegmentStartMethodInfo
instance (signature ~ (m ((Gst.Enums.Format, Int64))), MonadIO m) => O.MethodInfo MessageParseSegmentStartMethodInfo Message signature where
overloadedMethod = messageParseSegmentStart
#endif
foreign import ccall "gst_message_parse_state_changed" gst_message_parse_state_changed ::
Ptr Message ->
Ptr CUInt ->
Ptr CUInt ->
Ptr CUInt ->
IO ()
messageParseStateChanged ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Gst.Enums.State, Gst.Enums.State, Gst.Enums.State))
messageParseStateChanged :: Message -> m (State, State, State)
messageParseStateChanged Message
message = IO (State, State, State) -> m (State, State, State)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (State, State, State) -> m (State, State, State))
-> IO (State, State, State) -> m (State, State, State)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CUInt
oldstate <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr CUInt
newstate <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr CUInt
pending <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Message -> Ptr CUInt -> Ptr CUInt -> Ptr CUInt -> IO ()
gst_message_parse_state_changed Ptr Message
message' Ptr CUInt
oldstate Ptr CUInt
newstate Ptr CUInt
pending
CUInt
oldstate' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
oldstate
let oldstate'' :: State
oldstate'' = (Int -> State
forall a. Enum a => Int -> a
toEnum (Int -> State) -> (CUInt -> Int) -> CUInt -> State
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
oldstate'
CUInt
newstate' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
newstate
let newstate'' :: State
newstate'' = (Int -> State
forall a. Enum a => Int -> a
toEnum (Int -> State) -> (CUInt -> Int) -> CUInt -> State
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
newstate'
CUInt
pending' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
pending
let pending'' :: State
pending'' = (Int -> State
forall a. Enum a => Int -> a
toEnum (Int -> State) -> (CUInt -> Int) -> CUInt -> State
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
pending'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
oldstate
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
newstate
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
pending
(State, State, State) -> IO (State, State, State)
forall (m :: * -> *) a. Monad m => a -> m a
return (State
oldstate'', State
newstate'', State
pending'')
#if defined(ENABLE_OVERLOADING)
data MessageParseStateChangedMethodInfo
instance (signature ~ (m ((Gst.Enums.State, Gst.Enums.State, Gst.Enums.State))), MonadIO m) => O.MethodInfo MessageParseStateChangedMethodInfo Message signature where
overloadedMethod = messageParseStateChanged
#endif
foreign import ccall "gst_message_parse_step_done" gst_message_parse_step_done ::
Ptr Message ->
Ptr CUInt ->
Ptr Word64 ->
Ptr CDouble ->
Ptr CInt ->
Ptr CInt ->
Ptr Word64 ->
Ptr CInt ->
IO ()
messageParseStepDone ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Gst.Enums.Format, Word64, Double, Bool, Bool, Word64, Bool))
messageParseStepDone :: Message -> m (Format, Word64, Double, Bool, Bool, Word64, Bool)
messageParseStepDone Message
message = IO (Format, Word64, Double, Bool, Bool, Word64, Bool)
-> m (Format, Word64, Double, Bool, Bool, Word64, Bool)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Format, Word64, Double, Bool, Bool, Word64, Bool)
-> m (Format, Word64, Double, Bool, Bool, Word64, Bool))
-> IO (Format, Word64, Double, Bool, Bool, Word64, Bool)
-> m (Format, Word64, Double, Bool, Bool, Word64, Bool)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CUInt
format <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Word64
amount <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr CDouble
rate <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr CInt
flush <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
Ptr CInt
intermediate <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
Ptr Word64
duration <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr CInt
eos <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
Ptr Message
-> Ptr CUInt
-> Ptr Word64
-> Ptr CDouble
-> Ptr CInt
-> Ptr CInt
-> Ptr Word64
-> Ptr CInt
-> IO ()
gst_message_parse_step_done Ptr Message
message' Ptr CUInt
format Ptr Word64
amount Ptr CDouble
rate Ptr CInt
flush Ptr CInt
intermediate Ptr Word64
duration Ptr CInt
eos
CUInt
format' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
format
let format'' :: Format
format'' = (Int -> Format
forall a. Enum a => Int -> a
toEnum (Int -> Format) -> (CUInt -> Int) -> CUInt -> Format
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
format'
Word64
amount' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
amount
CDouble
rate' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
rate
let rate'' :: Double
rate'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
rate'
CInt
flush' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
flush
let flush'' :: Bool
flush'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
flush'
CInt
intermediate' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
intermediate
let intermediate'' :: Bool
intermediate'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
intermediate'
Word64
duration' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
duration
CInt
eos' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
eos
let eos'' :: Bool
eos'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
eos'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
format
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
amount
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
rate
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
flush
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
intermediate
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
duration
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
eos
(Format, Word64, Double, Bool, Bool, Word64, Bool)
-> IO (Format, Word64, Double, Bool, Bool, Word64, Bool)
forall (m :: * -> *) a. Monad m => a -> m a
return (Format
format'', Word64
amount', Double
rate'', Bool
flush'', Bool
intermediate'', Word64
duration', Bool
eos'')
#if defined(ENABLE_OVERLOADING)
data MessageParseStepDoneMethodInfo
instance (signature ~ (m ((Gst.Enums.Format, Word64, Double, Bool, Bool, Word64, Bool))), MonadIO m) => O.MethodInfo MessageParseStepDoneMethodInfo Message signature where
overloadedMethod = messageParseStepDone
#endif
foreign import ccall "gst_message_parse_step_start" gst_message_parse_step_start ::
Ptr Message ->
Ptr CInt ->
Ptr CUInt ->
Ptr Word64 ->
Ptr CDouble ->
Ptr CInt ->
Ptr CInt ->
IO ()
messageParseStepStart ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Bool, Gst.Enums.Format, Word64, Double, Bool, Bool))
messageParseStepStart :: Message -> m (Bool, Format, Word64, Double, Bool, Bool)
messageParseStepStart Message
message = IO (Bool, Format, Word64, Double, Bool, Bool)
-> m (Bool, Format, Word64, Double, Bool, Bool)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Format, Word64, Double, Bool, Bool)
-> m (Bool, Format, Word64, Double, Bool, Bool))
-> IO (Bool, Format, Word64, Double, Bool, Bool)
-> m (Bool, Format, Word64, Double, Bool, Bool)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CInt
active <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
Ptr CUInt
format <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Word64
amount <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr CDouble
rate <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr CInt
flush <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
Ptr CInt
intermediate <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
Ptr Message
-> Ptr CInt
-> Ptr CUInt
-> Ptr Word64
-> Ptr CDouble
-> Ptr CInt
-> Ptr CInt
-> IO ()
gst_message_parse_step_start Ptr Message
message' Ptr CInt
active Ptr CUInt
format Ptr Word64
amount Ptr CDouble
rate Ptr CInt
flush Ptr CInt
intermediate
CInt
active' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
active
let active'' :: Bool
active'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
active'
CUInt
format' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
format
let format'' :: Format
format'' = (Int -> Format
forall a. Enum a => Int -> a
toEnum (Int -> Format) -> (CUInt -> Int) -> CUInt -> Format
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
format'
Word64
amount' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
amount
CDouble
rate' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
rate
let rate'' :: Double
rate'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
rate'
CInt
flush' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
flush
let flush'' :: Bool
flush'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
flush'
CInt
intermediate' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
intermediate
let intermediate'' :: Bool
intermediate'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
intermediate'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
active
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
format
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
amount
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
rate
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
flush
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
intermediate
(Bool, Format, Word64, Double, Bool, Bool)
-> IO (Bool, Format, Word64, Double, Bool, Bool)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
active'', Format
format'', Word64
amount', Double
rate'', Bool
flush'', Bool
intermediate'')
#if defined(ENABLE_OVERLOADING)
data MessageParseStepStartMethodInfo
instance (signature ~ (m ((Bool, Gst.Enums.Format, Word64, Double, Bool, Bool))), MonadIO m) => O.MethodInfo MessageParseStepStartMethodInfo Message signature where
overloadedMethod = messageParseStepStart
#endif
foreign import ccall "gst_message_parse_stream_collection" gst_message_parse_stream_collection ::
Ptr Message ->
Ptr (Ptr Gst.StreamCollection.StreamCollection) ->
IO ()
messageParseStreamCollection ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Gst.StreamCollection.StreamCollection)
messageParseStreamCollection :: Message -> m StreamCollection
messageParseStreamCollection Message
message = IO StreamCollection -> m StreamCollection
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StreamCollection -> m StreamCollection)
-> IO StreamCollection -> m StreamCollection
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr StreamCollection)
collection <- IO (Ptr (Ptr StreamCollection))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.StreamCollection.StreamCollection))
Ptr Message -> Ptr (Ptr StreamCollection) -> IO ()
gst_message_parse_stream_collection Ptr Message
message' Ptr (Ptr StreamCollection)
collection
Ptr StreamCollection
collection' <- Ptr (Ptr StreamCollection) -> IO (Ptr StreamCollection)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr StreamCollection)
collection
StreamCollection
collection'' <- ((ManagedPtr StreamCollection -> StreamCollection)
-> Ptr StreamCollection -> IO StreamCollection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr StreamCollection -> StreamCollection
Gst.StreamCollection.StreamCollection) Ptr StreamCollection
collection'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr StreamCollection) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr StreamCollection)
collection
StreamCollection -> IO StreamCollection
forall (m :: * -> *) a. Monad m => a -> m a
return StreamCollection
collection''
#if defined(ENABLE_OVERLOADING)
data MessageParseStreamCollectionMethodInfo
instance (signature ~ (m (Gst.StreamCollection.StreamCollection)), MonadIO m) => O.MethodInfo MessageParseStreamCollectionMethodInfo Message signature where
overloadedMethod = messageParseStreamCollection
#endif
foreign import ccall "gst_message_parse_stream_status" gst_message_parse_stream_status ::
Ptr Message ->
Ptr CUInt ->
Ptr (Ptr Gst.Element.Element) ->
IO ()
messageParseStreamStatus ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Gst.Enums.StreamStatusType, Gst.Element.Element))
messageParseStreamStatus :: Message -> m (StreamStatusType, Element)
messageParseStreamStatus Message
message = IO (StreamStatusType, Element) -> m (StreamStatusType, Element)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (StreamStatusType, Element) -> m (StreamStatusType, Element))
-> IO (StreamStatusType, Element) -> m (StreamStatusType, Element)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CUInt
type_ <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr (Ptr Element)
owner <- IO (Ptr (Ptr Element))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Element.Element))
Ptr Message -> Ptr CUInt -> Ptr (Ptr Element) -> IO ()
gst_message_parse_stream_status Ptr Message
message' Ptr CUInt
type_ Ptr (Ptr Element)
owner
CUInt
type_' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
type_
let type_'' :: StreamStatusType
type_'' = (Int -> StreamStatusType
forall a. Enum a => Int -> a
toEnum (Int -> StreamStatusType)
-> (CUInt -> Int) -> CUInt -> StreamStatusType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
type_'
Ptr Element
owner' <- Ptr (Ptr Element) -> IO (Ptr Element)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Element)
owner
Element
owner'' <- ((ManagedPtr Element -> Element) -> Ptr Element -> IO Element
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Element -> Element
Gst.Element.Element) Ptr Element
owner'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
type_
Ptr (Ptr Element) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Element)
owner
(StreamStatusType, Element) -> IO (StreamStatusType, Element)
forall (m :: * -> *) a. Monad m => a -> m a
return (StreamStatusType
type_'', Element
owner'')
#if defined(ENABLE_OVERLOADING)
data MessageParseStreamStatusMethodInfo
instance (signature ~ (m ((Gst.Enums.StreamStatusType, Gst.Element.Element))), MonadIO m) => O.MethodInfo MessageParseStreamStatusMethodInfo Message signature where
overloadedMethod = messageParseStreamStatus
#endif
foreign import ccall "gst_message_parse_streams_selected" gst_message_parse_streams_selected ::
Ptr Message ->
Ptr (Ptr Gst.StreamCollection.StreamCollection) ->
IO ()
messageParseStreamsSelected ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Gst.StreamCollection.StreamCollection)
messageParseStreamsSelected :: Message -> m StreamCollection
messageParseStreamsSelected Message
message = IO StreamCollection -> m StreamCollection
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StreamCollection -> m StreamCollection)
-> IO StreamCollection -> m StreamCollection
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr StreamCollection)
collection <- IO (Ptr (Ptr StreamCollection))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.StreamCollection.StreamCollection))
Ptr Message -> Ptr (Ptr StreamCollection) -> IO ()
gst_message_parse_streams_selected Ptr Message
message' Ptr (Ptr StreamCollection)
collection
Ptr StreamCollection
collection' <- Ptr (Ptr StreamCollection) -> IO (Ptr StreamCollection)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr StreamCollection)
collection
StreamCollection
collection'' <- ((ManagedPtr StreamCollection -> StreamCollection)
-> Ptr StreamCollection -> IO StreamCollection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr StreamCollection -> StreamCollection
Gst.StreamCollection.StreamCollection) Ptr StreamCollection
collection'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr StreamCollection) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr StreamCollection)
collection
StreamCollection -> IO StreamCollection
forall (m :: * -> *) a. Monad m => a -> m a
return StreamCollection
collection''
#if defined(ENABLE_OVERLOADING)
data MessageParseStreamsSelectedMethodInfo
instance (signature ~ (m (Gst.StreamCollection.StreamCollection)), MonadIO m) => O.MethodInfo MessageParseStreamsSelectedMethodInfo Message signature where
overloadedMethod = messageParseStreamsSelected
#endif
foreign import ccall "gst_message_parse_structure_change" gst_message_parse_structure_change ::
Ptr Message ->
Ptr CUInt ->
Ptr (Ptr Gst.Element.Element) ->
Ptr CInt ->
IO ()
messageParseStructureChange ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Gst.Enums.StructureChangeType, Gst.Element.Element, Bool))
messageParseStructureChange :: Message -> m (StructureChangeType, Element, Bool)
messageParseStructureChange Message
message = IO (StructureChangeType, Element, Bool)
-> m (StructureChangeType, Element, Bool)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (StructureChangeType, Element, Bool)
-> m (StructureChangeType, Element, Bool))
-> IO (StructureChangeType, Element, Bool)
-> m (StructureChangeType, Element, Bool)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CUInt
type_ <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr (Ptr Element)
owner <- IO (Ptr (Ptr Element))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Element.Element))
Ptr CInt
busy <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
Ptr Message -> Ptr CUInt -> Ptr (Ptr Element) -> Ptr CInt -> IO ()
gst_message_parse_structure_change Ptr Message
message' Ptr CUInt
type_ Ptr (Ptr Element)
owner Ptr CInt
busy
CUInt
type_' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
type_
let type_'' :: StructureChangeType
type_'' = (Int -> StructureChangeType
forall a. Enum a => Int -> a
toEnum (Int -> StructureChangeType)
-> (CUInt -> Int) -> CUInt -> StructureChangeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
type_'
Ptr Element
owner' <- Ptr (Ptr Element) -> IO (Ptr Element)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Element)
owner
Element
owner'' <- ((ManagedPtr Element -> Element) -> Ptr Element -> IO Element
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Element -> Element
Gst.Element.Element) Ptr Element
owner'
CInt
busy' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
busy
let busy'' :: Bool
busy'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
busy'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
type_
Ptr (Ptr Element) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Element)
owner
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
busy
(StructureChangeType, Element, Bool)
-> IO (StructureChangeType, Element, Bool)
forall (m :: * -> *) a. Monad m => a -> m a
return (StructureChangeType
type_'', Element
owner'', Bool
busy'')
#if defined(ENABLE_OVERLOADING)
data MessageParseStructureChangeMethodInfo
instance (signature ~ (m ((Gst.Enums.StructureChangeType, Gst.Element.Element, Bool))), MonadIO m) => O.MethodInfo MessageParseStructureChangeMethodInfo Message signature where
overloadedMethod = messageParseStructureChange
#endif
foreign import ccall "gst_message_parse_tag" gst_message_parse_tag ::
Ptr Message ->
Ptr (Ptr Gst.TagList.TagList) ->
IO ()
messageParseTag ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Gst.TagList.TagList)
messageParseTag :: Message -> m TagList
messageParseTag Message
message = IO TagList -> m TagList
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TagList -> m TagList) -> IO TagList -> m TagList
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr TagList)
tagList <- IO (Ptr (Ptr TagList))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.TagList.TagList))
Ptr Message -> Ptr (Ptr TagList) -> IO ()
gst_message_parse_tag Ptr Message
message' Ptr (Ptr TagList)
tagList
Ptr TagList
tagList' <- Ptr (Ptr TagList) -> IO (Ptr TagList)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr TagList)
tagList
TagList
tagList'' <- ((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
tagList'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr TagList) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr TagList)
tagList
TagList -> IO TagList
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
tagList''
#if defined(ENABLE_OVERLOADING)
data MessageParseTagMethodInfo
instance (signature ~ (m (Gst.TagList.TagList)), MonadIO m) => O.MethodInfo MessageParseTagMethodInfo Message signature where
overloadedMethod = messageParseTag
#endif
foreign import ccall "gst_message_parse_toc" gst_message_parse_toc ::
Ptr Message ->
Ptr (Ptr Gst.Toc.Toc) ->
Ptr CInt ->
IO ()
messageParseToc ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((Gst.Toc.Toc, Bool))
messageParseToc :: Message -> m (Toc, Bool)
messageParseToc Message
message = IO (Toc, Bool) -> m (Toc, Bool)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Toc, Bool) -> m (Toc, Bool))
-> IO (Toc, Bool) -> m (Toc, Bool)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr Toc)
toc <- IO (Ptr (Ptr Toc))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Toc.Toc))
Ptr CInt
updated <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
Ptr Message -> Ptr (Ptr Toc) -> Ptr CInt -> IO ()
gst_message_parse_toc Ptr Message
message' Ptr (Ptr Toc)
toc Ptr CInt
updated
Ptr Toc
toc' <- Ptr (Ptr Toc) -> IO (Ptr Toc)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Toc)
toc
Toc
toc'' <- ((ManagedPtr Toc -> Toc) -> Ptr Toc -> IO Toc
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Toc -> Toc
Gst.Toc.Toc) Ptr Toc
toc'
CInt
updated' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
updated
let updated'' :: Bool
updated'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
updated'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr Toc) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Toc)
toc
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
updated
(Toc, Bool) -> IO (Toc, Bool)
forall (m :: * -> *) a. Monad m => a -> m a
return (Toc
toc'', Bool
updated'')
#if defined(ENABLE_OVERLOADING)
data MessageParseTocMethodInfo
instance (signature ~ (m ((Gst.Toc.Toc, Bool))), MonadIO m) => O.MethodInfo MessageParseTocMethodInfo Message signature where
overloadedMethod = messageParseToc
#endif
foreign import ccall "gst_message_parse_warning" gst_message_parse_warning ::
Ptr Message ->
Ptr (Ptr GError) ->
Ptr CString ->
IO ()
messageParseWarning ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m ((GError, T.Text))
messageParseWarning :: Message -> m (GError, Text)
messageParseWarning Message
message = IO (GError, Text) -> m (GError, Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GError, Text) -> m (GError, Text))
-> IO (GError, Text) -> m (GError, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr GError)
gerror <- IO (Ptr (Ptr GError))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GError))
Ptr CString
debug <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr Message -> Ptr (Ptr GError) -> Ptr CString -> IO ()
gst_message_parse_warning Ptr Message
message' Ptr (Ptr GError)
gerror Ptr CString
debug
Ptr GError
gerror' <- Ptr (Ptr GError) -> IO (Ptr GError)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GError)
gerror
GError
gerror'' <- ((ManagedPtr GError -> GError) -> Ptr GError -> IO GError
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr GError -> GError
GError) Ptr GError
gerror'
CString
debug' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
debug
Text
debug'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
debug'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
debug'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr GError) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GError)
gerror
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
debug
(GError, Text) -> IO (GError, Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (GError
gerror'', Text
debug'')
#if defined(ENABLE_OVERLOADING)
data MessageParseWarningMethodInfo
instance (signature ~ (m ((GError, T.Text))), MonadIO m) => O.MethodInfo MessageParseWarningMethodInfo Message signature where
overloadedMethod = messageParseWarning
#endif
foreign import ccall "gst_message_parse_warning_details" gst_message_parse_warning_details ::
Ptr Message ->
Ptr (Ptr Gst.Structure.Structure) ->
IO ()
messageParseWarningDetails ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m (Gst.Structure.Structure)
messageParseWarningDetails :: Message -> m Structure
messageParseWarningDetails Message
message = IO Structure -> m Structure
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Structure -> m Structure) -> IO Structure -> m Structure
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr Structure)
structure <- IO (Ptr (Ptr Structure))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Structure.Structure))
Ptr Message -> Ptr (Ptr Structure) -> IO ()
gst_message_parse_warning_details Ptr Message
message' Ptr (Ptr Structure)
structure
Ptr Structure
structure' <- Ptr (Ptr Structure) -> IO (Ptr Structure)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Structure)
structure
Structure
structure'' <- ((ManagedPtr Structure -> Structure)
-> Ptr Structure -> IO Structure
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Structure -> Structure
Gst.Structure.Structure) Ptr Structure
structure'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr Structure) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Structure)
structure
Structure -> IO Structure
forall (m :: * -> *) a. Monad m => a -> m a
return Structure
structure''
#if defined(ENABLE_OVERLOADING)
data MessageParseWarningDetailsMethodInfo
instance (signature ~ (m (Gst.Structure.Structure)), MonadIO m) => O.MethodInfo MessageParseWarningDetailsMethodInfo Message signature where
overloadedMethod = messageParseWarningDetails
#endif
foreign import ccall "gst_message_set_buffering_stats" gst_message_set_buffering_stats ::
Ptr Message ->
CUInt ->
Int32 ->
Int32 ->
Int64 ->
IO ()
messageSetBufferingStats ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> Gst.Enums.BufferingMode
-> Int32
-> Int32
-> Int64
-> m ()
messageSetBufferingStats :: Message -> BufferingMode -> Int32 -> Int32 -> Int64 -> m ()
messageSetBufferingStats Message
message BufferingMode
mode Int32
avgIn Int32
avgOut Int64
bufferingLeft = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (BufferingMode -> Int) -> BufferingMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BufferingMode -> Int
forall a. Enum a => a -> Int
fromEnum) BufferingMode
mode
Ptr Message -> CUInt -> Int32 -> Int32 -> Int64 -> IO ()
gst_message_set_buffering_stats Ptr Message
message' CUInt
mode' Int32
avgIn Int32
avgOut Int64
bufferingLeft
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageSetBufferingStatsMethodInfo
instance (signature ~ (Gst.Enums.BufferingMode -> Int32 -> Int32 -> Int64 -> m ()), MonadIO m) => O.MethodInfo MessageSetBufferingStatsMethodInfo Message signature where
overloadedMethod = messageSetBufferingStats
#endif
foreign import ccall "gst_message_set_group_id" gst_message_set_group_id ::
Ptr Message ->
Word32 ->
IO ()
messageSetGroupId ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> Word32
-> m ()
messageSetGroupId :: Message -> Word32 -> m ()
messageSetGroupId Message
message Word32
groupId = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr Message -> Word32 -> IO ()
gst_message_set_group_id Ptr Message
message' Word32
groupId
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageSetGroupIdMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo MessageSetGroupIdMethodInfo Message signature where
overloadedMethod = messageSetGroupId
#endif
foreign import ccall "gst_message_set_qos_stats" gst_message_set_qos_stats ::
Ptr Message ->
CUInt ->
Word64 ->
Word64 ->
IO ()
messageSetQosStats ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> Gst.Enums.Format
-> Word64
-> Word64
-> m ()
messageSetQosStats :: Message -> Format -> Word64 -> Word64 -> m ()
messageSetQosStats Message
message Format
format Word64
processed Word64
dropped = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
Ptr Message -> CUInt -> Word64 -> Word64 -> IO ()
gst_message_set_qos_stats Ptr Message
message' CUInt
format' Word64
processed Word64
dropped
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageSetQosStatsMethodInfo
instance (signature ~ (Gst.Enums.Format -> Word64 -> Word64 -> m ()), MonadIO m) => O.MethodInfo MessageSetQosStatsMethodInfo Message signature where
overloadedMethod = messageSetQosStats
#endif
foreign import ccall "gst_message_set_qos_values" gst_message_set_qos_values ::
Ptr Message ->
Int64 ->
CDouble ->
Int32 ->
IO ()
messageSetQosValues ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> Int64
-> Double
-> Int32
-> m ()
messageSetQosValues :: Message -> Int64 -> Double -> Int32 -> m ()
messageSetQosValues Message
message Int64
jitter Double
proportion Int32
quality = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
let proportion' :: CDouble
proportion' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
proportion
Ptr Message -> Int64 -> CDouble -> Int32 -> IO ()
gst_message_set_qos_values Ptr Message
message' Int64
jitter CDouble
proportion' Int32
quality
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageSetQosValuesMethodInfo
instance (signature ~ (Int64 -> Double -> Int32 -> m ()), MonadIO m) => O.MethodInfo MessageSetQosValuesMethodInfo Message signature where
overloadedMethod = messageSetQosValues
#endif
foreign import ccall "gst_message_set_seqnum" gst_message_set_seqnum ::
Ptr Message ->
Word32 ->
IO ()
messageSetSeqnum ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> Word32
-> m ()
messageSetSeqnum :: Message -> Word32 -> m ()
messageSetSeqnum Message
message Word32
seqnum = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr Message -> Word32 -> IO ()
gst_message_set_seqnum Ptr Message
message' Word32
seqnum
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageSetSeqnumMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.MethodInfo MessageSetSeqnumMethodInfo Message signature where
overloadedMethod = messageSetSeqnum
#endif
foreign import ccall "gst_message_set_stream_status_object" gst_message_set_stream_status_object ::
Ptr Message ->
Ptr GValue ->
IO ()
messageSetStreamStatusObject ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> GValue
-> m ()
messageSetStreamStatusObject :: Message -> GValue -> m ()
messageSetStreamStatusObject Message
message GValue
object = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr GValue
object' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
object
Ptr Message -> Ptr GValue -> IO ()
gst_message_set_stream_status_object Ptr Message
message' Ptr GValue
object'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
object
Ptr GValue -> IO ()
B.GValue.unsetGValue Ptr GValue
object'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageSetStreamStatusObjectMethodInfo
instance (signature ~ (GValue -> m ()), MonadIO m) => O.MethodInfo MessageSetStreamStatusObjectMethodInfo Message signature where
overloadedMethod = messageSetStreamStatusObject
#endif
foreign import ccall "gst_message_streams_selected_add" gst_message_streams_selected_add ::
Ptr Message ->
Ptr Gst.Stream.Stream ->
IO ()
messageStreamsSelectedAdd ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Stream.IsStream a) =>
Message
-> a
-> m ()
messageStreamsSelectedAdd :: Message -> a -> m ()
messageStreamsSelectedAdd Message
message a
stream = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr Stream
stream' <- a -> IO (Ptr Stream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Message -> Ptr Stream -> IO ()
gst_message_streams_selected_add Ptr Message
message' Ptr Stream
stream'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageStreamsSelectedAddMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, Gst.Stream.IsStream a) => O.MethodInfo MessageStreamsSelectedAddMethodInfo Message signature where
overloadedMethod = messageStreamsSelectedAdd
#endif
foreign import ccall "gst_message_streams_selected_get_size" gst_message_streams_selected_get_size ::
Ptr Message ->
IO Word32
messageStreamsSelectedGetSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m Word32
messageStreamsSelectedGetSize :: Message -> m Word32
messageStreamsSelectedGetSize Message
message = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Word32
result <- Ptr Message -> IO Word32
gst_message_streams_selected_get_size Ptr Message
message'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data MessageStreamsSelectedGetSizeMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo MessageStreamsSelectedGetSizeMethodInfo Message signature where
overloadedMethod = messageStreamsSelectedGetSize
#endif
foreign import ccall "gst_message_streams_selected_get_stream" gst_message_streams_selected_get_stream ::
Ptr Message ->
Word32 ->
IO (Ptr Gst.Stream.Stream)
messageStreamsSelectedGetStream ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> Word32
-> m (Maybe Gst.Stream.Stream)
messageStreamsSelectedGetStream :: Message -> Word32 -> m (Maybe Stream)
messageStreamsSelectedGetStream Message
message Word32
idx = IO (Maybe Stream) -> m (Maybe Stream)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Stream) -> m (Maybe Stream))
-> IO (Maybe Stream) -> m (Maybe Stream)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr Stream
result <- Ptr Message -> Word32 -> IO (Ptr Stream)
gst_message_streams_selected_get_stream Ptr Message
message' Word32
idx
Maybe Stream
maybeResult <- Ptr Stream -> (Ptr Stream -> IO Stream) -> IO (Maybe Stream)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Stream
result ((Ptr Stream -> IO Stream) -> IO (Maybe Stream))
-> (Ptr Stream -> IO Stream) -> IO (Maybe Stream)
forall a b. (a -> b) -> a -> b
$ \Ptr Stream
result' -> do
Stream
result'' <- ((ManagedPtr Stream -> Stream) -> Ptr Stream -> IO Stream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Stream -> Stream
Gst.Stream.Stream) Ptr Stream
result'
Stream -> IO Stream
forall (m :: * -> *) a. Monad m => a -> m a
return Stream
result''
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Maybe Stream -> IO (Maybe Stream)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Stream
maybeResult
#if defined(ENABLE_OVERLOADING)
data MessageStreamsSelectedGetStreamMethodInfo
instance (signature ~ (Word32 -> m (Maybe Gst.Stream.Stream)), MonadIO m) => O.MethodInfo MessageStreamsSelectedGetStreamMethodInfo Message signature where
overloadedMethod = messageStreamsSelectedGetStream
#endif
foreign import ccall "gst_message_writable_structure" gst_message_writable_structure ::
Ptr Message ->
IO (Ptr Gst.Structure.Structure)
messageWritableStructure ::
(B.CallStack.HasCallStack, MonadIO m) =>
Message
-> m Gst.Structure.Structure
messageWritableStructure :: Message -> m Structure
messageWritableStructure Message
message = IO Structure -> m Structure
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Structure -> m Structure) -> IO Structure -> m Structure
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr Structure
result <- Ptr Message -> IO (Ptr Structure)
gst_message_writable_structure Ptr Message
message'
Text -> Ptr Structure -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageWritableStructure" Ptr Structure
result
Structure
result' <- ((ManagedPtr Structure -> Structure)
-> Ptr Structure -> IO Structure
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Structure -> Structure
Gst.Structure.Structure) Ptr Structure
result
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Structure -> IO Structure
forall (m :: * -> *) a. Monad m => a -> m a
return Structure
result'
#if defined(ENABLE_OVERLOADING)
data MessageWritableStructureMethodInfo
instance (signature ~ (m Gst.Structure.Structure), MonadIO m) => O.MethodInfo MessageWritableStructureMethodInfo Message signature where
overloadedMethod = messageWritableStructure
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveMessageMethod (t :: Symbol) (o :: *) :: * where
ResolveMessageMethod "addRedirectEntry" o = MessageAddRedirectEntryMethodInfo
ResolveMessageMethod "hasName" o = MessageHasNameMethodInfo
ResolveMessageMethod "parseAsyncDone" o = MessageParseAsyncDoneMethodInfo
ResolveMessageMethod "parseBuffering" o = MessageParseBufferingMethodInfo
ResolveMessageMethod "parseBufferingStats" o = MessageParseBufferingStatsMethodInfo
ResolveMessageMethod "parseClockLost" o = MessageParseClockLostMethodInfo
ResolveMessageMethod "parseClockProvide" o = MessageParseClockProvideMethodInfo
ResolveMessageMethod "parseContextType" o = MessageParseContextTypeMethodInfo
ResolveMessageMethod "parseDeviceAdded" o = MessageParseDeviceAddedMethodInfo
ResolveMessageMethod "parseDeviceChanged" o = MessageParseDeviceChangedMethodInfo
ResolveMessageMethod "parseDeviceRemoved" o = MessageParseDeviceRemovedMethodInfo
ResolveMessageMethod "parseError" o = MessageParseErrorMethodInfo
ResolveMessageMethod "parseErrorDetails" o = MessageParseErrorDetailsMethodInfo
ResolveMessageMethod "parseGroupId" o = MessageParseGroupIdMethodInfo
ResolveMessageMethod "parseHaveContext" o = MessageParseHaveContextMethodInfo
ResolveMessageMethod "parseInfo" o = MessageParseInfoMethodInfo
ResolveMessageMethod "parseInfoDetails" o = MessageParseInfoDetailsMethodInfo
ResolveMessageMethod "parseNewClock" o = MessageParseNewClockMethodInfo
ResolveMessageMethod "parseProgress" o = MessageParseProgressMethodInfo
ResolveMessageMethod "parsePropertyNotify" o = MessageParsePropertyNotifyMethodInfo
ResolveMessageMethod "parseQos" o = MessageParseQosMethodInfo
ResolveMessageMethod "parseQosStats" o = MessageParseQosStatsMethodInfo
ResolveMessageMethod "parseQosValues" o = MessageParseQosValuesMethodInfo
ResolveMessageMethod "parseRedirectEntry" o = MessageParseRedirectEntryMethodInfo
ResolveMessageMethod "parseRequestState" o = MessageParseRequestStateMethodInfo
ResolveMessageMethod "parseResetTime" o = MessageParseResetTimeMethodInfo
ResolveMessageMethod "parseSegmentDone" o = MessageParseSegmentDoneMethodInfo
ResolveMessageMethod "parseSegmentStart" o = MessageParseSegmentStartMethodInfo
ResolveMessageMethod "parseStateChanged" o = MessageParseStateChangedMethodInfo
ResolveMessageMethod "parseStepDone" o = MessageParseStepDoneMethodInfo
ResolveMessageMethod "parseStepStart" o = MessageParseStepStartMethodInfo
ResolveMessageMethod "parseStreamCollection" o = MessageParseStreamCollectionMethodInfo
ResolveMessageMethod "parseStreamStatus" o = MessageParseStreamStatusMethodInfo
ResolveMessageMethod "parseStreamsSelected" o = MessageParseStreamsSelectedMethodInfo
ResolveMessageMethod "parseStructureChange" o = MessageParseStructureChangeMethodInfo
ResolveMessageMethod "parseTag" o = MessageParseTagMethodInfo
ResolveMessageMethod "parseToc" o = MessageParseTocMethodInfo
ResolveMessageMethod "parseWarning" o = MessageParseWarningMethodInfo
ResolveMessageMethod "parseWarningDetails" o = MessageParseWarningDetailsMethodInfo
ResolveMessageMethod "streamsSelectedAdd" o = MessageStreamsSelectedAddMethodInfo
ResolveMessageMethod "streamsSelectedGetSize" o = MessageStreamsSelectedGetSizeMethodInfo
ResolveMessageMethod "streamsSelectedGetStream" o = MessageStreamsSelectedGetStreamMethodInfo
ResolveMessageMethod "writableStructure" o = MessageWritableStructureMethodInfo
ResolveMessageMethod "getNumRedirectEntries" o = MessageGetNumRedirectEntriesMethodInfo
ResolveMessageMethod "getSeqnum" o = MessageGetSeqnumMethodInfo
ResolveMessageMethod "getStreamStatusObject" o = MessageGetStreamStatusObjectMethodInfo
ResolveMessageMethod "getStructure" o = MessageGetStructureMethodInfo
ResolveMessageMethod "setBufferingStats" o = MessageSetBufferingStatsMethodInfo
ResolveMessageMethod "setGroupId" o = MessageSetGroupIdMethodInfo
ResolveMessageMethod "setQosStats" o = MessageSetQosStatsMethodInfo
ResolveMessageMethod "setQosValues" o = MessageSetQosValuesMethodInfo
ResolveMessageMethod "setSeqnum" o = MessageSetSeqnumMethodInfo
ResolveMessageMethod "setStreamStatusObject" o = MessageSetStreamStatusObjectMethodInfo
ResolveMessageMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMessageMethod t Message, O.MethodInfo info Message p) => OL.IsLabel t (Message -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif