{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.Event
(
Event(..) ,
newZeroEvent ,
#if defined(ENABLE_OVERLOADING)
ResolveEventMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
EventCopySegmentMethodInfo ,
#endif
eventCopySegment ,
#if defined(ENABLE_OVERLOADING)
EventGetRunningTimeOffsetMethodInfo ,
#endif
eventGetRunningTimeOffset ,
#if defined(ENABLE_OVERLOADING)
EventGetSeqnumMethodInfo ,
#endif
eventGetSeqnum ,
#if defined(ENABLE_OVERLOADING)
EventGetStructureMethodInfo ,
#endif
eventGetStructure ,
#if defined(ENABLE_OVERLOADING)
EventHasNameMethodInfo ,
#endif
eventHasName ,
#if defined(ENABLE_OVERLOADING)
EventHasNameIdMethodInfo ,
#endif
eventHasNameId ,
eventNewBufferSize ,
eventNewCaps ,
eventNewCustom ,
eventNewEos ,
eventNewFlushStart ,
eventNewFlushStop ,
eventNewGap ,
eventNewInstantRateChange ,
eventNewInstantRateSyncTime ,
eventNewLatency ,
eventNewNavigation ,
eventNewProtection ,
eventNewQos ,
eventNewReconfigure ,
eventNewSeek ,
eventNewSegment ,
eventNewSegmentDone ,
eventNewSelectStreams ,
eventNewSinkMessage ,
eventNewStep ,
eventNewStreamCollection ,
eventNewStreamGroupDone ,
eventNewStreamStart ,
eventNewTag ,
eventNewToc ,
eventNewTocSelect ,
#if defined(ENABLE_OVERLOADING)
EventParseBufferSizeMethodInfo ,
#endif
eventParseBufferSize ,
#if defined(ENABLE_OVERLOADING)
EventParseCapsMethodInfo ,
#endif
eventParseCaps ,
#if defined(ENABLE_OVERLOADING)
EventParseFlushStopMethodInfo ,
#endif
eventParseFlushStop ,
#if defined(ENABLE_OVERLOADING)
EventParseGapMethodInfo ,
#endif
eventParseGap ,
#if defined(ENABLE_OVERLOADING)
EventParseGapFlagsMethodInfo ,
#endif
eventParseGapFlags ,
#if defined(ENABLE_OVERLOADING)
EventParseGroupIdMethodInfo ,
#endif
eventParseGroupId ,
#if defined(ENABLE_OVERLOADING)
EventParseInstantRateChangeMethodInfo ,
#endif
eventParseInstantRateChange ,
#if defined(ENABLE_OVERLOADING)
EventParseInstantRateSyncTimeMethodInfo ,
#endif
eventParseInstantRateSyncTime ,
#if defined(ENABLE_OVERLOADING)
EventParseLatencyMethodInfo ,
#endif
eventParseLatency ,
#if defined(ENABLE_OVERLOADING)
EventParseProtectionMethodInfo ,
#endif
eventParseProtection ,
#if defined(ENABLE_OVERLOADING)
EventParseQosMethodInfo ,
#endif
eventParseQos ,
#if defined(ENABLE_OVERLOADING)
EventParseSeekMethodInfo ,
#endif
eventParseSeek ,
#if defined(ENABLE_OVERLOADING)
EventParseSeekTrickmodeIntervalMethodInfo,
#endif
eventParseSeekTrickmodeInterval ,
#if defined(ENABLE_OVERLOADING)
EventParseSegmentMethodInfo ,
#endif
eventParseSegment ,
#if defined(ENABLE_OVERLOADING)
EventParseSegmentDoneMethodInfo ,
#endif
eventParseSegmentDone ,
#if defined(ENABLE_OVERLOADING)
EventParseSelectStreamsMethodInfo ,
#endif
eventParseSelectStreams ,
#if defined(ENABLE_OVERLOADING)
EventParseSinkMessageMethodInfo ,
#endif
eventParseSinkMessage ,
#if defined(ENABLE_OVERLOADING)
EventParseStepMethodInfo ,
#endif
eventParseStep ,
#if defined(ENABLE_OVERLOADING)
EventParseStreamMethodInfo ,
#endif
eventParseStream ,
#if defined(ENABLE_OVERLOADING)
EventParseStreamCollectionMethodInfo ,
#endif
eventParseStreamCollection ,
#if defined(ENABLE_OVERLOADING)
EventParseStreamFlagsMethodInfo ,
#endif
eventParseStreamFlags ,
#if defined(ENABLE_OVERLOADING)
EventParseStreamGroupDoneMethodInfo ,
#endif
eventParseStreamGroupDone ,
#if defined(ENABLE_OVERLOADING)
EventParseStreamStartMethodInfo ,
#endif
eventParseStreamStart ,
#if defined(ENABLE_OVERLOADING)
EventParseTagMethodInfo ,
#endif
eventParseTag ,
#if defined(ENABLE_OVERLOADING)
EventParseTocMethodInfo ,
#endif
eventParseToc ,
#if defined(ENABLE_OVERLOADING)
EventParseTocSelectMethodInfo ,
#endif
eventParseTocSelect ,
#if defined(ENABLE_OVERLOADING)
EventSetGapFlagsMethodInfo ,
#endif
eventSetGapFlags ,
#if defined(ENABLE_OVERLOADING)
EventSetGroupIdMethodInfo ,
#endif
eventSetGroupId ,
#if defined(ENABLE_OVERLOADING)
EventSetRunningTimeOffsetMethodInfo ,
#endif
eventSetRunningTimeOffset ,
#if defined(ENABLE_OVERLOADING)
EventSetSeekTrickmodeIntervalMethodInfo ,
#endif
eventSetSeekTrickmodeInterval ,
#if defined(ENABLE_OVERLOADING)
EventSetSeqnumMethodInfo ,
#endif
eventSetSeqnum ,
#if defined(ENABLE_OVERLOADING)
EventSetStreamMethodInfo ,
#endif
eventSetStream ,
#if defined(ENABLE_OVERLOADING)
EventSetStreamFlagsMethodInfo ,
#endif
eventSetStreamFlags ,
#if defined(ENABLE_OVERLOADING)
EventWritableStructureMethodInfo ,
#endif
eventWritableStructure ,
#if defined(ENABLE_OVERLOADING)
event_miniObject ,
#endif
getEventMiniObject ,
#if defined(ENABLE_OVERLOADING)
event_seqnum ,
#endif
getEventSeqnum ,
setEventSeqnum ,
#if defined(ENABLE_OVERLOADING)
event_timestamp ,
#endif
getEventTimestamp ,
setEventTimestamp ,
#if defined(ENABLE_OVERLOADING)
event_type ,
#endif
getEventType ,
setEventType ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
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.Buffer as Gst.Buffer
import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.Gst.Structs.Message as Gst.Message
import {-# SOURCE #-} qualified GI.Gst.Structs.MiniObject as Gst.MiniObject
import {-# SOURCE #-} qualified GI.Gst.Structs.Segment as Gst.Segment
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 Event = Event (SP.ManagedPtr Event)
deriving (Event -> Event -> Bool
(Event -> Event -> Bool) -> (Event -> Event -> Bool) -> Eq Event
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Event -> Event -> Bool
== :: Event -> Event -> Bool
$c/= :: Event -> Event -> Bool
/= :: Event -> Event -> Bool
Eq)
instance SP.ManagedPtrNewtype Event where
toManagedPtr :: Event -> ManagedPtr Event
toManagedPtr (Event ManagedPtr Event
p) = ManagedPtr Event
p
foreign import ccall "gst_event_get_type" c_gst_event_get_type ::
IO GType
type instance O.ParentTypes Event = '[]
instance O.HasParentTypes Event
instance B.Types.TypedObject Event where
glibType :: IO GType
glibType = IO GType
c_gst_event_get_type
instance B.Types.GBoxed Event
instance B.GValue.IsGValue (Maybe Event) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_event_get_type
gvalueSet_ :: Ptr GValue -> Maybe Event -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Event
P.Nothing = Ptr GValue -> Ptr Event -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Event
forall a. Ptr a
FP.nullPtr :: FP.Ptr Event)
gvalueSet_ Ptr GValue
gv (P.Just Event
obj) = Event -> (Ptr Event -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Event
obj (Ptr GValue -> Ptr Event -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Event)
gvalueGet_ Ptr GValue
gv = do
Ptr Event
ptr <- Ptr GValue -> IO (Ptr Event)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Event)
if Ptr Event
ptr Ptr Event -> Ptr Event -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Event
forall a. Ptr a
FP.nullPtr
then Event -> Maybe Event
forall a. a -> Maybe a
P.Just (Event -> Maybe Event) -> IO Event -> IO (Maybe Event)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Event -> Event
Event Ptr Event
ptr
else Maybe Event -> IO (Maybe Event)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Event
forall a. Maybe a
P.Nothing
newZeroEvent :: MonadIO m => m Event
newZeroEvent :: forall (m :: * -> *). MonadIO m => m Event
newZeroEvent = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Event)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
88 IO (Ptr Event) -> (Ptr Event -> IO Event) -> IO Event
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event
instance tag ~ 'AttrSet => Constructible Event tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Event -> Event) -> [AttrOp Event tag] -> m Event
new ManagedPtr Event -> Event
_ [AttrOp Event tag]
attrs = do
Event
o <- m Event
forall (m :: * -> *). MonadIO m => m Event
newZeroEvent
Event -> [AttrOp Event 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Event
o [AttrOp Event tag]
[AttrOp Event 'AttrSet]
attrs
Event -> m Event
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
o
getEventMiniObject :: MonadIO m => Event -> m Gst.MiniObject.MiniObject
getEventMiniObject :: forall (m :: * -> *). MonadIO m => Event -> m MiniObject
getEventMiniObject Event
s = IO MiniObject -> m MiniObject
forall a. IO a -> m a
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
$ Event -> (Ptr Event -> IO MiniObject) -> IO MiniObject
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Event
s ((Ptr Event -> IO MiniObject) -> IO MiniObject)
-> (Ptr Event -> IO MiniObject) -> IO MiniObject
forall a b. (a -> b) -> a -> b
$ \Ptr Event
ptr -> do
let val :: Ptr MiniObject
val = Ptr Event
ptr Ptr Event -> 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, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr MiniObject -> MiniObject
Gst.MiniObject.MiniObject) Ptr MiniObject
val
MiniObject -> IO MiniObject
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MiniObject
val'
#if defined(ENABLE_OVERLOADING)
data EventMiniObjectFieldInfo
instance AttrInfo EventMiniObjectFieldInfo where
type AttrBaseTypeConstraint EventMiniObjectFieldInfo = (~) Event
type AttrAllowedOps EventMiniObjectFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint EventMiniObjectFieldInfo = (~) (Ptr Gst.MiniObject.MiniObject)
type AttrTransferTypeConstraint EventMiniObjectFieldInfo = (~)(Ptr Gst.MiniObject.MiniObject)
type AttrTransferType EventMiniObjectFieldInfo = (Ptr Gst.MiniObject.MiniObject)
type AttrGetType EventMiniObjectFieldInfo = Gst.MiniObject.MiniObject
type AttrLabel EventMiniObjectFieldInfo = "mini_object"
type AttrOrigin EventMiniObjectFieldInfo = Event
attrGet = getEventMiniObject
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.miniObject"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#g:attr:miniObject"
})
event_miniObject :: AttrLabelProxy "miniObject"
event_miniObject = AttrLabelProxy
#endif
getEventType :: MonadIO m => Event -> m Gst.Enums.EventType
getEventType :: forall (m :: * -> *). MonadIO m => Event -> m EventType
getEventType Event
s = IO EventType -> m EventType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EventType -> m EventType) -> IO EventType -> m EventType
forall a b. (a -> b) -> a -> b
$ Event -> (Ptr Event -> IO EventType) -> IO EventType
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Event
s ((Ptr Event -> IO EventType) -> IO EventType)
-> (Ptr Event -> IO EventType) -> IO EventType
forall a b. (a -> b) -> a -> b
$ \Ptr Event
ptr -> do
CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr Event
ptr Ptr Event -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) :: IO CUInt
let val' :: EventType
val' = (Int -> EventType
forall a. Enum a => Int -> a
toEnum (Int -> EventType) -> (CUInt -> Int) -> CUInt -> EventType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
EventType -> IO EventType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return EventType
val'
setEventType :: MonadIO m => Event -> Gst.Enums.EventType -> m ()
setEventType :: forall (m :: * -> *). MonadIO m => Event -> EventType -> m ()
setEventType Event
s EventType
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Event -> (Ptr Event -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Event
s ((Ptr Event -> IO ()) -> IO ()) -> (Ptr Event -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Event
ptr -> do
let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (EventType -> Int) -> EventType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EventType -> Int
forall a. Enum a => a -> Int
fromEnum) EventType
val
Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Event
ptr Ptr Event -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data EventTypeFieldInfo
instance AttrInfo EventTypeFieldInfo where
type AttrBaseTypeConstraint EventTypeFieldInfo = (~) Event
type AttrAllowedOps EventTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventTypeFieldInfo = (~) Gst.Enums.EventType
type AttrTransferTypeConstraint EventTypeFieldInfo = (~)Gst.Enums.EventType
type AttrTransferType EventTypeFieldInfo = Gst.Enums.EventType
type AttrGetType EventTypeFieldInfo = Gst.Enums.EventType
type AttrLabel EventTypeFieldInfo = "type"
type AttrOrigin EventTypeFieldInfo = Event
attrGet = getEventType
attrSet = setEventType
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.type"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#g:attr:type"
})
event_type :: AttrLabelProxy "type"
event_type = AttrLabelProxy
#endif
getEventTimestamp :: MonadIO m => Event -> m Word64
getEventTimestamp :: forall (m :: * -> *). MonadIO m => Event -> m Word64
getEventTimestamp Event
s = IO Word64 -> m Word64
forall a. IO a -> m a
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
$ Event -> (Ptr Event -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Event
s ((Ptr Event -> IO Word64) -> IO Word64)
-> (Ptr Event -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Event
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Event
ptr Ptr Event -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) :: IO Word64
Word64 -> IO Word64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setEventTimestamp :: MonadIO m => Event -> Word64 -> m ()
setEventTimestamp :: forall (m :: * -> *). MonadIO m => Event -> Word64 -> m ()
setEventTimestamp Event
s Word64
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Event -> (Ptr Event -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Event
s ((Ptr Event -> IO ()) -> IO ()) -> (Ptr Event -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Event
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Event
ptr Ptr Event -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data EventTimestampFieldInfo
instance AttrInfo EventTimestampFieldInfo where
type AttrBaseTypeConstraint EventTimestampFieldInfo = (~) Event
type AttrAllowedOps EventTimestampFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventTimestampFieldInfo = (~) Word64
type AttrTransferTypeConstraint EventTimestampFieldInfo = (~)Word64
type AttrTransferType EventTimestampFieldInfo = Word64
type AttrGetType EventTimestampFieldInfo = Word64
type AttrLabel EventTimestampFieldInfo = "timestamp"
type AttrOrigin EventTimestampFieldInfo = Event
attrGet = getEventTimestamp
attrSet = setEventTimestamp
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.timestamp"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#g:attr:timestamp"
})
event_timestamp :: AttrLabelProxy "timestamp"
event_timestamp = AttrLabelProxy
#endif
getEventSeqnum :: MonadIO m => Event -> m Word32
getEventSeqnum :: forall (m :: * -> *). MonadIO m => Event -> m Word32
getEventSeqnum Event
s = IO Word32 -> m Word32
forall a. IO a -> m a
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
$ Event -> (Ptr Event -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Event
s ((Ptr Event -> IO Word32) -> IO Word32)
-> (Ptr Event -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr Event
ptr -> do
Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Event
ptr Ptr Event -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) :: IO Word32
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setEventSeqnum :: MonadIO m => Event -> Word32 -> m ()
setEventSeqnum :: forall (m :: * -> *). MonadIO m => Event -> Word32 -> m ()
setEventSeqnum Event
s Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Event -> (Ptr Event -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Event
s ((Ptr Event -> IO ()) -> IO ()) -> (Ptr Event -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Event
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Event
ptr Ptr Event -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data EventSeqnumFieldInfo
instance AttrInfo EventSeqnumFieldInfo where
type AttrBaseTypeConstraint EventSeqnumFieldInfo = (~) Event
type AttrAllowedOps EventSeqnumFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventSeqnumFieldInfo = (~) Word32
type AttrTransferTypeConstraint EventSeqnumFieldInfo = (~)Word32
type AttrTransferType EventSeqnumFieldInfo = Word32
type AttrGetType EventSeqnumFieldInfo = Word32
type AttrLabel EventSeqnumFieldInfo = "seqnum"
type AttrOrigin EventSeqnumFieldInfo = Event
attrGet = getEventSeqnum
attrSet = setEventSeqnum
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.seqnum"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#g:attr:seqnum"
})
event_seqnum :: AttrLabelProxy "seqnum"
event_seqnum = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Event
type instance O.AttributeList Event = EventAttributeList
type EventAttributeList = ('[ '("miniObject", EventMiniObjectFieldInfo), '("type", EventTypeFieldInfo), '("timestamp", EventTimestampFieldInfo), '("seqnum", EventSeqnumFieldInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "gst_event_new_buffer_size" gst_event_new_buffer_size ::
CUInt ->
Int64 ->
Int64 ->
CInt ->
IO (Ptr Event)
eventNewBufferSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.Format
-> Int64
-> Int64
-> Bool
-> m Event
eventNewBufferSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Format -> Int64 -> Int64 -> Bool -> m Event
eventNewBufferSize Format
format Int64
minsize Int64
maxsize Bool
async = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
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 async' :: CInt
async' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
async
Ptr Event
result <- CUInt -> Int64 -> Int64 -> CInt -> IO (Ptr Event)
gst_event_new_buffer_size CUInt
format' Int64
minsize Int64
maxsize CInt
async'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewBufferSize" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_caps" gst_event_new_caps ::
Ptr Gst.Caps.Caps ->
IO (Ptr Event)
eventNewCaps ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Caps.Caps
-> m Event
eventNewCaps :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Caps -> m Event
eventNewCaps Caps
caps = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr Caps
caps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
Ptr Event
result <- Ptr Caps -> IO (Ptr Event)
gst_event_new_caps Ptr Caps
caps'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewCaps" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_custom" gst_event_new_custom ::
CUInt ->
Ptr Gst.Structure.Structure ->
IO (Ptr Event)
eventNewCustom ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.EventType
-> Gst.Structure.Structure
-> m Event
eventNewCustom :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
EventType -> Structure -> m Event
eventNewCustom EventType
type_ Structure
structure = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (EventType -> Int) -> EventType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EventType -> Int
forall a. Enum a => a -> Int
fromEnum) EventType
type_
Ptr Structure
structure' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
structure
Ptr Event
result <- CUInt -> Ptr Structure -> IO (Ptr Event)
gst_event_new_custom CUInt
type_' Ptr Structure
structure'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewCustom" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Structure
structure
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_eos" gst_event_new_eos ::
IO (Ptr Event)
eventNewEos ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Event
eventNewEos :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Event
eventNewEos = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
result <- IO (Ptr Event)
gst_event_new_eos
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewEos" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_flush_start" gst_event_new_flush_start ::
IO (Ptr Event)
eventNewFlushStart ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Event
eventNewFlushStart :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Event
eventNewFlushStart = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
result <- IO (Ptr Event)
gst_event_new_flush_start
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewFlushStart" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_flush_stop" gst_event_new_flush_stop ::
CInt ->
IO (Ptr Event)
eventNewFlushStop ::
(B.CallStack.HasCallStack, MonadIO m) =>
Bool
-> m Event
eventNewFlushStop :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Bool -> m Event
eventNewFlushStop Bool
resetTime = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
let resetTime' :: CInt
resetTime' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
resetTime
Ptr Event
result <- CInt -> IO (Ptr Event)
gst_event_new_flush_stop CInt
resetTime'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewFlushStop" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_gap" gst_event_new_gap ::
Word64 ->
Word64 ->
IO (Ptr Event)
eventNewGap ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word64
-> Word64
-> m Event
eventNewGap :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word64 -> Word64 -> m Event
eventNewGap Word64
timestamp Word64
duration = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
result <- Word64 -> Word64 -> IO (Ptr Event)
gst_event_new_gap Word64
timestamp Word64
duration
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewGap" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_instant_rate_change" gst_event_new_instant_rate_change ::
CDouble ->
CUInt ->
IO (Ptr Event)
eventNewInstantRateChange ::
(B.CallStack.HasCallStack, MonadIO m) =>
Double
-> [Gst.Flags.SegmentFlags]
-> m Event
eventNewInstantRateChange :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Double -> [SegmentFlags] -> m Event
eventNewInstantRateChange Double
rateMultiplier [SegmentFlags]
newFlags = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
let rateMultiplier' :: CDouble
rateMultiplier' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
rateMultiplier
let newFlags' :: CUInt
newFlags' = [SegmentFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [SegmentFlags]
newFlags
Ptr Event
result <- CDouble -> CUInt -> IO (Ptr Event)
gst_event_new_instant_rate_change CDouble
rateMultiplier' CUInt
newFlags'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewInstantRateChange" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_instant_rate_sync_time" gst_event_new_instant_rate_sync_time ::
CDouble ->
Word64 ->
Word64 ->
IO (Ptr Event)
eventNewInstantRateSyncTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
Double
-> Word64
-> Word64
-> m Event
eventNewInstantRateSyncTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Double -> Word64 -> Word64 -> m Event
eventNewInstantRateSyncTime Double
rateMultiplier Word64
runningTime Word64
upstreamRunningTime = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
let rateMultiplier' :: CDouble
rateMultiplier' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
rateMultiplier
Ptr Event
result <- CDouble -> Word64 -> Word64 -> IO (Ptr Event)
gst_event_new_instant_rate_sync_time CDouble
rateMultiplier' Word64
runningTime Word64
upstreamRunningTime
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewInstantRateSyncTime" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_latency" gst_event_new_latency ::
Word64 ->
IO (Ptr Event)
eventNewLatency ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word64
-> m Event
eventNewLatency :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word64 -> m Event
eventNewLatency Word64
latency = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
result <- Word64 -> IO (Ptr Event)
gst_event_new_latency Word64
latency
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewLatency" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_navigation" gst_event_new_navigation ::
Ptr Gst.Structure.Structure ->
IO (Ptr Event)
eventNewNavigation ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Structure.Structure
-> m Event
eventNewNavigation :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Structure -> m Event
eventNewNavigation Structure
structure = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr Structure
structure' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
structure
Ptr Event
result <- Ptr Structure -> IO (Ptr Event)
gst_event_new_navigation Ptr Structure
structure'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewNavigation" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Structure
structure
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_protection" gst_event_new_protection ::
CString ->
Ptr Gst.Buffer.Buffer ->
CString ->
IO (Ptr Event)
eventNewProtection ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Gst.Buffer.Buffer
-> T.Text
-> m Event
eventNewProtection :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Buffer -> Text -> m Event
eventNewProtection Text
systemId Buffer
data_ Text
origin = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
CString
systemId' <- Text -> IO CString
textToCString Text
systemId
Ptr Buffer
data_' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
data_
CString
origin' <- Text -> IO CString
textToCString Text
origin
Ptr Event
result <- CString -> Ptr Buffer -> CString -> IO (Ptr Event)
gst_event_new_protection CString
systemId' Ptr Buffer
data_' CString
origin'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewProtection" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
data_
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
systemId'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
origin'
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_qos" gst_event_new_qos ::
CUInt ->
CDouble ->
Int64 ->
Word64 ->
IO (Ptr Event)
eventNewQos ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.QOSType
-> Double
-> Int64
-> Word64
-> m Event
eventNewQos :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
QOSType -> Double -> Int64 -> Word64 -> m Event
eventNewQos QOSType
type_ Double
proportion Int64
diff Word64
timestamp = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (QOSType -> Int) -> QOSType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QOSType -> Int
forall a. Enum a => a -> Int
fromEnum) QOSType
type_
let proportion' :: CDouble
proportion' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
proportion
Ptr Event
result <- CUInt -> CDouble -> Int64 -> Word64 -> IO (Ptr Event)
gst_event_new_qos CUInt
type_' CDouble
proportion' Int64
diff Word64
timestamp
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewQos" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_reconfigure" gst_event_new_reconfigure ::
IO (Ptr Event)
eventNewReconfigure ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Event
eventNewReconfigure :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Event
eventNewReconfigure = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
result <- IO (Ptr Event)
gst_event_new_reconfigure
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewReconfigure" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_seek" gst_event_new_seek ::
CDouble ->
CUInt ->
CUInt ->
CUInt ->
Int64 ->
CUInt ->
Int64 ->
IO (Ptr Event)
eventNewSeek ::
(B.CallStack.HasCallStack, MonadIO m) =>
Double
-> Gst.Enums.Format
-> [Gst.Flags.SeekFlags]
-> Gst.Enums.SeekType
-> Int64
-> Gst.Enums.SeekType
-> Int64
-> m Event
eventNewSeek :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Double
-> Format
-> [SeekFlags]
-> SeekType
-> Int64
-> SeekType
-> Int64
-> m Event
eventNewSeek Double
rate Format
format [SeekFlags]
flags SeekType
startType Int64
start SeekType
stopType Int64
stop = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
let rate' :: CDouble
rate' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
rate
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 flags' :: CUInt
flags' = [SeekFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [SeekFlags]
flags
let startType' :: CUInt
startType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (SeekType -> Int) -> SeekType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SeekType -> Int
forall a. Enum a => a -> Int
fromEnum) SeekType
startType
let stopType' :: CUInt
stopType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (SeekType -> Int) -> SeekType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SeekType -> Int
forall a. Enum a => a -> Int
fromEnum) SeekType
stopType
Ptr Event
result <- CDouble
-> CUInt
-> CUInt
-> CUInt
-> Int64
-> CUInt
-> Int64
-> IO (Ptr Event)
gst_event_new_seek CDouble
rate' CUInt
format' CUInt
flags' CUInt
startType' Int64
start CUInt
stopType' Int64
stop
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewSeek" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_segment" gst_event_new_segment ::
Ptr Gst.Segment.Segment ->
IO (Ptr Event)
eventNewSegment ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Segment.Segment
-> m Event
eventNewSegment :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> m Event
eventNewSegment Segment
segment = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr Segment
segment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
segment
Ptr Event
result <- Ptr Segment -> IO (Ptr Event)
gst_event_new_segment Ptr Segment
segment'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewSegment" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_segment_done" gst_event_new_segment_done ::
CUInt ->
Int64 ->
IO (Ptr Event)
eventNewSegmentDone ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.Format
-> Int64
-> m Event
eventNewSegmentDone :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Format -> Int64 -> m Event
eventNewSegmentDone Format
format Int64
position = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
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 Event
result <- CUInt -> Int64 -> IO (Ptr Event)
gst_event_new_segment_done CUInt
format' Int64
position
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewSegmentDone" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_select_streams" gst_event_new_select_streams ::
Ptr (GList CString) ->
IO (Ptr Event)
eventNewSelectStreams ::
(B.CallStack.HasCallStack, MonadIO m) =>
[T.Text]
-> m Event
eventNewSelectStreams :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[Text] -> m Event
eventNewSelectStreams [Text]
streams = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
[CString]
streams' <- (Text -> IO CString) -> [Text] -> IO [CString]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Text -> IO CString
textToCString [Text]
streams
Ptr (GList CString)
streams'' <- [CString] -> IO (Ptr (GList CString))
forall a. [Ptr a] -> IO (Ptr (GList (Ptr a)))
packGList [CString]
streams'
Ptr Event
result <- Ptr (GList CString) -> IO (Ptr Event)
gst_event_new_select_streams Ptr (GList CString)
streams''
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewSelectStreams" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
(CString -> IO ()) -> Ptr (GList CString) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (GList (Ptr a)) -> IO ()
mapGList CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (GList CString)
streams''
Ptr (GList CString) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList CString)
streams''
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_sink_message" gst_event_new_sink_message ::
CString ->
Ptr Gst.Message.Message ->
IO (Ptr Event)
eventNewSinkMessage ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Gst.Message.Message
-> m Event
eventNewSinkMessage :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Message -> m Event
eventNewSinkMessage Text
name Message
msg = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr Message
msg' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
msg
Ptr Event
result <- CString -> Ptr Message -> IO (Ptr Event)
gst_event_new_sink_message CString
name' Ptr Message
msg'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewSinkMessage" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
msg
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_step" gst_event_new_step ::
CUInt ->
Word64 ->
CDouble ->
CInt ->
CInt ->
IO (Ptr Event)
eventNewStep ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.Format
-> Word64
-> Double
-> Bool
-> Bool
-> m Event
eventNewStep :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Format -> Word64 -> Double -> Bool -> Bool -> m Event
eventNewStep Format
format Word64
amount Double
rate Bool
flush Bool
intermediate = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
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
P.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
P.fromEnum) Bool
flush
let intermediate' :: CInt
intermediate' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
intermediate
Ptr Event
result <- CUInt -> Word64 -> CDouble -> CInt -> CInt -> IO (Ptr Event)
gst_event_new_step CUInt
format' Word64
amount CDouble
rate' CInt
flush' CInt
intermediate'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewStep" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_stream_collection" gst_event_new_stream_collection ::
Ptr Gst.StreamCollection.StreamCollection ->
IO (Ptr Event)
eventNewStreamCollection ::
(B.CallStack.HasCallStack, MonadIO m, Gst.StreamCollection.IsStreamCollection a) =>
a
-> m Event
eventNewStreamCollection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStreamCollection a) =>
a -> m Event
eventNewStreamCollection a
collection = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr StreamCollection
collection' <- a -> IO (Ptr StreamCollection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
collection
Ptr Event
result <- Ptr StreamCollection -> IO (Ptr Event)
gst_event_new_stream_collection Ptr StreamCollection
collection'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewStreamCollection" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
collection
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_stream_group_done" gst_event_new_stream_group_done ::
Word32 ->
IO (Ptr Event)
eventNewStreamGroupDone ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> m Event
eventNewStreamGroupDone :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> m Event
eventNewStreamGroupDone Word32
groupId = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
result <- Word32 -> IO (Ptr Event)
gst_event_new_stream_group_done Word32
groupId
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewStreamGroupDone" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_stream_start" gst_event_new_stream_start ::
CString ->
IO (Ptr Event)
eventNewStreamStart ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Event
eventNewStreamStart :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Event
eventNewStreamStart Text
streamId = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
CString
streamId' <- Text -> IO CString
textToCString Text
streamId
Ptr Event
result <- CString -> IO (Ptr Event)
gst_event_new_stream_start CString
streamId'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewStreamStart" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
streamId'
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_tag" gst_event_new_tag ::
Ptr Gst.TagList.TagList ->
IO (Ptr Event)
eventNewTag ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.TagList.TagList
-> m Event
eventNewTag :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TagList -> m Event
eventNewTag TagList
taglist = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
Ptr TagList
taglist' <- TagList -> IO (Ptr TagList)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed TagList
taglist
Ptr Event
result <- Ptr TagList -> IO (Ptr Event)
gst_event_new_tag Ptr TagList
taglist'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewTag" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
TagList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TagList
taglist
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_toc" gst_event_new_toc ::
Ptr Gst.Toc.Toc ->
CInt ->
IO (Ptr Event)
eventNewToc ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Toc.Toc
-> Bool
-> m Event
eventNewToc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Toc -> Bool -> m Event
eventNewToc Toc
toc Bool
updated = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
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
P.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
P.fromEnum) Bool
updated
Ptr Event
result <- Ptr Toc -> CInt -> IO (Ptr Event)
gst_event_new_toc Ptr Toc
toc' CInt
updated'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewToc" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
Toc -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Toc
toc
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_new_toc_select" gst_event_new_toc_select ::
CString ->
IO (Ptr Event)
eventNewTocSelect ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Event
eventNewTocSelect :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Event
eventNewTocSelect Text
uid = IO Event -> m Event
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Event -> m Event) -> IO Event -> m Event
forall a b. (a -> b) -> a -> b
$ do
CString
uid' <- Text -> IO CString
textToCString Text
uid
Ptr Event
result <- CString -> IO (Ptr Event)
gst_event_new_toc_select CString
uid'
Text -> Ptr Event -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventNewTocSelect" Ptr Event
result
Event
result' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Event) Ptr Event
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uid'
Event -> IO Event
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_event_copy_segment" gst_event_copy_segment ::
Ptr Event ->
Ptr Gst.Segment.Segment ->
IO ()
eventCopySegment ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Gst.Segment.Segment
-> m ()
eventCopySegment :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Segment -> m ()
eventCopySegment Event
event Segment
segment = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Segment
segment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
segment
Ptr Event -> Ptr Segment -> IO ()
gst_event_copy_segment Ptr Event
event' Ptr Segment
segment'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventCopySegmentMethodInfo
instance (signature ~ (Gst.Segment.Segment -> m ()), MonadIO m) => O.OverloadedMethod EventCopySegmentMethodInfo Event signature where
overloadedMethod = eventCopySegment
instance O.OverloadedMethodInfo EventCopySegmentMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventCopySegment",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventCopySegment"
})
#endif
foreign import ccall "gst_event_get_running_time_offset" gst_event_get_running_time_offset ::
Ptr Event ->
IO Int64
eventGetRunningTimeOffset ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Int64
eventGetRunningTimeOffset :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Int64
eventGetRunningTimeOffset Event
event = IO Int64 -> m Int64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Int64
result <- Ptr Event -> IO Int64
gst_event_get_running_time_offset Ptr Event
event'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Int64 -> IO Int64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
result
#if defined(ENABLE_OVERLOADING)
data EventGetRunningTimeOffsetMethodInfo
instance (signature ~ (m Int64), MonadIO m) => O.OverloadedMethod EventGetRunningTimeOffsetMethodInfo Event signature where
overloadedMethod = eventGetRunningTimeOffset
instance O.OverloadedMethodInfo EventGetRunningTimeOffsetMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventGetRunningTimeOffset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventGetRunningTimeOffset"
})
#endif
foreign import ccall "gst_event_get_seqnum" gst_event_get_seqnum ::
Ptr Event ->
IO Word32
eventGetSeqnum ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Word32
eventGetSeqnum :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Word32
eventGetSeqnum Event
event = IO Word32 -> m Word32
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Word32
result <- Ptr Event -> IO Word32
gst_event_get_seqnum Ptr Event
event'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data EventGetSeqnumMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod EventGetSeqnumMethodInfo Event signature where
overloadedMethod = eventGetSeqnum
instance O.OverloadedMethodInfo EventGetSeqnumMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventGetSeqnum",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventGetSeqnum"
})
#endif
foreign import ccall "gst_event_get_structure" gst_event_get_structure ::
Ptr Event ->
IO (Ptr Gst.Structure.Structure)
eventGetStructure ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (Maybe Gst.Structure.Structure)
eventGetStructure :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Maybe Structure)
eventGetStructure Event
event = IO (Maybe Structure) -> m (Maybe Structure)
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Structure
result <- Ptr Event -> IO (Ptr Structure)
gst_event_get_structure Ptr Event
event'
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Structure
result''
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Maybe Structure -> IO (Maybe Structure)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Structure
maybeResult
#if defined(ENABLE_OVERLOADING)
data EventGetStructureMethodInfo
instance (signature ~ (m (Maybe Gst.Structure.Structure)), MonadIO m) => O.OverloadedMethod EventGetStructureMethodInfo Event signature where
overloadedMethod = eventGetStructure
instance O.OverloadedMethodInfo EventGetStructureMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventGetStructure",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventGetStructure"
})
#endif
foreign import ccall "gst_event_has_name" gst_event_has_name ::
Ptr Event ->
CString ->
IO CInt
eventHasName ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> T.Text
-> m Bool
eventHasName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Text -> m Bool
eventHasName Event
event Text
name = IO Bool -> m Bool
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CString
name' <- Text -> IO CString
textToCString Text
name
CInt
result <- Ptr Event -> CString -> IO CInt
gst_event_has_name Ptr Event
event' CString
name'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data EventHasNameMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.OverloadedMethod EventHasNameMethodInfo Event signature where
overloadedMethod = eventHasName
instance O.OverloadedMethodInfo EventHasNameMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventHasName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventHasName"
})
#endif
foreign import ccall "gst_event_has_name_id" gst_event_has_name_id ::
Ptr Event ->
Word32 ->
IO CInt
eventHasNameId ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Word32
-> m Bool
eventHasNameId :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Word32 -> m Bool
eventHasNameId Event
event Word32
name = IO Bool -> m Bool
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CInt
result <- Ptr Event -> Word32 -> IO CInt
gst_event_has_name_id Ptr Event
event' Word32
name
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data EventHasNameIdMethodInfo
instance (signature ~ (Word32 -> m Bool), MonadIO m) => O.OverloadedMethod EventHasNameIdMethodInfo Event signature where
overloadedMethod = eventHasNameId
instance O.OverloadedMethodInfo EventHasNameIdMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventHasNameId",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventHasNameId"
})
#endif
foreign import ccall "gst_event_parse_buffer_size" gst_event_parse_buffer_size ::
Ptr Event ->
Ptr CUInt ->
Ptr Int64 ->
Ptr Int64 ->
Ptr CInt ->
IO ()
eventParseBufferSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Gst.Enums.Format, Int64, Int64, Bool))
eventParseBufferSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Format, Int64, Int64, Bool)
eventParseBufferSize Event
event = IO (Format, Int64, Int64, Bool) -> m (Format, Int64, Int64, Bool)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Format, Int64, Int64, Bool) -> m (Format, Int64, Int64, Bool))
-> IO (Format, Int64, Int64, Bool)
-> m (Format, Int64, Int64, Bool)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CUInt
format <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Int64
minsize <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
Ptr Int64
maxsize <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
Ptr CInt
async <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
Ptr Event
-> Ptr CUInt -> Ptr Int64 -> Ptr Int64 -> Ptr CInt -> IO ()
gst_event_parse_buffer_size Ptr Event
event' Ptr CUInt
format Ptr Int64
minsize Ptr Int64
maxsize Ptr CInt
async
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
minsize' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
minsize
Int64
maxsize' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
maxsize
CInt
async' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
async
let async'' :: Bool
async'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
async'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
format
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
minsize
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
maxsize
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
async
(Format, Int64, Int64, Bool) -> IO (Format, Int64, Int64, Bool)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Format
format'', Int64
minsize', Int64
maxsize', Bool
async'')
#if defined(ENABLE_OVERLOADING)
data EventParseBufferSizeMethodInfo
instance (signature ~ (m ((Gst.Enums.Format, Int64, Int64, Bool))), MonadIO m) => O.OverloadedMethod EventParseBufferSizeMethodInfo Event signature where
overloadedMethod = eventParseBufferSize
instance O.OverloadedMethodInfo EventParseBufferSizeMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseBufferSize",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseBufferSize"
})
#endif
foreign import ccall "gst_event_parse_caps" gst_event_parse_caps ::
Ptr Event ->
Ptr (Ptr Gst.Caps.Caps) ->
IO ()
eventParseCaps ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (Gst.Caps.Caps)
eventParseCaps :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Caps
eventParseCaps Event
event = IO Caps -> m Caps
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Caps -> m Caps) -> IO Caps -> m Caps
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr (Ptr Caps)
caps <- IO (Ptr (Ptr Caps))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Caps.Caps))
Ptr Event -> Ptr (Ptr Caps) -> IO ()
gst_event_parse_caps Ptr Event
event' Ptr (Ptr Caps)
caps
Ptr Caps
caps' <- Ptr (Ptr Caps) -> IO (Ptr Caps)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Caps)
caps
Caps
caps'' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
caps'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr (Ptr Caps) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Caps)
caps
Caps -> IO Caps
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
caps''
#if defined(ENABLE_OVERLOADING)
data EventParseCapsMethodInfo
instance (signature ~ (m (Gst.Caps.Caps)), MonadIO m) => O.OverloadedMethod EventParseCapsMethodInfo Event signature where
overloadedMethod = eventParseCaps
instance O.OverloadedMethodInfo EventParseCapsMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseCaps"
})
#endif
foreign import ccall "gst_event_parse_flush_stop" gst_event_parse_flush_stop ::
Ptr Event ->
Ptr CInt ->
IO ()
eventParseFlushStop ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (Bool)
eventParseFlushStop :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Bool
eventParseFlushStop Event
event = IO Bool -> m Bool
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CInt
resetTime <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
Ptr Event -> Ptr CInt -> IO ()
gst_event_parse_flush_stop Ptr Event
event' Ptr CInt
resetTime
CInt
resetTime' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
resetTime
let resetTime'' :: Bool
resetTime'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
resetTime'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
resetTime
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
resetTime''
#if defined(ENABLE_OVERLOADING)
data EventParseFlushStopMethodInfo
instance (signature ~ (m (Bool)), MonadIO m) => O.OverloadedMethod EventParseFlushStopMethodInfo Event signature where
overloadedMethod = eventParseFlushStop
instance O.OverloadedMethodInfo EventParseFlushStopMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseFlushStop",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseFlushStop"
})
#endif
foreign import ccall "gst_event_parse_gap" gst_event_parse_gap ::
Ptr Event ->
Ptr Word64 ->
Ptr Word64 ->
IO ()
eventParseGap ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Word64, Word64))
eventParseGap :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Word64, Word64)
eventParseGap Event
event = IO (Word64, Word64) -> m (Word64, Word64)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Word64, Word64) -> m (Word64, Word64))
-> IO (Word64, Word64) -> m (Word64, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
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 Event -> Ptr Word64 -> Ptr Word64 -> IO ()
gst_event_parse_gap Ptr Event
event' Ptr Word64
timestamp Ptr Word64
duration
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
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
timestamp
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
duration
(Word64, Word64) -> IO (Word64, Word64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Word64
timestamp', Word64
duration')
#if defined(ENABLE_OVERLOADING)
data EventParseGapMethodInfo
instance (signature ~ (m ((Word64, Word64))), MonadIO m) => O.OverloadedMethod EventParseGapMethodInfo Event signature where
overloadedMethod = eventParseGap
instance O.OverloadedMethodInfo EventParseGapMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseGap",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseGap"
})
#endif
foreign import ccall "gst_event_parse_gap_flags" gst_event_parse_gap_flags ::
Ptr Event ->
Ptr CUInt ->
IO ()
eventParseGapFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ([Gst.Flags.GapFlags])
eventParseGapFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m [GapFlags]
eventParseGapFlags Event
event = IO [GapFlags] -> m [GapFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [GapFlags] -> m [GapFlags]) -> IO [GapFlags] -> m [GapFlags]
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CUInt
flags <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Event -> Ptr CUInt -> IO ()
gst_event_parse_gap_flags Ptr Event
event' Ptr CUInt
flags
CUInt
flags' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
flags
let flags'' :: [GapFlags]
flags'' = CUInt -> [GapFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
flags'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
flags
[GapFlags] -> IO [GapFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [GapFlags]
flags''
#if defined(ENABLE_OVERLOADING)
data EventParseGapFlagsMethodInfo
instance (signature ~ (m ([Gst.Flags.GapFlags])), MonadIO m) => O.OverloadedMethod EventParseGapFlagsMethodInfo Event signature where
overloadedMethod = eventParseGapFlags
instance O.OverloadedMethodInfo EventParseGapFlagsMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseGapFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseGapFlags"
})
#endif
foreign import ccall "gst_event_parse_group_id" gst_event_parse_group_id ::
Ptr Event ->
Ptr Word32 ->
IO CInt
eventParseGroupId ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Bool, Word32))
eventParseGroupId :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Bool, Word32)
eventParseGroupId Event
event = IO (Bool, Word32) -> m (Bool, Word32)
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Word32
groupId <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
CInt
result <- Ptr Event -> Ptr Word32 -> IO CInt
gst_event_parse_group_id Ptr Event
event' 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
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
groupId
(Bool, Word32) -> IO (Bool, Word32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word32
groupId')
#if defined(ENABLE_OVERLOADING)
data EventParseGroupIdMethodInfo
instance (signature ~ (m ((Bool, Word32))), MonadIO m) => O.OverloadedMethod EventParseGroupIdMethodInfo Event signature where
overloadedMethod = eventParseGroupId
instance O.OverloadedMethodInfo EventParseGroupIdMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseGroupId",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseGroupId"
})
#endif
foreign import ccall "gst_event_parse_instant_rate_change" gst_event_parse_instant_rate_change ::
Ptr Event ->
Ptr CDouble ->
Ptr CUInt ->
IO ()
eventParseInstantRateChange ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Double, [Gst.Flags.SegmentFlags]))
eventParseInstantRateChange :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Double, [SegmentFlags])
eventParseInstantRateChange Event
event = IO (Double, [SegmentFlags]) -> m (Double, [SegmentFlags])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Double, [SegmentFlags]) -> m (Double, [SegmentFlags]))
-> IO (Double, [SegmentFlags]) -> m (Double, [SegmentFlags])
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CDouble
rateMultiplier <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr CUInt
newFlags <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Event -> Ptr CDouble -> Ptr CUInt -> IO ()
gst_event_parse_instant_rate_change Ptr Event
event' Ptr CDouble
rateMultiplier Ptr CUInt
newFlags
CDouble
rateMultiplier' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
rateMultiplier
let rateMultiplier'' :: Double
rateMultiplier'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
rateMultiplier'
CUInt
newFlags' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
newFlags
let newFlags'' :: [SegmentFlags]
newFlags'' = CUInt -> [SegmentFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
newFlags'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
rateMultiplier
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
newFlags
(Double, [SegmentFlags]) -> IO (Double, [SegmentFlags])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Double
rateMultiplier'', [SegmentFlags]
newFlags'')
#if defined(ENABLE_OVERLOADING)
data EventParseInstantRateChangeMethodInfo
instance (signature ~ (m ((Double, [Gst.Flags.SegmentFlags]))), MonadIO m) => O.OverloadedMethod EventParseInstantRateChangeMethodInfo Event signature where
overloadedMethod = eventParseInstantRateChange
instance O.OverloadedMethodInfo EventParseInstantRateChangeMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseInstantRateChange",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseInstantRateChange"
})
#endif
foreign import ccall "gst_event_parse_instant_rate_sync_time" gst_event_parse_instant_rate_sync_time ::
Ptr Event ->
Ptr CDouble ->
Ptr Word64 ->
Ptr Word64 ->
IO ()
eventParseInstantRateSyncTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Double, Word64, Word64))
eventParseInstantRateSyncTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Double, Word64, Word64)
eventParseInstantRateSyncTime Event
event = IO (Double, Word64, Word64) -> m (Double, Word64, Word64)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Double, Word64, Word64) -> m (Double, Word64, Word64))
-> IO (Double, Word64, Word64) -> m (Double, Word64, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CDouble
rateMultiplier <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr Word64
runningTime <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Word64
upstreamRunningTime <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Event -> Ptr CDouble -> Ptr Word64 -> Ptr Word64 -> IO ()
gst_event_parse_instant_rate_sync_time Ptr Event
event' Ptr CDouble
rateMultiplier Ptr Word64
runningTime Ptr Word64
upstreamRunningTime
CDouble
rateMultiplier' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
rateMultiplier
let rateMultiplier'' :: Double
rateMultiplier'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
rateMultiplier'
Word64
runningTime' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
runningTime
Word64
upstreamRunningTime' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
upstreamRunningTime
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
rateMultiplier
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
runningTime
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
upstreamRunningTime
(Double, Word64, Word64) -> IO (Double, Word64, Word64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Double
rateMultiplier'', Word64
runningTime', Word64
upstreamRunningTime')
#if defined(ENABLE_OVERLOADING)
data EventParseInstantRateSyncTimeMethodInfo
instance (signature ~ (m ((Double, Word64, Word64))), MonadIO m) => O.OverloadedMethod EventParseInstantRateSyncTimeMethodInfo Event signature where
overloadedMethod = eventParseInstantRateSyncTime
instance O.OverloadedMethodInfo EventParseInstantRateSyncTimeMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseInstantRateSyncTime",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseInstantRateSyncTime"
})
#endif
foreign import ccall "gst_event_parse_latency" gst_event_parse_latency ::
Ptr Event ->
Ptr Word64 ->
IO ()
eventParseLatency ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (Word64)
eventParseLatency :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Word64
eventParseLatency Event
event = IO Word64 -> m Word64
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Word64
latency <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Event -> Ptr Word64 -> IO ()
gst_event_parse_latency Ptr Event
event' Ptr Word64
latency
Word64
latency' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
latency
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
latency
Word64 -> IO Word64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
latency'
#if defined(ENABLE_OVERLOADING)
data EventParseLatencyMethodInfo
instance (signature ~ (m (Word64)), MonadIO m) => O.OverloadedMethod EventParseLatencyMethodInfo Event signature where
overloadedMethod = eventParseLatency
instance O.OverloadedMethodInfo EventParseLatencyMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseLatency",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseLatency"
})
#endif
foreign import ccall "gst_event_parse_protection" gst_event_parse_protection ::
Ptr Event ->
Ptr CString ->
Ptr (Ptr Gst.Buffer.Buffer) ->
Ptr CString ->
IO ()
eventParseProtection ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((T.Text, Gst.Buffer.Buffer, Maybe T.Text))
eventParseProtection :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Text, Buffer, Maybe Text)
eventParseProtection Event
event = IO (Text, Buffer, Maybe Text) -> m (Text, Buffer, Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Buffer, Maybe Text) -> m (Text, Buffer, Maybe Text))
-> IO (Text, Buffer, Maybe Text) -> m (Text, Buffer, Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CString
systemId <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr (Ptr Buffer)
data_ <- IO (Ptr (Ptr Buffer))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Buffer.Buffer))
Ptr CString
origin <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr Event
-> Ptr CString -> Ptr (Ptr Buffer) -> Ptr CString -> IO ()
gst_event_parse_protection Ptr Event
event' Ptr CString
systemId Ptr (Ptr Buffer)
data_ Ptr CString
origin
CString
systemId' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
systemId
Text
systemId'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
systemId'
Ptr Buffer
data_' <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Buffer)
data_
Buffer
data_'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
data_'
CString
origin' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
origin
Maybe Text
maybeOrigin' <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
origin' ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
origin'' -> do
Text
origin''' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
origin''
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
origin'''
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
systemId
Ptr (Ptr Buffer) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Buffer)
data_
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
origin
(Text, Buffer, Maybe Text) -> IO (Text, Buffer, Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
systemId'', Buffer
data_'', Maybe Text
maybeOrigin')
#if defined(ENABLE_OVERLOADING)
data EventParseProtectionMethodInfo
instance (signature ~ (m ((T.Text, Gst.Buffer.Buffer, Maybe T.Text))), MonadIO m) => O.OverloadedMethod EventParseProtectionMethodInfo Event signature where
overloadedMethod = eventParseProtection
instance O.OverloadedMethodInfo EventParseProtectionMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseProtection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseProtection"
})
#endif
foreign import ccall "gst_event_parse_qos" gst_event_parse_qos ::
Ptr Event ->
Ptr CUInt ->
Ptr CDouble ->
Ptr Int64 ->
Ptr Word64 ->
IO ()
eventParseQos ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Gst.Enums.QOSType, Double, Int64, Word64))
eventParseQos :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (QOSType, Double, Int64, Word64)
eventParseQos Event
event = IO (QOSType, Double, Int64, Word64)
-> m (QOSType, Double, Int64, Word64)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (QOSType, Double, Int64, Word64)
-> m (QOSType, Double, Int64, Word64))
-> IO (QOSType, Double, Int64, Word64)
-> m (QOSType, Double, Int64, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CUInt
type_ <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr CDouble
proportion <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr Int64
diff <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
Ptr Word64
timestamp <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Event
-> Ptr CUInt -> Ptr CDouble -> Ptr Int64 -> Ptr Word64 -> IO ()
gst_event_parse_qos Ptr Event
event' Ptr CUInt
type_ Ptr CDouble
proportion Ptr Int64
diff Ptr Word64
timestamp
CUInt
type_' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
type_
let type_'' :: QOSType
type_'' = (Int -> QOSType
forall a. Enum a => Int -> a
toEnum (Int -> QOSType) -> (CUInt -> Int) -> CUInt -> QOSType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
type_'
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'
Int64
diff' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
diff
Word64
timestamp' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
timestamp
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
type_
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
proportion
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
diff
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
timestamp
(QOSType, Double, Int64, Word64)
-> IO (QOSType, Double, Int64, Word64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (QOSType
type_'', Double
proportion'', Int64
diff', Word64
timestamp')
#if defined(ENABLE_OVERLOADING)
data EventParseQosMethodInfo
instance (signature ~ (m ((Gst.Enums.QOSType, Double, Int64, Word64))), MonadIO m) => O.OverloadedMethod EventParseQosMethodInfo Event signature where
overloadedMethod = eventParseQos
instance O.OverloadedMethodInfo EventParseQosMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseQos",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseQos"
})
#endif
foreign import ccall "gst_event_parse_seek" gst_event_parse_seek ::
Ptr Event ->
Ptr CDouble ->
Ptr CUInt ->
Ptr CUInt ->
Ptr CUInt ->
Ptr Int64 ->
Ptr CUInt ->
Ptr Int64 ->
IO ()
eventParseSeek ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Double, Gst.Enums.Format, [Gst.Flags.SeekFlags], Gst.Enums.SeekType, Int64, Gst.Enums.SeekType, Int64))
eventParseSeek :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event
-> m (Double, Format, [SeekFlags], SeekType, Int64, SeekType,
Int64)
eventParseSeek Event
event = IO (Double, Format, [SeekFlags], SeekType, Int64, SeekType, Int64)
-> m (Double, Format, [SeekFlags], SeekType, Int64, SeekType,
Int64)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Double, Format, [SeekFlags], SeekType, Int64, SeekType, Int64)
-> m (Double, Format, [SeekFlags], SeekType, Int64, SeekType,
Int64))
-> IO
(Double, Format, [SeekFlags], SeekType, Int64, SeekType, Int64)
-> m (Double, Format, [SeekFlags], SeekType, Int64, SeekType,
Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CDouble
rate <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr CUInt
format <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr CUInt
flags <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr CUInt
startType <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Int64
start <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
Ptr CUInt
stopType <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Int64
stop <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
Ptr Event
-> Ptr CDouble
-> Ptr CUInt
-> Ptr CUInt
-> Ptr CUInt
-> Ptr Int64
-> Ptr CUInt
-> Ptr Int64
-> IO ()
gst_event_parse_seek Ptr Event
event' Ptr CDouble
rate Ptr CUInt
format Ptr CUInt
flags Ptr CUInt
startType Ptr Int64
start Ptr CUInt
stopType Ptr Int64
stop
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'
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'
CUInt
flags' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
flags
let flags'' :: [SeekFlags]
flags'' = CUInt -> [SeekFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
flags'
CUInt
startType' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
startType
let startType'' :: SeekType
startType'' = (Int -> SeekType
forall a. Enum a => Int -> a
toEnum (Int -> SeekType) -> (CUInt -> Int) -> CUInt -> SeekType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
startType'
Int64
start' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
start
CUInt
stopType' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
stopType
let stopType'' :: SeekType
stopType'' = (Int -> SeekType
forall a. Enum a => Int -> a
toEnum (Int -> SeekType) -> (CUInt -> Int) -> CUInt -> SeekType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
stopType'
Int64
stop' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
stop
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
rate
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
format
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
flags
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
startType
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
start
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
stopType
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
stop
(Double, Format, [SeekFlags], SeekType, Int64, SeekType, Int64)
-> IO
(Double, Format, [SeekFlags], SeekType, Int64, SeekType, Int64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Double
rate'', Format
format'', [SeekFlags]
flags'', SeekType
startType'', Int64
start', SeekType
stopType'', Int64
stop')
#if defined(ENABLE_OVERLOADING)
data EventParseSeekMethodInfo
instance (signature ~ (m ((Double, Gst.Enums.Format, [Gst.Flags.SeekFlags], Gst.Enums.SeekType, Int64, Gst.Enums.SeekType, Int64))), MonadIO m) => O.OverloadedMethod EventParseSeekMethodInfo Event signature where
overloadedMethod = eventParseSeek
instance O.OverloadedMethodInfo EventParseSeekMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseSeek",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseSeek"
})
#endif
foreign import ccall "gst_event_parse_seek_trickmode_interval" gst_event_parse_seek_trickmode_interval ::
Ptr Event ->
Ptr Word64 ->
IO ()
eventParseSeekTrickmodeInterval ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (Word64)
eventParseSeekTrickmodeInterval :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Word64
eventParseSeekTrickmodeInterval Event
event = IO Word64 -> m Word64
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Word64
interval <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Event -> Ptr Word64 -> IO ()
gst_event_parse_seek_trickmode_interval Ptr Event
event' Ptr Word64
interval
Word64
interval' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
interval
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
interval
Word64 -> IO Word64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
interval'
#if defined(ENABLE_OVERLOADING)
data EventParseSeekTrickmodeIntervalMethodInfo
instance (signature ~ (m (Word64)), MonadIO m) => O.OverloadedMethod EventParseSeekTrickmodeIntervalMethodInfo Event signature where
overloadedMethod = eventParseSeekTrickmodeInterval
instance O.OverloadedMethodInfo EventParseSeekTrickmodeIntervalMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseSeekTrickmodeInterval",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseSeekTrickmodeInterval"
})
#endif
foreign import ccall "gst_event_parse_segment" gst_event_parse_segment ::
Ptr Event ->
Ptr (Ptr Gst.Segment.Segment) ->
IO ()
eventParseSegment ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (Gst.Segment.Segment)
eventParseSegment :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Segment
eventParseSegment Event
event = IO Segment -> m Segment
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Segment -> m Segment) -> IO Segment -> m Segment
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr (Ptr Segment)
segment <- IO (Ptr (Ptr Segment))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Segment.Segment))
Ptr Event -> Ptr (Ptr Segment) -> IO ()
gst_event_parse_segment Ptr Event
event' Ptr (Ptr Segment)
segment
Ptr Segment
segment' <- Ptr (Ptr Segment) -> IO (Ptr Segment)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Segment)
segment
Segment
segment'' <- ((ManagedPtr Segment -> Segment) -> Ptr Segment -> IO Segment
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Segment -> Segment
Gst.Segment.Segment) Ptr Segment
segment'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr (Ptr Segment) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Segment)
segment
Segment -> IO Segment
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Segment
segment''
#if defined(ENABLE_OVERLOADING)
data EventParseSegmentMethodInfo
instance (signature ~ (m (Gst.Segment.Segment)), MonadIO m) => O.OverloadedMethod EventParseSegmentMethodInfo Event signature where
overloadedMethod = eventParseSegment
instance O.OverloadedMethodInfo EventParseSegmentMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseSegment",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseSegment"
})
#endif
foreign import ccall "gst_event_parse_segment_done" gst_event_parse_segment_done ::
Ptr Event ->
Ptr CUInt ->
Ptr Int64 ->
IO ()
eventParseSegmentDone ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Gst.Enums.Format, Int64))
eventParseSegmentDone :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Format, Int64)
eventParseSegmentDone Event
event = IO (Format, Int64) -> m (Format, Int64)
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
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 Event -> Ptr CUInt -> Ptr Int64 -> IO ()
gst_event_parse_segment_done Ptr Event
event' 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
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Format
format'', Int64
position')
#if defined(ENABLE_OVERLOADING)
data EventParseSegmentDoneMethodInfo
instance (signature ~ (m ((Gst.Enums.Format, Int64))), MonadIO m) => O.OverloadedMethod EventParseSegmentDoneMethodInfo Event signature where
overloadedMethod = eventParseSegmentDone
instance O.OverloadedMethodInfo EventParseSegmentDoneMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseSegmentDone",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseSegmentDone"
})
#endif
foreign import ccall "gst_event_parse_select_streams" gst_event_parse_select_streams ::
Ptr Event ->
Ptr (Ptr (GList CString)) ->
IO ()
eventParseSelectStreams ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ([T.Text])
eventParseSelectStreams :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m [Text]
eventParseSelectStreams Event
event = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr (Ptr (GList CString))
streams <- IO (Ptr (Ptr (GList CString)))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GList CString)))
Ptr Event -> Ptr (Ptr (GList CString)) -> IO ()
gst_event_parse_select_streams Ptr Event
event' Ptr (Ptr (GList CString))
streams
Ptr (GList CString)
streams' <- Ptr (Ptr (GList CString)) -> IO (Ptr (GList CString))
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GList CString))
streams
[CString]
streams'' <- Ptr (GList CString) -> IO [CString]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList CString)
streams'
[Text]
streams''' <- (CString -> IO Text) -> [CString] -> IO [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [CString]
streams''
(CString -> IO ()) -> Ptr (GList CString) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (GList (Ptr a)) -> IO ()
mapGList CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (GList CString)
streams'
Ptr (GList CString) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList CString)
streams'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr (Ptr (GList CString)) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GList CString))
streams
[Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
streams'''
#if defined(ENABLE_OVERLOADING)
data EventParseSelectStreamsMethodInfo
instance (signature ~ (m ([T.Text])), MonadIO m) => O.OverloadedMethod EventParseSelectStreamsMethodInfo Event signature where
overloadedMethod = eventParseSelectStreams
instance O.OverloadedMethodInfo EventParseSelectStreamsMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseSelectStreams",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseSelectStreams"
})
#endif
foreign import ccall "gst_event_parse_sink_message" gst_event_parse_sink_message ::
Ptr Event ->
Ptr (Ptr Gst.Message.Message) ->
IO ()
eventParseSinkMessage ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (Gst.Message.Message)
eventParseSinkMessage :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Message
eventParseSinkMessage Event
event = IO Message -> m Message
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr (Ptr Message)
msg <- IO (Ptr (Ptr Message))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Message.Message))
Ptr Event -> Ptr (Ptr Message) -> IO ()
gst_event_parse_sink_message Ptr Event
event' Ptr (Ptr Message)
msg
Ptr Message
msg' <- Ptr (Ptr Message) -> IO (Ptr Message)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Message)
msg
Message
msg'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Gst.Message.Message) Ptr Message
msg'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr (Ptr Message) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Message)
msg
Message -> IO Message
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Message
msg''
#if defined(ENABLE_OVERLOADING)
data EventParseSinkMessageMethodInfo
instance (signature ~ (m (Gst.Message.Message)), MonadIO m) => O.OverloadedMethod EventParseSinkMessageMethodInfo Event signature where
overloadedMethod = eventParseSinkMessage
instance O.OverloadedMethodInfo EventParseSinkMessageMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseSinkMessage",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseSinkMessage"
})
#endif
foreign import ccall "gst_event_parse_step" gst_event_parse_step ::
Ptr Event ->
Ptr CUInt ->
Ptr Word64 ->
Ptr CDouble ->
Ptr CInt ->
Ptr CInt ->
IO ()
eventParseStep ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Gst.Enums.Format, Word64, Double, Bool, Bool))
eventParseStep :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Format, Word64, Double, Bool, Bool)
eventParseStep Event
event = IO (Format, Word64, Double, Bool, Bool)
-> m (Format, Word64, Double, Bool, Bool)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Format, Word64, Double, Bool, Bool)
-> m (Format, Word64, Double, Bool, Bool))
-> IO (Format, Word64, Double, Bool, Bool)
-> m (Format, Word64, Double, Bool, Bool)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
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 Event
-> Ptr CUInt
-> Ptr Word64
-> Ptr CDouble
-> Ptr CInt
-> Ptr CInt
-> IO ()
gst_event_parse_step Ptr Event
event' Ptr CUInt
format Ptr Word64
amount Ptr CDouble
rate Ptr CInt
flush Ptr CInt
intermediate
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'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
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
(Format, Word64, Double, Bool, Bool)
-> IO (Format, Word64, Double, Bool, Bool)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Format
format'', Word64
amount', Double
rate'', Bool
flush'', Bool
intermediate'')
#if defined(ENABLE_OVERLOADING)
data EventParseStepMethodInfo
instance (signature ~ (m ((Gst.Enums.Format, Word64, Double, Bool, Bool))), MonadIO m) => O.OverloadedMethod EventParseStepMethodInfo Event signature where
overloadedMethod = eventParseStep
instance O.OverloadedMethodInfo EventParseStepMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseStep",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseStep"
})
#endif
foreign import ccall "gst_event_parse_stream" gst_event_parse_stream ::
Ptr Event ->
Ptr (Ptr Gst.Stream.Stream) ->
IO ()
eventParseStream ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (Gst.Stream.Stream)
eventParseStream :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Stream
eventParseStream Event
event = IO Stream -> m Stream
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Stream -> m Stream) -> IO Stream -> m Stream
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr (Ptr Stream)
stream <- IO (Ptr (Ptr Stream))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Stream.Stream))
Ptr Event -> Ptr (Ptr Stream) -> IO ()
gst_event_parse_stream Ptr Event
event' Ptr (Ptr Stream)
stream
Ptr Stream
stream' <- Ptr (Ptr Stream) -> IO (Ptr Stream)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Stream)
stream
Stream
stream'' <- ((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
stream'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr (Ptr Stream) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Stream)
stream
Stream -> IO Stream
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Stream
stream''
#if defined(ENABLE_OVERLOADING)
data EventParseStreamMethodInfo
instance (signature ~ (m (Gst.Stream.Stream)), MonadIO m) => O.OverloadedMethod EventParseStreamMethodInfo Event signature where
overloadedMethod = eventParseStream
instance O.OverloadedMethodInfo EventParseStreamMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseStream",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseStream"
})
#endif
foreign import ccall "gst_event_parse_stream_collection" gst_event_parse_stream_collection ::
Ptr Event ->
Ptr (Ptr Gst.StreamCollection.StreamCollection) ->
IO ()
eventParseStreamCollection ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (Gst.StreamCollection.StreamCollection)
eventParseStreamCollection :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m StreamCollection
eventParseStreamCollection Event
event = IO StreamCollection -> m StreamCollection
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr (Ptr StreamCollection)
collection <- IO (Ptr (Ptr StreamCollection))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.StreamCollection.StreamCollection))
Ptr Event -> Ptr (Ptr StreamCollection) -> IO ()
gst_event_parse_stream_collection Ptr Event
event' 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'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr (Ptr StreamCollection) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr StreamCollection)
collection
StreamCollection -> IO StreamCollection
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return StreamCollection
collection''
#if defined(ENABLE_OVERLOADING)
data EventParseStreamCollectionMethodInfo
instance (signature ~ (m (Gst.StreamCollection.StreamCollection)), MonadIO m) => O.OverloadedMethod EventParseStreamCollectionMethodInfo Event signature where
overloadedMethod = eventParseStreamCollection
instance O.OverloadedMethodInfo EventParseStreamCollectionMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseStreamCollection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseStreamCollection"
})
#endif
foreign import ccall "gst_event_parse_stream_flags" gst_event_parse_stream_flags ::
Ptr Event ->
Ptr CUInt ->
IO ()
eventParseStreamFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ([Gst.Flags.StreamFlags])
eventParseStreamFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m [StreamFlags]
eventParseStreamFlags Event
event = IO [StreamFlags] -> m [StreamFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [StreamFlags] -> m [StreamFlags])
-> IO [StreamFlags] -> m [StreamFlags]
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CUInt
flags <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
Ptr Event -> Ptr CUInt -> IO ()
gst_event_parse_stream_flags Ptr Event
event' Ptr CUInt
flags
CUInt
flags' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
flags
let flags'' :: [StreamFlags]
flags'' = CUInt -> [StreamFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
flags'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
flags
[StreamFlags] -> IO [StreamFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [StreamFlags]
flags''
#if defined(ENABLE_OVERLOADING)
data EventParseStreamFlagsMethodInfo
instance (signature ~ (m ([Gst.Flags.StreamFlags])), MonadIO m) => O.OverloadedMethod EventParseStreamFlagsMethodInfo Event signature where
overloadedMethod = eventParseStreamFlags
instance O.OverloadedMethodInfo EventParseStreamFlagsMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseStreamFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseStreamFlags"
})
#endif
foreign import ccall "gst_event_parse_stream_group_done" gst_event_parse_stream_group_done ::
Ptr Event ->
Ptr Word32 ->
IO ()
eventParseStreamGroupDone ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (Word32)
eventParseStreamGroupDone :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Word32
eventParseStreamGroupDone Event
event = IO Word32 -> m Word32
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Word32
groupId <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
Ptr Event -> Ptr Word32 -> IO ()
gst_event_parse_stream_group_done Ptr Event
event' Ptr Word32
groupId
Word32
groupId' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
groupId
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
groupId
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
groupId'
#if defined(ENABLE_OVERLOADING)
data EventParseStreamGroupDoneMethodInfo
instance (signature ~ (m (Word32)), MonadIO m) => O.OverloadedMethod EventParseStreamGroupDoneMethodInfo Event signature where
overloadedMethod = eventParseStreamGroupDone
instance O.OverloadedMethodInfo EventParseStreamGroupDoneMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseStreamGroupDone",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseStreamGroupDone"
})
#endif
foreign import ccall "gst_event_parse_stream_start" gst_event_parse_stream_start ::
Ptr Event ->
Ptr CString ->
IO ()
eventParseStreamStart ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (T.Text)
eventParseStreamStart :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Text
eventParseStreamStart Event
event = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CString
streamId <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr Event -> Ptr CString -> IO ()
gst_event_parse_stream_start Ptr Event
event' Ptr CString
streamId
CString
streamId' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
streamId
Text
streamId'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
streamId'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
streamId
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
streamId''
#if defined(ENABLE_OVERLOADING)
data EventParseStreamStartMethodInfo
instance (signature ~ (m (T.Text)), MonadIO m) => O.OverloadedMethod EventParseStreamStartMethodInfo Event signature where
overloadedMethod = eventParseStreamStart
instance O.OverloadedMethodInfo EventParseStreamStartMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseStreamStart",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseStreamStart"
})
#endif
foreign import ccall "gst_event_parse_tag" gst_event_parse_tag ::
Ptr Event ->
Ptr (Ptr Gst.TagList.TagList) ->
IO ()
eventParseTag ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (Gst.TagList.TagList)
eventParseTag :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m TagList
eventParseTag Event
event = IO TagList -> m TagList
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr (Ptr TagList)
taglist <- IO (Ptr (Ptr TagList))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.TagList.TagList))
Ptr Event -> Ptr (Ptr TagList) -> IO ()
gst_event_parse_tag Ptr Event
event' 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
newBoxed ManagedPtr TagList -> TagList
Gst.TagList.TagList) Ptr TagList
taglist'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr (Ptr TagList) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr TagList)
taglist
TagList -> IO TagList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TagList
taglist''
#if defined(ENABLE_OVERLOADING)
data EventParseTagMethodInfo
instance (signature ~ (m (Gst.TagList.TagList)), MonadIO m) => O.OverloadedMethod EventParseTagMethodInfo Event signature where
overloadedMethod = eventParseTag
instance O.OverloadedMethodInfo EventParseTagMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseTag",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseTag"
})
#endif
foreign import ccall "gst_event_parse_toc" gst_event_parse_toc ::
Ptr Event ->
Ptr (Ptr Gst.Toc.Toc) ->
Ptr CInt ->
IO ()
eventParseToc ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m ((Gst.Toc.Toc, Bool))
eventParseToc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m (Toc, Bool)
eventParseToc Event
event = IO (Toc, Bool) -> m (Toc, Bool)
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
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 Event -> Ptr (Ptr Toc) -> Ptr CInt -> IO ()
gst_event_parse_toc Ptr Event
event' 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'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Toc
toc'', Bool
updated'')
#if defined(ENABLE_OVERLOADING)
data EventParseTocMethodInfo
instance (signature ~ (m ((Gst.Toc.Toc, Bool))), MonadIO m) => O.OverloadedMethod EventParseTocMethodInfo Event signature where
overloadedMethod = eventParseToc
instance O.OverloadedMethodInfo EventParseTocMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseToc",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseToc"
})
#endif
foreign import ccall "gst_event_parse_toc_select" gst_event_parse_toc_select ::
Ptr Event ->
Ptr CString ->
IO ()
eventParseTocSelect ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m (T.Text)
eventParseTocSelect :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Event -> m Text
eventParseTocSelect Event
event = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CString
uid <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr Event -> Ptr CString -> IO ()
gst_event_parse_toc_select Ptr Event
event' Ptr CString
uid
CString
uid' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
uid
Text
uid'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
uid'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uid'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
uid
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
uid''
#if defined(ENABLE_OVERLOADING)
data EventParseTocSelectMethodInfo
instance (signature ~ (m (T.Text)), MonadIO m) => O.OverloadedMethod EventParseTocSelectMethodInfo Event signature where
overloadedMethod = eventParseTocSelect
instance O.OverloadedMethodInfo EventParseTocSelectMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventParseTocSelect",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventParseTocSelect"
})
#endif
foreign import ccall "gst_event_set_gap_flags" gst_event_set_gap_flags ::
Ptr Event ->
CUInt ->
IO ()
eventSetGapFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> [Gst.Flags.GapFlags]
-> m ()
eventSetGapFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> [GapFlags] -> m ()
eventSetGapFlags Event
event [GapFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
let flags' :: CUInt
flags' = [GapFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [GapFlags]
flags
Ptr Event -> CUInt -> IO ()
gst_event_set_gap_flags Ptr Event
event' CUInt
flags'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetGapFlagsMethodInfo
instance (signature ~ ([Gst.Flags.GapFlags] -> m ()), MonadIO m) => O.OverloadedMethod EventSetGapFlagsMethodInfo Event signature where
overloadedMethod = eventSetGapFlags
instance O.OverloadedMethodInfo EventSetGapFlagsMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventSetGapFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventSetGapFlags"
})
#endif
foreign import ccall "gst_event_set_group_id" gst_event_set_group_id ::
Ptr Event ->
Word32 ->
IO ()
eventSetGroupId ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Word32
-> m ()
eventSetGroupId :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Word32 -> m ()
eventSetGroupId Event
event Word32
groupId = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Event -> Word32 -> IO ()
gst_event_set_group_id Ptr Event
event' Word32
groupId
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetGroupIdMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod EventSetGroupIdMethodInfo Event signature where
overloadedMethod = eventSetGroupId
instance O.OverloadedMethodInfo EventSetGroupIdMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventSetGroupId",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventSetGroupId"
})
#endif
foreign import ccall "gst_event_set_running_time_offset" gst_event_set_running_time_offset ::
Ptr Event ->
Int64 ->
IO ()
eventSetRunningTimeOffset ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Int64
-> m ()
eventSetRunningTimeOffset :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Int64 -> m ()
eventSetRunningTimeOffset Event
event Int64
offset = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Event -> Int64 -> IO ()
gst_event_set_running_time_offset Ptr Event
event' Int64
offset
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetRunningTimeOffsetMethodInfo
instance (signature ~ (Int64 -> m ()), MonadIO m) => O.OverloadedMethod EventSetRunningTimeOffsetMethodInfo Event signature where
overloadedMethod = eventSetRunningTimeOffset
instance O.OverloadedMethodInfo EventSetRunningTimeOffsetMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventSetRunningTimeOffset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventSetRunningTimeOffset"
})
#endif
foreign import ccall "gst_event_set_seek_trickmode_interval" gst_event_set_seek_trickmode_interval ::
Ptr Event ->
Word64 ->
IO ()
eventSetSeekTrickmodeInterval ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Word64
-> m ()
eventSetSeekTrickmodeInterval :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Word64 -> m ()
eventSetSeekTrickmodeInterval Event
event Word64
interval = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Event -> Word64 -> IO ()
gst_event_set_seek_trickmode_interval Ptr Event
event' Word64
interval
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetSeekTrickmodeIntervalMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m) => O.OverloadedMethod EventSetSeekTrickmodeIntervalMethodInfo Event signature where
overloadedMethod = eventSetSeekTrickmodeInterval
instance O.OverloadedMethodInfo EventSetSeekTrickmodeIntervalMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventSetSeekTrickmodeInterval",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventSetSeekTrickmodeInterval"
})
#endif
foreign import ccall "gst_event_set_seqnum" gst_event_set_seqnum ::
Ptr Event ->
Word32 ->
IO ()
eventSetSeqnum ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> Word32
-> m ()
eventSetSeqnum :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> Word32 -> m ()
eventSetSeqnum Event
event Word32
seqnum = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Event -> Word32 -> IO ()
gst_event_set_seqnum Ptr Event
event' Word32
seqnum
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetSeqnumMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod EventSetSeqnumMethodInfo Event signature where
overloadedMethod = eventSetSeqnum
instance O.OverloadedMethodInfo EventSetSeqnumMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventSetSeqnum",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventSetSeqnum"
})
#endif
foreign import ccall "gst_event_set_stream" gst_event_set_stream ::
Ptr Event ->
Ptr Gst.Stream.Stream ->
IO ()
eventSetStream ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Stream.IsStream a) =>
Event
-> a
-> m ()
eventSetStream :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStream a) =>
Event -> a -> m ()
eventSetStream Event
event a
stream = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Stream
stream' <- a -> IO (Ptr Stream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Event -> Ptr Stream -> IO ()
gst_event_set_stream Ptr Event
event' Ptr Stream
stream'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetStreamMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, Gst.Stream.IsStream a) => O.OverloadedMethod EventSetStreamMethodInfo Event signature where
overloadedMethod = eventSetStream
instance O.OverloadedMethodInfo EventSetStreamMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventSetStream",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventSetStream"
})
#endif
foreign import ccall "gst_event_set_stream_flags" gst_event_set_stream_flags ::
Ptr Event ->
CUInt ->
IO ()
eventSetStreamFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> [Gst.Flags.StreamFlags]
-> m ()
eventSetStreamFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> [StreamFlags] -> m ()
eventSetStreamFlags Event
event [StreamFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
let flags' :: CUInt
flags' = [StreamFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [StreamFlags]
flags
Ptr Event -> CUInt -> IO ()
gst_event_set_stream_flags Ptr Event
event' CUInt
flags'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EventSetStreamFlagsMethodInfo
instance (signature ~ ([Gst.Flags.StreamFlags] -> m ()), MonadIO m) => O.OverloadedMethod EventSetStreamFlagsMethodInfo Event signature where
overloadedMethod = eventSetStreamFlags
instance O.OverloadedMethodInfo EventSetStreamFlagsMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventSetStreamFlags",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventSetStreamFlags"
})
#endif
foreign import ccall "gst_event_writable_structure" gst_event_writable_structure ::
Ptr Event ->
IO (Ptr Gst.Structure.Structure)
eventWritableStructure ::
(B.CallStack.HasCallStack, MonadIO m) =>
Event
-> m Gst.Structure.Structure
eventWritableStructure :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Event -> m Structure
eventWritableStructure Event
event = IO Structure -> m Structure
forall a. IO a -> m a
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 Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Structure
result <- Ptr Event -> IO (Ptr Structure)
gst_event_writable_structure Ptr Event
event'
Text -> Ptr Structure -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"eventWritableStructure" 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
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Structure -> IO Structure
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Structure
result'
#if defined(ENABLE_OVERLOADING)
data EventWritableStructureMethodInfo
instance (signature ~ (m Gst.Structure.Structure), MonadIO m) => O.OverloadedMethod EventWritableStructureMethodInfo Event signature where
overloadedMethod = eventWritableStructure
instance O.OverloadedMethodInfo EventWritableStructureMethodInfo Event where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Event.eventWritableStructure",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Event.html#v:eventWritableStructure"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveEventMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveEventMethod "copySegment" o = EventCopySegmentMethodInfo
ResolveEventMethod "hasName" o = EventHasNameMethodInfo
ResolveEventMethod "hasNameId" o = EventHasNameIdMethodInfo
ResolveEventMethod "parseBufferSize" o = EventParseBufferSizeMethodInfo
ResolveEventMethod "parseCaps" o = EventParseCapsMethodInfo
ResolveEventMethod "parseFlushStop" o = EventParseFlushStopMethodInfo
ResolveEventMethod "parseGap" o = EventParseGapMethodInfo
ResolveEventMethod "parseGapFlags" o = EventParseGapFlagsMethodInfo
ResolveEventMethod "parseGroupId" o = EventParseGroupIdMethodInfo
ResolveEventMethod "parseInstantRateChange" o = EventParseInstantRateChangeMethodInfo
ResolveEventMethod "parseInstantRateSyncTime" o = EventParseInstantRateSyncTimeMethodInfo
ResolveEventMethod "parseLatency" o = EventParseLatencyMethodInfo
ResolveEventMethod "parseProtection" o = EventParseProtectionMethodInfo
ResolveEventMethod "parseQos" o = EventParseQosMethodInfo
ResolveEventMethod "parseSeek" o = EventParseSeekMethodInfo
ResolveEventMethod "parseSeekTrickmodeInterval" o = EventParseSeekTrickmodeIntervalMethodInfo
ResolveEventMethod "parseSegment" o = EventParseSegmentMethodInfo
ResolveEventMethod "parseSegmentDone" o = EventParseSegmentDoneMethodInfo
ResolveEventMethod "parseSelectStreams" o = EventParseSelectStreamsMethodInfo
ResolveEventMethod "parseSinkMessage" o = EventParseSinkMessageMethodInfo
ResolveEventMethod "parseStep" o = EventParseStepMethodInfo
ResolveEventMethod "parseStream" o = EventParseStreamMethodInfo
ResolveEventMethod "parseStreamCollection" o = EventParseStreamCollectionMethodInfo
ResolveEventMethod "parseStreamFlags" o = EventParseStreamFlagsMethodInfo
ResolveEventMethod "parseStreamGroupDone" o = EventParseStreamGroupDoneMethodInfo
ResolveEventMethod "parseStreamStart" o = EventParseStreamStartMethodInfo
ResolveEventMethod "parseTag" o = EventParseTagMethodInfo
ResolveEventMethod "parseToc" o = EventParseTocMethodInfo
ResolveEventMethod "parseTocSelect" o = EventParseTocSelectMethodInfo
ResolveEventMethod "writableStructure" o = EventWritableStructureMethodInfo
ResolveEventMethod "getRunningTimeOffset" o = EventGetRunningTimeOffsetMethodInfo
ResolveEventMethod "getSeqnum" o = EventGetSeqnumMethodInfo
ResolveEventMethod "getStructure" o = EventGetStructureMethodInfo
ResolveEventMethod "setGapFlags" o = EventSetGapFlagsMethodInfo
ResolveEventMethod "setGroupId" o = EventSetGroupIdMethodInfo
ResolveEventMethod "setRunningTimeOffset" o = EventSetRunningTimeOffsetMethodInfo
ResolveEventMethod "setSeekTrickmodeInterval" o = EventSetSeekTrickmodeIntervalMethodInfo
ResolveEventMethod "setSeqnum" o = EventSetSeqnumMethodInfo
ResolveEventMethod "setStream" o = EventSetStreamMethodInfo
ResolveEventMethod "setStreamFlags" o = EventSetStreamFlagsMethodInfo
ResolveEventMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveEventMethod t Event, O.OverloadedMethod info Event p) => OL.IsLabel t (Event -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveEventMethod t Event, O.OverloadedMethod info Event p, R.HasField t Event p) => R.HasField t Event p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveEventMethod t Event, O.OverloadedMethodInfo info Event) => OL.IsLabel t (O.MethodProxy info Event) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif