-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

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

module GI.GstAudio.Flags
    ( 

 -- * Flags


-- ** AudioChannelMixerFlags #flag:AudioChannelMixerFlags#

    AudioChannelMixerFlags(..)              ,


-- ** AudioConverterFlags #flag:AudioConverterFlags#

    AudioConverterFlags(..)                 ,


-- ** AudioFlags #flag:AudioFlags#

    AudioFlags(..)                          ,


-- ** AudioFormatFlags #flag:AudioFormatFlags#

    AudioFormatFlags(..)                    ,


-- ** AudioPackFlags #flag:AudioPackFlags#

    AudioPackFlags(..)                      ,


-- ** AudioQuantizeFlags #flag:AudioQuantizeFlags#

    AudioQuantizeFlags(..)                  ,


-- ** AudioResamplerFlags #flag:AudioResamplerFlags#

    AudioResamplerFlags(..)                 ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R


-- Flags AudioResamplerFlags
-- | Different resampler flags.
-- 
-- /Since: 1.10/
data AudioResamplerFlags = 
      AudioResamplerFlagsNone
    -- ^ no flags
    | AudioResamplerFlagsNonInterleavedIn
    -- ^ input samples are non-interleaved.
    --    an array of blocks of samples, one for each channel, should be passed to the
    --    resample function.
    | AudioResamplerFlagsNonInterleavedOut
    -- ^ output samples are non-interleaved.
    --    an array of blocks of samples, one for each channel, should be passed to the
    --    resample function.
    | AudioResamplerFlagsVariableRate
    -- ^ optimize for dynamic updates of the sample
    --    rates with 'GI.GstAudio.Structs.AudioResampler.audioResamplerUpdate'. This will select an interpolating filter
    --    when @/GST_AUDIO_RESAMPLER_FILTER_MODE_AUTO/@ is configured.
    | AnotherAudioResamplerFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AudioResamplerFlags -> ShowS
[AudioResamplerFlags] -> ShowS
AudioResamplerFlags -> String
(Int -> AudioResamplerFlags -> ShowS)
-> (AudioResamplerFlags -> String)
-> ([AudioResamplerFlags] -> ShowS)
-> Show AudioResamplerFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioResamplerFlags] -> ShowS
$cshowList :: [AudioResamplerFlags] -> ShowS
show :: AudioResamplerFlags -> String
$cshow :: AudioResamplerFlags -> String
showsPrec :: Int -> AudioResamplerFlags -> ShowS
$cshowsPrec :: Int -> AudioResamplerFlags -> ShowS
Show, AudioResamplerFlags -> AudioResamplerFlags -> Bool
(AudioResamplerFlags -> AudioResamplerFlags -> Bool)
-> (AudioResamplerFlags -> AudioResamplerFlags -> Bool)
-> Eq AudioResamplerFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioResamplerFlags -> AudioResamplerFlags -> Bool
$c/= :: AudioResamplerFlags -> AudioResamplerFlags -> Bool
== :: AudioResamplerFlags -> AudioResamplerFlags -> Bool
$c== :: AudioResamplerFlags -> AudioResamplerFlags -> Bool
Eq)

instance P.Enum AudioResamplerFlags where
    fromEnum :: AudioResamplerFlags -> Int
fromEnum AudioResamplerFlags
AudioResamplerFlagsNone = Int
0
    fromEnum AudioResamplerFlags
AudioResamplerFlagsNonInterleavedIn = Int
1
    fromEnum AudioResamplerFlags
AudioResamplerFlagsNonInterleavedOut = Int
2
    fromEnum AudioResamplerFlags
AudioResamplerFlagsVariableRate = Int
4
    fromEnum (AnotherAudioResamplerFlags Int
k) = Int
k

    toEnum :: Int -> AudioResamplerFlags
toEnum Int
0 = AudioResamplerFlags
AudioResamplerFlagsNone
    toEnum Int
1 = AudioResamplerFlags
AudioResamplerFlagsNonInterleavedIn
    toEnum Int
2 = AudioResamplerFlags
AudioResamplerFlagsNonInterleavedOut
    toEnum Int
4 = AudioResamplerFlags
AudioResamplerFlagsVariableRate
    toEnum Int
k = Int -> AudioResamplerFlags
AnotherAudioResamplerFlags Int
k

instance P.Ord AudioResamplerFlags where
    compare :: AudioResamplerFlags -> AudioResamplerFlags -> Ordering
compare AudioResamplerFlags
a AudioResamplerFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioResamplerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioResamplerFlags
a) (AudioResamplerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioResamplerFlags
b)

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

foreign import ccall "gst_audio_resampler_flags_get_type" c_gst_audio_resampler_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AudioResamplerFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_audio_resampler_flags_get_type

instance B.Types.BoxedFlags AudioResamplerFlags

instance IsGFlag AudioResamplerFlags

-- Flags AudioQuantizeFlags
-- | Extra flags that can be passed to @/gst_audio_quantize_new()/@
data AudioQuantizeFlags = 
      AudioQuantizeFlagsNone
    -- ^ no flags
    | AudioQuantizeFlagsNonInterleaved
    -- ^ samples are non-interleaved
    | AnotherAudioQuantizeFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AudioQuantizeFlags -> ShowS
[AudioQuantizeFlags] -> ShowS
AudioQuantizeFlags -> String
(Int -> AudioQuantizeFlags -> ShowS)
-> (AudioQuantizeFlags -> String)
-> ([AudioQuantizeFlags] -> ShowS)
-> Show AudioQuantizeFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioQuantizeFlags] -> ShowS
$cshowList :: [AudioQuantizeFlags] -> ShowS
show :: AudioQuantizeFlags -> String
$cshow :: AudioQuantizeFlags -> String
showsPrec :: Int -> AudioQuantizeFlags -> ShowS
$cshowsPrec :: Int -> AudioQuantizeFlags -> ShowS
Show, AudioQuantizeFlags -> AudioQuantizeFlags -> Bool
(AudioQuantizeFlags -> AudioQuantizeFlags -> Bool)
-> (AudioQuantizeFlags -> AudioQuantizeFlags -> Bool)
-> Eq AudioQuantizeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioQuantizeFlags -> AudioQuantizeFlags -> Bool
$c/= :: AudioQuantizeFlags -> AudioQuantizeFlags -> Bool
== :: AudioQuantizeFlags -> AudioQuantizeFlags -> Bool
$c== :: AudioQuantizeFlags -> AudioQuantizeFlags -> Bool
Eq)

instance P.Enum AudioQuantizeFlags where
    fromEnum :: AudioQuantizeFlags -> Int
fromEnum AudioQuantizeFlags
AudioQuantizeFlagsNone = Int
0
    fromEnum AudioQuantizeFlags
AudioQuantizeFlagsNonInterleaved = Int
1
    fromEnum (AnotherAudioQuantizeFlags Int
k) = Int
k

    toEnum :: Int -> AudioQuantizeFlags
toEnum Int
0 = AudioQuantizeFlags
AudioQuantizeFlagsNone
    toEnum Int
1 = AudioQuantizeFlags
AudioQuantizeFlagsNonInterleaved
    toEnum Int
k = Int -> AudioQuantizeFlags
AnotherAudioQuantizeFlags Int
k

instance P.Ord AudioQuantizeFlags where
    compare :: AudioQuantizeFlags -> AudioQuantizeFlags -> Ordering
compare AudioQuantizeFlags
a AudioQuantizeFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioQuantizeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioQuantizeFlags
a) (AudioQuantizeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioQuantizeFlags
b)

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

foreign import ccall "gst_audio_quantize_flags_get_type" c_gst_audio_quantize_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AudioQuantizeFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_audio_quantize_flags_get_type

instance B.Types.BoxedFlags AudioQuantizeFlags

instance IsGFlag AudioQuantizeFlags

-- Flags AudioPackFlags
-- | The different flags that can be used when packing and unpacking.
data AudioPackFlags = 
      AudioPackFlagsNone
    -- ^ No flag
    | AudioPackFlagsTruncateRange
    -- ^ When the source has a smaller depth
    --   than the target format, set the least significant bits of the target
    --   to 0. This is likely slightly faster but less accurate. When this flag
    --   is not specified, the most significant bits of the source are duplicated
    --   in the least significant bits of the destination.
    | AnotherAudioPackFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AudioPackFlags -> ShowS
[AudioPackFlags] -> ShowS
AudioPackFlags -> String
(Int -> AudioPackFlags -> ShowS)
-> (AudioPackFlags -> String)
-> ([AudioPackFlags] -> ShowS)
-> Show AudioPackFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioPackFlags] -> ShowS
$cshowList :: [AudioPackFlags] -> ShowS
show :: AudioPackFlags -> String
$cshow :: AudioPackFlags -> String
showsPrec :: Int -> AudioPackFlags -> ShowS
$cshowsPrec :: Int -> AudioPackFlags -> ShowS
Show, AudioPackFlags -> AudioPackFlags -> Bool
(AudioPackFlags -> AudioPackFlags -> Bool)
-> (AudioPackFlags -> AudioPackFlags -> Bool) -> Eq AudioPackFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioPackFlags -> AudioPackFlags -> Bool
$c/= :: AudioPackFlags -> AudioPackFlags -> Bool
== :: AudioPackFlags -> AudioPackFlags -> Bool
$c== :: AudioPackFlags -> AudioPackFlags -> Bool
Eq)

instance P.Enum AudioPackFlags where
    fromEnum :: AudioPackFlags -> Int
fromEnum AudioPackFlags
AudioPackFlagsNone = Int
0
    fromEnum AudioPackFlags
AudioPackFlagsTruncateRange = Int
1
    fromEnum (AnotherAudioPackFlags Int
k) = Int
k

    toEnum :: Int -> AudioPackFlags
toEnum Int
0 = AudioPackFlags
AudioPackFlagsNone
    toEnum Int
1 = AudioPackFlags
AudioPackFlagsTruncateRange
    toEnum Int
k = Int -> AudioPackFlags
AnotherAudioPackFlags Int
k

instance P.Ord AudioPackFlags where
    compare :: AudioPackFlags -> AudioPackFlags -> Ordering
compare AudioPackFlags
a AudioPackFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioPackFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioPackFlags
a) (AudioPackFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioPackFlags
b)

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

foreign import ccall "gst_audio_pack_flags_get_type" c_gst_audio_pack_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AudioPackFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_audio_pack_flags_get_type

instance B.Types.BoxedFlags AudioPackFlags

instance IsGFlag AudioPackFlags

-- Flags AudioFormatFlags
-- | The different audio flags that a format info can have.
data AudioFormatFlags = 
      AudioFormatFlagsInteger
    -- ^ integer samples
    | AudioFormatFlagsFloat
    -- ^ float samples
    | AudioFormatFlagsSigned
    -- ^ signed samples
    | AudioFormatFlagsComplex
    -- ^ complex layout
    | AudioFormatFlagsUnpack
    -- ^ the format can be used in
    -- t'GI.GstAudio.Callbacks.AudioFormatUnpack' and t'GI.GstAudio.Callbacks.AudioFormatPack' functions
    | AnotherAudioFormatFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AudioFormatFlags -> ShowS
