{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Information describing audio properties. This information can be filled
-- in from GstCaps with 'GI.GstAudio.Functions.audioInfoFromCaps'.
-- 
-- Use the provided macros to access the info in this structure.

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

module GI.GstAudio.Structs.AudioInfo
    ( 

-- * Exported types
    AudioInfo(..)                           ,
    newZeroAudioInfo                        ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [convert]("GI.GstAudio.Structs.AudioInfo#g:method:convert"), [copy]("GI.GstAudio.Structs.AudioInfo#g:method:copy"), [free]("GI.GstAudio.Structs.AudioInfo#g:method:free"), [isEqual]("GI.GstAudio.Structs.AudioInfo#g:method:isEqual"), [toCaps]("GI.GstAudio.Structs.AudioInfo#g:method:toCaps").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- [setFormat]("GI.GstAudio.Structs.AudioInfo#g:method:setFormat").

#if defined(ENABLE_OVERLOADING)
    ResolveAudioInfoMethod                  ,
#endif

-- ** convert #method:convert#

#if defined(ENABLE_OVERLOADING)
    AudioInfoConvertMethodInfo              ,
#endif
    audioInfoConvert                        ,


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    AudioInfoCopyMethodInfo                 ,
#endif
    audioInfoCopy                           ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    AudioInfoFreeMethodInfo                 ,
#endif
    audioInfoFree                           ,


-- ** fromCaps #method:fromCaps#

    audioInfoFromCaps                       ,


-- ** init #method:init#

    audioInfoInit                           ,


-- ** isEqual #method:isEqual#

#if defined(ENABLE_OVERLOADING)
    AudioInfoIsEqualMethodInfo              ,
#endif
    audioInfoIsEqual                        ,


-- ** new #method:new#

    audioInfoNew                            ,


-- ** setFormat #method:setFormat#

#if defined(ENABLE_OVERLOADING)
    AudioInfoSetFormatMethodInfo            ,
#endif
    audioInfoSetFormat                      ,


-- ** toCaps #method:toCaps#

#if defined(ENABLE_OVERLOADING)
    AudioInfoToCapsMethodInfo               ,
#endif
    audioInfoToCaps                         ,




 -- * Properties


-- ** bpf #attr:bpf#
-- | the number of bytes for one frame, this is the size of one
--         sample * /@channels@/

#if defined(ENABLE_OVERLOADING)
    audioInfo_bpf                           ,
#endif
    getAudioInfoBpf                         ,
    setAudioInfoBpf                         ,


-- ** channels #attr:channels#
-- | the number of channels

#if defined(ENABLE_OVERLOADING)
    audioInfo_channels                      ,
#endif
    getAudioInfoChannels                    ,
    setAudioInfoChannels                    ,


-- ** finfo #attr:finfo#
-- | the format info of the audio

#if defined(ENABLE_OVERLOADING)
    audioInfo_finfo                         ,
#endif
    clearAudioInfoFinfo                     ,
    getAudioInfoFinfo                       ,
    setAudioInfoFinfo                       ,


-- ** flags #attr:flags#
-- | additional audio flags

#if defined(ENABLE_OVERLOADING)
    audioInfo_flags                         ,
#endif
    getAudioInfoFlags                       ,
    setAudioInfoFlags                       ,


-- ** layout #attr:layout#
-- | audio layout

#if defined(ENABLE_OVERLOADING)
    audioInfo_layout                        ,
#endif
    getAudioInfoLayout                      ,
    setAudioInfoLayout                      ,


-- ** rate #attr:rate#
-- | the audio sample rate

#if defined(ENABLE_OVERLOADING)
    audioInfo_rate                          ,
#endif
    getAudioInfoRate                        ,
    setAudioInfoRate                        ,




    ) 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

import qualified GI.Gst.Enums as Gst.Enums
import qualified GI.Gst.Structs.Caps as Gst.Caps
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

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

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

foreign import ccall "gst_audio_info_get_type" c_gst_audio_info_get_type :: 
    IO GType

type instance O.ParentTypes AudioInfo = '[]
instance O.HasParentTypes AudioInfo

instance B.Types.TypedObject AudioInfo where
    glibType :: IO GType
glibType = IO GType
c_gst_audio_info_get_type

instance B.Types.GBoxed AudioInfo

-- | Convert 'AudioInfo' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe AudioInfo) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_audio_info_get_type
    gvalueSet_ :: Ptr GValue -> Maybe AudioInfo -> IO ()
gvalueSet_ Ptr GValue
gv Maybe AudioInfo
P.Nothing = Ptr GValue -> Ptr AudioInfo -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr AudioInfo
forall a. Ptr a
FP.nullPtr :: FP.Ptr AudioInfo)
    gvalueSet_ Ptr GValue
gv (P.Just AudioInfo
obj) = AudioInfo -> (Ptr AudioInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr AudioInfo
obj (Ptr GValue -> Ptr AudioInfo -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe AudioInfo)
gvalueGet_ Ptr GValue
gv = do
        Ptr AudioInfo
ptr <- Ptr GValue -> IO (Ptr AudioInfo)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr AudioInfo)
        if Ptr AudioInfo
ptr Ptr AudioInfo -> Ptr AudioInfo -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr AudioInfo
forall a. Ptr a
FP.nullPtr
        then AudioInfo -> Maybe AudioInfo
forall a. a -> Maybe a
P.Just (AudioInfo -> Maybe AudioInfo)
-> IO AudioInfo -> IO (Maybe AudioInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr AudioInfo -> AudioInfo)
-> Ptr AudioInfo -> IO AudioInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr AudioInfo -> AudioInfo
AudioInfo Ptr AudioInfo
ptr
        else Maybe AudioInfo -> IO (Maybe AudioInfo)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AudioInfo
forall a. Maybe a
P.Nothing
        
    

-- | Construct a `AudioInfo` struct initialized to zero.
newZeroAudioInfo :: MonadIO m => m AudioInfo
newZeroAudioInfo :: forall (m :: * -> *). MonadIO m => m AudioInfo
newZeroAudioInfo = IO AudioInfo -> m AudioInfo
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
$ Int -> IO (Ptr AudioInfo)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
320 IO (Ptr AudioInfo)
-> (Ptr AudioInfo -> IO AudioInfo) -> IO AudioInfo
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr AudioInfo -> AudioInfo)
-> Ptr AudioInfo -> IO AudioInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AudioInfo -> AudioInfo
AudioInfo

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


-- | Get the value of the “@finfo@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' audioInfo #finfo
-- @
getAudioInfoFinfo :: MonadIO m => AudioInfo -> m (Maybe GstAudio.AudioFormatInfo.AudioFormatInfo)
getAudioInfoFinfo :: forall (m :: * -> *).
MonadIO m =>
AudioInfo -> m (Maybe AudioFormatInfo)
getAudioInfoFinfo AudioInfo
s = IO (Maybe AudioFormatInfo) -> m (Maybe AudioFormatInfo)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe AudioFormatInfo) -> m (Maybe AudioFormatInfo))
-> IO (Maybe AudioFormatInfo) -> m (Maybe AudioFormatInfo)
forall a b. (a -> b) -> a -> b
$ AudioInfo
-> (Ptr AudioInfo -> IO (Maybe AudioFormatInfo))
-> IO (Maybe AudioFormatInfo)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioInfo
s ((Ptr AudioInfo -> IO (Maybe AudioFormatInfo))
 -> IO (Maybe AudioFormatInfo))
-> (Ptr AudioInfo -> IO (Maybe AudioFormatInfo))
-> IO (Maybe AudioFormatInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr AudioInfo
ptr -> do
    Ptr AudioFormatInfo
val <- Ptr (Ptr AudioFormatInfo) -> IO (Ptr AudioFormatInfo)
forall a. Storable a => Ptr a -> IO a
peek (Ptr AudioInfo
ptr Ptr AudioInfo -> Int -> Ptr (Ptr AudioFormatInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr GstAudio.AudioFormatInfo.AudioFormatInfo)
    Maybe AudioFormatInfo
result <- Ptr AudioFormatInfo
-> (Ptr AudioFormatInfo -> IO AudioFormatInfo)
-> IO (Maybe AudioFormatInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr AudioFormatInfo
val ((Ptr AudioFormatInfo -> IO AudioFormatInfo)
 -> IO (Maybe AudioFormatInfo))
-> (Ptr AudioFormatInfo -> IO AudioFormatInfo)
-> IO (Maybe AudioFormatInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr AudioFormatInfo
val' -> do
        AudioFormatInfo
val'' <- ((ManagedPtr AudioFormatInfo -> AudioFormatInfo)
-> Ptr AudioFormatInfo -> IO AudioFormatInfo
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr AudioFormatInfo -> AudioFormatInfo
GstAudio.AudioFormatInfo.AudioFormatInfo) Ptr AudioFormatInfo
val'
        AudioFormatInfo -> IO AudioFormatInfo
forall (m :: * -> *) a. Monad m => a -> m a
return AudioFormatInfo
val''
    Maybe AudioFormatInfo -> IO (Maybe AudioFormatInfo)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AudioFormatInfo
result

-- | Set the value of the “@finfo@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' audioInfo [ #finfo 'Data.GI.Base.Attributes.:=' value ]
-- @
setAudioInfoFinfo :: MonadIO m => AudioInfo -> Ptr GstAudio.AudioFormatInfo.AudioFormatInfo -> m ()
setAudioInfoFinfo :: forall (m :: * -> *).
MonadIO m =>
AudioInfo -> Ptr AudioFormatInfo -> m ()
setAudioInfoFinfo AudioInfo
s Ptr AudioFormatInfo
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ AudioInfo -> (Ptr AudioInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioInfo
s ((Ptr AudioInfo -> IO ()) -> IO ())
-> (Ptr AudioInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AudioInfo
ptr -> do
    Ptr (Ptr AudioFormatInfo) -> Ptr AudioFormatInfo -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AudioInfo
ptr Ptr AudioInfo -> Int -> Ptr (Ptr AudioFormatInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr AudioFormatInfo
val :: Ptr GstAudio.AudioFormatInfo.AudioFormatInfo)

-- | Set the value of the “@finfo@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #finfo
-- @
clearAudioInfoFinfo :: MonadIO m => AudioInfo -> m ()
clearAudioInfoFinfo :: forall (m :: * -> *). MonadIO m => AudioInfo -> m ()
clearAudioInfoFinfo AudioInfo
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ AudioInfo -> (Ptr AudioInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioInfo
s ((Ptr AudioInfo -> IO ()) -> IO ())
-> (Ptr AudioInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AudioInfo
ptr -> do
    Ptr (Ptr AudioFormatInfo) -> Ptr AudioFormatInfo -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AudioInfo
ptr Ptr AudioInfo -> Int -> Ptr (Ptr AudioFormatInfo)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr AudioFormatInfo
forall a. Ptr a
FP.nullPtr :: Ptr GstAudio.AudioFormatInfo.AudioFormatInfo)

#if defined(ENABLE_OVERLOADING)
data AudioInfoFinfoFieldInfo
instance AttrInfo AudioInfoFinfoFieldInfo where
    type AttrBaseTypeConstraint AudioInfoFinfoFieldInfo = (~) AudioInfo
    type AttrAllowedOps AudioInfoFinfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint AudioInfoFinfoFieldInfo = (~) (Ptr GstAudio.AudioFormatInfo.AudioFormatInfo)
    type AttrTransferTypeConstraint AudioInfoFinfoFieldInfo = (~)(Ptr GstAudio.AudioFormatInfo.AudioFormatInfo)
    type AttrTransferType AudioInfoFinfoFieldInfo = (Ptr GstAudio.AudioFormatInfo.AudioFormatInfo)
    type AttrGetType AudioInfoFinfoFieldInfo = Maybe GstAudio.AudioFormatInfo.AudioFormatInfo
    type AttrLabel AudioInfoFinfoFieldInfo = "finfo"
    type AttrOrigin AudioInfoFinfoFieldInfo = AudioInfo
    attrGet = getAudioInfoFinfo
    attrSet = setAudioInfoFinfo
    attrConstruct = undefined
    attrClear = clearAudioInfoFinfo
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Structs.AudioInfo.finfo"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioInfo.html#g:attr:finfo"
        })

audioInfo_finfo :: AttrLabelProxy "finfo"
audioInfo_finfo = AttrLabelProxy

#endif


-- | Get the value of the “@flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' audioInfo #flags
-- @
getAudioInfoFlags :: MonadIO m => AudioInfo -> m [GstAudio.Flags.AudioFlags]
getAudioInfoFlags :: forall (m :: * -> *). MonadIO m => AudioInfo -> m [AudioFlags]
getAudioInfoFlags AudioInfo
s = IO [AudioFlags] -> m [AudioFlags]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [AudioFlags] -> m [AudioFlags])
-> IO [AudioFlags] -> m [AudioFlags]
forall a b. (a -> b) -> a -> b
$ AudioInfo -> (Ptr AudioInfo -> IO [AudioFlags]) -> IO [AudioFlags]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioInfo
s ((Ptr AudioInfo -> IO [AudioFlags]) -> IO [AudioFlags])
-> (Ptr AudioInfo -> IO [AudioFlags]) -> IO [AudioFlags]
forall a b. (a -> b) -> a -> b
$ \Ptr AudioInfo
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr AudioInfo
ptr Ptr AudioInfo -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CUInt
    let val' :: [AudioFlags]
val' = CUInt -> [AudioFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
    [AudioFlags] -> IO [AudioFlags]
forall (m :: * -> *) a. Monad m => a -> m a
return [AudioFlags]
val'

-- | Set the value of the “@flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' audioInfo [ #flags 'Data.GI.Base.Attributes.:=' value ]
-- @
setAudioInfoFlags :: MonadIO m => AudioInfo -> [GstAudio.Flags.AudioFlags] -> m ()
setAudioInfoFlags :: forall (m :: * -> *).
MonadIO m =>
AudioInfo -> [AudioFlags] -> m ()
setAudioInfoFlags AudioInfo
s [AudioFlags]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ AudioInfo -> (Ptr AudioInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioInfo
s ((Ptr AudioInfo -> IO ()) -> IO ())
-> (Ptr AudioInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AudioInfo
ptr -> do
    let val' :: CUInt
val' = [AudioFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [AudioFlags]
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AudioInfo
ptr Ptr AudioInfo -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CUInt
val' :: CUInt)

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

audioInfo_flags :: AttrLabelProxy "flags"
audioInfo_flags = AttrLabelProxy

#endif


-- | Get the value of the “@layout@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' audioInfo #layout
-- @
getAudioInfoLayout :: MonadIO m => AudioInfo -> m GstAudio.Enums.AudioLayout
getAudioInfoLayout :: forall (m :: * -> *). MonadIO m => AudioInfo -> m AudioLayout
getAudioInfoLayout AudioInfo
s = IO AudioLayout -> m AudioLayout
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AudioLayout -> m AudioLayout)
-> IO AudioLayout -> m AudioLayout
forall a b. (a -> b) -> a -> b
$ AudioInfo -> (Ptr AudioInfo -> IO AudioLayout) -> IO AudioLayout
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioInfo
s ((Ptr AudioInfo -> IO AudioLayout) -> IO AudioLayout)
-> (Ptr AudioInfo -> IO AudioLayout) -> IO AudioLayout
forall a b. (a -> b) -> a -> b
$ \Ptr AudioInfo
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr AudioInfo
ptr Ptr AudioInfo -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO CUInt
    let val' :: AudioLayout
val' = (Int -> AudioLayout
forall a. Enum a => Int -> a
toEnum (Int -> AudioLayout) -> (CUInt -> Int) -> CUInt -> AudioLayout
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    AudioLayout -> IO AudioLayout
forall (m :: * -> *) a. Monad m => a -> m a
return AudioLayout
val'

-- | Set the value of the “@layout@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' audioInfo [ #layout 'Data.GI.Base.Attributes.:=' value ]
-- @
setAudioInfoLayout :: MonadIO m => AudioInfo -> GstAudio.Enums.AudioLayout -> m ()
setAudioInfoLayout :: forall (m :: * -> *). MonadIO m => AudioInfo -> AudioLayout -> m ()
setAudioInfoLayout AudioInfo
s AudioLayout
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ AudioInfo -> (Ptr AudioInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioInfo
s ((Ptr AudioInfo -> IO ()) -> IO ())
-> (Ptr AudioInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AudioInfo
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (AudioLayout -> Int) -> AudioLayout -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AudioLayout -> Int
forall a. Enum a => a -> Int
fromEnum) AudioLayout
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AudioInfo
ptr Ptr AudioInfo -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (CUInt
val' :: CUInt)

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

audioInfo_layout :: AttrLabelProxy "layout"
audioInfo_layout = AttrLabelProxy

#endif


-- | Get the value of the “@rate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' audioInfo #rate
-- @
getAudioInfoRate :: MonadIO m => AudioInfo -> m Int32
getAudioInfoRate :: forall (m :: * -> *). MonadIO m => AudioInfo -> m Int32
getAudioInfoRate AudioInfo
s = 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
$ AudioInfo -> (Ptr AudioInfo -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioInfo
s ((Ptr AudioInfo -> IO Int32) -> IO Int32)
-> (Ptr AudioInfo -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr AudioInfo
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr AudioInfo
ptr Ptr AudioInfo -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@rate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' audioInfo [ #rate 'Data.GI.Base.Attributes.:=' value ]
-- @
setAudioInfoRate :: MonadIO m => AudioInfo -> Int32 -> m ()
setAudioInfoRate :: forall (m :: * -> *). MonadIO m => AudioInfo -> Int32 -> m ()
setAudioInfoRate AudioInfo
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ AudioInfo -> (Ptr AudioInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioInfo
s ((Ptr AudioInfo -> IO ()) -> IO ())
-> (Ptr AudioInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AudioInfo
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AudioInfo
ptr Ptr AudioInfo -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Int32
val :: Int32)

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

audioInfo_rate :: AttrLabelProxy "rate"
audioInfo_rate = AttrLabelProxy

#endif


-- | Get the value of the “@channels@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' audioInfo #channels
-- @
getAudioInfoChannels :: MonadIO m => AudioInfo -> m Int32
getAudioInfoChannels :: forall (m :: * -> *). MonadIO m => AudioInfo -> m Int32
getAudioInfoChannels AudioInfo
s = 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
$ AudioInfo -> (Ptr AudioInfo -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioInfo
s ((Ptr AudioInfo -> IO Int32) -> IO Int32)
-> (Ptr AudioInfo -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr AudioInfo
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr AudioInfo
ptr Ptr AudioInfo -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@channels@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' audioInfo [ #channels 'Data.GI.Base.Attributes.:=' value ]
-- @
setAudioInfoChannels :: MonadIO m => AudioInfo -> Int32 -> m ()
setAudioInfoChannels :: forall (m :: * -> *). MonadIO m => AudioInfo -> Int32 -> m ()
setAudioInfoChannels AudioInfo
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ AudioInfo -> (Ptr AudioInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioInfo
s ((Ptr AudioInfo -> IO ()) -> IO ())
-> (Ptr AudioInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AudioInfo
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AudioInfo
ptr Ptr AudioInfo -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (Int32
val :: Int32)

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

audioInfo_channels :: AttrLabelProxy "channels"
audioInfo_channels = AttrLabelProxy

#endif


-- | Get the value of the “@bpf@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' audioInfo #bpf
-- @
getAudioInfoBpf :: MonadIO m => AudioInfo -> m Int32
getAudioInfoBpf :: forall (m :: * -> *). MonadIO m => AudioInfo -> m Int32
getAudioInfoBpf AudioInfo
s = 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
$ AudioInfo -> (Ptr AudioInfo -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioInfo
s ((Ptr AudioInfo -> IO Int32) -> IO Int32)
-> (Ptr AudioInfo -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr AudioInfo
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr AudioInfo
ptr Ptr AudioInfo -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@bpf@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' audioInfo [ #bpf 'Data.GI.Base.Attributes.:=' value ]
-- @
setAudioInfoBpf :: MonadIO m => AudioInfo -> Int32 -> m ()
setAudioInfoBpf :: forall (m :: * -> *). MonadIO m => AudioInfo -> Int32 -> m ()
setAudioInfoBpf AudioInfo
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ AudioInfo -> (Ptr AudioInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioInfo
s ((Ptr AudioInfo -> IO ()) -> IO ())
-> (Ptr AudioInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AudioInfo
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AudioInfo
ptr Ptr AudioInfo -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Int32
val :: Int32)

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

audioInfo_bpf :: AttrLabelProxy "bpf"
audioInfo_bpf = AttrLabelProxy

#endif


-- XXX Skipped attribute for "AudioInfo:position"
-- Not implemented: Don't know how to unpack C array of type TCArray False 64 (-1) (TInterface (Name {namespace = "GstAudio", name = "AudioChannelPosition"}))

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList AudioInfo
type instance O.AttributeList AudioInfo = AudioInfoAttributeList
type AudioInfoAttributeList = ('[ '("finfo", AudioInfoFinfoFieldInfo), '("flags", AudioInfoFlagsFieldInfo), '("layout", AudioInfoLayoutFieldInfo), '("rate", AudioInfoRateFieldInfo), '("channels", AudioInfoChannelsFieldInfo), '("bpf", AudioInfoBpfFieldInfo)] :: [(Symbol, *)])
#endif

-- method AudioInfo::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GstAudio" , name = "AudioInfo" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_info_new" gst_audio_info_new :: 
    IO (Ptr AudioInfo)

-- | Allocate a new t'GI.GstAudio.Structs.AudioInfo.AudioInfo' that is also initialized with
-- 'GI.GstAudio.Functions.audioInfoInit'.
audioInfoNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m AudioInfo
    -- ^ __Returns:__ a new t'GI.GstAudio.Structs.AudioInfo.AudioInfo'. free with 'GI.GstAudio.Structs.AudioInfo.audioInfoFree'.
audioInfoNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m AudioInfo
audioInfoNew  = IO AudioInfo -> m AudioInfo
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
$ do
    Ptr AudioInfo
result <- IO (Ptr AudioInfo)
gst_audio_info_new
    Text -> Ptr AudioInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"audioInfoNew" Ptr AudioInfo
result
    AudioInfo
result' <- ((ManagedPtr AudioInfo -> AudioInfo)
-> Ptr AudioInfo -> IO AudioInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AudioInfo -> AudioInfo
AudioInfo) Ptr AudioInfo
result
    AudioInfo -> IO AudioInfo
forall (m :: * -> *) a. Monad m => a -> m a
return AudioInfo
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method AudioInfo::convert
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstAudioInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "src_fmt"
--           , argType = TInterface Name { namespace = "Gst" , name = "Format" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GstFormat of the @src_val"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "src_val"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "value to convert" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dest_fmt"
--           , argType = TInterface Name { namespace = "Gst" , name = "Format" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GstFormat of the @dest_val"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dest_val"
--           , argType = TBasicType TInt64
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "pointer to destination value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_info_convert" gst_audio_info_convert :: 
    Ptr AudioInfo ->                        -- info : TInterface (Name {namespace = "GstAudio", name = "AudioInfo"})
    CUInt ->                                -- src_fmt : TInterface (Name {namespace = "Gst", name = "Format"})
    Int64 ->                                -- src_val : TBasicType TInt64
    CUInt ->                                -- dest_fmt : TInterface (Name {namespace = "Gst", name = "Format"})
    Ptr Int64 ->                            -- dest_val : TBasicType TInt64
    IO CInt

-- | Converts among various t'GI.Gst.Enums.Format' types.  This function handles
-- GST_FORMAT_BYTES, GST_FORMAT_TIME, and GST_FORMAT_DEFAULT.  For
-- raw audio, GST_FORMAT_DEFAULT corresponds to audio frames.  This
-- function can be used to handle pad queries of the type GST_QUERY_CONVERT.
audioInfoConvert ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    AudioInfo
    -- ^ /@info@/: a t'GI.GstAudio.Structs.AudioInfo.AudioInfo'
    -> Gst.Enums.Format
    -- ^ /@srcFmt@/: t'GI.Gst.Enums.Format' of the /@srcVal@/
    -> Int64
    -- ^ /@srcVal@/: value to convert
    -> Gst.Enums.Format
    -- ^ /@destFmt@/: t'GI.Gst.Enums.Format' of the /@destVal@/
    -> m ((Bool, Int64))
    -- ^ __Returns:__ TRUE if the conversion was successful.
audioInfoConvert :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioInfo -> Format -> Int64 -> Format -> m (Bool, Int64)
audioInfoConvert AudioInfo
info Format
srcFmt Int64
srcVal Format
destFmt = IO (Bool, Int64) -> m (Bool, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
    Ptr AudioInfo
info' <- AudioInfo -> IO (Ptr AudioInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioInfo
info
    let srcFmt' :: CUInt
srcFmt' = (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
srcFmt
    let destFmt' :: CUInt
destFmt' = (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
destFmt
    Ptr Int64
destVal <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
    CInt
result <- Ptr AudioInfo -> CUInt -> Int64 -> CUInt -> Ptr Int64 -> IO CInt
gst_audio_info_convert Ptr AudioInfo
info' CUInt
srcFmt' Int64
srcVal CUInt
destFmt' Ptr Int64
destVal
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Int64
destVal' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
destVal
    AudioInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioInfo
info
    Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
destVal
    (Bool, Int64) -> IO (Bool, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
destVal')

#if defined(ENABLE_OVERLOADING)
data AudioInfoConvertMethodInfo
instance (signature ~ (Gst.Enums.Format -> Int64 -> Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m) => O.OverloadedMethod AudioInfoConvertMethodInfo AudioInfo signature where
    overloadedMethod = audioInfoConvert

instance O.OverloadedMethodInfo AudioInfoConvertMethodInfo AudioInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Structs.AudioInfo.audioInfoConvert",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioInfo.html#v:audioInfoConvert"
        })


#endif

-- method AudioInfo::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstAudioInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GstAudio" , name = "AudioInfo" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_info_copy" gst_audio_info_copy :: 
    Ptr AudioInfo ->                        -- info : TInterface (Name {namespace = "GstAudio", name = "AudioInfo"})
    IO (Ptr AudioInfo)

-- | Copy a GstAudioInfo structure.
audioInfoCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    AudioInfo
    -- ^ /@info@/: a t'GI.GstAudio.Structs.AudioInfo.AudioInfo'
    -> m AudioInfo
    -- ^ __Returns:__ a new t'GI.GstAudio.Structs.AudioInfo.AudioInfo'. free with gst_audio_info_free.
audioInfoCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioInfo -> m AudioInfo
audioInfoCopy AudioInfo
info = IO AudioInfo -> m AudioInfo
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
$ do
    Ptr AudioInfo
info' <- AudioInfo -> IO (Ptr AudioInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioInfo
info
    Ptr AudioInfo
result <- Ptr AudioInfo -> IO (Ptr AudioInfo)
gst_audio_info_copy Ptr AudioInfo
info'
    Text -> Ptr AudioInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"audioInfoCopy" Ptr AudioInfo
result
    AudioInfo
result' <- ((ManagedPtr AudioInfo -> AudioInfo)
-> Ptr AudioInfo -> IO AudioInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AudioInfo -> AudioInfo
AudioInfo) Ptr AudioInfo
result
    AudioInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioInfo
info
    AudioInfo -> IO AudioInfo
forall (m :: * -> *) a. Monad m => a -> m a
return AudioInfo
result'

#if defined(ENABLE_OVERLOADING)
data AudioInfoCopyMethodInfo
instance (signature ~ (m AudioInfo), MonadIO m) => O.OverloadedMethod AudioInfoCopyMethodInfo AudioInfo signature where
    overloadedMethod = audioInfoCopy

instance O.OverloadedMethodInfo AudioInfoCopyMethodInfo AudioInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Structs.AudioInfo.audioInfoCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioInfo.html#v:audioInfoCopy"
        })


#endif

-- method AudioInfo::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstAudioInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_info_free" gst_audio_info_free :: 
    Ptr AudioInfo ->                        -- info : TInterface (Name {namespace = "GstAudio", name = "AudioInfo"})
    IO ()

-- | Free a GstAudioInfo structure previously allocated with 'GI.GstAudio.Structs.AudioInfo.audioInfoNew'
-- or 'GI.GstAudio.Structs.AudioInfo.audioInfoCopy'.
audioInfoFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    AudioInfo
    -- ^ /@info@/: a t'GI.GstAudio.Structs.AudioInfo.AudioInfo'
    -> m ()
audioInfoFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioInfo -> m ()
audioInfoFree AudioInfo
info = 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 AudioInfo
info' <- AudioInfo -> IO (Ptr AudioInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioInfo
info
    Ptr AudioInfo -> IO ()
gst_audio_info_free Ptr AudioInfo
info'
    AudioInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioInfo
info
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AudioInfoFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod AudioInfoFreeMethodInfo AudioInfo signature where
    overloadedMethod = audioInfoFree

instance O.OverloadedMethodInfo AudioInfoFreeMethodInfo AudioInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Structs.AudioInfo.audioInfoFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioInfo.html#v:audioInfoFree"
        })


#endif

-- method AudioInfo::is_equal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstAudioInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "other"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstAudioInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_info_is_equal" gst_audio_info_is_equal :: 
    Ptr AudioInfo ->                        -- info : TInterface (Name {namespace = "GstAudio", name = "AudioInfo"})
    Ptr AudioInfo ->                        -- other : TInterface (Name {namespace = "GstAudio", name = "AudioInfo"})
    IO CInt

-- | Compares two t'GI.GstAudio.Structs.AudioInfo.AudioInfo' and returns whether they are equal or not
-- 
-- /Since: 1.2/
audioInfoIsEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    AudioInfo
    -- ^ /@info@/: a t'GI.GstAudio.Structs.AudioInfo.AudioInfo'
    -> AudioInfo
    -- ^ /@other@/: a t'GI.GstAudio.Structs.AudioInfo.AudioInfo'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@info@/ and /@other@/ are equal, else 'P.False'.
audioInfoIsEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioInfo -> AudioInfo -> m Bool
audioInfoIsEqual AudioInfo
info AudioInfo
other = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr AudioInfo
info' <- AudioInfo -> IO (Ptr AudioInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioInfo
info
    Ptr AudioInfo
other' <- AudioInfo -> IO (Ptr AudioInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioInfo
other
    CInt
result <- Ptr AudioInfo -> Ptr AudioInfo -> IO CInt
gst_audio_info_is_equal Ptr AudioInfo
info' Ptr AudioInfo
other'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    AudioInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioInfo
info
    AudioInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioInfo
other
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data AudioInfoIsEqualMethodInfo
instance (signature ~ (AudioInfo -> m Bool), MonadIO m) => O.OverloadedMethod AudioInfoIsEqualMethodInfo AudioInfo signature where
    overloadedMethod = audioInfoIsEqual

instance O.OverloadedMethodInfo AudioInfoIsEqualMethodInfo AudioInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Structs.AudioInfo.audioInfoIsEqual",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioInfo.html#v:audioInfoIsEqual"
        })


#endif

-- method AudioInfo::set_format
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstAudioInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "format"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioFormat" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the format" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rate"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the samplerate" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "channels"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of channels"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType =
--               TCArray
--                 False
--                 64
--                 (-1)
--                 (TInterface
--                    Name { namespace = "GstAudio" , name = "AudioChannelPosition" })
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the channel positions"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_info_set_format" gst_audio_info_set_format :: 
    Ptr AudioInfo ->                        -- info : TInterface (Name {namespace = "GstAudio", name = "AudioInfo"})
    CUInt ->                                -- format : TInterface (Name {namespace = "GstAudio", name = "AudioFormat"})
    Int32 ->                                -- rate : TBasicType TInt
    Int32 ->                                -- channels : TBasicType TInt
    Ptr CInt ->                             -- position : TCArray False 64 (-1) (TInterface (Name {namespace = "GstAudio", name = "AudioChannelPosition"}))
    IO ()

-- | Set the default info for the audio info of /@format@/ and /@rate@/ and /@channels@/.
-- 
-- Note: This initializes /@info@/ first, no values are preserved.
audioInfoSetFormat ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    AudioInfo
    -- ^ /@info@/: a t'GI.GstAudio.Structs.AudioInfo.AudioInfo'
    -> GstAudio.Enums.AudioFormat
    -- ^ /@format@/: the format
    -> Int32
    -- ^ /@rate@/: the samplerate
    -> Int32
    -- ^ /@channels@/: the number of channels
    -> Maybe ([GstAudio.Enums.AudioChannelPosition])
    -- ^ /@position@/: the channel positions
    -> m ()
audioInfoSetFormat :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioInfo
-> AudioFormat
-> Int32
-> Int32
-> Maybe [AudioChannelPosition]
-> m ()
audioInfoSetFormat AudioInfo
info AudioFormat
format Int32
rate Int32
channels Maybe [AudioChannelPosition]
position = 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 AudioInfo
info' <- AudioInfo -> IO (Ptr AudioInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioInfo
info
    let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (AudioFormat -> Int) -> AudioFormat -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AudioFormat -> Int
forall a. Enum a => a -> Int
fromEnum) AudioFormat
format
    Ptr CInt
maybePosition <- case Maybe [AudioChannelPosition]
position of
        Maybe [AudioChannelPosition]
Nothing -> Ptr CInt -> IO (Ptr CInt)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CInt
forall a. Ptr a
nullPtr
        Just [AudioChannelPosition]
jPosition -> do
            let jPosition' :: [CInt]
jPosition' = (AudioChannelPosition -> CInt) -> [AudioChannelPosition] -> [CInt]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt)
-> (AudioChannelPosition -> Int) -> AudioChannelPosition -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AudioChannelPosition -> Int
forall a. Enum a => a -> Int
fromEnum) [AudioChannelPosition]
jPosition
            Ptr CInt
jPosition'' <- [CInt] -> IO (Ptr CInt)
forall a. Storable a => [a] -> IO (Ptr a)
packStorableArray [CInt]
jPosition'
            Ptr CInt -> IO (Ptr CInt)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CInt
jPosition''
    Ptr AudioInfo -> CUInt -> Int32 -> Int32 -> Ptr CInt -> IO ()
gst_audio_info_set_format Ptr AudioInfo
info' CUInt
format' Int32
rate Int32
channels Ptr CInt
maybePosition
    AudioInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioInfo
info
    Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
maybePosition
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AudioInfoSetFormatMethodInfo
instance (signature ~ (GstAudio.Enums.AudioFormat -> Int32 -> Int32 -> Maybe ([GstAudio.Enums.AudioChannelPosition]) -> m ()), MonadIO m) => O.OverloadedMethod AudioInfoSetFormatMethodInfo AudioInfo signature where
    overloadedMethod = audioInfoSetFormat

instance O.OverloadedMethodInfo AudioInfoSetFormatMethodInfo AudioInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Structs.AudioInfo.audioInfoSetFormat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioInfo.html#v:audioInfoSetFormat"
        })


#endif

-- method AudioInfo::to_caps
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstAudioInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Caps" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_info_to_caps" gst_audio_info_to_caps :: 
    Ptr AudioInfo ->                        -- info : TInterface (Name {namespace = "GstAudio", name = "AudioInfo"})
    IO (Ptr Gst.Caps.Caps)

-- | Convert the values of /@info@/ into a t'GI.Gst.Structs.Caps.Caps'.
audioInfoToCaps ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    AudioInfo
    -- ^ /@info@/: a t'GI.GstAudio.Structs.AudioInfo.AudioInfo'
    -> m Gst.Caps.Caps
    -- ^ __Returns:__ the new t'GI.Gst.Structs.Caps.Caps' containing the
    --          info of /@info@/.
audioInfoToCaps :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AudioInfo -> m Caps
audioInfoToCaps AudioInfo
info = IO Caps -> m Caps
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Caps -> m Caps) -> IO Caps -> m Caps
forall a b. (a -> b) -> a -> b
$ do
    Ptr AudioInfo
info' <- AudioInfo -> IO (Ptr AudioInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AudioInfo
info
    Ptr Caps
result <- Ptr AudioInfo -> IO (Ptr Caps)
gst_audio_info_to_caps Ptr AudioInfo
info'
    Text -> Ptr Caps -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"audioInfoToCaps" Ptr Caps
result
    Caps
result' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result
    AudioInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AudioInfo
info
    Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result'

#if defined(ENABLE_OVERLOADING)
data AudioInfoToCapsMethodInfo
instance (signature ~ (m Gst.Caps.Caps), MonadIO m) => O.OverloadedMethod AudioInfoToCapsMethodInfo AudioInfo signature where
    overloadedMethod = audioInfoToCaps

instance O.OverloadedMethodInfo AudioInfoToCapsMethodInfo AudioInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstAudio.Structs.AudioInfo.audioInfoToCaps",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstaudio-1.0.24/docs/GI-GstAudio-Structs-AudioInfo.html#v:audioInfoToCaps"
        })


#endif

-- method AudioInfo::from_caps
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioInfo" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstAudioInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "caps"
--           , argType = TInterface Name { namespace = "Gst" , name = "Caps" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstCaps" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_info_from_caps" gst_audio_info_from_caps :: 
    Ptr AudioInfo ->                        -- info : TInterface (Name {namespace = "GstAudio", name = "AudioInfo"})
    Ptr Gst.Caps.Caps ->                    -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
    IO CInt

-- | Parse /@caps@/ and update /@info@/.
audioInfoFromCaps ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gst.Caps.Caps
    -- ^ /@caps@/: a t'GI.Gst.Structs.Caps.Caps'
    -> m ((Bool, AudioInfo))
    -- ^ __Returns:__ TRUE if /@caps@/ could be parsed
audioInfoFromCaps :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Caps -> m (Bool, AudioInfo)
audioInfoFromCaps Caps
caps = IO (Bool, AudioInfo) -> m (Bool, AudioInfo)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, AudioInfo) -> m (Bool, AudioInfo))
-> IO (Bool, AudioInfo) -> m (Bool, AudioInfo)
forall a b. (a -> b) -> a -> b
$ do
    Ptr AudioInfo
info <- Int -> IO (Ptr AudioInfo)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
320 :: IO (Ptr AudioInfo)
    Ptr Caps
caps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
    CInt
result <- Ptr AudioInfo -> Ptr Caps -> IO CInt
gst_audio_info_from_caps Ptr AudioInfo
info Ptr Caps
caps'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    AudioInfo
info' <- ((ManagedPtr AudioInfo -> AudioInfo)
-> Ptr AudioInfo -> IO AudioInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AudioInfo -> AudioInfo
AudioInfo) Ptr AudioInfo
info
    Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
    (Bool, AudioInfo) -> IO (Bool, AudioInfo)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', AudioInfo
info')

#if defined(ENABLE_OVERLOADING)
#endif

-- method AudioInfo::init
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "AudioInfo" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstAudioInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_info_init" gst_audio_info_init :: 
    Ptr AudioInfo ->                        -- info : TInterface (Name {namespace = "GstAudio", name = "AudioInfo"})
    IO ()

-- | Initialize /@info@/ with default values.
audioInfoInit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m (AudioInfo)
audioInfoInit :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m AudioInfo
audioInfoInit  = IO AudioInfo -> m AudioInfo
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
$ do
    Ptr AudioInfo
info <- Int -> IO (Ptr AudioInfo)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
320 :: IO (Ptr AudioInfo)
    Ptr AudioInfo -> IO ()
gst_audio_info_init Ptr AudioInfo
info
    AudioInfo
info' <- ((ManagedPtr AudioInfo -> AudioInfo)
-> Ptr AudioInfo -> IO AudioInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AudioInfo -> AudioInfo
AudioInfo) Ptr AudioInfo
info
    AudioInfo -> IO AudioInfo
forall (m :: * -> *) a. Monad m => a -> m a
return AudioInfo
info'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveAudioInfoMethod (t :: Symbol) (o :: *) :: * where
    ResolveAudioInfoMethod "convert" o = AudioInfoConvertMethodInfo
    ResolveAudioInfoMethod "copy" o = AudioInfoCopyMethodInfo
    ResolveAudioInfoMethod "free" o = AudioInfoFreeMethodInfo
    ResolveAudioInfoMethod "isEqual" o = AudioInfoIsEqualMethodInfo
    ResolveAudioInfoMethod "toCaps" o = AudioInfoToCapsMethodInfo
    ResolveAudioInfoMethod "setFormat" o = AudioInfoSetFormatMethodInfo
    ResolveAudioInfoMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif