{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Information describing DSD audio properties.
-- 
-- In DSD, the \"sample format\" is the bit. Unlike PCM, there are no further
-- \"sample formats\" in DSD. However, in software, DSD bits are grouped into
-- bytes (since dealing with individual bits is impractical), and these bytes
-- in turn are grouped into words. This becomes relevant when interleaving
-- channels and transmitting DSD data through audio APIs. The different
-- types of grouping DSD bytes are referred to as the \"DSD grouping forma\"
-- or just \"DSD format\". t'GI.GstAudio.Enums.DsdFormat' has a list of valid ways of grouping
-- DSD bytes into words.
-- 
-- DSD rates are equivalent to PCM sample rates, except that they specify
-- how many DSD bytes are consumed per second. This refers to the bytes per
-- second _per channel_; the rate does not change when the number of channel
-- changes. (Strictly speaking, it would be more correct to measure the
-- *bits* per second, since the bit is the DSD \"sample format\", but it is
-- more practical to use bytes.) In DSD, bit rates are always an integer
-- multiple of the CD audio rate (44100) or the DAT rate (48000). DSD64-44x
-- is 44100 * 64 = 2822400 bits per second, or 352800 bytes per second
-- (the latter would be used in this info structure). DSD64-48x is
-- 48000 * 64 = 3072000 bits per second, or 384000 bytes per second.
-- @/GST_DSD_MAKE_DSD_RATE_44x/@ can be used for specifying DSD-44x rates,
-- *and @/GST_DSD_MAKE_DSD_RATE_48x/@ can be used for specifying DSD-48x ones.
-- Also, since DSD-48x is less well known, when the multiplier is given
-- without the 44x\/48x specifier, 44x is typically implied.
-- 
-- It is important to know that in DSD, different format widths correspond
-- to different playtimes. That is, a word with 32 DSD bits covers two times
-- as much playtime as a word with 16 DSD bits. This is in contrast to PCM,
-- where one word (= one PCM sample) always covers a time period of 1\/samplerate,
-- no matter how many bits a PCM sample is made of. For this reason, DSD
-- and PCM widths and strides cannot be used the same way.
-- 
-- Multiple channels are arranged in DSD data either interleaved or non-
-- interleaved. This is similar to PCM. Interleaved layouts rotate between
-- channels and words. First, word 0 of channel 0 is present. Then word
-- 0 of channel 1 follows. Then word 0 of channel 2 etc. until all
-- channels are through, then comes word 1 of channel 0 etc.
-- 
-- Non-interleaved data is planar. First, all words of channel 0 are
-- present, then all words of channel 1 etc. Unlike interleaved data,
-- non-interleaved data can be sparse, that is, there can be space in
-- between the planes. the /@positions@/ array specifies the plane offsets.
-- 
-- In uncommon cases, the DSD bits in the data bytes can be stored in reverse
-- order. For example, normally, in DSDU8, the first byte contains DSD bits
-- 0 to 7, and the most significant bit of that byte is DSD bit 0. If this
-- order is reversed, then bit 7 is the first one instead. In that ase,
-- /@reversedBytes@/ is set to TRUE.
-- 
-- Use the provided macros to access the info in this structure.
-- 
-- /Since: 1.24/

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

module GI.GstAudio.Structs.DsdInfo
    ( 

-- * Exported types
    DsdInfo(..)                             ,
    newZeroDsdInfo                          ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveDsdInfoMethod                    ,
#endif

-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    DsdInfoCopyMethodInfo                   ,
#endif
    dsdInfoCopy                             ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    DsdInfoFreeMethodInfo                   ,
#endif
    dsdInfoFree                             ,


-- ** fromCaps #method:fromCaps#

    dsdInfoFromCaps                         ,


-- ** init #method:init#

    dsdInfoInit                             ,


-- ** isEqual #method:isEqual#

#if defined(ENABLE_OVERLOADING)
    DsdInfoIsEqualMethodInfo                ,
#endif
    dsdInfoIsEqual                          ,


-- ** new #method:new#

    dsdInfoNew                              ,


-- ** newFromCaps #method:newFromCaps#

    dsdInfoNewFromCaps                      ,


-- ** setFormat #method:setFormat#

#if defined(ENABLE_OVERLOADING)
    DsdInfoSetFormatMethodInfo              ,
#endif
    dsdInfoSetFormat                        ,


-- ** toCaps #method:toCaps#

#if defined(ENABLE_OVERLOADING)
    DsdInfoToCapsMethodInfo                 ,
#endif
    dsdInfoToCaps                           ,




 -- * Properties


-- ** channels #attr:channels#
-- | number of channels (must be at least 1)

#if defined(ENABLE_OVERLOADING)
    dsdInfo_channels                        ,
#endif
    getDsdInfoChannels                      ,
    setDsdInfoChannels                      ,


-- ** flags #attr:flags#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    dsdInfo_flags                           ,
#endif
    getDsdInfoFlags                         ,
    setDsdInfoFlags                         ,


-- ** format #attr:format#
-- | DSD grouping format

#if defined(ENABLE_OVERLOADING)
    dsdInfo_format                          ,
#endif
    getDsdInfoFormat                        ,
    setDsdInfoFormat                        ,


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

#if defined(ENABLE_OVERLOADING)
    dsdInfo_layout                          ,
#endif
    getDsdInfoLayout                        ,
    setDsdInfoLayout                        ,


-- ** rate #attr:rate#
-- | DSD rate

#if defined(ENABLE_OVERLOADING)
    dsdInfo_rate                            ,
#endif
    getDsdInfoRate                          ,
    setDsdInfoRate                          ,


-- ** reversedBytes #attr:reversedBytes#
-- | true if the DSD bits in the data bytes are reversed,
--   that is, the least significant bit comes first

#if defined(ENABLE_OVERLOADING)
    dsdInfo_reversedBytes                   ,
#endif
    getDsdInfoReversedBytes                 ,
    setDsdInfoReversedBytes                 ,




    ) 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.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.GstAudio.Enums as GstAudio.Enums
import {-# SOURCE #-} qualified GI.GstAudio.Flags as GstAudio.Flags

#else
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

#endif

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

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

foreign import ccall "gst_dsd_info_get_type" c_gst_dsd_info_get_type :: 
    IO GType

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

instance B.Types.TypedObject DsdInfo where
    glibType :: IO GType
glibType = IO GType
c_gst_dsd_info_get_type

instance B.Types.GBoxed DsdInfo

-- | Convert 'DsdInfo' 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 DsdInfo) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_dsd_info_get_type
    gvalueSet_ :: Ptr GValue -> Maybe DsdInfo -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DsdInfo
P.Nothing = Ptr GValue -> Ptr DsdInfo -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr DsdInfo
forall a. Ptr a
FP.nullPtr :: FP.Ptr DsdInfo)
    gvalueSet_ Ptr GValue