[AudioFormatFlags] -> ShowS
AudioFormatFlags -> String
(Int -> AudioFormatFlags -> ShowS)
-> (AudioFormatFlags -> String)
-> ([AudioFormatFlags] -> ShowS)
-> Show AudioFormatFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioFormatFlags] -> ShowS
$cshowList :: [AudioFormatFlags] -> ShowS
show :: AudioFormatFlags -> String
$cshow :: AudioFormatFlags -> String
showsPrec :: Int -> AudioFormatFlags -> ShowS
$cshowsPrec :: Int -> AudioFormatFlags -> ShowS
Show, AudioFormatFlags -> AudioFormatFlags -> Bool
(AudioFormatFlags -> AudioFormatFlags -> Bool)
-> (AudioFormatFlags -> AudioFormatFlags -> Bool)
-> Eq AudioFormatFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioFormatFlags -> AudioFormatFlags -> Bool
$c/= :: AudioFormatFlags -> AudioFormatFlags -> Bool
== :: AudioFormatFlags -> AudioFormatFlags -> Bool
$c== :: AudioFormatFlags -> AudioFormatFlags -> Bool
Eq)

instance P.Enum AudioFormatFlags where
    fromEnum :: AudioFormatFlags -> Int
fromEnum AudioFormatFlags
AudioFormatFlagsInteger = Int
1
    fromEnum AudioFormatFlags
AudioFormatFlagsFloat = Int
2
    fromEnum AudioFormatFlags
AudioFormatFlagsSigned = Int
4
    fromEnum AudioFormatFlags
AudioFormatFlagsComplex = Int
16
    fromEnum AudioFormatFlags
AudioFormatFlagsUnpack = Int
32
    fromEnum (AnotherAudioFormatFlags Int
k) = Int
k

    toEnum :: Int -> AudioFormatFlags
toEnum Int
1 = AudioFormatFlags
AudioFormatFlagsInteger
    toEnum Int
2 = AudioFormatFlags
AudioFormatFlagsFloat
    toEnum Int
4 = AudioFormatFlags
AudioFormatFlagsSigned
    toEnum Int
16 = AudioFormatFlags
AudioFormatFlagsComplex
    toEnum Int
32 = AudioFormatFlags
AudioFormatFlagsUnpack
    toEnum Int
k = Int -> AudioFormatFlags
AnotherAudioFormatFlags Int
k

instance P.Ord AudioFormatFlags where
    compare :: AudioFormatFlags -> AudioFormatFlags -> Ordering
compare AudioFormatFlags
a AudioFormatFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioFormatFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioFormatFlags
a) (AudioFormatFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioFormatFlags
b)

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

foreign import ccall "gst_audio_format_flags_get_type" c_gst_audio_format_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AudioFormatFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_audio_format_flags_get_type

instance B.Types.BoxedFlags AudioFormatFlags

instance IsGFlag AudioFormatFlags

-- Flags AudioFlags
-- | Extra audio flags
data AudioFlags = 
      AudioFlagsNone
    -- ^ no valid flag
    | AudioFlagsUnpositioned
    -- ^ the position array explicitly
    --     contains unpositioned channels.
    | AnotherAudioFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AudioFlags -> ShowS
[AudioFlags] -> ShowS
AudioFlags -> String
(Int -> AudioFlags -> ShowS)
-> (AudioFlags -> String)
-> ([AudioFlags] -> ShowS)
-> Show AudioFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioFlags] -> ShowS
$cshowList :: [AudioFlags] -> ShowS
show :: AudioFlags -> String
$cshow :: AudioFlags -> String
showsPrec :: Int -> AudioFlags -> ShowS
$cshowsPrec :: Int -> AudioFlags -> ShowS
Show, AudioFlags -> AudioFlags -> Bool
(AudioFlags -> AudioFlags -> Bool)
-> (AudioFlags -> AudioFlags -> Bool) -> Eq AudioFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioFlags -> AudioFlags -> Bool
$c/= :: AudioFlags -> AudioFlags -> Bool
== :: AudioFlags -> AudioFlags -> Bool
$c== :: AudioFlags -> AudioFlags -> Bool
Eq)

instance P.Enum AudioFlags where
    fromEnum :: AudioFlags -> Int
fromEnum AudioFlags
AudioFlagsNone = Int
0
    fromEnum AudioFlags
AudioFlagsUnpositioned = Int
1
    fromEnum (AnotherAudioFlags Int
k) = Int
k

    toEnum :: Int -> AudioFlags
toEnum Int
0 = AudioFlags
AudioFlagsNone
    toEnum Int
1 = AudioFlags
AudioFlagsUnpositioned
    toEnum Int
k = Int -> AudioFlags
AnotherAudioFlags Int
k

instance P.Ord AudioFlags where
    compare :: AudioFlags -> AudioFlags -> Ordering
compare AudioFlags
a AudioFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioFlags
a) (AudioFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioFlags
b)

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

foreign import ccall "gst_audio_flags_get_type" c_gst_audio_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AudioFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_audio_flags_get_type

instance B.Types.BoxedFlags AudioFlags

instance IsGFlag AudioFlags

-- Flags AudioConverterFlags
-- | Extra flags passed to 'GI.GstAudio.Structs.AudioConverter.audioConverterNew' and 'GI.GstAudio.Structs.AudioConverter.audioConverterSamples'.
data AudioConverterFlags = 
      AudioConverterFlagsNone
    -- ^ no flag
    | AudioConverterFlagsInWritable
    -- ^ the input sample arrays are writable and can be
    --    used as temporary storage during conversion.
    | AudioConverterFlagsVariableRate
    -- ^ allow arbitrary rate updates with
    --    'GI.GstAudio.Structs.AudioConverter.audioConverterUpdateConfig'.
    | AnotherAudioConverterFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AudioConverterFlags -> ShowS
[AudioConverterFlags] -> ShowS
AudioConverterFlags -> String
(Int -> AudioConverterFlags -> ShowS)
-> (AudioConverterFlags -> String)
-> ([AudioConverterFlags] -> ShowS)
-> Show AudioConverterFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioConverterFlags] -> ShowS
$cshowList :: [AudioConverterFlags] -> ShowS
show :: AudioConverterFlags -> String
$cshow :: AudioConverterFlags -> String
showsPrec :: Int -> AudioConverterFlags -> ShowS
$cshowsPrec :: Int -> AudioConverterFlags -> ShowS
Show, AudioConverterFlags -> AudioConverterFlags -> Bool
(AudioConverterFlags -> AudioConverterFlags -> Bool)
-> (AudioConverterFlags -> AudioConverterFlags -> Bool)
-> Eq AudioConverterFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioConverterFlags -> AudioConverterFlags -> Bool
$c/= :: AudioConverterFlags -> AudioConverterFlags -> Bool
== :: AudioConverterFlags -> AudioConverterFlags -> Bool
$c== :: AudioConverterFlags -> AudioConverterFlags -> Bool
Eq)

instance P.Enum AudioConverterFlags where
    fromEnum :: AudioConverterFlags -> Int
fromEnum AudioConverterFlags
AudioConverterFlagsNone = Int
0
    fromEnum AudioConverterFlags
AudioConverterFlagsInWritable = Int
1
    fromEnum AudioConverterFlags
AudioConverterFlagsVariableRate = Int
2
    fromEnum (AnotherAudioConverterFlags Int
k) = Int
k

    toEnum :: Int -> AudioConverterFlags
toEnum Int
0 = AudioConverterFlags
AudioConverterFlagsNone
    toEnum Int
1 = AudioConverterFlags
AudioConverterFlagsInWritable
    toEnum Int
2 = AudioConverterFlags
AudioConverterFlagsVariableRate
    toEnum Int
k = Int -> AudioConverterFlags
AnotherAudioConverterFlags Int
k

instance P.Ord AudioConverterFlags where
    compare :: AudioConverterFlags -> AudioConverterFlags -> Ordering
compare AudioConverterFlags
a AudioConverterFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioConverterFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioConverterFlags
a) (AudioConverterFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioConverterFlags
b)

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

foreign import ccall "gst_audio_converter_flags_get_type" c_gst_audio_converter_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AudioConverterFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_audio_converter_flags_get_type

instance B.Types.BoxedFlags AudioConverterFlags

instance IsGFlag AudioConverterFlags

-- Flags AudioChannelMixerFlags
-- | Flags passed to @/gst_audio_channel_mixer_new()/@
data AudioChannelMixerFlags = 
      AudioChannelMixerFlagsNone
    -- ^ no flag
    | AudioChannelMixerFlagsNonInterleavedIn
    -- ^ input channels are not interleaved
    | AudioChannelMixerFlagsNonInterleavedOut
    -- ^ output channels are not interleaved
    | AudioChannelMixerFlagsUnpositionedIn
    -- ^ input channels are explicitly unpositioned
    | AudioChannelMixerFlagsUnpositionedOut
    -- ^ output channels are explicitly unpositioned
    | AnotherAudioChannelMixerFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AudioChannelMixerFlags -> ShowS
[AudioChannelMixerFlags] -> ShowS
AudioChannelMixerFlags -> String
(Int -> AudioChannelMixerFlags -> ShowS)
-> (AudioChannelMixerFlags -> String)
-> ([AudioChannelMixerFlags] -> ShowS)
-> Show AudioChannelMixerFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioChannelMixerFlags] -> ShowS
$cshowList :: [AudioChannelMixerFlags] -> ShowS
show :: AudioChannelMixerFlags -> String
$cshow :: AudioChannelMixerFlags -> String
showsPrec :: Int -> AudioChannelMixerFlags -> ShowS
$cshowsPrec :: Int -> AudioChannelMixerFlags -> ShowS
Show, AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool
(AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool)
-> (AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool)
-> Eq AudioChannelMixerFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool
$c/= :: AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool
== :: AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool
$c== :: AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool
Eq)

instance P.Enum AudioChannelMixerFlags where
    fromEnum :: AudioChannelMixerFlags -> Int
fromEnum AudioChannelMixerFlags
AudioChannelMixerFlagsNone = Int
0
    fromEnum AudioChannelMixerFlags
AudioChannelMixerFlagsNonInterleavedIn = Int
1
    fromEnum AudioChannelMixerFlags
AudioChannelMixerFlagsNonInterleavedOut = Int
2
    fromEnum AudioChannelMixerFlags
AudioChannelMixerFlagsUnpositionedIn = Int
4
    fromEnum AudioChannelMixerFlags
AudioChannelMixerFlagsUnpositionedOut = Int
8
    fromEnum (AnotherAudioChannelMixerFlags Int
k) = Int
k

    toEnum :: Int -> AudioChannelMixerFlags
toEnum Int
0 = AudioChannelMixerFlags
AudioChannelMixerFlagsNone
    toEnum Int
1 = AudioChannelMixerFlags
AudioChannelMixerFlagsNonInterleavedIn
    toEnum Int
2 = AudioChannelMixerFlags
AudioChannelMixerFlagsNonInterleavedOut
    toEnum Int
4 = AudioChannelMixerFlags
AudioChannelMixerFlagsUnpositionedIn
    toEnum Int
8 = AudioChannelMixerFlags
AudioChannelMixerFlagsUnpositionedOut
    toEnum Int
k = Int -> AudioChannelMixerFlags
AnotherAudioChannelMixerFlags Int
k

instance P.Ord AudioChannelMixerFlags where
    compare :: AudioChannelMixerFlags -> AudioChannelMixerFlags -> Ordering
compare AudioChannelMixerFlags
a AudioChannelMixerFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioChannelMixerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioChannelMixerFlags
a) (AudioChannelMixerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioChannelMixerFlags
b)

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

foreign import ccall "gst_audio_channel_mixer_flags_get_type" c_gst_audio_channel_mixer_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AudioChannelMixerFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_audio_channel_mixer_flags_get_type

instance B.Types.BoxedFlags AudioChannelMixerFlags

instance IsGFlag AudioChannelMixerFlags