{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
-}

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

module GI.GstAudio.Enums
    (

 -- * Enumerations
-- ** AudioBaseSinkDiscontReason #enum:AudioBaseSinkDiscontReason#

    AudioBaseSinkDiscontReason(..)          ,


-- ** AudioBaseSinkSlaveMethod #enum:AudioBaseSinkSlaveMethod#

    AudioBaseSinkSlaveMethod(..)            ,


-- ** AudioBaseSrcSlaveMethod #enum:AudioBaseSrcSlaveMethod#

    AudioBaseSrcSlaveMethod(..)             ,


-- ** AudioCdSrcMode #enum:AudioCdSrcMode#

    AudioCdSrcMode(..)                      ,


-- ** AudioChannelPosition #enum:AudioChannelPosition#

    AudioChannelPosition(..)                ,


-- ** AudioDitherMethod #enum:AudioDitherMethod#

    AudioDitherMethod(..)                   ,


-- ** AudioFormat #enum:AudioFormat#

    AudioFormat(..)                         ,


-- ** AudioLayout #enum:AudioLayout#

    AudioLayout(..)                         ,


-- ** AudioNoiseShapingMethod #enum:AudioNoiseShapingMethod#

    AudioNoiseShapingMethod(..)             ,


-- ** AudioResamplerFilterInterpolation #enum:AudioResamplerFilterInterpolation#

    AudioResamplerFilterInterpolation(..)   ,


-- ** AudioResamplerFilterMode #enum:AudioResamplerFilterMode#

    AudioResamplerFilterMode(..)            ,


-- ** AudioResamplerMethod #enum:AudioResamplerMethod#

    AudioResamplerMethod(..)                ,


-- ** AudioRingBufferFormatType #enum:AudioRingBufferFormatType#

    AudioRingBufferFormatType(..)           ,


-- ** AudioRingBufferState #enum:AudioRingBufferState#

    AudioRingBufferState(..)                ,


-- ** StreamVolumeFormat #enum:StreamVolumeFormat#

    StreamVolumeFormat(..)                  ,




    ) 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.ManagedPtr as B.ManagedPtr
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.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


-- Enum StreamVolumeFormat
{- |
Different representations of a stream volume. 'GI.GstAudio.Functions.streamVolumeConvertVolume'
allows to convert between the different representations.

Formulas to convert from a linear to a cubic or dB volume are
cbrt(val) and 20 * log10 (val).
-}
data StreamVolumeFormat =
      StreamVolumeFormatLinear
    {- ^
    Linear scale factor, 1.0 = 100%
    -}
    | StreamVolumeFormatCubic
    {- ^
    Cubic volume scale
    -}
    | StreamVolumeFormatDb
    {- ^
    Logarithmic volume scale (dB, amplitude not power)
    -}
    | AnotherStreamVolumeFormat Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum StreamVolumeFormat where
    fromEnum StreamVolumeFormatLinear = 0
    fromEnum StreamVolumeFormatCubic = 1
    fromEnum StreamVolumeFormatDb = 2
    fromEnum (AnotherStreamVolumeFormat k) = k

    toEnum 0 = StreamVolumeFormatLinear
    toEnum 1 = StreamVolumeFormatCubic
    toEnum 2 = StreamVolumeFormatDb
    toEnum k = AnotherStreamVolumeFormat k

instance P.Ord StreamVolumeFormat where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

-- Enum AudioRingBufferState
{- |
The state of the ringbuffer.
-}
data AudioRingBufferState =
      AudioRingBufferStateStopped
    {- ^
    The ringbuffer is stopped
    -}
    | AudioRingBufferStatePaused
    {- ^
    The ringbuffer is paused
    -}
    | AudioRingBufferStateStarted
    {- ^
    The ringbuffer is started
    -}
    | AudioRingBufferStateError
    {- ^
    The ringbuffer has encountered an
        error after it has been started, e.g. because the device was
        disconnected (Since 1.2)
    -}
    | AnotherAudioRingBufferState Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioRingBufferState where
    fromEnum AudioRingBufferStateStopped = 0
    fromEnum AudioRingBufferStatePaused = 1
    fromEnum AudioRingBufferStateStarted = 2
    fromEnum AudioRingBufferStateError = 3
    fromEnum (AnotherAudioRingBufferState k) = k

    toEnum 0 = AudioRingBufferStateStopped
    toEnum 1 = AudioRingBufferStatePaused
    toEnum 2 = AudioRingBufferStateStarted
    toEnum 3 = AudioRingBufferStateError
    toEnum k = AnotherAudioRingBufferState k

instance P.Ord AudioRingBufferState where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_ring_buffer_state_get_type" c_gst_audio_ring_buffer_state_get_type ::
    IO GType

instance BoxedEnum AudioRingBufferState where
    boxedEnumType _ = c_gst_audio_ring_buffer_state_get_type

-- Enum AudioRingBufferFormatType
{- |
The format of the samples in the ringbuffer.
-}
data AudioRingBufferFormatType =
      AudioRingBufferFormatTypeRaw
    {- ^
    samples in linear or float
    -}
    | AudioRingBufferFormatTypeMuLaw
    {- ^
    samples in mulaw
    -}
    | AudioRingBufferFormatTypeALaw
    {- ^
    samples in alaw
    -}
    | AudioRingBufferFormatTypeImaAdpcm
    {- ^
    samples in ima adpcm
    -}
    | AudioRingBufferFormatTypeMpeg
    {- ^
    samples in mpeg audio (but not AAC) format
    -}
    | AudioRingBufferFormatTypeGsm
    {- ^
    samples in gsm format
    -}
    | AudioRingBufferFormatTypeIec958
    {- ^
    samples in IEC958 frames (e.g. AC3)
    -}
    | AudioRingBufferFormatTypeAc3
    {- ^
    samples in AC3 format
    -}
    | AudioRingBufferFormatTypeEac3
    {- ^
    samples in EAC3 format
    -}
    | AudioRingBufferFormatTypeDts
    {- ^
    samples in DTS format
    -}
    | AudioRingBufferFormatTypeMpeg2Aac
    {- ^
    samples in MPEG-2 AAC ADTS format
    -}
    | AudioRingBufferFormatTypeMpeg4Aac
    {- ^
    samples in MPEG-4 AAC ADTS format
    -}
    | AudioRingBufferFormatTypeMpeg2AacRaw
    {- ^
    samples in MPEG-2 AAC raw format (Since 1.12)
    -}
    | AudioRingBufferFormatTypeMpeg4AacRaw
    {- ^
    samples in MPEG-4 AAC raw format (Since 1.12)
    -}
    | AudioRingBufferFormatTypeFlac
    {- ^
    samples in FLAC format (Since 1.12)
    -}
    | AnotherAudioRingBufferFormatType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioRingBufferFormatType where
    fromEnum AudioRingBufferFormatTypeRaw = 0
    fromEnum AudioRingBufferFormatTypeMuLaw = 1
    fromEnum AudioRingBufferFormatTypeALaw = 2
    fromEnum AudioRingBufferFormatTypeImaAdpcm = 3
    fromEnum AudioRingBufferFormatTypeMpeg = 4
    fromEnum AudioRingBufferFormatTypeGsm = 5
    fromEnum AudioRingBufferFormatTypeIec958 = 6
    fromEnum AudioRingBufferFormatTypeAc3 = 7
    fromEnum AudioRingBufferFormatTypeEac3 = 8
    fromEnum AudioRingBufferFormatTypeDts = 9
    fromEnum AudioRingBufferFormatTypeMpeg2Aac = 10
    fromEnum AudioRingBufferFormatTypeMpeg4Aac = 11
    fromEnum AudioRingBufferFormatTypeMpeg2AacRaw = 12
    fromEnum AudioRingBufferFormatTypeMpeg4AacRaw = 13
    fromEnum AudioRingBufferFormatTypeFlac = 14
    fromEnum (AnotherAudioRingBufferFormatType k) = k

    toEnum 0 = AudioRingBufferFormatTypeRaw
    toEnum 1 = AudioRingBufferFormatTypeMuLaw
    toEnum 2 = AudioRingBufferFormatTypeALaw
    toEnum 3 = AudioRingBufferFormatTypeImaAdpcm
    toEnum 4 = AudioRingBufferFormatTypeMpeg
    toEnum 5 = AudioRingBufferFormatTypeGsm
    toEnum 6 = AudioRingBufferFormatTypeIec958
    toEnum 7 = AudioRingBufferFormatTypeAc3
    toEnum 8 = AudioRingBufferFormatTypeEac3
    toEnum 9 = AudioRingBufferFormatTypeDts
    toEnum 10 = AudioRingBufferFormatTypeMpeg2Aac
    toEnum 11 = AudioRingBufferFormatTypeMpeg4Aac
    toEnum 12 = AudioRingBufferFormatTypeMpeg2AacRaw
    toEnum 13 = AudioRingBufferFormatTypeMpeg4AacRaw
    toEnum 14 = AudioRingBufferFormatTypeFlac
    toEnum k = AnotherAudioRingBufferFormatType k

instance P.Ord AudioRingBufferFormatType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_ring_buffer_format_type_get_type" c_gst_audio_ring_buffer_format_type_get_type ::
    IO GType

instance BoxedEnum AudioRingBufferFormatType where
    boxedEnumType _ = c_gst_audio_ring_buffer_format_type_get_type

-- Enum AudioResamplerMethod
{- |
Different subsampling and upsampling methods

/Since: 1.6/
-}
data AudioResamplerMethod =
      AudioResamplerMethodNearest
    {- ^
    Duplicates the samples when
       upsampling and drops when downsampling
    -}
    | AudioResamplerMethodLinear
    {- ^
    Uses linear interpolation to reconstruct
       missing samples and averaging to downsample
    -}
    | AudioResamplerMethodCubic
    {- ^
    Uses cubic interpolation
    -}
    | AudioResamplerMethodBlackmanNuttall
    {- ^
    Uses Blackman-Nuttall windowed sinc interpolation
    -}
    | AudioResamplerMethodKaiser
    {- ^
    Uses Kaiser windowed sinc interpolation
    -}
    | AnotherAudioResamplerMethod Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioResamplerMethod where
    fromEnum AudioResamplerMethodNearest = 0
    fromEnum AudioResamplerMethodLinear = 1
    fromEnum AudioResamplerMethodCubic = 2
    fromEnum AudioResamplerMethodBlackmanNuttall = 3
    fromEnum AudioResamplerMethodKaiser = 4
    fromEnum (AnotherAudioResamplerMethod k) = k

    toEnum 0 = AudioResamplerMethodNearest
    toEnum 1 = AudioResamplerMethodLinear
    toEnum 2 = AudioResamplerMethodCubic
    toEnum 3 = AudioResamplerMethodBlackmanNuttall
    toEnum 4 = AudioResamplerMethodKaiser
    toEnum k = AnotherAudioResamplerMethod k

instance P.Ord AudioResamplerMethod where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_resampler_method_get_type" c_gst_audio_resampler_method_get_type ::
    IO GType

instance BoxedEnum AudioResamplerMethod where
    boxedEnumType _ = c_gst_audio_resampler_method_get_type

-- Enum AudioResamplerFilterMode
{- |
Select for the filter tables should be set up.
-}
data AudioResamplerFilterMode =
      AudioResamplerFilterModeInterpolated
    {- ^
    Use interpolated filter tables. This
        uses less memory but more CPU and is slightly less accurate but it allows for more
        efficient variable rate resampling with 'GI.GstAudio.Structs.AudioResampler.audioResamplerUpdate'.
    -}
    | AudioResamplerFilterModeFull
    {- ^
    Use full filter table. This uses more memory
        but less CPU.
    -}
    | AudioResamplerFilterModeAuto
    {- ^
    Automatically choose between interpolated
        and full filter tables.
    -}
    | AnotherAudioResamplerFilterMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioResamplerFilterMode where
    fromEnum AudioResamplerFilterModeInterpolated = 0
    fromEnum AudioResamplerFilterModeFull = 1
    fromEnum AudioResamplerFilterModeAuto = 2
    fromEnum (AnotherAudioResamplerFilterMode k) = k

    toEnum 0 = AudioResamplerFilterModeInterpolated
    toEnum 1 = AudioResamplerFilterModeFull
    toEnum 2 = AudioResamplerFilterModeAuto
    toEnum k = AnotherAudioResamplerFilterMode k

instance P.Ord AudioResamplerFilterMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_resampler_filter_mode_get_type" c_gst_audio_resampler_filter_mode_get_type ::
    IO GType

instance BoxedEnum AudioResamplerFilterMode where
    boxedEnumType _ = c_gst_audio_resampler_filter_mode_get_type

-- Enum AudioResamplerFilterInterpolation
{- |
The different filter interpolation methods.
-}
data AudioResamplerFilterInterpolation =
      AudioResamplerFilterInterpolationNone
    {- ^
    no interpolation
    -}
    | AudioResamplerFilterInterpolationLinear
    {- ^
    linear interpolation of the
      filter coeficients.
    -}
    | AudioResamplerFilterInterpolationCubic
    {- ^
    cubic interpolation of the
      filter coeficients.
    -}
    | AnotherAudioResamplerFilterInterpolation Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioResamplerFilterInterpolation where
    fromEnum AudioResamplerFilterInterpolationNone = 0
    fromEnum AudioResamplerFilterInterpolationLinear = 1
    fromEnum AudioResamplerFilterInterpolationCubic = 2
    fromEnum (AnotherAudioResamplerFilterInterpolation k) = k

    toEnum 0 = AudioResamplerFilterInterpolationNone
    toEnum 1 = AudioResamplerFilterInterpolationLinear
    toEnum 2 = AudioResamplerFilterInterpolationCubic
    toEnum k = AnotherAudioResamplerFilterInterpolation k

instance P.Ord AudioResamplerFilterInterpolation where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_resampler_filter_interpolation_get_type" c_gst_audio_resampler_filter_interpolation_get_type ::
    IO GType

instance BoxedEnum AudioResamplerFilterInterpolation where
    boxedEnumType _ = c_gst_audio_resampler_filter_interpolation_get_type

-- Enum AudioNoiseShapingMethod
{- |
Set of available noise shaping methods
-}
data AudioNoiseShapingMethod =
      AudioNoiseShapingMethodNone
    {- ^
    No noise shaping (default)
    -}
    | AudioNoiseShapingMethodErrorFeedback
    {- ^
    Error feedback
    -}
    | AudioNoiseShapingMethodSimple
    {- ^
    Simple 2-pole noise shaping
    -}
    | AudioNoiseShapingMethodMedium
    {- ^
    Medium 5-pole noise shaping
    -}
    | AudioNoiseShapingMethodHigh
    {- ^
    High 8-pole noise shaping
    -}
    | AnotherAudioNoiseShapingMethod Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioNoiseShapingMethod where
    fromEnum AudioNoiseShapingMethodNone = 0
    fromEnum AudioNoiseShapingMethodErrorFeedback = 1
    fromEnum AudioNoiseShapingMethodSimple = 2
    fromEnum AudioNoiseShapingMethodMedium = 3
    fromEnum AudioNoiseShapingMethodHigh = 4
    fromEnum (AnotherAudioNoiseShapingMethod k) = k

    toEnum 0 = AudioNoiseShapingMethodNone
    toEnum 1 = AudioNoiseShapingMethodErrorFeedback
    toEnum 2 = AudioNoiseShapingMethodSimple
    toEnum 3 = AudioNoiseShapingMethodMedium
    toEnum 4 = AudioNoiseShapingMethodHigh
    toEnum k = AnotherAudioNoiseShapingMethod k

instance P.Ord AudioNoiseShapingMethod where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_noise_shaping_method_get_type" c_gst_audio_noise_shaping_method_get_type ::
    IO GType

instance BoxedEnum AudioNoiseShapingMethod where
    boxedEnumType _ = c_gst_audio_noise_shaping_method_get_type

-- Enum AudioLayout
{- |
Layout of the audio samples for the different channels.
-}
data AudioLayout =
      AudioLayoutInterleaved
    {- ^
    interleaved audio
    -}
    | AudioLayoutNonInterleaved
    {- ^
    non-interleaved audio
    -}
    | AnotherAudioLayout Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioLayout where
    fromEnum AudioLayoutInterleaved = 0
    fromEnum AudioLayoutNonInterleaved = 1
    fromEnum (AnotherAudioLayout k) = k

    toEnum 0 = AudioLayoutInterleaved
    toEnum 1 = AudioLayoutNonInterleaved
    toEnum k = AnotherAudioLayout k

instance P.Ord AudioLayout where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_layout_get_type" c_gst_audio_layout_get_type ::
    IO GType

instance BoxedEnum AudioLayout where
    boxedEnumType _ = c_gst_audio_layout_get_type

-- Enum AudioFormat
{- |
Enum value describing the most common audio formats.
-}
data AudioFormat =
      AudioFormatUnknown
    {- ^
    unknown or unset audio format
    -}
    | AudioFormatEncoded
    {- ^
    encoded audio format
    -}
    | AudioFormatS8
    {- ^
    8 bits in 8 bits, signed
    -}
    | AudioFormatU8
    {- ^
    8 bits in 8 bits, unsigned
    -}
    | AudioFormatS16le
    {- ^
    16 bits in 16 bits, signed, little endian
    -}
    | AudioFormatS16be
    {- ^
    16 bits in 16 bits, signed, big endian
    -}
    | AudioFormatU16le
    {- ^
    16 bits in 16 bits, unsigned, little endian
    -}
    | AudioFormatU16be
    {- ^
    16 bits in 16 bits, unsigned, big endian
    -}
    | AudioFormatS2432le
    {- ^
    24 bits in 32 bits, signed, little endian
    -}
    | AudioFormatS2432be
    {- ^
    24 bits in 32 bits, signed, big endian
    -}
    | AudioFormatU2432le
    {- ^
    24 bits in 32 bits, unsigned, little endian
    -}
    | AudioFormatU2432be
    {- ^
    24 bits in 32 bits, unsigned, big endian
    -}
    | AudioFormatS32le
    {- ^
    32 bits in 32 bits, signed, little endian
    -}
    | AudioFormatS32be
    {- ^
    32 bits in 32 bits, signed, big endian
    -}
    | AudioFormatU32le
    {- ^
    32 bits in 32 bits, unsigned, little endian
    -}
    | AudioFormatU32be
    {- ^
    32 bits in 32 bits, unsigned, big endian
    -}
    | AudioFormatS24le
    {- ^
    24 bits in 24 bits, signed, little endian
    -}
    | AudioFormatS24be
    {- ^
    24 bits in 24 bits, signed, big endian
    -}
    | AudioFormatU24le
    {- ^
    24 bits in 24 bits, unsigned, little endian
    -}
    | AudioFormatU24be
    {- ^
    24 bits in 24 bits, unsigned, big endian
    -}
    | AudioFormatS20le
    {- ^
    20 bits in 24 bits, signed, little endian
    -}
    | AudioFormatS20be
    {- ^
    20 bits in 24 bits, signed, big endian
    -}
    | AudioFormatU20le
    {- ^
    20 bits in 24 bits, unsigned, little endian
    -}
    | AudioFormatU20be
    {- ^
    20 bits in 24 bits, unsigned, big endian
    -}
    | AudioFormatS18le
    {- ^
    18 bits in 24 bits, signed, little endian
    -}
    | AudioFormatS18be
    {- ^
    18 bits in 24 bits, signed, big endian
    -}
    | AudioFormatU18le
    {- ^
    18 bits in 24 bits, unsigned, little endian
    -}
    | AudioFormatU18be
    {- ^
    18 bits in 24 bits, unsigned, big endian
    -}
    | AudioFormatF32le
    {- ^
    32-bit floating point samples, little endian
    -}
    | AudioFormatF32be
    {- ^
    32-bit floating point samples, big endian
    -}
    | AudioFormatF64le
    {- ^
    64-bit floating point samples, little endian
    -}
    | AudioFormatF64be
    {- ^
    64-bit floating point samples, big endian
    -}
    | AudioFormatS16
    {- ^
    16 bits in 16 bits, signed, native endianness
    -}
    | AudioFormatU16
    {- ^
    16 bits in 16 bits, unsigned, native endianness
    -}
    | AudioFormatS2432
    {- ^
    24 bits in 32 bits, signed, native endianness
    -}
    | AudioFormatU2432
    {- ^
    24 bits in 32 bits, unsigned, native endianness
    -}
    | AudioFormatS32
    {- ^
    32 bits in 32 bits, signed, native endianness
    -}
    | AudioFormatU32
    {- ^
    32 bits in 32 bits, unsigned, native endianness
    -}
    | AudioFormatS24
    {- ^
    24 bits in 24 bits, signed, native endianness
    -}
    | AudioFormatU24
    {- ^
    24 bits in 24 bits, unsigned, native endianness
    -}
    | AudioFormatS20
    {- ^
    20 bits in 24 bits, signed, native endianness
    -}
    | AudioFormatU20
    {- ^
    20 bits in 24 bits, unsigned, native endianness
    -}
    | AudioFormatS18
    {- ^
    18 bits in 24 bits, signed, native endianness
    -}
    | AudioFormatU18
    {- ^
    18 bits in 24 bits, unsigned, native endianness
    -}
    | AudioFormatF32
    {- ^
    32-bit floating point samples, native endianness
    -}
    | AudioFormatF64
    {- ^
    64-bit floating point samples, native endianness
    -}
    | AnotherAudioFormat Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioFormat where
    fromEnum AudioFormatUnknown = 0
    fromEnum AudioFormatEncoded = 1
    fromEnum AudioFormatS8 = 2
    fromEnum AudioFormatU8 = 3
    fromEnum AudioFormatS16le = 4
    fromEnum AudioFormatS16be = 5
    fromEnum AudioFormatU16le = 6
    fromEnum AudioFormatU16be = 7
    fromEnum AudioFormatS2432le = 8
    fromEnum AudioFormatS2432be = 9
    fromEnum AudioFormatU2432le = 10
    fromEnum AudioFormatU2432be = 11
    fromEnum AudioFormatS32le = 12
    fromEnum AudioFormatS32be = 13
    fromEnum AudioFormatU32le = 14
    fromEnum AudioFormatU32be = 15
    fromEnum AudioFormatS24le = 16
    fromEnum AudioFormatS24be = 17
    fromEnum AudioFormatU24le = 18
    fromEnum AudioFormatU24be = 19
    fromEnum AudioFormatS20le = 20
    fromEnum AudioFormatS20be = 21
    fromEnum AudioFormatU20le = 22
    fromEnum AudioFormatU20be = 23
    fromEnum AudioFormatS18le = 24
    fromEnum AudioFormatS18be = 25
    fromEnum AudioFormatU18le = 26
    fromEnum AudioFormatU18be = 27
    fromEnum AudioFormatF32le = 28
    fromEnum AudioFormatF32be = 29
    fromEnum AudioFormatF64le = 30
    fromEnum AudioFormatF64be = 31
    fromEnum AudioFormatS16 = 4
    fromEnum AudioFormatU16 = 6
    fromEnum AudioFormatS2432 = 8
    fromEnum AudioFormatU2432 = 10
    fromEnum AudioFormatS32 = 12
    fromEnum AudioFormatU32 = 14
    fromEnum AudioFormatS24 = 16
    fromEnum AudioFormatU24 = 18
    fromEnum AudioFormatS20 = 20
    fromEnum AudioFormatU20 = 22
    fromEnum AudioFormatS18 = 24
    fromEnum AudioFormatU18 = 26
    fromEnum AudioFormatF32 = 28
    fromEnum AudioFormatF64 = 30
    fromEnum (AnotherAudioFormat k) = k

    toEnum 0 = AudioFormatUnknown
    toEnum 1 = AudioFormatEncoded
    toEnum 2 = AudioFormatS8
    toEnum 3 = AudioFormatU8
    toEnum 4 = AudioFormatS16le
    toEnum 5 = AudioFormatS16be
    toEnum 6 = AudioFormatU16le
    toEnum 7 = AudioFormatU16be
    toEnum 8 = AudioFormatS2432le
    toEnum 9 = AudioFormatS2432be
    toEnum 10 = AudioFormatU2432le
    toEnum 11 = AudioFormatU2432be
    toEnum 12 = AudioFormatS32le
    toEnum 13 = AudioFormatS32be
    toEnum 14 = AudioFormatU32le
    toEnum 15 = AudioFormatU32be
    toEnum 16 = AudioFormatS24le
    toEnum 17 = AudioFormatS24be
    toEnum 18 = AudioFormatU24le
    toEnum 19 = AudioFormatU24be
    toEnum 20 = AudioFormatS20le
    toEnum 21 = AudioFormatS20be
    toEnum 22 = AudioFormatU20le
    toEnum 23 = AudioFormatU20be
    toEnum 24 = AudioFormatS18le
    toEnum 25 = AudioFormatS18be
    toEnum 26 = AudioFormatU18le
    toEnum 27 = AudioFormatU18be
    toEnum 28 = AudioFormatF32le
    toEnum 29 = AudioFormatF32be
    toEnum 30 = AudioFormatF64le
    toEnum 31 = AudioFormatF64be
    toEnum 4 = AudioFormatS16
    toEnum 6 = AudioFormatU16
    toEnum 8 = AudioFormatS2432
    toEnum 10 = AudioFormatU2432
    toEnum 12 = AudioFormatS32
    toEnum 14 = AudioFormatU32
    toEnum 16 = AudioFormatS24
    toEnum 18 = AudioFormatU24
    toEnum 20 = AudioFormatS20
    toEnum 22 = AudioFormatU20
    toEnum 24 = AudioFormatS18
    toEnum 26 = AudioFormatU18
    toEnum 28 = AudioFormatF32
    toEnum 30 = AudioFormatF64
    toEnum k = AnotherAudioFormat k

instance P.Ord AudioFormat where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_format_get_type" c_gst_audio_format_get_type ::
    IO GType

instance BoxedEnum AudioFormat where
    boxedEnumType _ = c_gst_audio_format_get_type

-- Enum AudioDitherMethod
{- |
Set of available dithering methods.
-}
data AudioDitherMethod =
      AudioDitherMethodNone
    {- ^
    No dithering
    -}
    | AudioDitherMethodRpdf
    {- ^
    Rectangular dithering
    -}
    | AudioDitherMethodTpdf
    {- ^
    Triangular dithering (default)
    -}
    | AudioDitherMethodTpdfHf
    {- ^
    High frequency triangular dithering
    -}
    | AnotherAudioDitherMethod Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioDitherMethod where
    fromEnum AudioDitherMethodNone = 0
    fromEnum AudioDitherMethodRpdf = 1
    fromEnum AudioDitherMethodTpdf = 2
    fromEnum AudioDitherMethodTpdfHf = 3
    fromEnum (AnotherAudioDitherMethod k) = k

    toEnum 0 = AudioDitherMethodNone
    toEnum 1 = AudioDitherMethodRpdf
    toEnum 2 = AudioDitherMethodTpdf
    toEnum 3 = AudioDitherMethodTpdfHf
    toEnum k = AnotherAudioDitherMethod k

instance P.Ord AudioDitherMethod where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_dither_method_get_type" c_gst_audio_dither_method_get_type ::
    IO GType

instance BoxedEnum AudioDitherMethod where
    boxedEnumType _ = c_gst_audio_dither_method_get_type

-- Enum AudioChannelPosition
{- |
Audio channel positions.

These are the channels defined in SMPTE 2036-2-2008
Table 1 for 22.2 audio systems with the Surround and Wide channels from
DTS Coherent Acoustics (v.1.3.1) and 10.2 and 7.1 layouts. In the caps the
actual channel layout is expressed with a channel count and a channel mask,
which describes the existing channels. The positions in the bit mask correspond
to the enum values.
For negotiation it is allowed to have more bits set in the channel mask than
the number of channels to specify the allowed channel positions but this is
not allowed in negotiated caps. It is not allowed in any situation other
than the one mentioned below to have less bits set in the channel mask than
the number of channels.

/@gSTAUDIOCHANNELPOSITIONMONO@/ can only be used with a single mono channel that
has no direction information and would be mixed into all directional channels.
This is expressed in caps by having a single channel and no channel mask.

/@gSTAUDIOCHANNELPOSITIONNONE@/ can only be used if all channels have this position.
This is expressed in caps by having a channel mask with no bits set.

As another special case it is allowed to have two channels without a channel mask.
This implicitely means that this is a stereo stream with a front left and front right
channel.
-}
data AudioChannelPosition =
      AudioChannelPositionNone
    {- ^
    used for position-less channels, e.g.
        from a sound card that records 1024 channels; mutually exclusive with
        any other channel position
    -}
    | AudioChannelPositionMono
    {- ^
    Mono without direction;
        can only be used with 1 channel
    -}
    | AudioChannelPositionInvalid
    {- ^
    invalid position
    -}
    | AudioChannelPositionFrontLeft
    {- ^
    Front left
    -}
    | AudioChannelPositionFrontRight
    {- ^
    Front right
    -}
    | AudioChannelPositionFrontCenter
    {- ^
    Front center
    -}
    | AudioChannelPositionLfe1
    {- ^
    Low-frequency effects 1 (subwoofer)
    -}
    | AudioChannelPositionRearLeft
    {- ^
    Rear left
    -}
    | AudioChannelPositionRearRight
    {- ^
    Rear right
    -}
    | AudioChannelPositionFrontLeftOfCenter
    {- ^
    Front left of center
    -}
    | AudioChannelPositionFrontRightOfCenter
    {- ^
    Front right of center
    -}
    | AudioChannelPositionRearCenter
    {- ^
    Rear center
    -}
    | AudioChannelPositionLfe2
    {- ^
    Low-frequency effects 2 (subwoofer)
    -}
    | AudioChannelPositionSideLeft
    {- ^
    Side left
    -}
    | AudioChannelPositionSideRight
    {- ^
    Side right
    -}
    | AudioChannelPositionTopFrontLeft
    {- ^
    Top front left
    -}
    | AudioChannelPositionTopFrontRight
    {- ^
    Top front right
    -}
    | AudioChannelPositionTopFrontCenter
    {- ^
    Top front center
    -}
    | AudioChannelPositionTopCenter
    {- ^
    Top center
    -}
    | AudioChannelPositionTopRearLeft
    {- ^
    Top rear left
    -}
    | AudioChannelPositionTopRearRight
    {- ^
    Top rear right
    -}
    | AudioChannelPositionTopSideLeft
    {- ^
    Top side right
    -}
    | AudioChannelPositionTopSideRight
    {- ^
    Top rear right
    -}
    | AudioChannelPositionTopRearCenter
    {- ^
    Top rear center
    -}
    | AudioChannelPositionBottomFrontCenter
    {- ^
    Bottom front center
    -}
    | AudioChannelPositionBottomFrontLeft
    {- ^
    Bottom front left
    -}
    | AudioChannelPositionBottomFrontRight
    {- ^
    Bottom front right
    -}
    | AudioChannelPositionWideLeft
    {- ^
    Wide left (between front left and side left)
    -}
    | AudioChannelPositionWideRight
    {- ^
    Wide right (between front right and side right)
    -}
    | AudioChannelPositionSurroundLeft
    {- ^
    Surround left (between rear left and side left)
    -}
    | AudioChannelPositionSurroundRight
    {- ^
    Surround right (between rear right and side right)
    -}
    | AnotherAudioChannelPosition Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioChannelPosition where
    fromEnum AudioChannelPositionNone = -3
    fromEnum AudioChannelPositionMono = -2
    fromEnum AudioChannelPositionInvalid = -1
    fromEnum AudioChannelPositionFrontLeft = 0
    fromEnum AudioChannelPositionFrontRight = 1
    fromEnum AudioChannelPositionFrontCenter = 2
    fromEnum AudioChannelPositionLfe1 = 3
    fromEnum AudioChannelPositionRearLeft = 4
    fromEnum AudioChannelPositionRearRight = 5
    fromEnum AudioChannelPositionFrontLeftOfCenter = 6
    fromEnum AudioChannelPositionFrontRightOfCenter = 7
    fromEnum AudioChannelPositionRearCenter = 8
    fromEnum AudioChannelPositionLfe2 = 9
    fromEnum AudioChannelPositionSideLeft = 10
    fromEnum AudioChannelPositionSideRight = 11
    fromEnum AudioChannelPositionTopFrontLeft = 12
    fromEnum AudioChannelPositionTopFrontRight = 13
    fromEnum AudioChannelPositionTopFrontCenter = 14
    fromEnum AudioChannelPositionTopCenter = 15
    fromEnum AudioChannelPositionTopRearLeft = 16
    fromEnum AudioChannelPositionTopRearRight = 17
    fromEnum AudioChannelPositionTopSideLeft = 18
    fromEnum AudioChannelPositionTopSideRight = 19
    fromEnum AudioChannelPositionTopRearCenter = 20
    fromEnum AudioChannelPositionBottomFrontCenter = 21
    fromEnum AudioChannelPositionBottomFrontLeft = 22
    fromEnum AudioChannelPositionBottomFrontRight = 23
    fromEnum AudioChannelPositionWideLeft = 24
    fromEnum AudioChannelPositionWideRight = 25
    fromEnum AudioChannelPositionSurroundLeft = 26
    fromEnum AudioChannelPositionSurroundRight = 27
    fromEnum (AnotherAudioChannelPosition k) = k

    toEnum -3 = AudioChannelPositionNone
    toEnum -2 = AudioChannelPositionMono
    toEnum -1 = AudioChannelPositionInvalid
    toEnum 0 = AudioChannelPositionFrontLeft
    toEnum 1 = AudioChannelPositionFrontRight
    toEnum 2 = AudioChannelPositionFrontCenter
    toEnum 3 = AudioChannelPositionLfe1
    toEnum 4 = AudioChannelPositionRearLeft
    toEnum 5 = AudioChannelPositionRearRight
    toEnum 6 = AudioChannelPositionFrontLeftOfCenter
    toEnum 7 = AudioChannelPositionFrontRightOfCenter
    toEnum 8 = AudioChannelPositionRearCenter
    toEnum 9 = AudioChannelPositionLfe2
    toEnum 10 = AudioChannelPositionSideLeft
    toEnum 11 = AudioChannelPositionSideRight
    toEnum 12 = AudioChannelPositionTopFrontLeft
    toEnum 13 = AudioChannelPositionTopFrontRight
    toEnum 14 = AudioChannelPositionTopFrontCenter
    toEnum 15 = AudioChannelPositionTopCenter
    toEnum 16 = AudioChannelPositionTopRearLeft
    toEnum 17 = AudioChannelPositionTopRearRight
    toEnum 18 = AudioChannelPositionTopSideLeft
    toEnum 19 = AudioChannelPositionTopSideRight
    toEnum 20 = AudioChannelPositionTopRearCenter
    toEnum 21 = AudioChannelPositionBottomFrontCenter
    toEnum 22 = AudioChannelPositionBottomFrontLeft
    toEnum 23 = AudioChannelPositionBottomFrontRight
    toEnum 24 = AudioChannelPositionWideLeft
    toEnum 25 = AudioChannelPositionWideRight
    toEnum 26 = AudioChannelPositionSurroundLeft
    toEnum 27 = AudioChannelPositionSurroundRight
    toEnum k = AnotherAudioChannelPosition k

instance P.Ord AudioChannelPosition where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_channel_position_get_type" c_gst_audio_channel_position_get_type ::
    IO GType

instance BoxedEnum AudioChannelPosition where
    boxedEnumType _ = c_gst_audio_channel_position_get_type

-- Enum AudioCdSrcMode
{- |
Mode in which the CD audio source operates. Influences timestamping,
EOS handling and seeking.
-}
data AudioCdSrcMode =
      AudioCdSrcModeNormal
    {- ^
    each single track is a stream
    -}
    | AudioCdSrcModeContinuous
    {- ^
    the entire disc is a single stream
    -}
    | AnotherAudioCdSrcMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioCdSrcMode where
    fromEnum AudioCdSrcModeNormal = 0
    fromEnum AudioCdSrcModeContinuous = 1
    fromEnum (AnotherAudioCdSrcMode k) = k

    toEnum 0 = AudioCdSrcModeNormal
    toEnum 1 = AudioCdSrcModeContinuous
    toEnum k = AnotherAudioCdSrcMode k

instance P.Ord AudioCdSrcMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_cd_src_mode_get_type" c_gst_audio_cd_src_mode_get_type ::
    IO GType

instance BoxedEnum AudioCdSrcMode where
    boxedEnumType _ = c_gst_audio_cd_src_mode_get_type

-- Enum AudioBaseSrcSlaveMethod
{- |
Different possible clock slaving algorithms when the internal audio clock was
not selected as the pipeline clock.
-}
data AudioBaseSrcSlaveMethod =
      AudioBaseSrcSlaveMethodResample
    {- ^
    Resample to match the master clock.
    -}
    | AudioBaseSrcSlaveMethodReTimestamp
    {- ^
    Retimestamp output buffers with master
    clock time.
    -}
    | AudioBaseSrcSlaveMethodSkew
    {- ^
    Adjust capture pointer when master clock
    drifts too much.
    -}
    | AudioBaseSrcSlaveMethodNone
    {- ^
    No adjustment is done.
    -}
    | AnotherAudioBaseSrcSlaveMethod Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioBaseSrcSlaveMethod where
    fromEnum AudioBaseSrcSlaveMethodResample = 0
    fromEnum AudioBaseSrcSlaveMethodReTimestamp = 1
    fromEnum AudioBaseSrcSlaveMethodSkew = 2
    fromEnum AudioBaseSrcSlaveMethodNone = 3
    fromEnum (AnotherAudioBaseSrcSlaveMethod k) = k

    toEnum 0 = AudioBaseSrcSlaveMethodResample
    toEnum 1 = AudioBaseSrcSlaveMethodReTimestamp
    toEnum 2 = AudioBaseSrcSlaveMethodSkew
    toEnum 3 = AudioBaseSrcSlaveMethodNone
    toEnum k = AnotherAudioBaseSrcSlaveMethod k

instance P.Ord AudioBaseSrcSlaveMethod where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_base_src_slave_method_get_type" c_gst_audio_base_src_slave_method_get_type ::
    IO GType

instance BoxedEnum AudioBaseSrcSlaveMethod where
    boxedEnumType _ = c_gst_audio_base_src_slave_method_get_type

-- Enum AudioBaseSinkSlaveMethod
{- |
Different possible clock slaving algorithms used when the internal audio
clock is not selected as the pipeline master clock.
-}
data AudioBaseSinkSlaveMethod =
      AudioBaseSinkSlaveMethodResample
    {- ^
    Resample to match the master clock
    -}
    | AudioBaseSinkSlaveMethodSkew
    {- ^
    Adjust playout pointer when master clock
    drifts too much.
    -}
    | AudioBaseSinkSlaveMethodNone
    {- ^
    No adjustment is done.
    -}
    | AudioBaseSinkSlaveMethodCustom
    {- ^
    Use custom clock slaving algorithm (Since: 1.6)
    -}
    | AnotherAudioBaseSinkSlaveMethod Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioBaseSinkSlaveMethod where
    fromEnum AudioBaseSinkSlaveMethodResample = 0
    fromEnum AudioBaseSinkSlaveMethodSkew = 1
    fromEnum AudioBaseSinkSlaveMethodNone = 2
    fromEnum AudioBaseSinkSlaveMethodCustom = 3
    fromEnum (AnotherAudioBaseSinkSlaveMethod k) = k

    toEnum 0 = AudioBaseSinkSlaveMethodResample
    toEnum 1 = AudioBaseSinkSlaveMethodSkew
    toEnum 2 = AudioBaseSinkSlaveMethodNone
    toEnum 3 = AudioBaseSinkSlaveMethodCustom
    toEnum k = AnotherAudioBaseSinkSlaveMethod k

instance P.Ord AudioBaseSinkSlaveMethod where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_base_sink_slave_method_get_type" c_gst_audio_base_sink_slave_method_get_type ::
    IO GType

instance BoxedEnum AudioBaseSinkSlaveMethod where
    boxedEnumType _ = c_gst_audio_base_sink_slave_method_get_type

-- Enum AudioBaseSinkDiscontReason
{- |
Different possible reasons for discontinuities. This enum is useful for the custom
slave method.

/Since: 1.6/
-}
data AudioBaseSinkDiscontReason =
      AudioBaseSinkDiscontReasonNoDiscont
    {- ^
    No discontinuity occurred
    -}
    | AudioBaseSinkDiscontReasonNewCaps
    {- ^
    New caps are set, causing renegotiotion
    -}
    | AudioBaseSinkDiscontReasonFlush
    {- ^
    Samples have been flushed
    -}
    | AudioBaseSinkDiscontReasonSyncLatency
    {- ^
    Sink was synchronized to the estimated latency (occurs during initialization)
    -}
    | AudioBaseSinkDiscontReasonAlignment
    {- ^
    Aligning buffers failed because the timestamps are too discontinuous
    -}
    | AudioBaseSinkDiscontReasonDeviceFailure
    {- ^
    Audio output device experienced and recovered from an error but introduced latency in the process (see also /@gstAudioBaseSinkReportDeviceFailure@/())
    -}
    | AnotherAudioBaseSinkDiscontReason Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AudioBaseSinkDiscontReason where
    fromEnum AudioBaseSinkDiscontReasonNoDiscont = 0
    fromEnum AudioBaseSinkDiscontReasonNewCaps = 1
    fromEnum AudioBaseSinkDiscontReasonFlush = 2
    fromEnum AudioBaseSinkDiscontReasonSyncLatency = 3
    fromEnum AudioBaseSinkDiscontReasonAlignment = 4
    fromEnum AudioBaseSinkDiscontReasonDeviceFailure = 5
    fromEnum (AnotherAudioBaseSinkDiscontReason k) = k

    toEnum 0 = AudioBaseSinkDiscontReasonNoDiscont
    toEnum 1 = AudioBaseSinkDiscontReasonNewCaps
    toEnum 2 = AudioBaseSinkDiscontReasonFlush
    toEnum 3 = AudioBaseSinkDiscontReasonSyncLatency
    toEnum 4 = AudioBaseSinkDiscontReasonAlignment
    toEnum 5 = AudioBaseSinkDiscontReasonDeviceFailure
    toEnum k = AnotherAudioBaseSinkDiscontReason k

instance P.Ord AudioBaseSinkDiscontReason where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_audio_base_sink_discont_reason_get_type" c_gst_audio_base_sink_discont_reason_get_type ::
    IO GType

instance BoxedEnum AudioBaseSinkDiscontReason where
    boxedEnumType _ = c_gst_audio_base_sink_discont_reason_get_type