gv (P.Just DsdInfo
obj) = DsdInfo -> (Ptr DsdInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DsdInfo
obj (Ptr GValue -> Ptr DsdInfo -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe DsdInfo)
gvalueGet_ Ptr GValue
gv = do
        Ptr DsdInfo
ptr <- Ptr GValue -> IO (Ptr DsdInfo)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr DsdInfo)
        if Ptr DsdInfo
ptr Ptr DsdInfo -> Ptr DsdInfo -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr DsdInfo
forall a. Ptr a
FP.nullPtr
        then DsdInfo -> Maybe DsdInfo
forall a. a -> Maybe a
P.Just (DsdInfo -> Maybe DsdInfo) -> IO DsdInfo -> IO (Maybe DsdInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr DsdInfo -> DsdInfo) -> Ptr DsdInfo -> IO DsdInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr DsdInfo -> DsdInfo
DsdInfo Ptr DsdInfo
ptr
        else Maybe DsdInfo -> IO (Maybe DsdInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DsdInfo
forall a. Maybe a
P.Nothing
        
    

-- | Construct a `DsdInfo` struct initialized to zero.
newZeroDsdInfo :: MonadIO m => m DsdInfo
newZeroDsdInfo :: forall (m :: * -> *). MonadIO m => m DsdInfo
newZeroDsdInfo = IO DsdInfo -> m DsdInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DsdInfo -> m DsdInfo) -> IO DsdInfo -> m DsdInfo
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr DsdInfo)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
312 IO (Ptr DsdInfo) -> (Ptr DsdInfo -> IO DsdInfo) -> IO DsdInfo
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr DsdInfo -> DsdInfo) -> Ptr DsdInfo -> IO DsdInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DsdInfo -> DsdInfo
DsdInfo

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


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

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

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

dsdInfo_format :: AttrLabelProxy "format"
dsdInfo_format = 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' dsdInfo #rate
-- @
getDsdInfoRate :: MonadIO m => DsdInfo -> m Int32
getDsdInfoRate :: forall (m :: * -> *). MonadIO m => DsdInfo -> m Int32
getDsdInfoRate DsdInfo
s = IO Int32 -> m Int32
forall a. IO a -> m a
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
$ DsdInfo -> (Ptr DsdInfo -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DsdInfo
s ((Ptr DsdInfo -> IO Int32) -> IO Int32)
-> (Ptr DsdInfo -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr DsdInfo
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr DsdInfo
ptr Ptr DsdInfo -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO Int32
    Int32 -> IO Int32
forall a. a -> IO a
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' dsdInfo [ #rate 'Data.GI.Base.Attributes.:=' value ]
-- @
setDsdInfoRate :: MonadIO m => DsdInfo -> Int32 -> m ()
setDsdInfoRate :: forall (m :: * -> *). MonadIO m => DsdInfo -> Int32 -> m ()
setDsdInfoRate DsdInfo
s Int32
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
$ DsdInfo -> (Ptr DsdInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DsdInfo
s ((Ptr DsdInfo -> IO ()) -> IO ())
-> (Ptr DsdInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DsdInfo
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DsdInfo
ptr Ptr DsdInfo -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Int32
val :: Int32)

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

dsdInfo_rate :: AttrLabelProxy "rate"
dsdInfo_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' dsdInfo #channels
-- @
getDsdInfoChannels :: MonadIO m => DsdInfo -> m Int32
getDsdInfoChannels :: forall (m :: * -> *). MonadIO m => DsdInfo -> m Int32
getDsdInfoChannels DsdInfo
s = IO Int32 -> m Int32
forall a. IO a -> m a
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
$ DsdInfo -> (Ptr DsdInfo -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DsdInfo
s ((Ptr DsdInfo -> IO Int32) -> IO Int32)
-> (Ptr DsdInfo -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr DsdInfo
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr DsdInfo
ptr Ptr DsdInfo -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Int32
    Int32 -> IO Int32
forall a. a -> IO a
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' dsdInfo [ #channels 'Data.GI.Base.Attributes.:=' value ]
-- @
setDsdInfoChannels :: MonadIO m => DsdInfo -> Int32 -> m ()
setDsdInfoChannels :: forall (m :: * -> *). MonadIO m => DsdInfo -> Int32 -> m ()
setDsdInfoChannels DsdInfo
s Int32
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
$ DsdInfo -> (Ptr DsdInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DsdInfo
s ((Ptr DsdInfo -> IO ()) -> IO ())
-> (Ptr DsdInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DsdInfo
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DsdInfo
ptr Ptr DsdInfo -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Int32
val :: Int32)

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

dsdInfo_channels :: AttrLabelProxy "channels"
dsdInfo_channels = 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' dsdInfo #layout
-- @
getDsdInfoLayout :: MonadIO m => DsdInfo -> m GstAudio.Enums.AudioLayout
getDsdInfoLayout :: forall (m :: * -> *). MonadIO m => DsdInfo -> m AudioLayout
getDsdInfoLayout DsdInfo
s = IO AudioLayout -> m AudioLayout
forall a. IO a -> m a
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
$ DsdInfo -> (Ptr DsdInfo -> IO AudioLayout) -> IO AudioLayout
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DsdInfo
s ((Ptr DsdInfo -> IO AudioLayout) -> IO AudioLayout)
-> (Ptr DsdInfo -> IO AudioLayout) -> IO AudioLayout
forall a b. (a -> b) -> a -> b
$ \Ptr DsdInfo
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr DsdInfo
ptr Ptr DsdInfo -> 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 a. a -> IO a
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' dsdInfo [ #layout 'Data.GI.Base.Attributes.:=' value ]
-- @
setDsdInfoLayout :: MonadIO m => DsdInfo -> GstAudio.Enums.AudioLayout -> m ()
setDsdInfoLayout :: forall (m :: * -> *). MonadIO m => DsdInfo -> AudioLayout -> m ()
setDsdInfoLayout DsdInfo
s AudioLayout
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
$ DsdInfo -> (Ptr DsdInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DsdInfo
s ((Ptr DsdInfo -> IO ()) -> IO ())
-> (Ptr DsdInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DsdInfo
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 DsdInfo
ptr Ptr DsdInfo -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (CUInt
val' :: CUInt)

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

dsdInfo_layout :: AttrLabelProxy "layout"
dsdInfo_layout = AttrLabelProxy

#endif


-- | Get the value of the “@reversed_bytes@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' dsdInfo #reversedBytes
-- @
getDsdInfoReversedBytes :: MonadIO m => DsdInfo -> m Bool
getDsdInfoReversedBytes :: forall (m :: * -> *). MonadIO m => DsdInfo -> m Bool
getDsdInfoReversedBytes DsdInfo
s = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ DsdInfo -> (Ptr DsdInfo -> IO Bool) -> IO Bool
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DsdInfo
s ((Ptr DsdInfo -> IO Bool) -> IO Bool)
-> (Ptr DsdInfo -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr DsdInfo
ptr -> do
    CInt
val <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr DsdInfo
ptr Ptr DsdInfo -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CInt
    let val' :: Bool
val' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
val'

-- | Set the value of the “@reversed_bytes@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' dsdInfo [ #reversedBytes 'Data.GI.Base.Attributes.:=' value ]
-- @
setDsdInfoReversedBytes :: MonadIO m => DsdInfo -> Bool -> m ()
setDsdInfoReversedBytes :: forall (m :: * -> *). MonadIO m => DsdInfo -> Bool -> m ()
setDsdInfoReversedBytes DsdInfo
s Bool
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
$ DsdInfo -> (Ptr DsdInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DsdInfo
s ((Ptr DsdInfo -> IO ()) -> IO ())
-> (Ptr DsdInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DsdInfo
ptr -> do
    let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
val
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DsdInfo
ptr Ptr DsdInfo -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CInt
val' :: CInt)

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

dsdInfo_reversedBytes :: AttrLabelProxy "reversedBytes"
dsdInfo_reversedBytes = AttrLabelProxy

#endif


-- XXX Skipped attribute for "DsdInfo:positions"
-- Not implemented: Don't know how to unpack C array of type TCArray False 64 (-1) (TInterface (Name {namespace = "GstAudio", name = "AudioChannelPosition"}))
-- | 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' dsdInfo #flags
-- @
getDsdInfoFlags :: MonadIO m => DsdInfo -> m [GstAudio.Flags.AudioFlags]
getDsdInfoFlags :: forall (m :: * -> *). MonadIO m => DsdInfo -> m [AudioFlags]
getDsdInfoFlags DsdInfo
s = IO [AudioFlags] -> m [AudioFlags]
forall a. IO a -> m a
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
$ DsdInfo -> (Ptr DsdInfo -> IO [AudioFlags]) -> IO [AudioFlags]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DsdInfo
s ((Ptr DsdInfo -> IO [AudioFlags]) -> IO [AudioFlags])
-> (Ptr DsdInfo -> IO [AudioFlags]) -> IO [AudioFlags]
forall a b. (a -> b) -> a -> b
$ \Ptr DsdInfo
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr DsdInfo
ptr Ptr DsdInfo -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
276) :: 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 a. a -> IO a
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' dsdInfo [ #flags 'Data.GI.Base.Attributes.:=' value ]
-- @
setDsdInfoFlags :: MonadIO m => DsdInfo -> [GstAudio.Flags.AudioFlags] -> m ()
setDsdInfoFlags :: forall (m :: * -> *). MonadIO m => DsdInfo -> [AudioFlags] -> m ()
setDsdInfoFlags DsdInfo
s [AudioFlags]
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
$ DsdInfo -> (Ptr DsdInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DsdInfo
s ((Ptr DsdInfo -> IO ()) -> IO ())
-> (Ptr DsdInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr DsdInfo
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 DsdInfo
ptr Ptr DsdInfo -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
276) (CUInt
val' :: CUInt)

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

dsdInfo_flags :: AttrLabelProxy "flags"
dsdInfo_flags = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DsdInfo
type instance O.AttributeList DsdInfo = DsdInfoAttributeList
type DsdInfoAttributeList = ('[ '("format", DsdInfoFormatFieldInfo), '("rate", DsdInfoRateFieldInfo), '("channels", DsdInfoChannelsFieldInfo), '("layout", DsdInfoLayoutFieldInfo), '("reversedBytes", DsdInfoReversedBytesFieldInfo), '("flags", DsdInfoFlagsFieldInfo)] :: [(Symbol, DK.Type)])
#endif

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

foreign import ccall "gst_dsd_info_new" gst_dsd_info_new :: 
    IO (Ptr DsdInfo)

-- | Allocate a new t'GI.GstAudio.Structs.DsdInfo.DsdInfo' that is also initialized with
-- 'GI.GstAudio.Functions.dsdInfoInit'.
-- 
-- /Since: 1.24/
dsdInfoNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m DsdInfo
    -- ^ __Returns:__ a new t'GI.GstAudio.Structs.DsdInfo.DsdInfo'. free with 'GI.GstAudio.Structs.DsdInfo.dsdInfoFree'.
dsdInfoNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m DsdInfo
dsdInfoNew  = IO DsdInfo -> m DsdInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DsdInfo -> m DsdInfo) -> IO DsdInfo -> m DsdInfo
forall a b. (a -> b) -> a -> b
$ do
    Ptr DsdInfo
result <- IO (Ptr DsdInfo)
gst_dsd_info_new
    Text -> Ptr DsdInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dsdInfoNew" Ptr DsdInfo
result
    DsdInfo
result' <- ((ManagedPtr DsdInfo -> DsdInfo) -> Ptr DsdInfo -> IO DsdInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DsdInfo -> DsdInfo
DsdInfo) Ptr DsdInfo
result
    DsdInfo -> IO DsdInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DsdInfo
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method DsdInfo::new_from_caps
-- method type : Constructor
-- Args: [ 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GstAudio" , name = "DsdInfo" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_dsd_info_new_from_caps" gst_dsd_info_new_from_caps :: 
    Ptr Gst.Caps.Caps ->                    -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
    IO (Ptr DsdInfo)

-- | Parse /@caps@/ to generate a t'GI.GstAudio.Structs.DsdInfo.DsdInfo'.
-- 
-- /Since: 1.24/
dsdInfoNewFromCaps ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gst.Caps.Caps
    -- ^ /@caps@/: a t'GI.Gst.Structs.Caps.Caps'
    -> m DsdInfo
    -- ^ __Returns:__ A t'GI.GstAudio.Structs.DsdInfo.DsdInfo', or 'P.Nothing' if /@caps@/ couldn\'t be parsed
dsdInfoNewFromCaps :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Caps -> m DsdInfo
dsdInfoNewFromCaps Caps
caps = IO DsdInfo -> m DsdInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DsdInfo -> m DsdInfo) -> IO DsdInfo -> m DsdInfo
forall a b. (a -> b) -> a -> b
$ do
    Ptr Caps
caps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
    Ptr DsdInfo
result <- Ptr Caps -> IO (Ptr DsdInfo)
gst_dsd_info_new_from_caps Ptr Caps
caps'
    Text -> Ptr DsdInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dsdInfoNewFromCaps" Ptr DsdInfo
result
    DsdInfo
result' <- ((ManagedPtr DsdInfo -> DsdInfo) -> Ptr DsdInfo -> IO DsdInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DsdInfo -> DsdInfo
DsdInfo) Ptr DsdInfo
result
    Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
    DsdInfo -> IO DsdInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DsdInfo
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

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

-- | Copy a GstDsdInfo structure.
-- 
-- /Since: 1.24/
dsdInfoCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    DsdInfo
    -- ^ /@info@/: a t'GI.GstAudio.Structs.DsdInfo.DsdInfo'
    -> m DsdInfo
    -- ^ __Returns:__ a new t'GI.GstAudio.Structs.DsdInfo.DsdInfo'. free with gst_dsd_info_free.
dsdInfoCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DsdInfo -> m DsdInfo
dsdInfoCopy DsdInfo
info = IO DsdInfo -> m DsdInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DsdInfo -> m DsdInfo) -> IO DsdInfo -> m DsdInfo
forall a b. (a -> b) -> a -> b
$ do
    Ptr DsdInfo
info' <- DsdInfo -> IO (Ptr DsdInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DsdInfo
info
    Ptr DsdInfo
result <- Ptr DsdInfo -> IO (Ptr DsdInfo)
gst_dsd_info_copy Ptr DsdInfo
info'
    Text -> Ptr DsdInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dsdInfoCopy" Ptr DsdInfo
result
    DsdInfo
result' <- ((ManagedPtr DsdInfo -> DsdInfo) -> Ptr DsdInfo -> IO DsdInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DsdInfo -> DsdInfo
DsdInfo) Ptr DsdInfo
result
    DsdInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DsdInfo
info
    DsdInfo -> IO DsdInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DsdInfo
result'

#if defined(ENABLE_OVERLOADING)
data DsdInfoCopyMethodInfo
instance (signature ~ (m DsdInfo), MonadIO m) => O.OverloadedMethod DsdInfoCopyMethodInfo DsdInfo signature where
    overloadedMethod = dsdInfoCopy

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


#endif

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

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

-- | Free a GstDsdInfo structure previously allocated with 'GI.GstAudio.Structs.DsdInfo.dsdInfoNew'
-- or 'GI.GstAudio.Structs.DsdInfo.dsdInfoCopy'.
-- 
-- /Since: 1.24/
dsdInfoFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    DsdInfo
    -- ^ /@info@/: a t'GI.GstAudio.Structs.DsdInfo.DsdInfo'
    -> m ()
dsdInfoFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => DsdInfo -> m ()
dsdInfoFree DsdInfo
info = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DsdInfo
info' <- DsdInfo -> IO (Ptr DsdInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DsdInfo
info
    Ptr DsdInfo -> IO ()
gst_dsd_info_free Ptr DsdInfo
info'
    DsdInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DsdInfo
info
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DsdInfoFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod DsdInfoFreeMethodInfo DsdInfo signature where
    overloadedMethod = dsdInfoFree

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


#endif

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

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

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

#if defined(ENABLE_OVERLOADING)
data DsdInfoIsEqualMethodInfo
instance (signature ~ (DsdInfo -> m Bool), MonadIO m) => O.OverloadedMethod DsdInfoIsEqualMethodInfo DsdInfo signature where
    overloadedMethod = dsdInfoIsEqual

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


#endif

-- method DsdInfo::set_format
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "DsdInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDsdInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "format"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "DsdFormat" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the format" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rate"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the DSD rate" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "positions"
--           , 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Set the default info for the DSD info of /@format@/ and /@rate@/ and /@channels@/.
-- 
-- Note: This initializes /@info@/ first, no values are preserved.
-- 
-- /Since: 1.24/
dsdInfoSetFormat ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    DsdInfo
    -- ^ /@info@/: a t'GI.GstAudio.Structs.DsdInfo.DsdInfo'
    -> GstAudio.Enums.DsdFormat
    -- ^ /@format@/: the format
    -> Int32
    -- ^ /@rate@/: the DSD rate
    -> Int32
    -- ^ /@channels@/: the number of channels
    -> Maybe ([GstAudio.Enums.AudioChannelPosition])
    -- ^ /@positions@/: the channel positions
    -> m ()
dsdInfoSetFormat :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DsdInfo
-> DsdFormat
-> Int32
-> Int32
-> Maybe [AudioChannelPosition]
-> m ()
dsdInfoSetFormat DsdInfo
info DsdFormat
format Int32
rate Int32
channels Maybe [AudioChannelPosition]
positions = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DsdInfo
info' <- DsdInfo -> IO (Ptr DsdInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DsdInfo
info
    let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (DsdFormat -> Int) -> DsdFormat -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DsdFormat -> Int
forall a. Enum a => a -> Int
fromEnum) DsdFormat
format
    Ptr CInt
maybePositions <- case Maybe [AudioChannelPosition]
positions of
        Maybe [AudioChannelPosition]
Nothing -> Ptr CInt -> IO (Ptr CInt)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CInt
forall a. Ptr a
nullPtr
        Just [AudioChannelPosition]
jPositions -> do
            let jPositions' :: [CInt]
jPositions' = (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]
jPositions
            Ptr CInt
jPositions'' <- [CInt] -> IO (Ptr CInt)
forall a. Storable a => [a] -> IO (Ptr a)
packStorableArray [CInt]
jPositions'
            Ptr CInt -> IO (Ptr CInt)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CInt
jPositions''
    Ptr DsdInfo -> CUInt -> Int32 -> Int32 -> Ptr CInt -> IO ()
gst_dsd_info_set_format Ptr DsdInfo
info' CUInt
format' Int32
rate Int32
channels Ptr CInt
maybePositions
    DsdInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DsdInfo
info
    Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
maybePositions
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DsdInfoSetFormatMethodInfo
instance (signature ~ (GstAudio.Enums.DsdFormat -> Int32 -> Int32 -> Maybe ([GstAudio.Enums.AudioChannelPosition]) -> m ()), MonadIO m) => O.OverloadedMethod DsdInfoSetFormatMethodInfo DsdInfo signature where
    overloadedMethod = dsdInfoSetFormat

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


#endif

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

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

-- | Convert the values of /@info@/ into a t'GI.Gst.Structs.Caps.Caps'.
-- 
-- /Since: 1.24/
dsdInfoToCaps ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    DsdInfo
    -- ^ /@info@/: a t'GI.GstAudio.Structs.DsdInfo.DsdInfo'
    -> m Gst.Caps.Caps
    -- ^ __Returns:__ the new t'GI.Gst.Structs.Caps.Caps' containing the
    --          info of /@info@/.
dsdInfoToCaps :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DsdInfo -> m Caps
dsdInfoToCaps DsdInfo
info = IO Caps -> m Caps
forall a. IO a -> m a
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 DsdInfo
info' <- DsdInfo -> IO (Ptr DsdInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DsdInfo
info
    Ptr Caps
result <- Ptr DsdInfo -> IO (Ptr Caps)
gst_dsd_info_to_caps Ptr DsdInfo
info'
    Text -> Ptr Caps -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dsdInfoToCaps" 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
    DsdInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DsdInfo
info
    Caps -> IO Caps
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result'

#if defined(ENABLE_OVERLOADING)
data DsdInfoToCapsMethodInfo
instance (signature ~ (m Gst.Caps.Caps), MonadIO m) => O.OverloadedMethod DsdInfoToCapsMethodInfo DsdInfo signature where
    overloadedMethod = dsdInfoToCaps

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


#endif

-- method DsdInfo::from_caps
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "GstAudio" , name = "DsdInfo" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDsdInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

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

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

#if defined(ENABLE_OVERLOADING)
#endif

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

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

-- | Initialize /@info@/ with default values.
-- 
-- /Since: 1.24/
dsdInfoInit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m (DsdInfo)
dsdInfoInit :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m DsdInfo
dsdInfoInit  = IO DsdInfo -> m DsdInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DsdInfo -> m DsdInfo) -> IO DsdInfo -> m DsdInfo
forall a b. (a -> b) -> a -> b
$ do
    Ptr DsdInfo
info <- Int -> IO (Ptr DsdInfo)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
312 :: IO (Ptr DsdInfo)
    Ptr DsdInfo -> IO ()
gst_dsd_info_init Ptr DsdInfo
info
    DsdInfo
info' <- ((ManagedPtr DsdInfo -> DsdInfo) -> Ptr DsdInfo -> IO DsdInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DsdInfo -> DsdInfo
DsdInfo) Ptr DsdInfo
info
    DsdInfo -> IO DsdInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DsdInfo
info'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveDsdInfoMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveDsdInfoMethod "copy" o = DsdInfoCopyMethodInfo
    ResolveDsdInfoMethod "free" o = DsdInfoFreeMethodInfo
    ResolveDsdInfoMethod "isEqual" o = DsdInfoIsEqualMethodInfo
    ResolveDsdInfoMethod "toCaps" o = DsdInfoToCapsMethodInfo
    ResolveDsdInfoMethod "setFormat" o = DsdInfoSetFormatMethodInfo
    ResolveDsdInfoMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif