{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.Segment
(
Segment(..) ,
newZeroSegment ,
#if defined(ENABLE_OVERLOADING)
ResolveSegmentMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
SegmentClipMethodInfo ,
#endif
segmentClip ,
#if defined(ENABLE_OVERLOADING)
SegmentCopyMethodInfo ,
#endif
segmentCopy ,
#if defined(ENABLE_OVERLOADING)
SegmentCopyIntoMethodInfo ,
#endif
segmentCopyInto ,
#if defined(ENABLE_OVERLOADING)
SegmentDoSeekMethodInfo ,
#endif
segmentDoSeek ,
#if defined(ENABLE_OVERLOADING)
SegmentFreeMethodInfo ,
#endif
segmentFree ,
#if defined(ENABLE_OVERLOADING)
SegmentInitMethodInfo ,
#endif
segmentInit ,
#if defined(ENABLE_OVERLOADING)
SegmentIsEqualMethodInfo ,
#endif
segmentIsEqual ,
segmentNew ,
#if defined(ENABLE_OVERLOADING)
SegmentOffsetRunningTimeMethodInfo ,
#endif
segmentOffsetRunningTime ,
#if defined(ENABLE_OVERLOADING)
SegmentPositionFromRunningTimeMethodInfo,
#endif
segmentPositionFromRunningTime ,
#if defined(ENABLE_OVERLOADING)
SegmentPositionFromRunningTimeFullMethodInfo,
#endif
segmentPositionFromRunningTimeFull ,
#if defined(ENABLE_OVERLOADING)
SegmentPositionFromStreamTimeMethodInfo ,
#endif
segmentPositionFromStreamTime ,
#if defined(ENABLE_OVERLOADING)
SegmentPositionFromStreamTimeFullMethodInfo,
#endif
segmentPositionFromStreamTimeFull ,
#if defined(ENABLE_OVERLOADING)
SegmentSetRunningTimeMethodInfo ,
#endif
segmentSetRunningTime ,
#if defined(ENABLE_OVERLOADING)
SegmentToPositionMethodInfo ,
#endif
segmentToPosition ,
#if defined(ENABLE_OVERLOADING)
SegmentToRunningTimeMethodInfo ,
#endif
segmentToRunningTime ,
#if defined(ENABLE_OVERLOADING)
SegmentToRunningTimeFullMethodInfo ,
#endif
segmentToRunningTimeFull ,
#if defined(ENABLE_OVERLOADING)
SegmentToStreamTimeMethodInfo ,
#endif
segmentToStreamTime ,
#if defined(ENABLE_OVERLOADING)
SegmentToStreamTimeFullMethodInfo ,
#endif
segmentToStreamTimeFull ,
getSegmentAppliedRate ,
#if defined(ENABLE_OVERLOADING)
segment_appliedRate ,
#endif
setSegmentAppliedRate ,
getSegmentBase ,
#if defined(ENABLE_OVERLOADING)
segment_base ,
#endif
setSegmentBase ,
getSegmentDuration ,
#if defined(ENABLE_OVERLOADING)
segment_duration ,
#endif
setSegmentDuration ,
getSegmentFlags ,
#if defined(ENABLE_OVERLOADING)
segment_flags ,
#endif
setSegmentFlags ,
getSegmentFormat ,
#if defined(ENABLE_OVERLOADING)
segment_format ,
#endif
setSegmentFormat ,
getSegmentOffset ,
#if defined(ENABLE_OVERLOADING)
segment_offset ,
#endif
setSegmentOffset ,
getSegmentPosition ,
#if defined(ENABLE_OVERLOADING)
segment_position ,
#endif
setSegmentPosition ,
getSegmentRate ,
#if defined(ENABLE_OVERLOADING)
segment_rate ,
#endif
setSegmentRate ,
getSegmentStart ,
#if defined(ENABLE_OVERLOADING)
segment_start ,
#endif
setSegmentStart ,
getSegmentStop ,
#if defined(ENABLE_OVERLOADING)
segment_stop ,
#endif
setSegmentStop ,
getSegmentTime ,
#if defined(ENABLE_OVERLOADING)
segment_time ,
#endif
setSegmentTime ,
) 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.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
newtype Segment = Segment (SP.ManagedPtr Segment)
deriving (Segment -> Segment -> Bool
(Segment -> Segment -> Bool)
-> (Segment -> Segment -> Bool) -> Eq Segment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Segment -> Segment -> Bool
$c/= :: Segment -> Segment -> Bool
== :: Segment -> Segment -> Bool
$c== :: Segment -> Segment -> Bool
Eq)
instance SP.ManagedPtrNewtype Segment where
toManagedPtr :: Segment -> ManagedPtr Segment
toManagedPtr (Segment ManagedPtr Segment
p) = ManagedPtr Segment
p
foreign import ccall "gst_segment_get_type" c_gst_segment_get_type ::
IO GType
type instance O.ParentTypes Segment = '[]
instance O.HasParentTypes Segment
instance B.Types.TypedObject Segment where
glibType :: IO GType
glibType = IO GType
c_gst_segment_get_type
instance B.Types.GBoxed Segment
instance B.GValue.IsGValue (Maybe Segment) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_segment_get_type
gvalueSet_ :: Ptr GValue -> Maybe Segment -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Segment
P.Nothing = Ptr GValue -> Ptr Segment -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Segment
forall a. Ptr a
FP.nullPtr :: FP.Ptr Segment)
gvalueSet_ Ptr GValue
gv (P.Just Segment
obj) = Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Segment
obj (Ptr GValue -> Ptr Segment -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Segment)
gvalueGet_ Ptr GValue
gv = do
Ptr Segment
ptr <- Ptr GValue -> IO (Ptr Segment)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Segment)
if Ptr Segment
ptr Ptr Segment -> Ptr Segment -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Segment
forall a. Ptr a
FP.nullPtr
then Segment -> Maybe Segment
forall a. a -> Maybe a
P.Just (Segment -> Maybe Segment) -> IO Segment -> IO (Maybe Segment)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Segment -> Segment) -> Ptr Segment -> IO Segment
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Segment -> Segment
Segment Ptr Segment
ptr
else Maybe Segment -> IO (Maybe Segment)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Segment
forall a. Maybe a
P.Nothing
newZeroSegment :: MonadIO m => m Segment
newZeroSegment :: forall (m :: * -> *). MonadIO m => m Segment
newZeroSegment = IO Segment -> m Segment
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
$ Int -> IO (Ptr Segment)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
120 IO (Ptr Segment) -> (Ptr Segment -> IO Segment) -> IO Segment
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Segment -> Segment) -> Ptr Segment -> IO Segment
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Segment -> Segment
Segment
instance tag ~ 'AttrSet => Constructible Segment tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Segment -> Segment)
-> [AttrOp Segment tag] -> m Segment
new ManagedPtr Segment -> Segment
_ [AttrOp Segment tag]
attrs = do
Segment
o <- m Segment
forall (m :: * -> *). MonadIO m => m Segment
newZeroSegment
Segment -> [AttrOp Segment 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Segment
o [AttrOp Segment tag]
[AttrOp Segment 'AttrSet]
attrs
Segment -> m Segment
forall (m :: * -> *) a. Monad m => a -> m a
return Segment
o
getSegmentFlags :: MonadIO m => Segment -> m [Gst.Flags.SegmentFlags]
getSegmentFlags :: forall (m :: * -> *). MonadIO m => Segment -> m [SegmentFlags]
getSegmentFlags Segment
s = IO [SegmentFlags] -> m [SegmentFlags]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [SegmentFlags] -> m [SegmentFlags])
-> IO [SegmentFlags] -> m [SegmentFlags]
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO [SegmentFlags]) -> IO [SegmentFlags]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO [SegmentFlags]) -> IO [SegmentFlags])
-> (Ptr Segment -> IO [SegmentFlags]) -> IO [SegmentFlags]
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr Segment
ptr Ptr Segment -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CUInt
let val' :: [SegmentFlags]
val' = CUInt -> [SegmentFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
[SegmentFlags] -> IO [SegmentFlags]
forall (m :: * -> *) a. Monad m => a -> m a
return [SegmentFlags]
val'
setSegmentFlags :: MonadIO m => Segment -> [Gst.Flags.SegmentFlags] -> m ()
setSegmentFlags :: forall (m :: * -> *).
MonadIO m =>
Segment -> [SegmentFlags] -> m ()
setSegmentFlags Segment
s [SegmentFlags]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
let val' :: CUInt
val' = [SegmentFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [SegmentFlags]
val
Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Segment
ptr Ptr Segment -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data SegmentFlagsFieldInfo
instance AttrInfo SegmentFlagsFieldInfo where
type AttrBaseTypeConstraint SegmentFlagsFieldInfo = (~) Segment
type AttrAllowedOps SegmentFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SegmentFlagsFieldInfo = (~) [Gst.Flags.SegmentFlags]
type AttrTransferTypeConstraint SegmentFlagsFieldInfo = (~)[Gst.Flags.SegmentFlags]
type AttrTransferType SegmentFlagsFieldInfo = [Gst.Flags.SegmentFlags]
type AttrGetType SegmentFlagsFieldInfo = [Gst.Flags.SegmentFlags]
type AttrLabel SegmentFlagsFieldInfo = "flags"
type AttrOrigin SegmentFlagsFieldInfo = Segment
attrGet = getSegmentFlags
attrSet = setSegmentFlags
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.flags"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#g:attr:flags"
})
segment_flags :: AttrLabelProxy "flags"
segment_flags = AttrLabelProxy
#endif
getSegmentRate :: MonadIO m => Segment -> m Double
getSegmentRate :: forall (m :: * -> *). MonadIO m => Segment -> m Double
getSegmentRate Segment
s = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO Double) -> IO Double)
-> (Ptr Segment -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr Segment
ptr Ptr Segment -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CDouble
let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'
setSegmentRate :: MonadIO m => Segment -> Double -> m ()
setSegmentRate :: forall (m :: * -> *). MonadIO m => Segment -> Double -> m ()
setSegmentRate Segment
s Double
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
let val' :: CDouble
val' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
Ptr CDouble -> CDouble -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Segment
ptr Ptr Segment -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CDouble
val' :: CDouble)
#if defined(ENABLE_OVERLOADING)
data SegmentRateFieldInfo
instance AttrInfo SegmentRateFieldInfo where
type AttrBaseTypeConstraint SegmentRateFieldInfo = (~) Segment
type AttrAllowedOps SegmentRateFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SegmentRateFieldInfo = (~) Double
type AttrTransferTypeConstraint SegmentRateFieldInfo = (~)Double
type AttrTransferType SegmentRateFieldInfo = Double
type AttrGetType SegmentRateFieldInfo = Double
type AttrLabel SegmentRateFieldInfo = "rate"
type AttrOrigin SegmentRateFieldInfo = Segment
attrGet = getSegmentRate
attrSet = setSegmentRate
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.rate"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#g:attr:rate"
})
segment_rate :: AttrLabelProxy "rate"
segment_rate = AttrLabelProxy
#endif
getSegmentAppliedRate :: MonadIO m => Segment -> m Double
getSegmentAppliedRate :: forall (m :: * -> *). MonadIO m => Segment -> m Double
getSegmentAppliedRate Segment
s = IO Double -> m Double
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO Double) -> IO Double)
-> (Ptr Segment -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr Segment
ptr Ptr Segment -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CDouble
let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
Double -> IO Double
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'
setSegmentAppliedRate :: MonadIO m => Segment -> Double -> m ()
setSegmentAppliedRate :: forall (m :: * -> *). MonadIO m => Segment -> Double -> m ()
setSegmentAppliedRate Segment
s Double
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
let val' :: CDouble
val' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
Ptr CDouble -> CDouble -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Segment
ptr Ptr Segment -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CDouble
val' :: CDouble)
#if defined(ENABLE_OVERLOADING)
data SegmentAppliedRateFieldInfo
instance AttrInfo SegmentAppliedRateFieldInfo where
type AttrBaseTypeConstraint SegmentAppliedRateFieldInfo = (~) Segment
type AttrAllowedOps SegmentAppliedRateFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SegmentAppliedRateFieldInfo = (~) Double
type AttrTransferTypeConstraint SegmentAppliedRateFieldInfo = (~)Double
type AttrTransferType SegmentAppliedRateFieldInfo = Double
type AttrGetType SegmentAppliedRateFieldInfo = Double
type AttrLabel SegmentAppliedRateFieldInfo = "applied_rate"
type AttrOrigin SegmentAppliedRateFieldInfo = Segment
attrGet = getSegmentAppliedRate
attrSet = setSegmentAppliedRate
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.appliedRate"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#g:attr:appliedRate"
})
segment_appliedRate :: AttrLabelProxy "appliedRate"
segment_appliedRate = AttrLabelProxy
#endif
getSegmentFormat :: MonadIO m => Segment -> m Gst.Enums.Format
getSegmentFormat :: forall (m :: * -> *). MonadIO m => Segment -> m Format
getSegmentFormat Segment
s = IO Format -> m Format
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Format -> m Format) -> IO Format -> m Format
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO Format) -> IO Format
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO Format) -> IO Format)
-> (Ptr Segment -> IO Format) -> IO Format
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr Segment
ptr Ptr Segment -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CUInt
let val' :: Format
val' = (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
val
Format -> IO Format
forall (m :: * -> *) a. Monad m => a -> m a
return Format
val'
setSegmentFormat :: MonadIO m => Segment -> Gst.Enums.Format -> m ()
setSegmentFormat :: forall (m :: * -> *). MonadIO m => Segment -> Format -> m ()
setSegmentFormat Segment
s Format
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
let val' :: CUInt
val' = (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
val
Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Segment
ptr Ptr Segment -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data SegmentFormatFieldInfo
instance AttrInfo SegmentFormatFieldInfo where
type AttrBaseTypeConstraint SegmentFormatFieldInfo = (~) Segment
type AttrAllowedOps SegmentFormatFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SegmentFormatFieldInfo = (~) Gst.Enums.Format
type AttrTransferTypeConstraint SegmentFormatFieldInfo = (~)Gst.Enums.Format
type AttrTransferType SegmentFormatFieldInfo = Gst.Enums.Format
type AttrGetType SegmentFormatFieldInfo = Gst.Enums.Format
type AttrLabel SegmentFormatFieldInfo = "format"
type AttrOrigin SegmentFormatFieldInfo = Segment
attrGet = getSegmentFormat
attrSet = setSegmentFormat
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.format"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#g:attr:format"
})
segment_format :: AttrLabelProxy "format"
segment_format = AttrLabelProxy
#endif
getSegmentBase :: MonadIO m => Segment -> m Word64
getSegmentBase :: forall (m :: * -> *). MonadIO m => Segment -> m Word64
getSegmentBase Segment
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO Word64) -> IO Word64)
-> (Ptr Segment -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentBase :: MonadIO m => Segment -> Word64 -> m ()
setSegmentBase :: forall (m :: * -> *). MonadIO m => Segment -> Word64 -> m ()
setSegmentBase Segment
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data SegmentBaseFieldInfo
instance AttrInfo SegmentBaseFieldInfo where
type AttrBaseTypeConstraint SegmentBaseFieldInfo = (~) Segment
type AttrAllowedOps SegmentBaseFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SegmentBaseFieldInfo = (~) Word64
type AttrTransferTypeConstraint SegmentBaseFieldInfo = (~)Word64
type AttrTransferType SegmentBaseFieldInfo = Word64
type AttrGetType SegmentBaseFieldInfo = Word64
type AttrLabel SegmentBaseFieldInfo = "base"
type AttrOrigin SegmentBaseFieldInfo = Segment
attrGet = getSegmentBase
attrSet = setSegmentBase
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.base"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#g:attr:base"
})
segment_base :: AttrLabelProxy "base"
segment_base = AttrLabelProxy
#endif
getSegmentOffset :: MonadIO m => Segment -> m Word64
getSegmentOffset :: forall (m :: * -> *). MonadIO m => Segment -> m Word64
getSegmentOffset Segment
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO Word64) -> IO Word64)
-> (Ptr Segment -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentOffset :: MonadIO m => Segment -> Word64 -> m ()
setSegmentOffset :: forall (m :: * -> *). MonadIO m => Segment -> Word64 -> m ()
setSegmentOffset Segment
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data SegmentOffsetFieldInfo
instance AttrInfo SegmentOffsetFieldInfo where
type AttrBaseTypeConstraint SegmentOffsetFieldInfo = (~) Segment
type AttrAllowedOps SegmentOffsetFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SegmentOffsetFieldInfo = (~) Word64
type AttrTransferTypeConstraint SegmentOffsetFieldInfo = (~)Word64
type AttrTransferType SegmentOffsetFieldInfo = Word64
type AttrGetType SegmentOffsetFieldInfo = Word64
type AttrLabel SegmentOffsetFieldInfo = "offset"
type AttrOrigin SegmentOffsetFieldInfo = Segment
attrGet = getSegmentOffset
attrSet = setSegmentOffset
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.offset"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#g:attr:offset"
})
segment_offset :: AttrLabelProxy "offset"
segment_offset = AttrLabelProxy
#endif
getSegmentStart :: MonadIO m => Segment -> m Word64
getSegmentStart :: forall (m :: * -> *). MonadIO m => Segment -> m Word64
getSegmentStart Segment
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO Word64) -> IO Word64)
-> (Ptr Segment -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentStart :: MonadIO m => Segment -> Word64 -> m ()
setSegmentStart :: forall (m :: * -> *). MonadIO m => Segment -> Word64 -> m ()
setSegmentStart Segment
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data SegmentStartFieldInfo
instance AttrInfo SegmentStartFieldInfo where
type AttrBaseTypeConstraint SegmentStartFieldInfo = (~) Segment
type AttrAllowedOps SegmentStartFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SegmentStartFieldInfo = (~) Word64
type AttrTransferTypeConstraint SegmentStartFieldInfo = (~)Word64
type AttrTransferType SegmentStartFieldInfo = Word64
type AttrGetType SegmentStartFieldInfo = Word64
type AttrLabel SegmentStartFieldInfo = "start"
type AttrOrigin SegmentStartFieldInfo = Segment
attrGet = getSegmentStart
attrSet = setSegmentStart
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.start"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#g:attr:start"
})
segment_start :: AttrLabelProxy "start"
segment_start = AttrLabelProxy
#endif
getSegmentStop :: MonadIO m => Segment -> m Word64
getSegmentStop :: forall (m :: * -> *). MonadIO m => Segment -> m Word64
getSegmentStop Segment
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO Word64) -> IO Word64)
-> (Ptr Segment -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentStop :: MonadIO m => Segment -> Word64 -> m ()
setSegmentStop :: forall (m :: * -> *). MonadIO m => Segment -> Word64 -> m ()
setSegmentStop Segment
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data SegmentStopFieldInfo
instance AttrInfo SegmentStopFieldInfo where
type AttrBaseTypeConstraint SegmentStopFieldInfo = (~) Segment
type AttrAllowedOps SegmentStopFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SegmentStopFieldInfo = (~) Word64
type AttrTransferTypeConstraint SegmentStopFieldInfo = (~)Word64
type AttrTransferType SegmentStopFieldInfo = Word64
type AttrGetType SegmentStopFieldInfo = Word64
type AttrLabel SegmentStopFieldInfo = "stop"
type AttrOrigin SegmentStopFieldInfo = Segment
attrGet = getSegmentStop
attrSet = setSegmentStop
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.stop"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#g:attr:stop"
})
segment_stop :: AttrLabelProxy "stop"
segment_stop = AttrLabelProxy
#endif
getSegmentTime :: MonadIO m => Segment -> m Word64
getSegmentTime :: forall (m :: * -> *). MonadIO m => Segment -> m Word64
getSegmentTime Segment
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO Word64) -> IO Word64)
-> (Ptr Segment -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentTime :: MonadIO m => Segment -> Word64 -> m ()
setSegmentTime :: forall (m :: * -> *). MonadIO m => Segment -> Word64 -> m ()
setSegmentTime Segment
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data SegmentTimeFieldInfo
instance AttrInfo SegmentTimeFieldInfo where
type AttrBaseTypeConstraint SegmentTimeFieldInfo = (~) Segment
type AttrAllowedOps SegmentTimeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SegmentTimeFieldInfo = (~) Word64
type AttrTransferTypeConstraint SegmentTimeFieldInfo = (~)Word64
type AttrTransferType SegmentTimeFieldInfo = Word64
type AttrGetType SegmentTimeFieldInfo = Word64
type AttrLabel SegmentTimeFieldInfo = "time"
type AttrOrigin SegmentTimeFieldInfo = Segment
attrGet = getSegmentTime
attrSet = setSegmentTime
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.time"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#g:attr:time"
})
segment_time :: AttrLabelProxy "time"
segment_time = AttrLabelProxy
#endif
getSegmentPosition :: MonadIO m => Segment -> m Word64
getSegmentPosition :: forall (m :: * -> *). MonadIO m => Segment -> m Word64
getSegmentPosition Segment
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO Word64) -> IO Word64)
-> (Ptr Segment -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentPosition :: MonadIO m => Segment -> Word64 -> m ()
setSegmentPosition :: forall (m :: * -> *). MonadIO m => Segment -> Word64 -> m ()
setSegmentPosition Segment
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data SegmentPositionFieldInfo
instance AttrInfo SegmentPositionFieldInfo where
type AttrBaseTypeConstraint SegmentPositionFieldInfo = (~) Segment
type AttrAllowedOps SegmentPositionFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SegmentPositionFieldInfo = (~) Word64
type AttrTransferTypeConstraint SegmentPositionFieldInfo = (~)Word64
type AttrTransferType SegmentPositionFieldInfo = Word64
type AttrGetType SegmentPositionFieldInfo = Word64
type AttrLabel SegmentPositionFieldInfo = "position"
type AttrOrigin SegmentPositionFieldInfo = Segment
attrGet = getSegmentPosition
attrSet = setSegmentPosition
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.position"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#g:attr:position"
})
segment_position :: AttrLabelProxy "position"
segment_position = AttrLabelProxy
#endif
getSegmentDuration :: MonadIO m => Segment -> m Word64
getSegmentDuration :: forall (m :: * -> *). MonadIO m => Segment -> m Word64
getSegmentDuration Segment
s = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO Word64) -> IO Word64)
-> (Ptr Segment -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentDuration :: MonadIO m => Segment -> Word64 -> m ()
setSegmentDuration :: forall (m :: * -> *). MonadIO m => Segment -> Word64 -> m ()
setSegmentDuration Segment
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Segment -> (Ptr Segment -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Segment
s ((Ptr Segment -> IO ()) -> IO ())
-> (Ptr Segment -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Segment
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Segment
ptr Ptr Segment -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data SegmentDurationFieldInfo
instance AttrInfo SegmentDurationFieldInfo where
type AttrBaseTypeConstraint SegmentDurationFieldInfo = (~) Segment
type AttrAllowedOps SegmentDurationFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SegmentDurationFieldInfo = (~) Word64
type AttrTransferTypeConstraint SegmentDurationFieldInfo = (~)Word64
type AttrTransferType SegmentDurationFieldInfo = Word64
type AttrGetType SegmentDurationFieldInfo = Word64
type AttrLabel SegmentDurationFieldInfo = "duration"
type AttrOrigin SegmentDurationFieldInfo = Segment
attrGet = getSegmentDuration
attrSet = setSegmentDuration
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.duration"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#g:attr:duration"
})
segment_duration :: AttrLabelProxy "duration"
segment_duration = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Segment
type instance O.AttributeList Segment = SegmentAttributeList
type SegmentAttributeList = ('[ '("flags", SegmentFlagsFieldInfo), '("rate", SegmentRateFieldInfo), '("appliedRate", SegmentAppliedRateFieldInfo), '("format", SegmentFormatFieldInfo), '("base", SegmentBaseFieldInfo), '("offset", SegmentOffsetFieldInfo), '("start", SegmentStartFieldInfo), '("stop", SegmentStopFieldInfo), '("time", SegmentTimeFieldInfo), '("position", SegmentPositionFieldInfo), '("duration", SegmentDurationFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_segment_new" gst_segment_new ::
IO (Ptr Segment)
segmentNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Segment
segmentNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Segment
segmentNew = IO Segment -> m Segment
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 Segment
result <- IO (Ptr Segment)
gst_segment_new
Text -> Ptr Segment -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"segmentNew" Ptr Segment
result
Segment
result' <- ((ManagedPtr Segment -> Segment) -> Ptr Segment -> IO Segment
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Segment -> Segment
Segment) Ptr Segment
result
Segment -> IO Segment
forall (m :: * -> *) a. Monad m => a -> m a
return Segment
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_segment_clip" gst_segment_clip ::
Ptr Segment ->
CUInt ->
Word64 ->
Word64 ->
Ptr Word64 ->
Ptr Word64 ->
IO CInt
segmentClip ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Gst.Enums.Format
-> Word64
-> Word64
-> m ((Bool, Word64, Word64))
segmentClip :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Format -> Word64 -> Word64 -> m (Bool, Word64, Word64)
segmentClip Segment
segment Format
format Word64
start Word64
stop = IO (Bool, Word64, Word64) -> m (Bool, Word64, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word64, Word64) -> m (Bool, Word64, Word64))
-> IO (Bool, Word64, Word64) -> m (Bool, Word64, Word64)
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
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 Word64
clipStart <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Word64
clipStop <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
CInt
result <- Ptr Segment
-> CUInt -> Word64 -> Word64 -> Ptr Word64 -> Ptr Word64 -> IO CInt
gst_segment_clip Ptr Segment
segment' CUInt
format' Word64
start Word64
stop Ptr Word64
clipStart Ptr Word64
clipStop
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Word64
clipStart' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
clipStart
Word64
clipStop' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
clipStop
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
clipStart
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
clipStop
(Bool, Word64, Word64) -> IO (Bool, Word64, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word64
clipStart', Word64
clipStop')
#if defined(ENABLE_OVERLOADING)
data SegmentClipMethodInfo
instance (signature ~ (Gst.Enums.Format -> Word64 -> Word64 -> m ((Bool, Word64, Word64))), MonadIO m) => O.OverloadedMethod SegmentClipMethodInfo Segment signature where
overloadedMethod = segmentClip
instance O.OverloadedMethodInfo SegmentClipMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentClip",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentClip"
})
#endif
foreign import ccall "gst_segment_copy" gst_segment_copy ::
Ptr Segment ->
IO (Ptr Segment)
segmentCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> m Segment
segmentCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> m Segment
segmentCopy Segment
segment = IO Segment -> m Segment
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 Segment
segment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
segment
Ptr Segment
result <- Ptr Segment -> IO (Ptr Segment)
gst_segment_copy Ptr Segment
segment'
Text -> Ptr Segment -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"segmentCopy" Ptr Segment
result
Segment
result' <- ((ManagedPtr Segment -> Segment) -> Ptr Segment -> IO Segment
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Segment -> Segment
Segment) Ptr Segment
result
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Segment -> IO Segment
forall (m :: * -> *) a. Monad m => a -> m a
return Segment
result'
#if defined(ENABLE_OVERLOADING)
data SegmentCopyMethodInfo
instance (signature ~ (m Segment), MonadIO m) => O.OverloadedMethod SegmentCopyMethodInfo Segment signature where
overloadedMethod = segmentCopy
instance O.OverloadedMethodInfo SegmentCopyMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentCopy"
})
#endif
foreign import ccall "gst_segment_copy_into" gst_segment_copy_into ::
Ptr Segment ->
Ptr Segment ->
IO ()
segmentCopyInto ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Segment
-> m ()
segmentCopyInto :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Segment -> m ()
segmentCopyInto Segment
src Segment
dest = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Segment
src' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
src
Ptr Segment
dest' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
dest
Ptr Segment -> Ptr Segment -> IO ()
gst_segment_copy_into Ptr Segment
src' Ptr Segment
dest'
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
src
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
dest
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SegmentCopyIntoMethodInfo
instance (signature ~ (Segment -> m ()), MonadIO m) => O.OverloadedMethod SegmentCopyIntoMethodInfo Segment signature where
overloadedMethod = segmentCopyInto
instance O.OverloadedMethodInfo SegmentCopyIntoMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentCopyInto",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentCopyInto"
})
#endif
foreign import ccall "gst_segment_do_seek" gst_segment_do_seek ::
Ptr Segment ->
CDouble ->
CUInt ->
CUInt ->
CUInt ->
Word64 ->
CUInt ->
Word64 ->
Ptr CInt ->
IO CInt
segmentDoSeek ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Double
-> Gst.Enums.Format
-> [Gst.Flags.SeekFlags]
-> Gst.Enums.SeekType
-> Word64
-> Gst.Enums.SeekType
-> Word64
-> m ((Bool, Bool))
segmentDoSeek :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment
-> Double
-> Format
-> [SeekFlags]
-> SeekType
-> Word64
-> SeekType
-> Word64
-> m (Bool, Bool)
segmentDoSeek Segment
segment Double
rate Format
format [SeekFlags]
flags SeekType
startType Word64
start SeekType
stopType Word64
stop = IO (Bool, Bool) -> m (Bool, Bool)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Bool) -> m (Bool, Bool))
-> IO (Bool, Bool) -> m (Bool, Bool)
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
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 CInt
update <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
CInt
result <- Ptr Segment
-> CDouble
-> CUInt
-> CUInt
-> CUInt
-> Word64
-> CUInt
-> Word64
-> Ptr CInt
-> IO CInt
gst_segment_do_seek Ptr Segment
segment' CDouble
rate' CUInt
format' CUInt
flags' CUInt
startType' Word64
start CUInt
stopType' Word64
stop Ptr CInt
update
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CInt
update' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
update
let update'' :: Bool
update'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
update'
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
update
(Bool, Bool) -> IO (Bool, Bool)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Bool
update'')
#if defined(ENABLE_OVERLOADING)
data SegmentDoSeekMethodInfo
instance (signature ~ (Double -> Gst.Enums.Format -> [Gst.Flags.SeekFlags] -> Gst.Enums.SeekType -> Word64 -> Gst.Enums.SeekType -> Word64 -> m ((Bool, Bool))), MonadIO m) => O.OverloadedMethod SegmentDoSeekMethodInfo Segment signature where
overloadedMethod = segmentDoSeek
instance O.OverloadedMethodInfo SegmentDoSeekMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentDoSeek",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentDoSeek"
})
#endif
foreign import ccall "gst_segment_free" gst_segment_free ::
Ptr Segment ->
IO ()
segmentFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> m ()
segmentFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Segment -> m ()
segmentFree Segment
segment = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Segment
segment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Segment
segment
Ptr Segment -> IO ()
gst_segment_free Ptr Segment
segment'
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SegmentFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SegmentFreeMethodInfo Segment signature where
overloadedMethod = segmentFree
instance O.OverloadedMethodInfo SegmentFreeMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentFree"
})
#endif
foreign import ccall "gst_segment_init" gst_segment_init ::
Ptr Segment ->
CUInt ->
IO ()
segmentInit ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Gst.Enums.Format
-> m ()
segmentInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Format -> m ()
segmentInit Segment
segment Format
format = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Segment
segment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
segment
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 Segment -> CUInt -> IO ()
gst_segment_init Ptr Segment
segment' CUInt
format'
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SegmentInitMethodInfo
instance (signature ~ (Gst.Enums.Format -> m ()), MonadIO m) => O.OverloadedMethod SegmentInitMethodInfo Segment signature where
overloadedMethod = segmentInit
instance O.OverloadedMethodInfo SegmentInitMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentInit",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentInit"
})
#endif
foreign import ccall "gst_segment_is_equal" gst_segment_is_equal ::
Ptr Segment ->
Ptr Segment ->
IO CInt
segmentIsEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Segment
-> m Bool
segmentIsEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Segment -> m Bool
segmentIsEqual Segment
s0 Segment
s1 = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Segment
s0' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
s0
Ptr Segment
s1' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
s1
CInt
result <- Ptr Segment -> Ptr Segment -> IO CInt
gst_segment_is_equal Ptr Segment
s0' Ptr Segment
s1'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
s0
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
s1
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data SegmentIsEqualMethodInfo
instance (signature ~ (Segment -> m Bool), MonadIO m) => O.OverloadedMethod SegmentIsEqualMethodInfo Segment signature where
overloadedMethod = segmentIsEqual
instance O.OverloadedMethodInfo SegmentIsEqualMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentIsEqual",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentIsEqual"
})
#endif
foreign import ccall "gst_segment_offset_running_time" gst_segment_offset_running_time ::
Ptr Segment ->
CUInt ->
Int64 ->
IO CInt
segmentOffsetRunningTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Gst.Enums.Format
-> Int64
-> m Bool
segmentOffsetRunningTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Format -> Int64 -> m Bool
segmentOffsetRunningTime Segment
segment Format
format Int64
offset = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Segment
segment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
segment
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
CInt
result <- Ptr Segment -> CUInt -> Int64 -> IO CInt
gst_segment_offset_running_time Ptr Segment
segment' CUInt
format' Int64
offset
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data SegmentOffsetRunningTimeMethodInfo
instance (signature ~ (Gst.Enums.Format -> Int64 -> m Bool), MonadIO m) => O.OverloadedMethod SegmentOffsetRunningTimeMethodInfo Segment signature where
overloadedMethod = segmentOffsetRunningTime
instance O.OverloadedMethodInfo SegmentOffsetRunningTimeMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentOffsetRunningTime",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentOffsetRunningTime"
})
#endif
foreign import ccall "gst_segment_position_from_running_time" gst_segment_position_from_running_time ::
Ptr Segment ->
CUInt ->
Word64 ->
IO Word64
segmentPositionFromRunningTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Gst.Enums.Format
-> Word64
-> m Word64
segmentPositionFromRunningTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Format -> Word64 -> m Word64
segmentPositionFromRunningTime Segment
segment Format
format Word64
runningTime = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr Segment
segment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
segment
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
Word64
result <- Ptr Segment -> CUInt -> Word64 -> IO Word64
gst_segment_position_from_running_time Ptr Segment
segment' CUInt
format' Word64
runningTime
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data SegmentPositionFromRunningTimeMethodInfo
instance (signature ~ (Gst.Enums.Format -> Word64 -> m Word64), MonadIO m) => O.OverloadedMethod SegmentPositionFromRunningTimeMethodInfo Segment signature where
overloadedMethod = segmentPositionFromRunningTime
instance O.OverloadedMethodInfo SegmentPositionFromRunningTimeMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentPositionFromRunningTime",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentPositionFromRunningTime"
})
#endif
foreign import ccall "gst_segment_position_from_running_time_full" gst_segment_position_from_running_time_full ::
Ptr Segment ->
CUInt ->
Word64 ->
Ptr Word64 ->
IO Int32
segmentPositionFromRunningTimeFull ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Gst.Enums.Format
-> Word64
-> m ((Int32, Word64))
segmentPositionFromRunningTimeFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Format -> Word64 -> m (Int32, Word64)
segmentPositionFromRunningTimeFull Segment
segment Format
format Word64
runningTime = IO (Int32, Word64) -> m (Int32, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Word64) -> m (Int32, Word64))
-> IO (Int32, Word64) -> m (Int32, Word64)
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
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 Word64
position <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Int32
result <- Ptr Segment -> CUInt -> Word64 -> Ptr Word64 -> IO Int32
gst_segment_position_from_running_time_full Ptr Segment
segment' CUInt
format' Word64
runningTime Ptr Word64
position
Word64
position' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
position
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
position
(Int32, Word64) -> IO (Int32, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
result, Word64
position')
#if defined(ENABLE_OVERLOADING)
data SegmentPositionFromRunningTimeFullMethodInfo
instance (signature ~ (Gst.Enums.Format -> Word64 -> m ((Int32, Word64))), MonadIO m) => O.OverloadedMethod SegmentPositionFromRunningTimeFullMethodInfo Segment signature where
overloadedMethod = segmentPositionFromRunningTimeFull
instance O.OverloadedMethodInfo SegmentPositionFromRunningTimeFullMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentPositionFromRunningTimeFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentPositionFromRunningTimeFull"
})
#endif
foreign import ccall "gst_segment_position_from_stream_time" gst_segment_position_from_stream_time ::
Ptr Segment ->
CUInt ->
Word64 ->
IO Word64
segmentPositionFromStreamTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Gst.Enums.Format
-> Word64
-> m Word64
segmentPositionFromStreamTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Format -> Word64 -> m Word64
segmentPositionFromStreamTime Segment
segment Format
format Word64
streamTime = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr Segment
segment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
segment
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
Word64
result <- Ptr Segment -> CUInt -> Word64 -> IO Word64
gst_segment_position_from_stream_time Ptr Segment
segment' CUInt
format' Word64
streamTime
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data SegmentPositionFromStreamTimeMethodInfo
instance (signature ~ (Gst.Enums.Format -> Word64 -> m Word64), MonadIO m) => O.OverloadedMethod SegmentPositionFromStreamTimeMethodInfo Segment signature where
overloadedMethod = segmentPositionFromStreamTime
instance O.OverloadedMethodInfo SegmentPositionFromStreamTimeMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentPositionFromStreamTime",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentPositionFromStreamTime"
})
#endif
foreign import ccall "gst_segment_position_from_stream_time_full" gst_segment_position_from_stream_time_full ::
Ptr Segment ->
CUInt ->
Word64 ->
Ptr Word64 ->
IO Int32
segmentPositionFromStreamTimeFull ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Gst.Enums.Format
-> Word64
-> m ((Int32, Word64))
segmentPositionFromStreamTimeFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Format -> Word64 -> m (Int32, Word64)
segmentPositionFromStreamTimeFull Segment
segment Format
format Word64
streamTime = IO (Int32, Word64) -> m (Int32, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Word64) -> m (Int32, Word64))
-> IO (Int32, Word64) -> m (Int32, Word64)
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
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 Word64
position <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Int32
result <- Ptr Segment -> CUInt -> Word64 -> Ptr Word64 -> IO Int32
gst_segment_position_from_stream_time_full Ptr Segment
segment' CUInt
format' Word64
streamTime Ptr Word64
position
Word64
position' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
position
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
position
(Int32, Word64) -> IO (Int32, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
result, Word64
position')
#if defined(ENABLE_OVERLOADING)
data SegmentPositionFromStreamTimeFullMethodInfo
instance (signature ~ (Gst.Enums.Format -> Word64 -> m ((Int32, Word64))), MonadIO m) => O.OverloadedMethod SegmentPositionFromStreamTimeFullMethodInfo Segment signature where
overloadedMethod = segmentPositionFromStreamTimeFull
instance O.OverloadedMethodInfo SegmentPositionFromStreamTimeFullMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentPositionFromStreamTimeFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentPositionFromStreamTimeFull"
})
#endif
foreign import ccall "gst_segment_set_running_time" gst_segment_set_running_time ::
Ptr Segment ->
CUInt ->
Word64 ->
IO CInt
segmentSetRunningTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Gst.Enums.Format
-> Word64
-> m Bool
segmentSetRunningTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Format -> Word64 -> m Bool
segmentSetRunningTime Segment
segment Format
format Word64
runningTime = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Segment
segment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
segment
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
CInt
result <- Ptr Segment -> CUInt -> Word64 -> IO CInt
gst_segment_set_running_time Ptr Segment
segment' CUInt
format' Word64
runningTime
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data SegmentSetRunningTimeMethodInfo
instance (signature ~ (Gst.Enums.Format -> Word64 -> m Bool), MonadIO m) => O.OverloadedMethod SegmentSetRunningTimeMethodInfo Segment signature where
overloadedMethod = segmentSetRunningTime
instance O.OverloadedMethodInfo SegmentSetRunningTimeMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentSetRunningTime",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentSetRunningTime"
})
#endif
foreign import ccall "gst_segment_to_position" gst_segment_to_position ::
Ptr Segment ->
CUInt ->
Word64 ->
IO Word64
{-# DEPRECATED segmentToPosition ["Use 'GI.Gst.Structs.Segment.segmentPositionFromRunningTime' instead."] #-}
segmentToPosition ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Gst.Enums.Format
-> Word64
-> m Word64
segmentToPosition :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Format -> Word64 -> m Word64
segmentToPosition Segment
segment Format
format Word64
runningTime = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr Segment
segment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
segment
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
Word64
result <- Ptr Segment -> CUInt -> Word64 -> IO Word64
gst_segment_to_position Ptr Segment
segment' CUInt
format' Word64
runningTime
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data SegmentToPositionMethodInfo
instance (signature ~ (Gst.Enums.Format -> Word64 -> m Word64), MonadIO m) => O.OverloadedMethod SegmentToPositionMethodInfo Segment signature where
overloadedMethod = segmentToPosition
instance O.OverloadedMethodInfo SegmentToPositionMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentToPosition",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentToPosition"
})
#endif
foreign import ccall "gst_segment_to_running_time" gst_segment_to_running_time ::
Ptr Segment ->
CUInt ->
Word64 ->
IO Word64
segmentToRunningTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Gst.Enums.Format
-> Word64
-> m Word64
segmentToRunningTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Format -> Word64 -> m Word64
segmentToRunningTime Segment
segment Format
format Word64
position = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr Segment
segment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
segment
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
Word64
result <- Ptr Segment -> CUInt -> Word64 -> IO Word64
gst_segment_to_running_time Ptr Segment
segment' CUInt
format' Word64
position
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data SegmentToRunningTimeMethodInfo
instance (signature ~ (Gst.Enums.Format -> Word64 -> m Word64), MonadIO m) => O.OverloadedMethod SegmentToRunningTimeMethodInfo Segment signature where
overloadedMethod = segmentToRunningTime
instance O.OverloadedMethodInfo SegmentToRunningTimeMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentToRunningTime",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentToRunningTime"
})
#endif
foreign import ccall "gst_segment_to_running_time_full" gst_segment_to_running_time_full ::
Ptr Segment ->
CUInt ->
Word64 ->
Ptr Word64 ->
IO Int32
segmentToRunningTimeFull ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Gst.Enums.Format
-> Word64
-> m ((Int32, Word64))
segmentToRunningTimeFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Format -> Word64 -> m (Int32, Word64)
segmentToRunningTimeFull Segment
segment Format
format Word64
position = IO (Int32, Word64) -> m (Int32, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Word64) -> m (Int32, Word64))
-> IO (Int32, Word64) -> m (Int32, Word64)
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
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 Word64
runningTime <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Int32
result <- Ptr Segment -> CUInt -> Word64 -> Ptr Word64 -> IO Int32
gst_segment_to_running_time_full Ptr Segment
segment' CUInt
format' Word64
position Ptr Word64
runningTime
Word64
runningTime' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
runningTime
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
runningTime
(Int32, Word64) -> IO (Int32, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
result, Word64
runningTime')
#if defined(ENABLE_OVERLOADING)
data SegmentToRunningTimeFullMethodInfo
instance (signature ~ (Gst.Enums.Format -> Word64 -> m ((Int32, Word64))), MonadIO m) => O.OverloadedMethod SegmentToRunningTimeFullMethodInfo Segment signature where
overloadedMethod = segmentToRunningTimeFull
instance O.OverloadedMethodInfo SegmentToRunningTimeFullMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentToRunningTimeFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentToRunningTimeFull"
})
#endif
foreign import ccall "gst_segment_to_stream_time" gst_segment_to_stream_time ::
Ptr Segment ->
CUInt ->
Word64 ->
IO Word64
segmentToStreamTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Gst.Enums.Format
-> Word64
-> m Word64
segmentToStreamTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Format -> Word64 -> m Word64
segmentToStreamTime Segment
segment Format
format Word64
position = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
Ptr Segment
segment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
segment
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
Word64
result <- Ptr Segment -> CUInt -> Word64 -> IO Word64
gst_segment_to_stream_time Ptr Segment
segment' CUInt
format' Word64
position
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data SegmentToStreamTimeMethodInfo
instance (signature ~ (Gst.Enums.Format -> Word64 -> m Word64), MonadIO m) => O.OverloadedMethod SegmentToStreamTimeMethodInfo Segment signature where
overloadedMethod = segmentToStreamTime
instance O.OverloadedMethodInfo SegmentToStreamTimeMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentToStreamTime",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentToStreamTime"
})
#endif
foreign import ccall "gst_segment_to_stream_time_full" gst_segment_to_stream_time_full ::
Ptr Segment ->
CUInt ->
Word64 ->
Ptr Word64 ->
IO Int32
segmentToStreamTimeFull ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> Gst.Enums.Format
-> Word64
-> m ((Int32, Word64))
segmentToStreamTimeFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Segment -> Format -> Word64 -> m (Int32, Word64)
segmentToStreamTimeFull Segment
segment Format
format Word64
position = IO (Int32, Word64) -> m (Int32, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Word64) -> m (Int32, Word64))
-> IO (Int32, Word64) -> m (Int32, Word64)
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
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 Word64
streamTime <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Int32
result <- Ptr Segment -> CUInt -> Word64 -> Ptr Word64 -> IO Int32
gst_segment_to_stream_time_full Ptr Segment
segment' CUInt
format' Word64
position Ptr Word64
streamTime
Word64
streamTime' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
streamTime
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
streamTime
(Int32, Word64) -> IO (Int32, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
result, Word64
streamTime')
#if defined(ENABLE_OVERLOADING)
data SegmentToStreamTimeFullMethodInfo
instance (signature ~ (Gst.Enums.Format -> Word64 -> m ((Int32, Word64))), MonadIO m) => O.OverloadedMethod SegmentToStreamTimeFullMethodInfo Segment signature where
overloadedMethod = segmentToStreamTimeFull
instance O.OverloadedMethodInfo SegmentToStreamTimeFullMethodInfo Segment where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Segment.segmentToStreamTimeFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-Segment.html#v:segmentToStreamTimeFull"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveSegmentMethod (t :: Symbol) (o :: *) :: * where
ResolveSegmentMethod "clip" o = SegmentClipMethodInfo
ResolveSegmentMethod "copy" o = SegmentCopyMethodInfo
ResolveSegmentMethod "copyInto" o = SegmentCopyIntoMethodInfo
ResolveSegmentMethod "doSeek" o = SegmentDoSeekMethodInfo
ResolveSegmentMethod "free" o = SegmentFreeMethodInfo
ResolveSegmentMethod "init" o = SegmentInitMethodInfo
ResolveSegmentMethod "isEqual" o = SegmentIsEqualMethodInfo
ResolveSegmentMethod "offsetRunningTime" o = SegmentOffsetRunningTimeMethodInfo
ResolveSegmentMethod "positionFromRunningTime" o = SegmentPositionFromRunningTimeMethodInfo
ResolveSegmentMethod "positionFromRunningTimeFull" o = SegmentPositionFromRunningTimeFullMethodInfo
ResolveSegmentMethod "positionFromStreamTime" o = SegmentPositionFromStreamTimeMethodInfo
ResolveSegmentMethod "positionFromStreamTimeFull" o = SegmentPositionFromStreamTimeFullMethodInfo
ResolveSegmentMethod "toPosition" o = SegmentToPositionMethodInfo
ResolveSegmentMethod "toRunningTime" o = SegmentToRunningTimeMethodInfo
ResolveSegmentMethod "toRunningTimeFull" o = SegmentToRunningTimeFullMethodInfo
ResolveSegmentMethod "toStreamTime" o = SegmentToStreamTimeMethodInfo
ResolveSegmentMethod "toStreamTimeFull" o = SegmentToStreamTimeFullMethodInfo
ResolveSegmentMethod "setRunningTime" o = SegmentSetRunningTimeMethodInfo
ResolveSegmentMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveSegmentMethod t Segment, O.OverloadedMethod info Segment p) => OL.IsLabel t (Segment -> 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 ~ ResolveSegmentMethod t Segment, O.OverloadedMethod info Segment p, R.HasField t Segment p) => R.HasField t Segment p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveSegmentMethod t Segment, O.OverloadedMethodInfo info Segment) => OL.IsLabel t (O.MethodProxy info Segment) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif