{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.GstAudio.Structs.AudioDownmixMeta.AudioDownmixMeta' defines an audio downmix matrix to be send along with
-- audio buffers. These functions in this module help to create and attach the
-- meta as well as extracting it.
-- 
-- /Since: 1.16/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.GstAudio.Structs.AudioMeta
    ( 

-- * Exported types
    AudioMeta(..)                           ,
    newZeroAudioMeta                        ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveAudioMetaMethod                  ,
#endif

-- ** getInfo #method:getInfo#

    audioMetaGetInfo                        ,




 -- * Properties


-- ** info #attr:info#
-- | the audio properties of the buffer

#if defined(ENABLE_OVERLOADING)
    audioMeta_info                          ,
#endif
    getAudioMetaInfo                        ,


-- ** meta #attr:meta#
-- | parent t'GI.Gst.Structs.Meta.Meta'

#if defined(ENABLE_OVERLOADING)
    audioMeta_meta                          ,
#endif
    getAudioMetaMeta                        ,


-- ** offsets #attr:offsets#
-- | the offsets (in bytes) where each channel plane starts in the
--   buffer or 'P.Nothing' if the buffer has interleaved layout; if not 'P.Nothing', this
--   is guaranteed to be an array of /@info@/.channels elements

#if defined(ENABLE_OVERLOADING)
    audioMeta_offsets                       ,
#endif
    getAudioMetaOffsets                     ,
    setAudioMetaOffsets                     ,


-- ** samples #attr:samples#
-- | the number of valid samples in the buffer

#if defined(ENABLE_OVERLOADING)
    audioMeta_samples                       ,
#endif
    getAudioMetaSamples                     ,
    setAudioMetaSamples                     ,




    ) 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 qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Gst.Enums as Gst.Enums
import qualified GI.Gst.Structs.Caps as Gst.Caps
import qualified GI.Gst.Structs.Meta as Gst.Meta
import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo
import qualified GI.GstAudio.Callbacks as GstAudio.Callbacks
import {-# SOURCE #-} qualified GI.GstAudio.Enums as GstAudio.Enums
import {-# SOURCE #-} qualified GI.GstAudio.Flags as GstAudio.Flags
import {-# SOURCE #-} qualified GI.GstAudio.Structs.AudioFormatInfo as GstAudio.AudioFormatInfo
import {-# SOURCE #-} qualified GI.GstAudio.Structs.AudioInfo as GstAudio.AudioInfo

#else
import qualified GI.Gst.Structs.Meta as Gst.Meta
import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo
import {-# SOURCE #-} qualified GI.GstAudio.Structs.AudioInfo as GstAudio.AudioInfo

#endif

-- | Memory-managed wrapper type.
newtype AudioMeta = AudioMeta (SP.ManagedPtr AudioMeta)
    deriving (AudioMeta -> AudioMeta -> Bool
(AudioMeta -> AudioMeta -> Bool)
-> (AudioMeta -> AudioMeta -> Bool) -> Eq AudioMeta
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AudioMeta -> AudioMeta -> Bool
== :: AudioMeta -> AudioMeta -> Bool
$c/= :: AudioMeta -> AudioMeta -> Bool
/= :: AudioMeta -> AudioMeta -> Bool
Eq)

instance SP.ManagedPtrNewtype AudioMeta where
    toManagedPtr :: AudioMeta -> ManagedPtr AudioMeta
toManagedPtr (AudioMeta ManagedPtr AudioMeta
p) = ManagedPtr AudioMeta
p

instance BoxedPtr AudioMeta where
    boxedPtrCopy :: AudioMeta -> IO AudioMeta
boxedPtrCopy = \AudioMeta
p -> AudioMeta -> (Ptr AudioMeta -> IO AudioMeta) -> IO AudioMeta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr AudioMeta
p (Int -> Ptr AudioMeta -> IO (Ptr AudioMeta)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
448 (Ptr AudioMeta -> IO (Ptr AudioMeta))
-> (Ptr AudioMeta -> IO AudioMeta) -> Ptr AudioMeta -> IO AudioMeta
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr AudioMeta -> AudioMeta)
-> Ptr AudioMeta -> IO AudioMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr AudioMeta -> AudioMeta
AudioMeta)
    boxedPtrFree :: AudioMeta -> IO ()
boxedPtrFree = \AudioMeta
x -> AudioMeta -> (Ptr AudioMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr AudioMeta
x Ptr AudioMeta -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr AudioMeta where
    boxedPtrCalloc :: IO (Ptr AudioMeta)
boxedPtrCalloc = Int -> IO (Ptr AudioMeta)
forall a. Int -> IO (Ptr a)
callocBytes Int
448


-- | Construct a `AudioMeta` struct initialized to zero.
newZeroAudioMeta :: MonadIO m => m AudioMeta
newZeroAudioMeta :: forall (m :: * -> *). MonadIO m => m AudioMeta
newZeroAudioMeta = IO AudioMeta -> m AudioMeta
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AudioMeta -> m AudioMeta) -> IO AudioMeta -> m AudioMeta
forall a b. (a -> b) -> a -> b
$ IO (Ptr AudioMeta)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr AudioMeta)
-> (Ptr AudioMeta -> IO AudioMeta) -> IO AudioMeta
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr AudioMeta -> AudioMeta)
-> Ptr AudioMeta -> IO AudioMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr AudioMeta -> AudioMeta
AudioMeta

instance tag ~ 'AttrSet => Constructible AudioMeta tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr AudioMeta -> AudioMeta)
-> [AttrOp AudioMeta tag] -> m AudioMeta
new ManagedPtr AudioMeta -> AudioMeta
_ [AttrOp AudioMeta tag]
attrs = do
        AudioMeta
o <- m AudioMeta
forall (m :: * -> *). MonadIO m => m AudioMeta
newZeroAudioMeta
        AudioMeta -> [AttrOp AudioMeta 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set AudioMeta
o [AttrOp AudioMeta tag]
[AttrOp AudioMeta 'AttrSet]
attrs
        AudioMeta -> m AudioMeta
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return AudioMeta
o


-- | Get the value of the “@meta@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' audioMeta #meta
-- @
getAudioMetaMeta :: MonadIO m => AudioMeta -> m Gst.Meta.Meta
getAudioMetaMeta :: forall (m :: * -> *). MonadIO m => AudioMeta -> m Meta
getAudioMetaMeta AudioMeta
s = IO Meta -> m Meta
forall a. IO a -> m a
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
$ AudioMeta -> (Ptr AudioMeta -> IO Meta) -> IO Meta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioMeta
s ((Ptr AudioMeta -> IO Meta) -> IO Meta)
-> (Ptr AudioMeta -> IO Meta) -> IO Meta
forall a b. (a -> b) -> a -> b
$ \Ptr AudioMeta
ptr -> do
    let val :: Ptr Meta
val = Ptr AudioMeta
ptr Ptr AudioMeta -> 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Meta
val'

#if defined(ENABLE_OVERLOADING)
data AudioMetaMetaFieldInfo
instance AttrInfo AudioMetaMetaFieldInfo where
    type AttrBaseTypeConstraint AudioMetaMetaFieldInfo = (~) AudioMeta
    type AttrAllowedOps AudioMetaMetaFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint AudioMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta)
    type AttrTransferTypeConstraint AudioMetaMetaFieldInfo = (~)(Ptr Gst.Meta.Meta)
    type AttrTransferType AudioMetaMetaFieldInfo = (Ptr Gst.Meta.Meta)
    type AttrGetType AudioMetaMetaFieldInfo = Gst.Meta.Meta
    type AttrLabel AudioMetaMetaFieldInfo = "meta"
    type AttrOrigin AudioMetaMetaFieldInfo = AudioMeta
    attrGet = getAudioMetaMeta
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Structs.AudioMeta.meta"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.28/docs/GI-GstAudio-Structs-AudioMeta.html#g:attr:meta"
        })

audioMeta_meta :: AttrLabelProxy "meta"
audioMeta_meta = AttrLabelProxy

#endif


-- | Get the value of the “@info@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' audioMeta #info
-- @
getAudioMetaInfo :: MonadIO m => AudioMeta -> m GstAudio.AudioInfo.AudioInfo
getAudioMetaInfo :: forall (m :: * -> *). MonadIO m => AudioMeta -> m AudioInfo
getAudioMetaInfo AudioMeta
s = IO AudioInfo -> m AudioInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AudioInfo -> m AudioInfo) -> IO AudioInfo -> m AudioInfo
forall a b. (a -> b) -> a -> b
$ AudioMeta -> (Ptr AudioMeta -> IO AudioInfo) -> IO AudioInfo
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioMeta
s ((Ptr AudioMeta -> IO AudioInfo) -> IO AudioInfo)
-> (Ptr AudioMeta -> IO AudioInfo) -> IO AudioInfo
forall a b. (a -> b) -> a -> b
$ \Ptr AudioMeta
ptr -> do
    let val :: Ptr AudioInfo
val = Ptr AudioMeta
ptr Ptr AudioMeta -> Int -> Ptr AudioInfo
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: (Ptr GstAudio.AudioInfo.AudioInfo)
    AudioInfo
val' <- ((ManagedPtr AudioInfo -> AudioInfo)
-> Ptr AudioInfo -> IO AudioInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr AudioInfo -> AudioInfo
GstAudio.AudioInfo.AudioInfo) Ptr AudioInfo
val
    AudioInfo -> IO AudioInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return AudioInfo
val'

#if defined(ENABLE_OVERLOADING)
data AudioMetaInfoFieldInfo
instance AttrInfo AudioMetaInfoFieldInfo where
    type AttrBaseTypeConstraint AudioMetaInfoFieldInfo = (~) AudioMeta
    type AttrAllowedOps AudioMetaInfoFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint AudioMetaInfoFieldInfo = (~) (Ptr GstAudio.AudioInfo.AudioInfo)
    type AttrTransferTypeConstraint AudioMetaInfoFieldInfo = (~)(Ptr GstAudio.AudioInfo.AudioInfo)
    type AttrTransferType AudioMetaInfoFieldInfo = (Ptr GstAudio.AudioInfo.AudioInfo)
    type AttrGetType AudioMetaInfoFieldInfo = GstAudio.AudioInfo.AudioInfo
    type AttrLabel AudioMetaInfoFieldInfo = "info"
    type AttrOrigin AudioMetaInfoFieldInfo = AudioMeta
    attrGet = getAudioMetaInfo
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Structs.AudioMeta.info"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.28/docs/GI-GstAudio-Structs-AudioMeta.html#g:attr:info"
        })

audioMeta_info :: AttrLabelProxy "info"
audioMeta_info = AttrLabelProxy

#endif


-- | Get the value of the “@samples@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' audioMeta #samples
-- @
getAudioMetaSamples :: MonadIO m => AudioMeta -> m FCT.CSize
getAudioMetaSamples :: forall (m :: * -> *). MonadIO m => AudioMeta -> m CSize
getAudioMetaSamples AudioMeta
s = IO CSize -> m CSize
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
forall a b. (a -> b) -> a -> b
$ AudioMeta -> (Ptr AudioMeta -> IO CSize) -> IO CSize
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioMeta
s ((Ptr AudioMeta -> IO CSize) -> IO CSize)
-> (Ptr AudioMeta -> IO CSize) -> IO CSize
forall a b. (a -> b) -> a -> b
$ \Ptr AudioMeta
ptr -> do
    CSize
val <- Ptr CSize -> IO CSize
forall a. Storable a => Ptr a -> IO a
peek (Ptr AudioMeta
ptr Ptr AudioMeta -> Int -> Ptr CSize
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
336) :: IO FCT.CSize
    CSize -> IO CSize
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CSize
val

-- | Set the value of the “@samples@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' audioMeta [ #samples 'Data.GI.Base.Attributes.:=' value ]
-- @
setAudioMetaSamples :: MonadIO m => AudioMeta -> FCT.CSize -> m ()
setAudioMetaSamples :: forall (m :: * -> *). MonadIO m => AudioMeta -> CSize -> m ()
setAudioMetaSamples AudioMeta
s CSize
val = 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
$ AudioMeta -> (Ptr AudioMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioMeta
s ((Ptr AudioMeta -> IO ()) -> IO ())
-> (Ptr AudioMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AudioMeta
ptr -> do
    Ptr CSize -> CSize -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AudioMeta
ptr Ptr AudioMeta -> Int -> Ptr CSize
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
336) (CSize
val :: FCT.CSize)

#if defined(ENABLE_OVERLOADING)
data AudioMetaSamplesFieldInfo
instance AttrInfo AudioMetaSamplesFieldInfo where
    type AttrBaseTypeConstraint AudioMetaSamplesFieldInfo = (~) AudioMeta
    type AttrAllowedOps AudioMetaSamplesFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AudioMetaSamplesFieldInfo = (~) FCT.CSize
    type AttrTransferTypeConstraint AudioMetaSamplesFieldInfo = (~)FCT.CSize
    type AttrTransferType AudioMetaSamplesFieldInfo = FCT.CSize
    type AttrGetType AudioMetaSamplesFieldInfo = FCT.CSize
    type AttrLabel AudioMetaSamplesFieldInfo = "samples"
    type AttrOrigin AudioMetaSamplesFieldInfo = AudioMeta
    attrGet = getAudioMetaSamples
    attrSet = setAudioMetaSamples
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Structs.AudioMeta.samples"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.28/docs/GI-GstAudio-Structs-AudioMeta.html#g:attr:samples"
        })

audioMeta_samples :: AttrLabelProxy "samples"
audioMeta_samples = AttrLabelProxy

#endif


-- | Get the value of the “@offsets@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' audioMeta #offsets
-- @
getAudioMetaOffsets :: MonadIO m => AudioMeta -> m FCT.CSize
getAudioMetaOffsets :: forall (m :: * -> *). MonadIO m => AudioMeta -> m CSize
getAudioMetaOffsets AudioMeta
s = IO CSize -> m CSize
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CSize -> m CSize) -> IO CSize -> m CSize
forall a b. (a -> b) -> a -> b
$ AudioMeta -> (Ptr AudioMeta -> IO CSize) -> IO CSize
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioMeta
s ((Ptr AudioMeta -> IO CSize) -> IO CSize)
-> (Ptr AudioMeta -> IO CSize) -> IO CSize
forall a b. (a -> b) -> a -> b
$ \Ptr AudioMeta
ptr -> do
    CSize
val <- Ptr CSize -> IO CSize
forall a. Storable a => Ptr a -> IO a
peek (Ptr AudioMeta
ptr Ptr AudioMeta -> Int -> Ptr CSize
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
344) :: IO FCT.CSize
    CSize -> IO CSize
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CSize
val

-- | Set the value of the “@offsets@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' audioMeta [ #offsets 'Data.GI.Base.Attributes.:=' value ]
-- @
setAudioMetaOffsets :: MonadIO m => AudioMeta -> FCT.CSize -> m ()
setAudioMetaOffsets :: forall (m :: * -> *). MonadIO m => AudioMeta -> CSize -> m ()
setAudioMetaOffsets AudioMeta
s CSize
val = 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
$ AudioMeta -> (Ptr AudioMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioMeta
s ((Ptr AudioMeta -> IO ()) -> IO ())
-> (Ptr AudioMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AudioMeta
ptr -> do
    Ptr CSize -> CSize -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AudioMeta
ptr Ptr AudioMeta -> Int -> Ptr CSize
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
344) (CSize
val :: FCT.CSize)

#if defined(ENABLE_OVERLOADING)
data AudioMetaOffsetsFieldInfo
instance AttrInfo AudioMetaOffsetsFieldInfo where
    type AttrBaseTypeConstraint AudioMetaOffsetsFieldInfo = (~) AudioMeta
    type AttrAllowedOps AudioMetaOffsetsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AudioMetaOffsetsFieldInfo = (~) FCT.CSize
    type AttrTransferTypeConstraint AudioMetaOffsetsFieldInfo = (~)FCT.CSize
    type AttrTransferType AudioMetaOffsetsFieldInfo = FCT.CSize
    type AttrGetType AudioMetaOffsetsFieldInfo = FCT.CSize
    type AttrLabel AudioMetaOffsetsFieldInfo = "offsets"
    type AttrOrigin AudioMetaOffsetsFieldInfo = AudioMeta
    attrGet = getAudioMetaOffsets
    attrSet = setAudioMetaOffsets
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Structs.AudioMeta.offsets"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.28/docs/GI-GstAudio-Structs-AudioMeta.html#g:attr:offsets"
        })

audioMeta_offsets :: AttrLabelProxy "offsets"
audioMeta_offsets = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList AudioMeta
type instance O.AttributeList AudioMeta = AudioMetaAttributeList
type AudioMetaAttributeList = ('[ '("meta", AudioMetaMetaFieldInfo), '("info", AudioMetaInfoFieldInfo), '("samples", AudioMetaSamplesFieldInfo), '("offsets", AudioMetaOffsetsFieldInfo)] :: [(Symbol, DK.Type)])
#endif

-- method AudioMeta::get_info
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "MetaInfo" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_meta_get_info" gst_audio_meta_get_info :: 
    IO (Ptr Gst.MetaInfo.MetaInfo)

-- | /No description available in the introspection data./
audioMetaGetInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Gst.MetaInfo.MetaInfo
audioMetaGetInfo :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m MetaInfo
audioMetaGetInfo  = IO MetaInfo -> m MetaInfo
forall a. IO a -> m a
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_meta_get_info
    Text -> Ptr MetaInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"audioMetaGetInfo" 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MetaInfo
result'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveAudioMetaMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveAudioMetaMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveAudioMetaMethod t AudioMeta, O.OverloadedMethod info AudioMeta p) => OL.IsLabel t (AudioMeta -> 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 ~ ResolveAudioMetaMethod t AudioMeta, O.OverloadedMethod info AudioMeta p, R.HasField t AudioMeta p) => R.HasField t AudioMeta p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveAudioMetaMethod t AudioMeta, O.OverloadedMethodInfo info AudioMeta) => OL.IsLabel t (O.MethodProxy info AudioMeta) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif