-- | 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.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.GI.Base.Signals as B.Signals
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


-- Flags AudioResamplerFlags
-- | Different resampler flags.
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 AudioResamplerFlagsNone = 0
    fromEnum AudioResamplerFlagsNonInterleavedIn = 1
    fromEnum AudioResamplerFlagsNonInterleavedOut = 2
    fromEnum AudioResamplerFlagsVariableRate = 4
    fromEnum (AnotherAudioResamplerFlags k :: Int
k) = Int
k

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

instance P.Ord AudioResamplerFlags where
    compare :: AudioResamplerFlags -> AudioResamplerFlags -> Ordering
compare a :: AudioResamplerFlags
a b :: 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)

foreign import ccall "gst_audio_resampler_flags_get_type" c_gst_audio_resampler_flags_get_type :: 
    IO GType

instance BoxedFlags AudioResamplerFlags where
    boxedFlagsType :: Proxy AudioResamplerFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_resampler_flags_get_type

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 AudioQuantizeFlagsNone = 0
    fromEnum AudioQuantizeFlagsNonInterleaved = 1
    fromEnum (AnotherAudioQuantizeFlags k :: Int
k) = Int
k

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

instance P.Ord AudioQuantizeFlags where
    compare :: AudioQuantizeFlags -> AudioQuantizeFlags -> Ordering
compare a :: AudioQuantizeFlags
a b :: 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)

foreign import ccall "gst_audio_quantize_flags_get_type" c_gst_audio_quantize_flags_get_type :: 
    IO GType

instance BoxedFlags AudioQuantizeFlags where
    boxedFlagsType :: Proxy AudioQuantizeFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_quantize_flags_get_type

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 sightly 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 AudioPackFlagsNone = 0
    fromEnum AudioPackFlagsTruncateRange = 1
    fromEnum (AnotherAudioPackFlags k :: Int
k) = Int
k

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

instance P.Ord AudioPackFlags where
    compare :: AudioPackFlags -> AudioPackFlags -> Ordering
compare a :: AudioPackFlags
a b :: 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)

foreign import ccall "gst_audio_pack_flags_get_type" c_gst_audio_pack_flags_get_type :: 
    IO GType

instance BoxedFlags AudioPackFlags where
    boxedFlagsType :: Proxy AudioPackFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_pack_flags_get_type

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 AudioFormatFlagsInteger = 1
    fromEnum AudioFormatFlagsFloat = 2
    fromEnum AudioFormatFlagsSigned = 4
    fromEnum AudioFormatFlagsComplex = 16
    fromEnum AudioFormatFlagsUnpack = 32
    fromEnum (AnotherAudioFormatFlags k :: Int
k) = Int
k

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

instance P.Ord AudioFormatFlags where
    compare :: AudioFormatFlags -> AudioFormatFlags -> Ordering
compare a :: AudioFormatFlags
a b :: 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)

foreign import ccall "gst_audio_format_flags_get_type" c_gst_audio_format_flags_get_type :: 
    IO GType

instance BoxedFlags AudioFormatFlags where
    boxedFlagsType :: Proxy AudioFormatFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_format_flags_get_type

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 AudioFlagsNone = 0
    fromEnum AudioFlagsUnpositioned = 1
    fromEnum (AnotherAudioFlags k :: Int
k) = Int
k

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

instance P.Ord AudioFlags where
    compare :: AudioFlags -> AudioFlags -> Ordering
compare a :: AudioFlags
a b :: 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)

foreign import ccall "gst_audio_flags_get_type" c_gst_audio_flags_get_type :: 
    IO GType

instance BoxedFlags AudioFlags where
    boxedFlagsType :: Proxy AudioFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_flags_get_type

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 AudioConverterFlagsNone = 0
    fromEnum AudioConverterFlagsInWritable = 1
    fromEnum AudioConverterFlagsVariableRate = 2
    fromEnum (AnotherAudioConverterFlags k :: Int
k) = Int
k

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

instance P.Ord AudioConverterFlags where
    compare :: AudioConverterFlags -> AudioConverterFlags -> Ordering
compare a :: AudioConverterFlags
a b :: 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)

foreign import ccall "gst_audio_converter_flags_get_type" c_gst_audio_converter_flags_get_type :: 
    IO GType

instance BoxedFlags AudioConverterFlags where
    boxedFlagsType :: Proxy AudioConverterFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_converter_flags_get_type

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 AudioChannelMixerFlagsNone = 0
    fromEnum AudioChannelMixerFlagsNonInterleavedIn = 1
    fromEnum AudioChannelMixerFlagsNonInterleavedOut = 2
    fromEnum AudioChannelMixerFlagsUnpositionedIn = 4
    fromEnum AudioChannelMixerFlagsUnpositionedOut = 8
    fromEnum (AnotherAudioChannelMixerFlags k :: Int
k) = Int
k

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

instance P.Ord AudioChannelMixerFlags where
    compare :: AudioChannelMixerFlags -> AudioChannelMixerFlags -> Ordering
compare a :: AudioChannelMixerFlags
a b :: 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)

foreign import ccall "gst_audio_channel_mixer_flags_get_type" c_gst_audio_channel_mixer_flags_get_type :: 
    IO GType

instance BoxedFlags AudioChannelMixerFlags where
    boxedFlagsType :: Proxy AudioChannelMixerFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_channel_mixer_flags_get_type

instance IsGFlag AudioChannelMixerFlags