{-# 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 ,
noSegment ,
#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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
newtype Segment = Segment (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)
foreign import ccall "gst_segment_get_type" c_gst_segment_get_type ::
IO GType
instance BoxedObject Segment where
boxedType :: Segment -> IO GType
boxedType _ = IO GType
c_gst_segment_get_type
instance B.GValue.IsGValue Segment where
toGValue :: Segment -> IO GValue
toGValue o :: Segment
o = do
GType
gtype <- IO GType
c_gst_segment_get_type
Segment -> (Ptr Segment -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Segment
o (GType
-> (GValue -> Ptr Segment -> IO ()) -> Ptr Segment -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Segment -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO Segment
fromGValue gv :: GValue
gv = do
Ptr Segment
ptr <- GValue -> IO (Ptr Segment)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr Segment)
(ManagedPtr Segment -> Segment) -> Ptr Segment -> IO Segment
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Segment -> Segment
Segment Ptr Segment
ptr
newZeroSegment :: MonadIO m => m Segment
newZeroSegment :: 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. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 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, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Segment -> Segment
Segment
instance tag ~ 'AttrSet => Constructible Segment tag where
new :: (ManagedPtr Segment -> Segment)
-> [AttrOp Segment tag] -> m Segment
new _ attrs :: [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
noSegment :: Maybe Segment
noSegment :: Maybe Segment
noSegment = Maybe Segment
forall a. Maybe a
Nothing
getSegmentFlags :: MonadIO m => Segment -> m [Gst.Flags.SegmentFlags]
getSegmentFlags :: Segment -> m [SegmentFlags]
getSegmentFlags s :: 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 :: 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` 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 :: Segment -> [SegmentFlags] -> m ()
setSegmentFlags s :: Segment
s val :: [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 :: 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` 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
segment_flags :: AttrLabelProxy "flags"
segment_flags = AttrLabelProxy
#endif
getSegmentRate :: MonadIO m => Segment -> m Double
getSegmentRate :: Segment -> m Double
getSegmentRate s :: 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 :: 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` 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 :: Segment -> Double -> m ()
setSegmentRate s :: Segment
s val :: 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 :: 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` 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
segment_rate :: AttrLabelProxy "rate"
segment_rate = AttrLabelProxy
#endif
getSegmentAppliedRate :: MonadIO m => Segment -> m Double
getSegmentAppliedRate :: Segment -> m Double
getSegmentAppliedRate s :: 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 :: 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` 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 :: Segment -> Double -> m ()
setSegmentAppliedRate s :: Segment
s val :: 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 :: 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` 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
segment_appliedRate :: AttrLabelProxy "appliedRate"
segment_appliedRate = AttrLabelProxy
#endif
getSegmentFormat :: MonadIO m => Segment -> m Gst.Enums.Format
getSegmentFormat :: Segment -> m Format
getSegmentFormat s :: 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 :: 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` 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 :: Segment -> Format -> m ()
setSegmentFormat s :: Segment
s val :: 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 :: 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` 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
segment_format :: AttrLabelProxy "format"
segment_format = AttrLabelProxy
#endif
getSegmentBase :: MonadIO m => Segment -> m Word64
getSegmentBase :: Segment -> m Word64
getSegmentBase s :: 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 :: 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` 32) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentBase :: MonadIO m => Segment -> Word64 -> m ()
setSegmentBase :: Segment -> Word64 -> m ()
setSegmentBase s :: Segment
s val :: 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 :: 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` 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
segment_base :: AttrLabelProxy "base"
segment_base = AttrLabelProxy
#endif
getSegmentOffset :: MonadIO m => Segment -> m Word64
getSegmentOffset :: Segment -> m Word64
getSegmentOffset s :: 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 :: 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` 40) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentOffset :: MonadIO m => Segment -> Word64 -> m ()
setSegmentOffset :: Segment -> Word64 -> m ()
setSegmentOffset s :: Segment
s val :: 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 :: 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` 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
segment_offset :: AttrLabelProxy "offset"
segment_offset = AttrLabelProxy
#endif
getSegmentStart :: MonadIO m => Segment -> m Word64
getSegmentStart :: Segment -> m Word64
getSegmentStart s :: 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 :: 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` 48) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentStart :: MonadIO m => Segment -> Word64 -> m ()
setSegmentStart :: Segment -> Word64 -> m ()
setSegmentStart s :: Segment
s val :: 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 :: 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` 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
segment_start :: AttrLabelProxy "start"
segment_start = AttrLabelProxy
#endif
getSegmentStop :: MonadIO m => Segment -> m Word64
getSegmentStop :: Segment -> m Word64
getSegmentStop s :: 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 :: 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` 56) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentStop :: MonadIO m => Segment -> Word64 -> m ()
setSegmentStop :: Segment -> Word64 -> m ()
setSegmentStop s :: Segment
s val :: 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 :: 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` 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
segment_stop :: AttrLabelProxy "stop"
segment_stop = AttrLabelProxy
#endif
getSegmentTime :: MonadIO m => Segment -> m Word64
getSegmentTime :: Segment -> m Word64
getSegmentTime s :: 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 :: 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` 64) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentTime :: MonadIO m => Segment -> Word64 -> m ()
setSegmentTime :: Segment -> Word64 -> m ()
setSegmentTime s :: Segment
s val :: 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 :: 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` 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
segment_time :: AttrLabelProxy "time"
segment_time = AttrLabelProxy
#endif
getSegmentPosition :: MonadIO m => Segment -> m Word64
getSegmentPosition :: Segment -> m Word64
getSegmentPosition s :: 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 :: 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` 72) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentPosition :: MonadIO m => Segment -> Word64 -> m ()
setSegmentPosition :: Segment -> Word64 -> m ()
setSegmentPosition s :: Segment
s val :: 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 :: 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` 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
segment_position :: AttrLabelProxy "position"
segment_position = AttrLabelProxy
#endif
getSegmentDuration :: MonadIO m => Segment -> m Word64
getSegmentDuration :: Segment -> m Word64
getSegmentDuration s :: 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 :: 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` 80) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setSegmentDuration :: MonadIO m => Segment -> Word64 -> m ()
setSegmentDuration :: Segment -> Word64 -> m ()
setSegmentDuration s :: Segment
s val :: 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 :: 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` 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
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 :: 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 "segmentNew" Ptr Segment
result
Segment
result' <- ((ManagedPtr Segment -> Segment) -> Ptr Segment -> IO Segment
forall a.
(HasCallStack, BoxedObject 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 :: Segment -> Format -> Word64 -> Word64 -> m (Bool, Word64, Word64)
segmentClip segment :: Segment
segment format :: Format
format start :: Word64
start stop :: 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
/= 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.MethodInfo SegmentClipMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> m Segment
segmentCopy segment :: 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 "segmentCopy" Ptr Segment
result
Segment
result' <- ((ManagedPtr Segment -> Segment) -> Ptr Segment -> IO Segment
forall a.
(HasCallStack, BoxedObject 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.MethodInfo SegmentCopyMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Segment -> m ()
segmentCopyInto src :: Segment
src dest :: 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.MethodInfo SegmentCopyIntoMethodInfo Segment signature where
overloadedMethod = 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 :: Segment
-> Double
-> Format
-> [SeekFlags]
-> SeekType
-> Word64
-> SeekType
-> Word64
-> m (Bool, Bool)
segmentDoSeek segment :: Segment
segment rate :: Double
rate format :: Format
format flags :: [SeekFlags]
flags startType :: SeekType
startType start :: Word64
start stopType :: SeekType
stopType stop :: 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
/= 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
/= 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.MethodInfo SegmentDoSeekMethodInfo Segment signature where
overloadedMethod = segmentDoSeek
#endif
foreign import ccall "gst_segment_free" gst_segment_free ::
Ptr Segment ->
IO ()
segmentFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
Segment
-> m ()
segmentFree :: Segment -> m ()
segmentFree segment :: 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, BoxedObject 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.MethodInfo SegmentFreeMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Format -> m ()
segmentInit segment :: Segment
segment format :: 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.MethodInfo SegmentInitMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Segment -> m Bool
segmentIsEqual s0 :: Segment
s0 s1 :: 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
/= 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.MethodInfo SegmentIsEqualMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Format -> Int64 -> m Bool
segmentOffsetRunningTime segment :: Segment
segment format :: Format
format offset :: 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
/= 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.MethodInfo SegmentOffsetRunningTimeMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Format -> Word64 -> m Word64
segmentPositionFromRunningTime segment :: Segment
segment format :: Format
format runningTime :: 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.MethodInfo SegmentPositionFromRunningTimeMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Format -> Word64 -> m (Int32, Word64)
segmentPositionFromRunningTimeFull segment :: Segment
segment format :: Format
format runningTime :: 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.MethodInfo SegmentPositionFromRunningTimeFullMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Format -> Word64 -> m Word64
segmentPositionFromStreamTime segment :: Segment
segment format :: Format
format streamTime :: 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.MethodInfo SegmentPositionFromStreamTimeMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Format -> Word64 -> m (Int32, Word64)
segmentPositionFromStreamTimeFull segment :: Segment
segment format :: Format
format streamTime :: 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.MethodInfo SegmentPositionFromStreamTimeFullMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Format -> Word64 -> m Bool
segmentSetRunningTime segment :: Segment
segment format :: Format
format runningTime :: 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
/= 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.MethodInfo SegmentSetRunningTimeMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Format -> Word64 -> m Word64
segmentToPosition segment :: Segment
segment format :: Format
format runningTime :: 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.MethodInfo SegmentToPositionMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Format -> Word64 -> m Word64
segmentToRunningTime segment :: Segment
segment format :: Format
format position :: 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.MethodInfo SegmentToRunningTimeMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Format -> Word64 -> m (Int32, Word64)
segmentToRunningTimeFull segment :: Segment
segment format :: Format
format position :: 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.MethodInfo SegmentToRunningTimeFullMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Format -> Word64 -> m Word64
segmentToStreamTime segment :: Segment
segment format :: Format
format position :: 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.MethodInfo SegmentToStreamTimeMethodInfo Segment signature where
overloadedMethod = 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 :: Segment -> Format -> Word64 -> m (Int32, Word64)
segmentToStreamTimeFull segment :: Segment
segment format :: Format
format position :: 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.MethodInfo SegmentToStreamTimeFullMethodInfo Segment signature where
overloadedMethod = 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.MethodInfo 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
#endif