{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.Sample
(
Sample(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveSampleMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
SampleGetBufferMethodInfo ,
#endif
sampleGetBuffer ,
#if defined(ENABLE_OVERLOADING)
SampleGetBufferListMethodInfo ,
#endif
sampleGetBufferList ,
#if defined(ENABLE_OVERLOADING)
SampleGetCapsMethodInfo ,
#endif
sampleGetCaps ,
#if defined(ENABLE_OVERLOADING)
SampleGetInfoMethodInfo ,
#endif
sampleGetInfo ,
#if defined(ENABLE_OVERLOADING)
SampleGetSegmentMethodInfo ,
#endif
sampleGetSegment ,
sampleNew ,
#if defined(ENABLE_OVERLOADING)
SampleSetBufferMethodInfo ,
#endif
sampleSetBuffer ,
#if defined(ENABLE_OVERLOADING)
SampleSetBufferListMethodInfo ,
#endif
sampleSetBufferList ,
#if defined(ENABLE_OVERLOADING)
SampleSetCapsMethodInfo ,
#endif
sampleSetCaps ,
#if defined(ENABLE_OVERLOADING)
SampleSetInfoMethodInfo ,
#endif
sampleSetInfo ,
#if defined(ENABLE_OVERLOADING)
SampleSetSegmentMethodInfo ,
#endif
sampleSetSegment ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import {-# SOURCE #-} qualified GI.Gst.Structs.Buffer as Gst.Buffer
import {-# SOURCE #-} qualified GI.Gst.Structs.BufferList as Gst.BufferList
import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.Gst.Structs.Segment as Gst.Segment
import {-# SOURCE #-} qualified GI.Gst.Structs.Structure as Gst.Structure
newtype Sample = Sample (SP.ManagedPtr Sample)
deriving (Sample -> Sample -> Bool
(Sample -> Sample -> Bool)
-> (Sample -> Sample -> Bool) -> Eq Sample
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Sample -> Sample -> Bool
== :: Sample -> Sample -> Bool
$c/= :: Sample -> Sample -> Bool
/= :: Sample -> Sample -> Bool
Eq)
instance SP.ManagedPtrNewtype Sample where
toManagedPtr :: Sample -> ManagedPtr Sample
toManagedPtr (Sample ManagedPtr Sample
p) = ManagedPtr Sample
p
foreign import ccall "gst_sample_get_type" c_gst_sample_get_type ::
IO GType
type instance O.ParentTypes Sample = '[]
instance O.HasParentTypes Sample
instance B.Types.TypedObject Sample where
glibType :: IO GType
glibType = IO GType
c_gst_sample_get_type
instance B.Types.GBoxed Sample
instance B.GValue.IsGValue (Maybe Sample) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_sample_get_type
gvalueSet_ :: Ptr GValue -> Maybe Sample -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Sample
P.Nothing = Ptr GValue -> Ptr Sample -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Sample
forall a. Ptr a
FP.nullPtr :: FP.Ptr Sample)
gvalueSet_ Ptr GValue
gv (P.Just Sample
obj) = Sample -> (Ptr Sample -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Sample
obj (Ptr GValue -> Ptr Sample -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Sample)
gvalueGet_ Ptr GValue
gv = do
Ptr Sample
ptr <- Ptr GValue -> IO (Ptr Sample)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Sample)
if Ptr Sample
ptr Ptr Sample -> Ptr Sample -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Sample
forall a. Ptr a
FP.nullPtr
then Sample -> Maybe Sample
forall a. a -> Maybe a
P.Just (Sample -> Maybe Sample) -> IO Sample -> IO (Maybe Sample)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Sample -> Sample) -> Ptr Sample -> IO Sample
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Sample -> Sample
Sample Ptr Sample
ptr
else Maybe Sample -> IO (Maybe Sample)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Sample
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Sample
type instance O.AttributeList Sample = SampleAttributeList
type SampleAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "gst_sample_new" gst_sample_new ::
Ptr Gst.Buffer.Buffer ->
Ptr Gst.Caps.Caps ->
Ptr Gst.Segment.Segment ->
Ptr Gst.Structure.Structure ->
IO (Ptr Sample)
sampleNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (Gst.Buffer.Buffer)
-> Maybe (Gst.Caps.Caps)
-> Maybe (Gst.Segment.Segment)
-> Maybe (Gst.Structure.Structure)
-> m Sample
sampleNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Buffer
-> Maybe Caps -> Maybe Segment -> Maybe Structure -> m Sample
sampleNew Maybe Buffer
buffer Maybe Caps
caps Maybe Segment
segment Maybe Structure
info = IO Sample -> m Sample
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Sample -> m Sample) -> IO Sample -> m Sample
forall a b. (a -> b) -> a -> b
$ do
Ptr Buffer
maybeBuffer <- case Maybe Buffer
buffer of
Maybe Buffer
Nothing -> Ptr Buffer -> IO (Ptr Buffer)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Buffer
forall a. Ptr a
nullPtr
Just Buffer
jBuffer -> do
Ptr Buffer
jBuffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
jBuffer
Ptr Buffer -> IO (Ptr Buffer)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Buffer
jBuffer'
Ptr Caps
maybeCaps <- case Maybe Caps
caps of
Maybe Caps
Nothing -> Ptr Caps -> IO (Ptr Caps)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
forall a. Ptr a
nullPtr
Just Caps
jCaps -> do
Ptr Caps
jCaps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
jCaps
Ptr Caps -> IO (Ptr Caps)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
jCaps'
Ptr Segment
maybeSegment <- case Maybe Segment
segment of
Maybe Segment
Nothing -> Ptr Segment -> IO (Ptr Segment)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Segment
forall a. Ptr a
nullPtr
Just Segment
jSegment -> do
Ptr Segment
jSegment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
jSegment
Ptr Segment -> IO (Ptr Segment)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Segment
jSegment'
Ptr Structure
maybeInfo <- case Maybe Structure
info of
Maybe Structure
Nothing -> Ptr Structure -> IO (Ptr Structure)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
forall a. Ptr a
nullPtr
Just Structure
jInfo -> do
Ptr Structure
jInfo' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
jInfo
Ptr Structure -> IO (Ptr Structure)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Structure
jInfo'
Ptr Sample
result <- Ptr Buffer
-> Ptr Caps -> Ptr Segment -> Ptr Structure -> IO (Ptr Sample)
gst_sample_new Ptr Buffer
maybeBuffer Ptr Caps
maybeCaps Ptr Segment
maybeSegment Ptr Structure
maybeInfo
Text -> Ptr Sample -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sampleNew" Ptr Sample
result
Sample
result' <- ((ManagedPtr Sample -> Sample) -> Ptr Sample -> IO Sample
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Sample -> Sample
Sample) Ptr Sample
result
Maybe Buffer -> (Buffer -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Buffer
buffer Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Caps -> (Caps -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Caps
caps Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Segment -> (Segment -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Segment
segment Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Structure -> (Structure -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Structure
info Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Sample -> IO Sample
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Sample
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_sample_get_buffer" gst_sample_get_buffer ::
Ptr Sample ->
IO (Ptr Gst.Buffer.Buffer)
sampleGetBuffer ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sample
-> m (Maybe Gst.Buffer.Buffer)
sampleGetBuffer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sample -> m (Maybe Buffer)
sampleGetBuffer Sample
sample = IO (Maybe Buffer) -> m (Maybe Buffer)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Buffer) -> m (Maybe Buffer))
-> IO (Maybe Buffer) -> m (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ do
Ptr Sample
sample' <- Sample -> IO (Ptr Sample)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sample
sample
Ptr Buffer
result <- Ptr Sample -> IO (Ptr Buffer)
gst_sample_get_buffer Ptr Sample
sample'
Maybe Buffer
maybeResult <- Ptr Buffer -> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Buffer
result ((Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer))
-> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
result' -> do
Buffer
result'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
result'
Buffer -> IO Buffer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result''
Sample -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sample
sample
Maybe Buffer -> IO (Maybe Buffer)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
maybeResult
#if defined(ENABLE_OVERLOADING)
data SampleGetBufferMethodInfo
instance (signature ~ (m (Maybe Gst.Buffer.Buffer)), MonadIO m) => O.OverloadedMethod SampleGetBufferMethodInfo Sample signature where
overloadedMethod = sampleGetBuffer
instance O.OverloadedMethodInfo SampleGetBufferMethodInfo Sample where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Sample.sampleGetBuffer",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Sample.html#v:sampleGetBuffer"
})
#endif
foreign import ccall "gst_sample_get_buffer_list" gst_sample_get_buffer_list ::
Ptr Sample ->
IO (Ptr Gst.BufferList.BufferList)
sampleGetBufferList ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sample
-> m (Maybe Gst.BufferList.BufferList)
sampleGetBufferList :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sample -> m (Maybe BufferList)
sampleGetBufferList Sample
sample = IO (Maybe BufferList) -> m (Maybe BufferList)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BufferList) -> m (Maybe BufferList))
-> IO (Maybe BufferList) -> m (Maybe BufferList)
forall a b. (a -> b) -> a -> b
$ do
Ptr Sample
sample' <- Sample -> IO (Ptr Sample)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sample
sample
Ptr BufferList
result <- Ptr Sample -> IO (Ptr BufferList)
gst_sample_get_buffer_list Ptr Sample
sample'
Maybe BufferList
maybeResult <- Ptr BufferList
-> (Ptr BufferList -> IO BufferList) -> IO (Maybe BufferList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BufferList
result ((Ptr BufferList -> IO BufferList) -> IO (Maybe BufferList))
-> (Ptr BufferList -> IO BufferList) -> IO (Maybe BufferList)
forall a b. (a -> b) -> a -> b
$ \Ptr BufferList
result' -> do
BufferList
result'' <- ((ManagedPtr BufferList -> BufferList)
-> Ptr BufferList -> IO BufferList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr BufferList -> BufferList
Gst.BufferList.BufferList) Ptr BufferList
result'
BufferList -> IO BufferList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BufferList
result''
Sample -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sample
sample
Maybe BufferList -> IO (Maybe BufferList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BufferList
maybeResult
#if defined(ENABLE_OVERLOADING)
data SampleGetBufferListMethodInfo
instance (signature ~ (m (Maybe Gst.BufferList.BufferList)), MonadIO m) => O.OverloadedMethod SampleGetBufferListMethodInfo Sample signature where
overloadedMethod = sampleGetBufferList
instance O.OverloadedMethodInfo SampleGetBufferListMethodInfo Sample where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Sample.sampleGetBufferList",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Sample.html#v:sampleGetBufferList"
})
#endif
foreign import ccall "gst_sample_get_caps" gst_sample_get_caps ::
Ptr Sample ->
IO (Ptr Gst.Caps.Caps)
sampleGetCaps ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sample
-> m (Maybe Gst.Caps.Caps)
sampleGetCaps :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sample -> m (Maybe Caps)
sampleGetCaps Sample
sample = IO (Maybe Caps) -> m (Maybe Caps)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Caps) -> m (Maybe Caps))
-> IO (Maybe Caps) -> m (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ do
Ptr Sample
sample' <- Sample -> IO (Ptr Sample)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sample
sample
Ptr Caps
result <- Ptr Sample -> IO (Ptr Caps)
gst_sample_get_caps Ptr Sample
sample'
Maybe Caps
maybeResult <- Ptr Caps -> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Caps
result ((Ptr Caps -> IO Caps) -> IO (Maybe Caps))
-> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ \Ptr Caps
result' -> do
Caps
result'' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result'
Caps -> IO Caps
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result''
Sample -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sample
sample
Maybe Caps -> IO (Maybe Caps)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Caps
maybeResult
#if defined(ENABLE_OVERLOADING)
data SampleGetCapsMethodInfo
instance (signature ~ (m (Maybe Gst.Caps.Caps)), MonadIO m) => O.OverloadedMethod SampleGetCapsMethodInfo Sample signature where
overloadedMethod = sampleGetCaps
instance O.OverloadedMethodInfo SampleGetCapsMethodInfo Sample where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Sample.sampleGetCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Sample.html#v:sampleGetCaps"
})
#endif
foreign import ccall "gst_sample_get_info" gst_sample_get_info ::
Ptr Sample ->
IO (Ptr Gst.Structure.Structure)
sampleGetInfo ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sample
-> m (Maybe Gst.Structure.Structure)
sampleGetInfo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sample -> m (Maybe Structure)
sampleGetInfo Sample
sample = IO (Maybe Structure) -> m (Maybe Structure)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Structure) -> m (Maybe Structure))
-> IO (Maybe Structure) -> m (Maybe Structure)
forall a b. (a -> b) -> a -> b
$ do
Ptr Sample
sample' <- Sample -> IO (Ptr Sample)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sample
sample
Ptr Structure
result <- Ptr Sample -> IO (Ptr Structure)
gst_sample_get_info Ptr Sample
sample'
Maybe Structure
maybeResult <- Ptr Structure
-> (Ptr Structure -> IO Structure) -> IO (Maybe Structure)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Structure
result ((Ptr Structure -> IO Structure) -> IO (Maybe Structure))
-> (Ptr Structure -> IO Structure) -> IO (Maybe Structure)
forall a b. (a -> b) -> a -> b
$ \Ptr Structure
result' -> do
Structure
result'' <- ((ManagedPtr Structure -> Structure)
-> Ptr Structure -> IO Structure
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Structure -> Structure
Gst.Structure.Structure) Ptr Structure
result'
Structure -> IO Structure
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Structure
result''
Sample -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sample
sample
Maybe Structure -> IO (Maybe Structure)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Structure
maybeResult
#if defined(ENABLE_OVERLOADING)
data SampleGetInfoMethodInfo
instance (signature ~ (m (Maybe Gst.Structure.Structure)), MonadIO m) => O.OverloadedMethod SampleGetInfoMethodInfo Sample signature where
overloadedMethod = sampleGetInfo
instance O.OverloadedMethodInfo SampleGetInfoMethodInfo Sample where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Sample.sampleGetInfo",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Sample.html#v:sampleGetInfo"
})
#endif
foreign import ccall "gst_sample_get_segment" gst_sample_get_segment ::
Ptr Sample ->
IO (Ptr Gst.Segment.Segment)
sampleGetSegment ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sample
-> m Gst.Segment.Segment
sampleGetSegment :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sample -> m Segment
sampleGetSegment Sample
sample = IO Segment -> m Segment
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Segment -> m Segment) -> IO Segment -> m Segment
forall a b. (a -> b) -> a -> b
$ do
Ptr Sample
sample' <- Sample -> IO (Ptr Sample)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sample
sample
Ptr Segment
result <- Ptr Sample -> IO (Ptr Segment)
gst_sample_get_segment Ptr Sample
sample'
Text -> Ptr Segment -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"sampleGetSegment" Ptr Segment
result
Segment
result' <- ((ManagedPtr Segment -> Segment) -> Ptr Segment -> IO Segment
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Segment -> Segment
Gst.Segment.Segment) Ptr Segment
result
Sample -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sample
sample
Segment -> IO Segment
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Segment
result'
#if defined(ENABLE_OVERLOADING)
data SampleGetSegmentMethodInfo
instance (signature ~ (m Gst.Segment.Segment), MonadIO m) => O.OverloadedMethod SampleGetSegmentMethodInfo Sample signature where
overloadedMethod = sampleGetSegment
instance O.OverloadedMethodInfo SampleGetSegmentMethodInfo Sample where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Sample.sampleGetSegment",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Sample.html#v:sampleGetSegment"
})
#endif
foreign import ccall "gst_sample_set_buffer" gst_sample_set_buffer ::
Ptr Sample ->
Ptr Gst.Buffer.Buffer ->
IO ()
sampleSetBuffer ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sample
-> Gst.Buffer.Buffer
-> m ()
sampleSetBuffer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sample -> Buffer -> m ()
sampleSetBuffer Sample
sample Buffer
buffer = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Sample
sample' <- Sample -> IO (Ptr Sample)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sample
sample
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr Sample -> Ptr Buffer -> IO ()
gst_sample_set_buffer Ptr Sample
sample' Ptr Buffer
buffer'
Sample -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sample
sample
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SampleSetBufferMethodInfo
instance (signature ~ (Gst.Buffer.Buffer -> m ()), MonadIO m) => O.OverloadedMethod SampleSetBufferMethodInfo Sample signature where
overloadedMethod = sampleSetBuffer
instance O.OverloadedMethodInfo SampleSetBufferMethodInfo Sample where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Sample.sampleSetBuffer",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Sample.html#v:sampleSetBuffer"
})
#endif
foreign import ccall "gst_sample_set_buffer_list" gst_sample_set_buffer_list ::
Ptr Sample ->
Ptr Gst.BufferList.BufferList ->
IO ()
sampleSetBufferList ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sample
-> Gst.BufferList.BufferList
-> m ()
sampleSetBufferList :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sample -> BufferList -> m ()
sampleSetBufferList Sample
sample BufferList
bufferList = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Sample
sample' <- Sample -> IO (Ptr Sample)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sample
sample
Ptr BufferList
bufferList' <- BufferList -> IO (Ptr BufferList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BufferList
bufferList
Ptr Sample -> Ptr BufferList -> IO ()
gst_sample_set_buffer_list Ptr Sample
sample' Ptr BufferList
bufferList'
Sample -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sample
sample
BufferList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BufferList
bufferList
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SampleSetBufferListMethodInfo
instance (signature ~ (Gst.BufferList.BufferList -> m ()), MonadIO m) => O.OverloadedMethod SampleSetBufferListMethodInfo Sample signature where
overloadedMethod = sampleSetBufferList
instance O.OverloadedMethodInfo SampleSetBufferListMethodInfo Sample where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Sample.sampleSetBufferList",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Sample.html#v:sampleSetBufferList"
})
#endif
foreign import ccall "gst_sample_set_caps" gst_sample_set_caps ::
Ptr Sample ->
Ptr Gst.Caps.Caps ->
IO ()
sampleSetCaps ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sample
-> Gst.Caps.Caps
-> m ()
sampleSetCaps :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sample -> Caps -> m ()
sampleSetCaps Sample
sample Caps
caps = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Sample
sample' <- Sample -> IO (Ptr Sample)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sample
sample
Ptr Caps
caps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
Ptr Sample -> Ptr Caps -> IO ()
gst_sample_set_caps Ptr Sample
sample' Ptr Caps
caps'
Sample -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sample
sample
Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SampleSetCapsMethodInfo
instance (signature ~ (Gst.Caps.Caps -> m ()), MonadIO m) => O.OverloadedMethod SampleSetCapsMethodInfo Sample signature where
overloadedMethod = sampleSetCaps
instance O.OverloadedMethodInfo SampleSetCapsMethodInfo Sample where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Sample.sampleSetCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Sample.html#v:sampleSetCaps"
})
#endif
foreign import ccall "gst_sample_set_info" gst_sample_set_info ::
Ptr Sample ->
Ptr Gst.Structure.Structure ->
IO CInt
sampleSetInfo ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sample
-> Gst.Structure.Structure
-> m Bool
sampleSetInfo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sample -> Structure -> m Bool
sampleSetInfo Sample
sample Structure
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Sample
sample' <- Sample -> IO (Ptr Sample)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sample
sample
Ptr Structure
info' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Structure
info
CInt
result <- Ptr Sample -> Ptr Structure -> IO CInt
gst_sample_set_info Ptr Sample
sample' Ptr Structure
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Sample -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sample
sample
Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Structure
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data SampleSetInfoMethodInfo
instance (signature ~ (Gst.Structure.Structure -> m Bool), MonadIO m) => O.OverloadedMethod SampleSetInfoMethodInfo Sample signature where
overloadedMethod = sampleSetInfo
instance O.OverloadedMethodInfo SampleSetInfoMethodInfo Sample where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Sample.sampleSetInfo",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Sample.html#v:sampleSetInfo"
})
#endif
foreign import ccall "gst_sample_set_segment" gst_sample_set_segment ::
Ptr Sample ->
Ptr Gst.Segment.Segment ->
IO ()
sampleSetSegment ::
(B.CallStack.HasCallStack, MonadIO m) =>
Sample
-> Gst.Segment.Segment
-> m ()
sampleSetSegment :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Sample -> Segment -> m ()
sampleSetSegment Sample
sample Segment
segment = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Sample
sample' <- Sample -> IO (Ptr Sample)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Sample
sample
Ptr Segment
segment' <- Segment -> IO (Ptr Segment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Segment
segment
Ptr Sample -> Ptr Segment -> IO ()
gst_sample_set_segment Ptr Sample
sample' Ptr Segment
segment'
Sample -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Sample
sample
Segment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Segment
segment
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SampleSetSegmentMethodInfo
instance (signature ~ (Gst.Segment.Segment -> m ()), MonadIO m) => O.OverloadedMethod SampleSetSegmentMethodInfo Sample signature where
overloadedMethod = sampleSetSegment
instance O.OverloadedMethodInfo SampleSetSegmentMethodInfo Sample where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.Sample.sampleSetSegment",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.29/docs/GI-Gst-Structs-Sample.html#v:sampleSetSegment"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveSampleMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveSampleMethod "getBuffer" o = SampleGetBufferMethodInfo
ResolveSampleMethod "getBufferList" o = SampleGetBufferListMethodInfo
ResolveSampleMethod "getCaps" o = SampleGetCapsMethodInfo
ResolveSampleMethod "getInfo" o = SampleGetInfoMethodInfo
ResolveSampleMethod "getSegment" o = SampleGetSegmentMethodInfo
ResolveSampleMethod "setBuffer" o = SampleSetBufferMethodInfo
ResolveSampleMethod "setBufferList" o = SampleSetBufferListMethodInfo
ResolveSampleMethod "setCaps" o = SampleSetCapsMethodInfo
ResolveSampleMethod "setInfo" o = SampleSetInfoMethodInfo
ResolveSampleMethod "setSegment" o = SampleSetSegmentMethodInfo
ResolveSampleMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveSampleMethod t Sample, O.OverloadedMethod info Sample p) => OL.IsLabel t (Sample -> 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 ~ ResolveSampleMethod t Sample, O.OverloadedMethod info Sample p, R.HasField t Sample p) => R.HasField t Sample p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveSampleMethod t Sample, O.OverloadedMethodInfo info Sample) => OL.IsLabel t (O.MethodProxy info Sample) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif