#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstAudio.Flags
(
AudioChannelMixerFlags(..) ,
AudioConverterFlags(..) ,
AudioFlags(..) ,
AudioFormatFlags(..) ,
AudioPackFlags(..) ,
AudioQuantizeFlags(..) ,
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
data AudioResamplerFlags =
AudioResamplerFlagsNone
| AudioResamplerFlagsNonInterleavedIn
| AudioResamplerFlagsNonInterleavedOut
| AudioResamplerFlagsVariableRate
| AnotherAudioResamplerFlags Int
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
data AudioQuantizeFlags =
AudioQuantizeFlagsNone
| AudioQuantizeFlagsNonInterleaved
| AnotherAudioQuantizeFlags Int
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
data AudioPackFlags =
AudioPackFlagsNone
| AudioPackFlagsTruncateRange
| AnotherAudioPackFlags Int
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
data AudioFormatFlags =
AudioFormatFlagsInteger
| AudioFormatFlagsFloat
| AudioFormatFlagsSigned
| AudioFormatFlagsComplex
| AudioFormatFlagsUnpack
| AnotherAudioFormatFlags Int
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
data AudioFlags =
AudioFlagsNone
| AudioFlagsUnpositioned
| AnotherAudioFlags Int
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
data AudioConverterFlags =
AudioConverterFlagsNone
| AudioConverterFlagsInWritable
| AudioConverterFlagsVariableRate
| AnotherAudioConverterFlags Int
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
data AudioChannelMixerFlags =
AudioChannelMixerFlagsNone
| AudioChannelMixerFlagsNonInterleavedIn
| AudioChannelMixerFlagsNonInterleavedOut
| AudioChannelMixerFlagsUnpositionedIn
| AudioChannelMixerFlagsUnpositionedOut
| AnotherAudioChannelMixerFlags Int
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