{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstAudio.Structs.AudioStreamAlign
(
AudioStreamAlign(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveAudioStreamAlignMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
AudioStreamAlignCopyMethodInfo ,
#endif
audioStreamAlignCopy ,
#if defined(ENABLE_OVERLOADING)
AudioStreamAlignFreeMethodInfo ,
#endif
audioStreamAlignFree ,
#if defined(ENABLE_OVERLOADING)
AudioStreamAlignGetAlignmentThresholdMethodInfo,
#endif
audioStreamAlignGetAlignmentThreshold ,
#if defined(ENABLE_OVERLOADING)
AudioStreamAlignGetDiscontWaitMethodInfo,
#endif
audioStreamAlignGetDiscontWait ,
#if defined(ENABLE_OVERLOADING)
AudioStreamAlignGetRateMethodInfo ,
#endif
audioStreamAlignGetRate ,
#if defined(ENABLE_OVERLOADING)
AudioStreamAlignGetSamplesSinceDiscontMethodInfo,
#endif
audioStreamAlignGetSamplesSinceDiscont ,
#if defined(ENABLE_OVERLOADING)
AudioStreamAlignGetTimestampAtDiscontMethodInfo,
#endif
audioStreamAlignGetTimestampAtDiscont ,
#if defined(ENABLE_OVERLOADING)
AudioStreamAlignMarkDiscontMethodInfo ,
#endif
audioStreamAlignMarkDiscont ,
audioStreamAlignNew ,
#if defined(ENABLE_OVERLOADING)
AudioStreamAlignProcessMethodInfo ,
#endif
audioStreamAlignProcess ,
#if defined(ENABLE_OVERLOADING)
AudioStreamAlignSetAlignmentThresholdMethodInfo,
#endif
audioStreamAlignSetAlignmentThreshold ,
#if defined(ENABLE_OVERLOADING)
AudioStreamAlignSetDiscontWaitMethodInfo,
#endif
audioStreamAlignSetDiscontWait ,
#if defined(ENABLE_OVERLOADING)
AudioStreamAlignSetRateMethodInfo ,
#endif
audioStreamAlignSetRate ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
newtype AudioStreamAlign = AudioStreamAlign (SP.ManagedPtr AudioStreamAlign)
deriving (AudioStreamAlign -> AudioStreamAlign -> Bool
(AudioStreamAlign -> AudioStreamAlign -> Bool)
-> (AudioStreamAlign -> AudioStreamAlign -> Bool)
-> Eq AudioStreamAlign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioStreamAlign -> AudioStreamAlign -> Bool
$c/= :: AudioStreamAlign -> AudioStreamAlign -> Bool
== :: AudioStreamAlign -> AudioStreamAlign -> Bool
$c== :: AudioStreamAlign -> AudioStreamAlign -> Bool
Eq)
instance SP.ManagedPtrNewtype AudioStreamAlign where
toManagedPtr :: AudioStreamAlign -> ManagedPtr AudioStreamAlign
toManagedPtr (AudioStreamAlign ManagedPtr AudioStreamAlign
p) = ManagedPtr AudioStreamAlign
p
foreign import ccall "gst_audio_stream_align_get_type" c_gst_audio_stream_align_get_type ::
IO GType
type instance O.ParentTypes AudioStreamAlign = '[]
instance O.HasParentTypes AudioStreamAlign
instance B.Types.TypedObject AudioStreamAlign where
glibType :: IO GType
glibType = IO GType
c_gst_audio_stream_align_get_type
instance B.Types.GBoxed AudioStreamAlign
instance B.GValue.IsGValue (Maybe AudioStreamAlign) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_audio_stream_align_get_type
gvalueSet_ :: Ptr GValue -> Maybe AudioStreamAlign -> IO ()
gvalueSet_ Ptr GValue
gv Maybe AudioStreamAlign
P.Nothing = Ptr GValue -> Ptr AudioStreamAlign -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr AudioStreamAlign
forall a. Ptr a
FP.nullPtr :: FP.Ptr AudioStreamAlign)
gvalueSet_ Ptr GValue
gv (P.Just AudioStreamAlign
obj) = AudioStreamAlign -> (Ptr AudioStreamAlign -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr AudioStreamAlign
obj (Ptr GValue -> Ptr AudioStreamAlign -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe AudioStreamAlign)
gvalueGet_ Ptr GValue
gv = do
Ptr AudioStreamAlign
ptr <- Ptr GValue -> IO (Ptr AudioStreamAlign)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr AudioStreamAlign)
if Ptr AudioStreamAlign
ptr Ptr AudioStreamAlign -> Ptr AudioStreamAlign -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr AudioStreamAlign
forall a. Ptr a
FP.nullPtr
then AudioStreamAlign -> Maybe AudioStreamAlign
forall a. a -> Maybe a
P.Just (AudioStreamAlign -> Maybe AudioStreamAlign)
-> IO AudioStreamAlign -> IO (Maybe AudioStreamAlign)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr AudioStreamAlign -> AudioStreamAlign)
-> Ptr AudioStreamAlign -> IO AudioStreamAlign
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr AudioStreamAlign -> AudioStreamAlign
AudioStreamAlign Ptr AudioStreamAlign
ptr
else Maybe AudioStreamAlign -> IO (Maybe AudioStreamAlign)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AudioStreamAlign
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList AudioStreamAlign
type instance O.AttributeList AudioStreamAlign = AudioStreamAlignAttributeList
type AudioStreamAlignAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "gst_audio_stream_align_new" gst_audio_stream_align_new ::
Int32 ->
Word64 ->
Word64 ->
IO (Ptr AudioStreamAlign)
audioStreamAlignNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Int32
-> Word64
-> Word64
-> m AudioStreamAlign
audioStreamAlignNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Int32 -> Word64 -> Word64 -> m AudioStreamAlign
audioStreamAlignNew Int32
rate Word64
alignmentThreshold Word64
discontWait = IO AudioStreamAlign -> m AudioStreamAlign
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AudioStreamAlign -> m AudioStreamAlign)
-> IO AudioStreamAlign -> m AudioStreamAlign
forall a b. (a -> b) -> a -> b
$ do
Ptr AudioStreamAlign
result <- Int32 -> Word64 -> Word64 -> IO (Ptr AudioStreamAlign)
gst_audio_stream_align_new Int32
rate Word64
alignmentThreshold Word64
discontWait
Text -> Ptr AudioStreamAlign -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"audioStreamAlignNew" Ptr AudioStreamAlign
result
AudioStreamAlign
result' <- ((ManagedPtr AudioStreamAlign -> AudioStreamAlign)
-> Ptr AudioStreamAlign -> IO AudioStreamAlign
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AudioStreamAlign -> AudioStreamAlign
AudioStreamAlign) Ptr AudioStreamAlign
result
AudioStreamAlign -> IO AudioStreamAlign
forall (m :: * -> *) a. Monad m => a -> m a
return AudioStreamAlign
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_audio_stream_align_copy" gst_audio_stream_align_copy ::
Ptr AudioStreamAlign ->
IO (Ptr AudioStreamAlign)
audioStreamAlignCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
AudioStreamAlign
-> m AudioStreamAlign
audioStreamAlignCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioStreamAlign -> m AudioStreamAlign
audioStreamAlignCopy AudioStreamAlign
align = IO AudioStreamAlign -> m AudioStreamAlign
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AudioStreamAlign -> m AudioStreamAlign)
-> IO AudioStreamAlign -> m AudioStreamAlign
forall a b. (a -> b) -> a -> b
$ do
Ptr AudioStreamAlign
align' <- AudioStreamAlign -> IO (Ptr AudioStreamAlign)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioStreamAlign
align
Ptr AudioStreamAlign
result <- Ptr AudioStreamAlign -> IO (Ptr AudioStreamAlign)
gst_audio_stream_align_copy Ptr AudioStreamAlign
align'
Text -> Ptr AudioStreamAlign -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"audioStreamAlignCopy" Ptr AudioStreamAlign
result
AudioStreamAlign
result' <- ((ManagedPtr AudioStreamAlign -> AudioStreamAlign)
-> Ptr AudioStreamAlign -> IO AudioStreamAlign
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AudioStreamAlign -> AudioStreamAlign
AudioStreamAlign) Ptr AudioStreamAlign
result
AudioStreamAlign -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioStreamAlign
align
AudioStreamAlign -> IO AudioStreamAlign
forall (m :: * -> *) a. Monad m => a -> m a
return AudioStreamAlign
result'
#if defined(ENABLE_OVERLOADING)
data AudioStreamAlignCopyMethodInfo
instance (signature ~ (m AudioStreamAlign), MonadIO m) => O.OverloadedMethod AudioStreamAlignCopyMethodInfo AudioStreamAlign signature where
overloadedMethod = audioStreamAlignCopy
instance O.OverloadedMethodInfo AudioStreamAlignCopyMethodInfo AudioStreamAlign where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstAudio.Structs.AudioStreamAlign.audioStreamAlignCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioStreamAlign.html#v:audioStreamAlignCopy"
})
#endif
foreign import ccall "gst_audio_stream_align_free" gst_audio_stream_align_free ::
Ptr AudioStreamAlign ->
IO ()
audioStreamAlignFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
AudioStreamAlign
-> m ()
audioStreamAlignFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioStreamAlign -> m ()
audioStreamAlignFree AudioStreamAlign
align = 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 AudioStreamAlign
align' <- AudioStreamAlign -> IO (Ptr AudioStreamAlign)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioStreamAlign
align
Ptr AudioStreamAlign -> IO ()
gst_audio_stream_align_free Ptr AudioStreamAlign
align'
AudioStreamAlign -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioStreamAlign
align
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AudioStreamAlignFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod AudioStreamAlignFreeMethodInfo AudioStreamAlign signature where
overloadedMethod = audioStreamAlignFree
instance O.OverloadedMethodInfo AudioStreamAlignFreeMethodInfo AudioStreamAlign where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstAudio.Structs.AudioStreamAlign.audioStreamAlignFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioStreamAlign.html#v:audioStreamAlignFree"
})
#endif
foreign import ccall "gst_audio_stream_align_get_alignment_threshold" gst_audio_stream_align_get_alignment_threshold ::
Ptr AudioStreamAlign ->
IO Word64
audioStreamAlignGetAlignmentThreshold ::
(B.CallStack.HasCallStack, MonadIO m) =>
AudioStreamAlign
-> m Word64
audioStreamAlignGetAlignmentThreshold :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioStreamAlign -> m Word64
audioStreamAlignGetAlignmentThreshold AudioStreamAlign
align = 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 AudioStreamAlign
align' <- AudioStreamAlign -> IO (Ptr AudioStreamAlign)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioStreamAlign
align
Word64
result <- Ptr AudioStreamAlign -> IO Word64
gst_audio_stream_align_get_alignment_threshold Ptr AudioStreamAlign
align'
AudioStreamAlign -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioStreamAlign
align
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data AudioStreamAlignGetAlignmentThresholdMethodInfo
instance (signature ~ (m Word64), MonadIO m) => O.OverloadedMethod AudioStreamAlignGetAlignmentThresholdMethodInfo AudioStreamAlign signature where
overloadedMethod = audioStreamAlignGetAlignmentThreshold
instance O.OverloadedMethodInfo AudioStreamAlignGetAlignmentThresholdMethodInfo AudioStreamAlign where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstAudio.Structs.AudioStreamAlign.audioStreamAlignGetAlignmentThreshold",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioStreamAlign.html#v:audioStreamAlignGetAlignmentThreshold"
})
#endif
foreign import ccall "gst_audio_stream_align_get_discont_wait" gst_audio_stream_align_get_discont_wait ::
Ptr AudioStreamAlign ->
IO Word64
audioStreamAlignGetDiscontWait ::
(B.CallStack.HasCallStack, MonadIO m) =>
AudioStreamAlign
-> m Word64
audioStreamAlignGetDiscontWait :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioStreamAlign -> m Word64
audioStreamAlignGetDiscontWait AudioStreamAlign
align = 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 AudioStreamAlign
align' <- AudioStreamAlign -> IO (Ptr AudioStreamAlign)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioStreamAlign
align
Word64
result <- Ptr AudioStreamAlign -> IO Word64
gst_audio_stream_align_get_discont_wait Ptr AudioStreamAlign
align'
AudioStreamAlign -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioStreamAlign
align
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data AudioStreamAlignGetDiscontWaitMethodInfo
instance (signature ~ (m Word64), MonadIO m) => O.OverloadedMethod AudioStreamAlignGetDiscontWaitMethodInfo AudioStreamAlign signature where
overloadedMethod = audioStreamAlignGetDiscontWait
instance O.OverloadedMethodInfo AudioStreamAlignGetDiscontWaitMethodInfo AudioStreamAlign where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstAudio.Structs.AudioStreamAlign.audioStreamAlignGetDiscontWait",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioStreamAlign.html#v:audioStreamAlignGetDiscontWait"
})
#endif
foreign import ccall "gst_audio_stream_align_get_rate" gst_audio_stream_align_get_rate ::
Ptr AudioStreamAlign ->
IO Int32
audioStreamAlignGetRate ::
(B.CallStack.HasCallStack, MonadIO m) =>
AudioStreamAlign
-> m Int32
audioStreamAlignGetRate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioStreamAlign -> m Int32
audioStreamAlignGetRate AudioStreamAlign
align = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr AudioStreamAlign
align' <- AudioStreamAlign -> IO (Ptr AudioStreamAlign)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioStreamAlign
align
Int32
result <- Ptr AudioStreamAlign -> IO Int32
gst_audio_stream_align_get_rate Ptr AudioStreamAlign
align'
AudioStreamAlign -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioStreamAlign
align
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data AudioStreamAlignGetRateMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod AudioStreamAlignGetRateMethodInfo AudioStreamAlign signature where
overloadedMethod = audioStreamAlignGetRate
instance O.OverloadedMethodInfo AudioStreamAlignGetRateMethodInfo AudioStreamAlign where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstAudio.Structs.AudioStreamAlign.audioStreamAlignGetRate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioStreamAlign.html#v:audioStreamAlignGetRate"
})
#endif
foreign import ccall "gst_audio_stream_align_get_samples_since_discont" gst_audio_stream_align_get_samples_since_discont ::
Ptr AudioStreamAlign ->
IO Word64
audioStreamAlignGetSamplesSinceDiscont ::
(B.CallStack.HasCallStack, MonadIO m) =>
AudioStreamAlign
-> m Word64
audioStreamAlignGetSamplesSinceDiscont :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioStreamAlign -> m Word64
audioStreamAlignGetSamplesSinceDiscont AudioStreamAlign
align = 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 AudioStreamAlign
align' <- AudioStreamAlign -> IO (Ptr AudioStreamAlign)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioStreamAlign
align
Word64
result <- Ptr AudioStreamAlign -> IO Word64
gst_audio_stream_align_get_samples_since_discont Ptr AudioStreamAlign
align'
AudioStreamAlign -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioStreamAlign
align
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data AudioStreamAlignGetSamplesSinceDiscontMethodInfo
instance (signature ~ (m Word64), MonadIO m) => O.OverloadedMethod AudioStreamAlignGetSamplesSinceDiscontMethodInfo AudioStreamAlign signature where
overloadedMethod = audioStreamAlignGetSamplesSinceDiscont
instance O.OverloadedMethodInfo AudioStreamAlignGetSamplesSinceDiscontMethodInfo AudioStreamAlign where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstAudio.Structs.AudioStreamAlign.audioStreamAlignGetSamplesSinceDiscont",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioStreamAlign.html#v:audioStreamAlignGetSamplesSinceDiscont"
})
#endif
foreign import ccall "gst_audio_stream_align_get_timestamp_at_discont" gst_audio_stream_align_get_timestamp_at_discont ::
Ptr AudioStreamAlign ->
IO Word64
audioStreamAlignGetTimestampAtDiscont ::
(B.CallStack.HasCallStack, MonadIO m) =>
AudioStreamAlign
-> m Word64
audioStreamAlignGetTimestampAtDiscont :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioStreamAlign -> m Word64
audioStreamAlignGetTimestampAtDiscont AudioStreamAlign
align = 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 AudioStreamAlign
align' <- AudioStreamAlign -> IO (Ptr AudioStreamAlign)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioStreamAlign
align
Word64
result <- Ptr AudioStreamAlign -> IO Word64
gst_audio_stream_align_get_timestamp_at_discont Ptr AudioStreamAlign
align'
AudioStreamAlign -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioStreamAlign
align
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
#if defined(ENABLE_OVERLOADING)
data AudioStreamAlignGetTimestampAtDiscontMethodInfo
instance (signature ~ (m Word64), MonadIO m) => O.OverloadedMethod AudioStreamAlignGetTimestampAtDiscontMethodInfo AudioStreamAlign signature where
overloadedMethod = audioStreamAlignGetTimestampAtDiscont
instance O.OverloadedMethodInfo AudioStreamAlignGetTimestampAtDiscontMethodInfo AudioStreamAlign where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstAudio.Structs.AudioStreamAlign.audioStreamAlignGetTimestampAtDiscont",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioStreamAlign.html#v:audioStreamAlignGetTimestampAtDiscont"
})
#endif
foreign import ccall "gst_audio_stream_align_mark_discont" gst_audio_stream_align_mark_discont ::
Ptr AudioStreamAlign ->
IO ()
audioStreamAlignMarkDiscont ::
(B.CallStack.HasCallStack, MonadIO m) =>
AudioStreamAlign
-> m ()
audioStreamAlignMarkDiscont :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioStreamAlign -> m ()
audioStreamAlignMarkDiscont AudioStreamAlign
align = 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 AudioStreamAlign
align' <- AudioStreamAlign -> IO (Ptr AudioStreamAlign)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioStreamAlign
align
Ptr AudioStreamAlign -> IO ()
gst_audio_stream_align_mark_discont Ptr AudioStreamAlign
align'
AudioStreamAlign -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioStreamAlign
align
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AudioStreamAlignMarkDiscontMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod AudioStreamAlignMarkDiscontMethodInfo AudioStreamAlign signature where
overloadedMethod = audioStreamAlignMarkDiscont
instance O.OverloadedMethodInfo AudioStreamAlignMarkDiscontMethodInfo AudioStreamAlign where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstAudio.Structs.AudioStreamAlign.audioStreamAlignMarkDiscont",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioStreamAlign.html#v:audioStreamAlignMarkDiscont"
})
#endif
foreign import ccall "gst_audio_stream_align_process" gst_audio_stream_align_process ::
Ptr AudioStreamAlign ->
CInt ->
Word64 ->
Word32 ->
Ptr Word64 ->
Ptr Word64 ->
Ptr Word64 ->
IO CInt
audioStreamAlignProcess ::
(B.CallStack.HasCallStack, MonadIO m) =>
AudioStreamAlign
-> Bool
-> Word64
-> Word32
-> m ((Bool, Word64, Word64, Word64))
audioStreamAlignProcess :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioStreamAlign
-> Bool -> Word64 -> Word32 -> m (Bool, Word64, Word64, Word64)
audioStreamAlignProcess AudioStreamAlign
align Bool
discont Word64
timestamp Word32
nSamples = IO (Bool, Word64, Word64, Word64)
-> m (Bool, Word64, Word64, Word64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word64, Word64, Word64)
-> m (Bool, Word64, Word64, Word64))
-> IO (Bool, Word64, Word64, Word64)
-> m (Bool, Word64, Word64, Word64)
forall a b. (a -> b) -> a -> b
$ do
Ptr AudioStreamAlign
align' <- AudioStreamAlign -> IO (Ptr AudioStreamAlign)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioStreamAlign
align
let discont' :: CInt
discont' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
discont
Ptr Word64
outTimestamp <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Word64
outDuration <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
Ptr Word64
outSamplePosition <- IO (Ptr Word64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
CInt
result <- Ptr AudioStreamAlign
-> CInt
-> Word64
-> Word32
-> Ptr Word64
-> Ptr Word64
-> Ptr Word64
-> IO CInt
gst_audio_stream_align_process Ptr AudioStreamAlign
align' CInt
discont' Word64
timestamp Word32
nSamples Ptr Word64
outTimestamp Ptr Word64
outDuration Ptr Word64
outSamplePosition
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Word64
outTimestamp' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
outTimestamp
Word64
outDuration' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
outDuration
Word64
outSamplePosition' <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
outSamplePosition
AudioStreamAlign -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioStreamAlign
align
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
outTimestamp
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
outDuration
Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
outSamplePosition
(Bool, Word64, Word64, Word64) -> IO (Bool, Word64, Word64, Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word64
outTimestamp', Word64
outDuration', Word64
outSamplePosition')
#if defined(ENABLE_OVERLOADING)
data AudioStreamAlignProcessMethodInfo
instance (signature ~ (Bool -> Word64 -> Word32 -> m ((Bool, Word64, Word64, Word64))), MonadIO m) => O.OverloadedMethod AudioStreamAlignProcessMethodInfo AudioStreamAlign signature where
overloadedMethod = audioStreamAlignProcess
instance O.OverloadedMethodInfo AudioStreamAlignProcessMethodInfo AudioStreamAlign where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstAudio.Structs.AudioStreamAlign.audioStreamAlignProcess",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioStreamAlign.html#v:audioStreamAlignProcess"
})
#endif
foreign import ccall "gst_audio_stream_align_set_alignment_threshold" gst_audio_stream_align_set_alignment_threshold ::
Ptr AudioStreamAlign ->
Word64 ->
IO ()
audioStreamAlignSetAlignmentThreshold ::
(B.CallStack.HasCallStack, MonadIO m) =>
AudioStreamAlign
-> Word64
-> m ()
audioStreamAlignSetAlignmentThreshold :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioStreamAlign -> Word64 -> m ()
audioStreamAlignSetAlignmentThreshold AudioStreamAlign
align Word64
alignmentThreshold = 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 AudioStreamAlign
align' <- AudioStreamAlign -> IO (Ptr AudioStreamAlign)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioStreamAlign
align
Ptr AudioStreamAlign -> Word64 -> IO ()
gst_audio_stream_align_set_alignment_threshold Ptr AudioStreamAlign
align' Word64
alignmentThreshold
AudioStreamAlign -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioStreamAlign
align
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AudioStreamAlignSetAlignmentThresholdMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m) => O.OverloadedMethod AudioStreamAlignSetAlignmentThresholdMethodInfo AudioStreamAlign signature where
overloadedMethod = audioStreamAlignSetAlignmentThreshold
instance O.OverloadedMethodInfo AudioStreamAlignSetAlignmentThresholdMethodInfo AudioStreamAlign where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstAudio.Structs.AudioStreamAlign.audioStreamAlignSetAlignmentThreshold",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioStreamAlign.html#v:audioStreamAlignSetAlignmentThreshold"
})
#endif
foreign import ccall "gst_audio_stream_align_set_discont_wait" gst_audio_stream_align_set_discont_wait ::
Ptr AudioStreamAlign ->
Word64 ->
IO ()
audioStreamAlignSetDiscontWait ::
(B.CallStack.HasCallStack, MonadIO m) =>
AudioStreamAlign
-> Word64
-> m ()
audioStreamAlignSetDiscontWait :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioStreamAlign -> Word64 -> m ()
audioStreamAlignSetDiscontWait AudioStreamAlign
align Word64
discontWait = 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 AudioStreamAlign
align' <- AudioStreamAlign -> IO (Ptr AudioStreamAlign)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioStreamAlign
align
Ptr AudioStreamAlign -> Word64 -> IO ()
gst_audio_stream_align_set_discont_wait Ptr AudioStreamAlign
align' Word64
discontWait
AudioStreamAlign -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioStreamAlign
align
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AudioStreamAlignSetDiscontWaitMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m) => O.OverloadedMethod AudioStreamAlignSetDiscontWaitMethodInfo AudioStreamAlign signature where
overloadedMethod = audioStreamAlignSetDiscontWait
instance O.OverloadedMethodInfo AudioStreamAlignSetDiscontWaitMethodInfo AudioStreamAlign where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstAudio.Structs.AudioStreamAlign.audioStreamAlignSetDiscontWait",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioStreamAlign.html#v:audioStreamAlignSetDiscontWait"
})
#endif
foreign import ccall "gst_audio_stream_align_set_rate" gst_audio_stream_align_set_rate ::
Ptr AudioStreamAlign ->
Int32 ->
IO ()
audioStreamAlignSetRate ::
(B.CallStack.HasCallStack, MonadIO m) =>
AudioStreamAlign
-> Int32
-> m ()
audioStreamAlignSetRate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioStreamAlign -> Int32 -> m ()
audioStreamAlignSetRate AudioStreamAlign
align Int32
rate = 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 AudioStreamAlign
align' <- AudioStreamAlign -> IO (Ptr AudioStreamAlign)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioStreamAlign
align
Ptr AudioStreamAlign -> Int32 -> IO ()
gst_audio_stream_align_set_rate Ptr AudioStreamAlign
align' Int32
rate
AudioStreamAlign -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioStreamAlign
align
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AudioStreamAlignSetRateMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m) => O.OverloadedMethod AudioStreamAlignSetRateMethodInfo AudioStreamAlign signature where
overloadedMethod = audioStreamAlignSetRate
instance O.OverloadedMethodInfo AudioStreamAlignSetRateMethodInfo AudioStreamAlign where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstAudio.Structs.AudioStreamAlign.audioStreamAlignSetRate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioStreamAlign.html#v:audioStreamAlignSetRate"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveAudioStreamAlignMethod (t :: Symbol) (o :: *) :: * where
ResolveAudioStreamAlignMethod "copy" o = AudioStreamAlignCopyMethodInfo
ResolveAudioStreamAlignMethod "free" o = AudioStreamAlignFreeMethodInfo
ResolveAudioStreamAlignMethod "markDiscont" o = AudioStreamAlignMarkDiscontMethodInfo
ResolveAudioStreamAlignMethod "process" o = AudioStreamAlignProcessMethodInfo
ResolveAudioStreamAlignMethod "getAlignmentThreshold" o = AudioStreamAlignGetAlignmentThresholdMethodInfo
ResolveAudioStreamAlignMethod "getDiscontWait" o = AudioStreamAlignGetDiscontWaitMethodInfo
ResolveAudioStreamAlignMethod "getRate" o = AudioStreamAlignGetRateMethodInfo
ResolveAudioStreamAlignMethod "getSamplesSinceDiscont" o = AudioStreamAlignGetSamplesSinceDiscontMethodInfo
ResolveAudioStreamAlignMethod "getTimestampAtDiscont" o = AudioStreamAlignGetTimestampAtDiscontMethodInfo
ResolveAudioStreamAlignMethod "setAlignmentThreshold" o = AudioStreamAlignSetAlignmentThresholdMethodInfo
ResolveAudioStreamAlignMethod "setDiscontWait" o = AudioStreamAlignSetDiscontWaitMethodInfo
ResolveAudioStreamAlignMethod "setRate" o = AudioStreamAlignSetRateMethodInfo
ResolveAudioStreamAlignMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveAudioStreamAlignMethod t AudioStreamAlign, O.OverloadedMethod info AudioStreamAlign p) => OL.IsLabel t (AudioStreamAlign -> 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 ~ ResolveAudioStreamAlignMethod t AudioStreamAlign, O.OverloadedMethod info AudioStreamAlign p, R.HasField t AudioStreamAlign p) => R.HasField t AudioStreamAlign p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveAudioStreamAlignMethod t AudioStreamAlign, O.OverloadedMethodInfo info AudioStreamAlign) => OL.IsLabel t (O.MethodProxy info AudioStreamAlign) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif