{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstAudio.Structs.AudioClippingMeta
(
AudioClippingMeta(..) ,
newZeroAudioClippingMeta ,
#if defined(ENABLE_OVERLOADING)
ResolveAudioClippingMetaMethod ,
#endif
audioClippingMetaGetInfo ,
#if defined(ENABLE_OVERLOADING)
audioClippingMeta_end ,
#endif
getAudioClippingMetaEnd ,
setAudioClippingMetaEnd ,
#if defined(ENABLE_OVERLOADING)
audioClippingMeta_format ,
#endif
getAudioClippingMetaFormat ,
setAudioClippingMetaFormat ,
#if defined(ENABLE_OVERLOADING)
audioClippingMeta_meta ,
#endif
getAudioClippingMetaMeta ,
#if defined(ENABLE_OVERLOADING)
audioClippingMeta_start ,
#endif
getAudioClippingMetaStart ,
setAudioClippingMetaStart ,
) 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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.Gst.Enums as Gst.Enums
import qualified GI.Gst.Structs.Meta as Gst.Meta
import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo
newtype AudioClippingMeta = AudioClippingMeta (SP.ManagedPtr AudioClippingMeta)
deriving (AudioClippingMeta -> AudioClippingMeta -> Bool
(AudioClippingMeta -> AudioClippingMeta -> Bool)
-> (AudioClippingMeta -> AudioClippingMeta -> Bool)
-> Eq AudioClippingMeta
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioClippingMeta -> AudioClippingMeta -> Bool
$c/= :: AudioClippingMeta -> AudioClippingMeta -> Bool
== :: AudioClippingMeta -> AudioClippingMeta -> Bool
$c== :: AudioClippingMeta -> AudioClippingMeta -> Bool
Eq)
instance SP.ManagedPtrNewtype AudioClippingMeta where
toManagedPtr :: AudioClippingMeta -> ManagedPtr AudioClippingMeta
toManagedPtr (AudioClippingMeta ManagedPtr AudioClippingMeta
p) = ManagedPtr AudioClippingMeta
p
instance BoxedPtr AudioClippingMeta where
boxedPtrCopy :: AudioClippingMeta -> IO AudioClippingMeta
boxedPtrCopy = \AudioClippingMeta
p -> AudioClippingMeta
-> (Ptr AudioClippingMeta -> IO AudioClippingMeta)
-> IO AudioClippingMeta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr AudioClippingMeta
p (Int -> Ptr AudioClippingMeta -> IO (Ptr AudioClippingMeta)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
40 (Ptr AudioClippingMeta -> IO (Ptr AudioClippingMeta))
-> (Ptr AudioClippingMeta -> IO AudioClippingMeta)
-> Ptr AudioClippingMeta
-> IO AudioClippingMeta
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr AudioClippingMeta -> AudioClippingMeta)
-> Ptr AudioClippingMeta -> IO AudioClippingMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr AudioClippingMeta -> AudioClippingMeta
AudioClippingMeta)
boxedPtrFree :: AudioClippingMeta -> IO ()
boxedPtrFree = \AudioClippingMeta
x -> AudioClippingMeta -> (Ptr AudioClippingMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr AudioClippingMeta
x Ptr AudioClippingMeta -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr AudioClippingMeta where
boxedPtrCalloc :: IO (Ptr AudioClippingMeta)
boxedPtrCalloc = Int -> IO (Ptr AudioClippingMeta)
forall a. Int -> IO (Ptr a)
callocBytes Int
40
newZeroAudioClippingMeta :: MonadIO m => m AudioClippingMeta
newZeroAudioClippingMeta :: forall (m :: * -> *). MonadIO m => m AudioClippingMeta
newZeroAudioClippingMeta = IO AudioClippingMeta -> m AudioClippingMeta
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AudioClippingMeta -> m AudioClippingMeta)
-> IO AudioClippingMeta -> m AudioClippingMeta
forall a b. (a -> b) -> a -> b
$ IO (Ptr AudioClippingMeta)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr AudioClippingMeta)
-> (Ptr AudioClippingMeta -> IO AudioClippingMeta)
-> IO AudioClippingMeta
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr AudioClippingMeta -> AudioClippingMeta)
-> Ptr AudioClippingMeta -> IO AudioClippingMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr AudioClippingMeta -> AudioClippingMeta
AudioClippingMeta
instance tag ~ 'AttrSet => Constructible AudioClippingMeta tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr AudioClippingMeta -> AudioClippingMeta)
-> [AttrOp AudioClippingMeta tag] -> m AudioClippingMeta
new ManagedPtr AudioClippingMeta -> AudioClippingMeta
_ [AttrOp AudioClippingMeta tag]
attrs = do
AudioClippingMeta
o <- m AudioClippingMeta
forall (m :: * -> *). MonadIO m => m AudioClippingMeta
newZeroAudioClippingMeta
AudioClippingMeta -> [AttrOp AudioClippingMeta 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set AudioClippingMeta
o [AttrOp AudioClippingMeta tag]
[AttrOp AudioClippingMeta 'AttrSet]
attrs
AudioClippingMeta -> m AudioClippingMeta
forall (m :: * -> *) a. Monad m => a -> m a
return AudioClippingMeta
o
getAudioClippingMetaMeta :: MonadIO m => AudioClippingMeta -> m Gst.Meta.Meta
getAudioClippingMetaMeta :: forall (m :: * -> *). MonadIO m => AudioClippingMeta -> m Meta
getAudioClippingMetaMeta AudioClippingMeta
s = IO Meta -> m Meta
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Meta -> m Meta) -> IO Meta -> m Meta
forall a b. (a -> b) -> a -> b
$ AudioClippingMeta -> (Ptr AudioClippingMeta -> IO Meta) -> IO Meta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioClippingMeta
s ((Ptr AudioClippingMeta -> IO Meta) -> IO Meta)
-> (Ptr AudioClippingMeta -> IO Meta) -> IO Meta
forall a b. (a -> b) -> a -> b
$ \Ptr AudioClippingMeta
ptr -> do
let val :: Ptr Meta
val = Ptr AudioClippingMeta
ptr Ptr AudioClippingMeta -> Int -> Ptr Meta
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Gst.Meta.Meta)
Meta
val' <- ((ManagedPtr Meta -> Meta) -> Ptr Meta -> IO Meta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Meta -> Meta
Gst.Meta.Meta) Ptr Meta
val
Meta -> IO Meta
forall (m :: * -> *) a. Monad m => a -> m a
return Meta
val'
#if defined(ENABLE_OVERLOADING)
data AudioClippingMetaMetaFieldInfo
instance AttrInfo AudioClippingMetaMetaFieldInfo where
type AttrBaseTypeConstraint AudioClippingMetaMetaFieldInfo = (~) AudioClippingMeta
type AttrAllowedOps AudioClippingMetaMetaFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint AudioClippingMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta)
type AttrTransferTypeConstraint AudioClippingMetaMetaFieldInfo = (~)(Ptr Gst.Meta.Meta)
type AttrTransferType AudioClippingMetaMetaFieldInfo = (Ptr Gst.Meta.Meta)
type AttrGetType AudioClippingMetaMetaFieldInfo = Gst.Meta.Meta
type AttrLabel AudioClippingMetaMetaFieldInfo = "meta"
type AttrOrigin AudioClippingMetaMetaFieldInfo = AudioClippingMeta
attrGet = getAudioClippingMetaMeta
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
audioClippingMeta_meta :: AttrLabelProxy "meta"
audioClippingMeta_meta = AttrLabelProxy
#endif
getAudioClippingMetaFormat :: MonadIO m => AudioClippingMeta -> m Gst.Enums.Format
getAudioClippingMetaFormat :: forall (m :: * -> *). MonadIO m => AudioClippingMeta -> m Format
getAudioClippingMetaFormat AudioClippingMeta
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
$ AudioClippingMeta
-> (Ptr AudioClippingMeta -> IO Format) -> IO Format
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioClippingMeta
s ((Ptr AudioClippingMeta -> IO Format) -> IO Format)
-> (Ptr AudioClippingMeta -> IO Format) -> IO Format
forall a b. (a -> b) -> a -> b
$ \Ptr AudioClippingMeta
ptr -> do
CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr AudioClippingMeta
ptr Ptr AudioClippingMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: 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'
setAudioClippingMetaFormat :: MonadIO m => AudioClippingMeta -> Gst.Enums.Format -> m ()
setAudioClippingMetaFormat :: forall (m :: * -> *).
MonadIO m =>
AudioClippingMeta -> Format -> m ()
setAudioClippingMetaFormat AudioClippingMeta
s Format
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ AudioClippingMeta -> (Ptr AudioClippingMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioClippingMeta
s ((Ptr AudioClippingMeta -> IO ()) -> IO ())
-> (Ptr AudioClippingMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AudioClippingMeta
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 AudioClippingMeta
ptr Ptr AudioClippingMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data AudioClippingMetaFormatFieldInfo
instance AttrInfo AudioClippingMetaFormatFieldInfo where
type AttrBaseTypeConstraint AudioClippingMetaFormatFieldInfo = (~) AudioClippingMeta
type AttrAllowedOps AudioClippingMetaFormatFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint AudioClippingMetaFormatFieldInfo = (~) Gst.Enums.Format
type AttrTransferTypeConstraint AudioClippingMetaFormatFieldInfo = (~)Gst.Enums.Format
type AttrTransferType AudioClippingMetaFormatFieldInfo = Gst.Enums.Format
type AttrGetType AudioClippingMetaFormatFieldInfo = Gst.Enums.Format
type AttrLabel AudioClippingMetaFormatFieldInfo = "format"
type AttrOrigin AudioClippingMetaFormatFieldInfo = AudioClippingMeta
attrGet = getAudioClippingMetaFormat
attrSet = setAudioClippingMetaFormat
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
audioClippingMeta_format :: AttrLabelProxy "format"
audioClippingMeta_format = AttrLabelProxy
#endif
getAudioClippingMetaStart :: MonadIO m => AudioClippingMeta -> m Word64
getAudioClippingMetaStart :: forall (m :: * -> *). MonadIO m => AudioClippingMeta -> m Word64
getAudioClippingMetaStart AudioClippingMeta
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
$ AudioClippingMeta
-> (Ptr AudioClippingMeta -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioClippingMeta
s ((Ptr AudioClippingMeta -> IO Word64) -> IO Word64)
-> (Ptr AudioClippingMeta -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr AudioClippingMeta
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr AudioClippingMeta
ptr Ptr AudioClippingMeta -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setAudioClippingMetaStart :: MonadIO m => AudioClippingMeta -> Word64 -> m ()
setAudioClippingMetaStart :: forall (m :: * -> *).
MonadIO m =>
AudioClippingMeta -> Word64 -> m ()
setAudioClippingMetaStart AudioClippingMeta
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ AudioClippingMeta -> (Ptr AudioClippingMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioClippingMeta
s ((Ptr AudioClippingMeta -> IO ()) -> IO ())
-> (Ptr AudioClippingMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AudioClippingMeta
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AudioClippingMeta
ptr Ptr AudioClippingMeta -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data AudioClippingMetaStartFieldInfo
instance AttrInfo AudioClippingMetaStartFieldInfo where
type AttrBaseTypeConstraint AudioClippingMetaStartFieldInfo = (~) AudioClippingMeta
type AttrAllowedOps AudioClippingMetaStartFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint AudioClippingMetaStartFieldInfo = (~) Word64
type AttrTransferTypeConstraint AudioClippingMetaStartFieldInfo = (~)Word64
type AttrTransferType AudioClippingMetaStartFieldInfo = Word64
type AttrGetType AudioClippingMetaStartFieldInfo = Word64
type AttrLabel AudioClippingMetaStartFieldInfo = "start"
type AttrOrigin AudioClippingMetaStartFieldInfo = AudioClippingMeta
attrGet = getAudioClippingMetaStart
attrSet = setAudioClippingMetaStart
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
audioClippingMeta_start :: AttrLabelProxy "start"
audioClippingMeta_start = AttrLabelProxy
#endif
getAudioClippingMetaEnd :: MonadIO m => AudioClippingMeta -> m Word64
getAudioClippingMetaEnd :: forall (m :: * -> *). MonadIO m => AudioClippingMeta -> m Word64
getAudioClippingMetaEnd AudioClippingMeta
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
$ AudioClippingMeta
-> (Ptr AudioClippingMeta -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioClippingMeta
s ((Ptr AudioClippingMeta -> IO Word64) -> IO Word64)
-> (Ptr AudioClippingMeta -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \Ptr AudioClippingMeta
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr AudioClippingMeta
ptr Ptr AudioClippingMeta -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setAudioClippingMetaEnd :: MonadIO m => AudioClippingMeta -> Word64 -> m ()
setAudioClippingMetaEnd :: forall (m :: * -> *).
MonadIO m =>
AudioClippingMeta -> Word64 -> m ()
setAudioClippingMetaEnd AudioClippingMeta
s Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ AudioClippingMeta -> (Ptr AudioClippingMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioClippingMeta
s ((Ptr AudioClippingMeta -> IO ()) -> IO ())
-> (Ptr AudioClippingMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AudioClippingMeta
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AudioClippingMeta
ptr Ptr AudioClippingMeta -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data AudioClippingMetaEndFieldInfo
instance AttrInfo AudioClippingMetaEndFieldInfo where
type AttrBaseTypeConstraint AudioClippingMetaEndFieldInfo = (~) AudioClippingMeta
type AttrAllowedOps AudioClippingMetaEndFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint AudioClippingMetaEndFieldInfo = (~) Word64
type AttrTransferTypeConstraint AudioClippingMetaEndFieldInfo = (~)Word64
type AttrTransferType AudioClippingMetaEndFieldInfo = Word64
type AttrGetType AudioClippingMetaEndFieldInfo = Word64
type AttrLabel AudioClippingMetaEndFieldInfo = "end"
type AttrOrigin AudioClippingMetaEndFieldInfo = AudioClippingMeta
attrGet = getAudioClippingMetaEnd
attrSet = setAudioClippingMetaEnd
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
audioClippingMeta_end :: AttrLabelProxy "end"
audioClippingMeta_end = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList AudioClippingMeta
type instance O.AttributeList AudioClippingMeta = AudioClippingMetaAttributeList
type AudioClippingMetaAttributeList = ('[ '("meta", AudioClippingMetaMetaFieldInfo), '("format", AudioClippingMetaFormatFieldInfo), '("start", AudioClippingMetaStartFieldInfo), '("end", AudioClippingMetaEndFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_audio_clipping_meta_get_info" gst_audio_clipping_meta_get_info ::
IO (Ptr Gst.MetaInfo.MetaInfo)
audioClippingMetaGetInfo ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Gst.MetaInfo.MetaInfo
audioClippingMetaGetInfo :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m MetaInfo
audioClippingMetaGetInfo = IO MetaInfo -> m MetaInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MetaInfo -> m MetaInfo) -> IO MetaInfo -> m MetaInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr MetaInfo
result <- IO (Ptr MetaInfo)
gst_audio_clipping_meta_get_info
Text -> Ptr MetaInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"audioClippingMetaGetInfo" Ptr MetaInfo
result
MetaInfo
result' <- ((ManagedPtr MetaInfo -> MetaInfo) -> Ptr MetaInfo -> IO MetaInfo
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr MetaInfo -> MetaInfo
Gst.MetaInfo.MetaInfo) Ptr MetaInfo
result
MetaInfo -> IO MetaInfo
forall (m :: * -> *) a. Monad m => a -> m a
return MetaInfo
result'
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveAudioClippingMetaMethod (t :: Symbol) (o :: *) :: * where
ResolveAudioClippingMetaMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveAudioClippingMetaMethod t AudioClippingMeta, O.OverloadedMethod info AudioClippingMeta p) => OL.IsLabel t (AudioClippingMeta -> 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 ~ ResolveAudioClippingMetaMethod t AudioClippingMeta, O.OverloadedMethod info AudioClippingMeta p, R.HasField t AudioClippingMeta p) => R.HasField t AudioClippingMeta p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveAudioClippingMetaMethod t AudioClippingMeta, O.OverloadedMethodInfo info AudioClippingMeta) => OL.IsLabel t (O.MethodProxy info AudioClippingMeta) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif