-- | 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.Gst.Flags
    ( 

 -- * Flags
-- ** AllocatorFlags #flag:AllocatorFlags#

    AllocatorFlags(..)                      ,


-- ** BinFlags #flag:BinFlags#

    BinFlags(..)                            ,


-- ** BufferCopyFlags #flag:BufferCopyFlags#

    BufferCopyFlags(..)                     ,


-- ** BufferFlags #flag:BufferFlags#

    BufferFlags(..)                         ,


-- ** BufferPoolAcquireFlags #flag:BufferPoolAcquireFlags#

    BufferPoolAcquireFlags(..)              ,


-- ** BusFlags #flag:BusFlags#

    BusFlags(..)                            ,


-- ** CapsFlags #flag:CapsFlags#

    CapsFlags(..)                           ,


-- ** ClockFlags #flag:ClockFlags#

    ClockFlags(..)                          ,


-- ** DebugColorFlags #flag:DebugColorFlags#

    DebugColorFlags(..)                     ,


-- ** DebugGraphDetails #flag:DebugGraphDetails#

    DebugGraphDetails(..)                   ,


-- ** ElementFlags #flag:ElementFlags#

    ElementFlags(..)                        ,


-- ** EventTypeFlags #flag:EventTypeFlags#

    EventTypeFlags(..)                      ,


-- ** LockFlags #flag:LockFlags#

    LockFlags(..)                           ,


-- ** MapFlags #flag:MapFlags#

    MapFlags(..)                            ,


-- ** MemoryFlags #flag:MemoryFlags#

    MemoryFlags(..)                         ,


-- ** MessageType #flag:MessageType#

    MessageType(..)                         ,


-- ** MetaFlags #flag:MetaFlags#

    MetaFlags(..)                           ,


-- ** MiniObjectFlags #flag:MiniObjectFlags#

    MiniObjectFlags(..)                     ,


-- ** ObjectFlags #flag:ObjectFlags#

    ObjectFlags(..)                         ,


-- ** PadFlags #flag:PadFlags#

    PadFlags(..)                            ,


-- ** PadLinkCheck #flag:PadLinkCheck#

    PadLinkCheck(..)                        ,


-- ** PadProbeType #flag:PadProbeType#

    PadProbeType(..)                        ,


-- ** PadTemplateFlags #flag:PadTemplateFlags#

    PadTemplateFlags(..)                    ,


-- ** ParseFlags #flag:ParseFlags#

    ParseFlags(..)                          ,


-- ** PipelineFlags #flag:PipelineFlags#

    PipelineFlags(..)                       ,


-- ** PluginDependencyFlags #flag:PluginDependencyFlags#

    PluginDependencyFlags(..)               ,


-- ** PluginFlags #flag:PluginFlags#

    PluginFlags(..)                         ,


-- ** QueryTypeFlags #flag:QueryTypeFlags#

    QueryTypeFlags(..)                      ,


-- ** SchedulingFlags #flag:SchedulingFlags#

    SchedulingFlags(..)                     ,


-- ** SeekFlags #flag:SeekFlags#

    SeekFlags(..)                           ,


-- ** SegmentFlags #flag:SegmentFlags#

    SegmentFlags(..)                        ,


-- ** StackTraceFlags #flag:StackTraceFlags#

    StackTraceFlags(..)                     ,


-- ** StreamFlags #flag:StreamFlags#

    StreamFlags(..)                         ,


-- ** StreamType #flag:StreamType#

    StreamType(..)                          ,


-- ** TracerValueFlags #flag:TracerValueFlags#

    TracerValueFlags(..)                    ,




    ) 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.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


-- Flags TracerValueFlags
-- | Flag that describe the value. These flags help applications processing the
-- logs to understand the values.
data TracerValueFlags = 
      TracerValueFlagsNone
    -- ^ no flags
    | TracerValueFlagsOptional
    -- ^ the value is optional. When using this flag
    --   one need to have an additional boolean arg before this value in the
    --   var-args list passed to  @/gst_tracer_record_log()/@.
    | TracerValueFlagsAggregated
    -- ^ the value is a combined figure, since the
    --   start of tracing. Examples are averages or timestamps.
    | AnotherTracerValueFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TracerValueFlags -> ShowS
[TracerValueFlags] -> ShowS
TracerValueFlags -> String
(Int -> TracerValueFlags -> ShowS)
-> (TracerValueFlags -> String)
-> ([TracerValueFlags] -> ShowS)
-> Show TracerValueFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TracerValueFlags] -> ShowS
$cshowList :: [TracerValueFlags] -> ShowS
show :: TracerValueFlags -> String
$cshow :: TracerValueFlags -> String
showsPrec :: Int -> TracerValueFlags -> ShowS
$cshowsPrec :: Int -> TracerValueFlags -> ShowS
Show, TracerValueFlags -> TracerValueFlags -> Bool
(TracerValueFlags -> TracerValueFlags -> Bool)
-> (TracerValueFlags -> TracerValueFlags -> Bool)
-> Eq TracerValueFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TracerValueFlags -> TracerValueFlags -> Bool
$c/= :: TracerValueFlags -> TracerValueFlags -> Bool
== :: TracerValueFlags -> TracerValueFlags -> Bool
$c== :: TracerValueFlags -> TracerValueFlags -> Bool
Eq)

instance P.Enum TracerValueFlags where
    fromEnum :: TracerValueFlags -> Int
fromEnum TracerValueFlags
TracerValueFlagsNone = Int
0
    fromEnum TracerValueFlags
TracerValueFlagsOptional = Int
1
    fromEnum TracerValueFlags
TracerValueFlagsAggregated = Int
2
    fromEnum (AnotherTracerValueFlags Int
k) = Int
k

    toEnum :: Int -> TracerValueFlags
toEnum Int
0 = TracerValueFlags
TracerValueFlagsNone
    toEnum Int
1 = TracerValueFlags
TracerValueFlagsOptional
    toEnum Int
2 = TracerValueFlags
TracerValueFlagsAggregated
    toEnum Int
k = Int -> TracerValueFlags
AnotherTracerValueFlags Int
k

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

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

foreign import ccall "gst_tracer_value_flags_get_type" c_gst_tracer_value_flags_get_type :: 
    IO GType

instance B.Types.TypedObject TracerValueFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_tracer_value_flags_get_type

instance B.Types.BoxedFlags TracerValueFlags

instance IsGFlag TracerValueFlags

-- Flags StreamType
-- | t'GI.Gst.Flags.StreamType' describes a high level classification set for
-- flows of data in t'GI.Gst.Objects.Stream.Stream' objects.
-- 
-- Note that this is a flag, and therefore users should not assume it
-- will be a single value. Do not use the equality operator for checking
-- whether a stream is of a certain type.
-- 
-- /Since: 1.10/
data StreamType = 
      StreamTypeUnknown
    -- ^ The stream is of unknown (unclassified) type.
    | StreamTypeAudio
    -- ^ The stream is of audio data
    | StreamTypeVideo
    -- ^ The stream carries video data
    | StreamTypeContainer
    -- ^ The stream is a muxed container type
    | StreamTypeText
    -- ^ The stream contains subtitle \/ subpicture data.
    | AnotherStreamType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StreamType -> ShowS
[StreamType] -> ShowS
StreamType -> String
(Int -> StreamType -> ShowS)
-> (StreamType -> String)
-> ([StreamType] -> ShowS)
-> Show StreamType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StreamType] -> ShowS
$cshowList :: [StreamType] -> ShowS
show :: StreamType -> String
$cshow :: StreamType -> String
showsPrec :: Int -> StreamType -> ShowS
$cshowsPrec :: Int -> StreamType -> ShowS
Show, StreamType -> StreamType -> Bool
(StreamType -> StreamType -> Bool)
-> (StreamType -> StreamType -> Bool) -> Eq StreamType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StreamType -> StreamType -> Bool
$c/= :: StreamType -> StreamType -> Bool
== :: StreamType -> StreamType -> Bool
$c== :: StreamType -> StreamType -> Bool
Eq)

instance P.Enum StreamType where
    fromEnum :: StreamType -> Int
fromEnum StreamType
StreamTypeUnknown = Int
1
    fromEnum StreamType
StreamTypeAudio = Int
2
    fromEnum StreamType
StreamTypeVideo = Int
4
    fromEnum StreamType
StreamTypeContainer = Int
8
    fromEnum StreamType
StreamTypeText = Int
16
    fromEnum (AnotherStreamType Int
k) = Int
k

    toEnum :: Int -> StreamType
toEnum Int
1 = StreamType
StreamTypeUnknown
    toEnum Int
2 = StreamType
StreamTypeAudio
    toEnum Int
4 = StreamType
StreamTypeVideo
    toEnum Int
8 = StreamType
StreamTypeContainer
    toEnum Int
16 = StreamType
StreamTypeText
    toEnum Int
k = Int -> StreamType
AnotherStreamType Int
k

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

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

foreign import ccall "gst_stream_type_get_type" c_gst_stream_type_get_type :: 
    IO GType

instance B.Types.TypedObject StreamType where
    glibType :: IO GType
glibType = IO GType
c_gst_stream_type_get_type

instance B.Types.BoxedFlags StreamType

instance IsGFlag StreamType

-- Flags StreamFlags
-- | /No description available in the introspection data./
-- 
-- /Since: 1.2/
data StreamFlags = 
      StreamFlagsNone
    -- ^ This stream has no special attributes
    | StreamFlagsSparse
    -- ^ This stream is a sparse stream (e.g. a subtitle
    --    stream), data may flow only in irregular intervals with large gaps in
    --    between.
    | StreamFlagsSelect
    -- ^ This stream should be selected by default. This
    --    flag may be used by demuxers to signal that a stream should be selected
    --    by default in a playback scenario.
    | StreamFlagsUnselect
    -- ^ This stream should not be selected by default.
    --    This flag may be used by demuxers to signal that a stream should not
    --    be selected by default in a playback scenario, but only if explicitly
    --    selected by the user (e.g. an audio track for the hard of hearing or
    --    a director\'s commentary track).
    | AnotherStreamFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StreamFlags -> ShowS
[StreamFlags] -> ShowS
StreamFlags -> String
(Int -> StreamFlags -> ShowS)
-> (StreamFlags -> String)
-> ([StreamFlags] -> ShowS)
-> Show StreamFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StreamFlags] -> ShowS
$cshowList :: [StreamFlags] -> ShowS
show :: StreamFlags -> String
$cshow :: StreamFlags -> String
showsPrec :: Int -> StreamFlags -> ShowS
$cshowsPrec :: Int -> StreamFlags -> ShowS
Show, StreamFlags -> StreamFlags -> Bool
(StreamFlags -> StreamFlags -> Bool)
-> (StreamFlags -> StreamFlags -> Bool) -> Eq StreamFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StreamFlags -> StreamFlags -> Bool
$c/= :: StreamFlags -> StreamFlags -> Bool
== :: StreamFlags -> StreamFlags -> Bool
$c== :: StreamFlags -> StreamFlags -> Bool
Eq)

instance P.Enum StreamFlags where
    fromEnum :: StreamFlags -> Int
fromEnum StreamFlags
StreamFlagsNone = Int
0
    fromEnum StreamFlags
StreamFlagsSparse = Int
1
    fromEnum StreamFlags
StreamFlagsSelect = Int
2
    fromEnum StreamFlags
StreamFlagsUnselect = Int
4
    fromEnum (AnotherStreamFlags Int
k) = Int
k

    toEnum :: Int -> StreamFlags
toEnum Int
0 = StreamFlags
StreamFlagsNone
    toEnum Int
1 = StreamFlags
StreamFlagsSparse
    toEnum Int
2 = StreamFlags
StreamFlagsSelect
    toEnum Int
4 = StreamFlags
StreamFlagsUnselect
    toEnum Int
k = Int -> StreamFlags
AnotherStreamFlags Int
k

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

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

foreign import ccall "gst_stream_flags_get_type" c_gst_stream_flags_get_type :: 
    IO GType

instance B.Types.TypedObject StreamFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_stream_flags_get_type

instance B.Types.BoxedFlags StreamFlags

instance IsGFlag StreamFlags

-- Flags StackTraceFlags
-- | /No description available in the introspection data./
-- 
-- /Since: 1.12/
data StackTraceFlags = 
      StackTraceFlagsFull
    -- ^ Try to retrieve as much information as
    --                             possible when getting the stack trace
    | AnotherStackTraceFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StackTraceFlags -> ShowS
[StackTraceFlags] -> ShowS
StackTraceFlags -> String
(Int -> StackTraceFlags -> ShowS)
-> (StackTraceFlags -> String)
-> ([StackTraceFlags] -> ShowS)
-> Show StackTraceFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StackTraceFlags] -> ShowS
$cshowList :: [StackTraceFlags] -> ShowS
show :: StackTraceFlags -> String
$cshow :: StackTraceFlags -> String
showsPrec :: Int -> StackTraceFlags -> ShowS
$cshowsPrec :: Int -> StackTraceFlags -> ShowS
Show, StackTraceFlags -> StackTraceFlags -> Bool
(StackTraceFlags -> StackTraceFlags -> Bool)
-> (StackTraceFlags -> StackTraceFlags -> Bool)
-> Eq StackTraceFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StackTraceFlags -> StackTraceFlags -> Bool
$c/= :: StackTraceFlags -> StackTraceFlags -> Bool
== :: StackTraceFlags -> StackTraceFlags -> Bool
$c== :: StackTraceFlags -> StackTraceFlags -> Bool
Eq)

instance P.Enum StackTraceFlags where
    fromEnum :: StackTraceFlags -> Int
fromEnum StackTraceFlags
StackTraceFlagsFull = Int
1
    fromEnum (AnotherStackTraceFlags Int
k) = Int
k

    toEnum :: Int -> StackTraceFlags
toEnum Int
1 = StackTraceFlags
StackTraceFlagsFull
    toEnum Int
k = Int -> StackTraceFlags
AnotherStackTraceFlags Int
k

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

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

foreign import ccall "gst_stack_trace_flags_get_type" c_gst_stack_trace_flags_get_type :: 
    IO GType

instance B.Types.TypedObject StackTraceFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_stack_trace_flags_get_type

instance B.Types.BoxedFlags StackTraceFlags

instance IsGFlag StackTraceFlags

-- Flags SegmentFlags
-- | Flags for the GstSegment structure. Currently mapped to the corresponding
-- values of the seek flags.
data SegmentFlags = 
      SegmentFlagsNone
    -- ^ no flags
    | SegmentFlagsReset
    -- ^ reset the pipeline running_time to the segment
    --                          running_time
    | SegmentFlagsTrickmode
    -- ^ perform skip playback (Since: 1.6)
    | SegmentFlagsSkip
    -- ^ Deprecated backward compatibility flag, replaced
    --                         by /@gSTSEGMENTFLAGTRICKMODE@/
    | SegmentFlagsSegment
    -- ^ send SEGMENT_DONE instead of EOS
    | SegmentFlagsTrickmodeKeyUnits
    -- ^ Decode only keyframes, where
    --                                        possible (Since: 1.6)
    | SegmentFlagsTrickmodeNoAudio
    -- ^ Do not decode any audio, where
    --                                        possible (Since: 1.6)
    | AnotherSegmentFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SegmentFlags -> ShowS
[SegmentFlags] -> ShowS
SegmentFlags -> String
(Int -> SegmentFlags -> ShowS)
-> (SegmentFlags -> String)
-> ([SegmentFlags] -> ShowS)
-> Show SegmentFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SegmentFlags] -> ShowS
$cshowList :: [SegmentFlags] -> ShowS
show :: SegmentFlags -> String
$cshow :: SegmentFlags -> String
showsPrec :: Int -> SegmentFlags -> ShowS
$cshowsPrec :: Int -> SegmentFlags -> ShowS
Show, SegmentFlags -> SegmentFlags -> Bool
(SegmentFlags -> SegmentFlags -> Bool)
-> (SegmentFlags -> SegmentFlags -> Bool) -> Eq SegmentFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SegmentFlags -> SegmentFlags -> Bool
$c/= :: SegmentFlags -> SegmentFlags -> Bool
== :: SegmentFlags -> SegmentFlags -> Bool
$c== :: SegmentFlags -> SegmentFlags -> Bool
Eq)

instance P.Enum SegmentFlags where
    fromEnum :: SegmentFlags -> Int
fromEnum SegmentFlags
SegmentFlagsNone = Int
0
    fromEnum SegmentFlags
SegmentFlagsReset = Int
1
    fromEnum SegmentFlags
SegmentFlagsTrickmode = Int
16
    fromEnum SegmentFlags
SegmentFlagsSkip = Int
16
    fromEnum SegmentFlags
SegmentFlagsSegment = Int
8
    fromEnum SegmentFlags
SegmentFlagsTrickmodeKeyUnits = Int
128
    fromEnum SegmentFlags
SegmentFlagsTrickmodeNoAudio = Int
256
    fromEnum (AnotherSegmentFlags Int
k) = Int
k

    toEnum :: Int -> SegmentFlags
toEnum Int
0 = SegmentFlags
SegmentFlagsNone
    toEnum Int
1 = SegmentFlags
SegmentFlagsReset
    toEnum Int
16 = SegmentFlags
SegmentFlagsTrickmode
    toEnum Int
8 = SegmentFlags
SegmentFlagsSegment
    toEnum Int
128 = SegmentFlags
SegmentFlagsTrickmodeKeyUnits
    toEnum Int
256 = SegmentFlags
SegmentFlagsTrickmodeNoAudio
    toEnum Int
k = Int -> SegmentFlags
AnotherSegmentFlags Int
k

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

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

foreign import ccall "gst_segment_flags_get_type" c_gst_segment_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SegmentFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_segment_flags_get_type

instance B.Types.BoxedFlags SegmentFlags

instance IsGFlag SegmentFlags

-- Flags SeekFlags
-- | Flags to be used with 'GI.Gst.Objects.Element.elementSeek' or 'GI.Gst.Structs.Event.eventNewSeek'. All flags
-- can be used together.
-- 
-- A non flushing seek might take some time to perform as the currently
-- playing data in the pipeline will not be cleared.
-- 
-- An accurate seek might be slower for formats that don\'t have any indexes
-- or timestamp markers in the stream. Specifying this flag might require a
-- complete scan of the file in those cases.
-- 
-- When performing a segment seek: after the playback of the segment completes,
-- no EOS will be emitted by the element that performed the seek, but a
-- 'GI.Gst.Flags.MessageTypeSegmentDone' message will be posted on the bus by the element.
-- When this message is posted, it is possible to send a new seek event to
-- continue playback. With this seek method it is possible to perform seamless
-- looping or simple linear editing.
-- 
-- When doing fast forward (rate > 1.0) or fast reverse (rate \< -1.0) trickmode
-- playback, the 'GI.Gst.Flags.SeekFlagsTrickmode' flag can be used to instruct decoders
-- and demuxers to adjust the playback rate by skipping frames. This can improve
-- performance and decrease CPU usage because not all frames need to be decoded.
-- 
-- Beyond that, the 'GI.Gst.Flags.SeekFlagsTrickmodeKeyUnits' flag can be used to
-- request that decoders skip all frames except key units, and
-- 'GI.Gst.Flags.SeekFlagsTrickmodeNoAudio' flags can be used to request that audio
-- decoders do no decoding at all, and simple output silence.
-- 
-- The 'GI.Gst.Flags.SeekFlagsSnapBefore' flag can be used to snap to the previous
-- relevant location, and the 'GI.Gst.Flags.SeekFlagsSnapAfter' flag can be used to
-- select the next relevant location. If 'GI.Gst.Flags.SeekFlagsKeyUnit' is specified,
-- the relevant location is a keyframe. If both flags are specified, the nearest
-- of these locations will be selected. If none are specified, the implementation is
-- free to select whichever it wants.
-- 
-- The before and after here are in running time, so when playing backwards,
-- the next location refers to the one that will played in next, and not the
-- one that is located after in the actual source stream.
-- 
-- Also see part-seeking.txt in the GStreamer design documentation for more
-- details on the meaning of these flags and the behaviour expected of
-- elements that handle them.
data SeekFlags = 
      SeekFlagsNone
    -- ^ no flag
    | SeekFlagsFlush
    -- ^ flush pipeline
    | SeekFlagsAccurate
    -- ^ accurate position is requested, this might
    --                     be considerably slower for some formats.
    | SeekFlagsKeyUnit
    -- ^ seek to the nearest keyframe. This might be
    --                     faster but less accurate.
    | SeekFlagsSegment
    -- ^ perform a segment seek.
    | SeekFlagsTrickmode
    -- ^ when doing fast forward or fast reverse playback, allow
    --                     elements to skip frames instead of generating all
    --                     frames. (Since: 1.6)
    | SeekFlagsSkip
    -- ^ Deprecated backward compatibility flag, replaced
    --                     by 'GI.Gst.Flags.SeekFlagsTrickmode'
    | SeekFlagsSnapBefore
    -- ^ go to a location before the requested position,
    --                     if 'GI.Gst.Flags.SeekFlagsKeyUnit' this means the keyframe at or before
    --                     the requested position the one at or before the seek target.
    | SeekFlagsSnapAfter
    -- ^ go to a location after the requested position,
    --                     if 'GI.Gst.Flags.SeekFlagsKeyUnit' this means the keyframe at of after the
    --                     requested position.
    | SeekFlagsSnapNearest
    -- ^ go to a position near the requested position,
    --                     if 'GI.Gst.Flags.SeekFlagsKeyUnit' this means the keyframe closest
    --                     to the requested position, if both keyframes are at an equal
    --                     distance, behaves like 'GI.Gst.Flags.SeekFlagsSnapBefore'.
    | SeekFlagsTrickmodeKeyUnits
    -- ^ when doing fast forward or fast reverse
    --                     playback, request that elements only decode keyframes
    --                     and skip all other content, for formats that have
    --                     keyframes. (Since: 1.6)
    | SeekFlagsTrickmodeNoAudio
    -- ^ when doing fast forward or fast reverse
    --                     playback, request that audio decoder elements skip
    --                     decoding and output only gap events or silence. (Since: 1.6)
    | AnotherSeekFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SeekFlags -> ShowS
[SeekFlags] -> ShowS
SeekFlags -> String
(Int -> SeekFlags -> ShowS)
-> (SeekFlags -> String)
-> ([SeekFlags] -> ShowS)
-> Show SeekFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SeekFlags] -> ShowS
$cshowList :: [SeekFlags] -> ShowS
show :: SeekFlags -> String
$cshow :: SeekFlags -> String
showsPrec :: Int -> SeekFlags -> ShowS
$cshowsPrec :: Int -> SeekFlags -> ShowS
Show, SeekFlags -> SeekFlags -> Bool
(SeekFlags -> SeekFlags -> Bool)
-> (SeekFlags -> SeekFlags -> Bool) -> Eq SeekFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SeekFlags -> SeekFlags -> Bool
$c/= :: SeekFlags -> SeekFlags -> Bool
== :: SeekFlags -> SeekFlags -> Bool
$c== :: SeekFlags -> SeekFlags -> Bool
Eq)

instance P.Enum SeekFlags where
    fromEnum :: SeekFlags -> Int
fromEnum SeekFlags
SeekFlagsNone = Int
0
    fromEnum SeekFlags
SeekFlagsFlush = Int
1
    fromEnum SeekFlags
SeekFlagsAccurate = Int
2
    fromEnum SeekFlags
SeekFlagsKeyUnit = Int
4
    fromEnum SeekFlags
SeekFlagsSegment = Int
8
    fromEnum SeekFlags
SeekFlagsTrickmode = Int
16
    fromEnum SeekFlags
SeekFlagsSkip = Int
16
    fromEnum SeekFlags
SeekFlagsSnapBefore = Int
32
    fromEnum SeekFlags
SeekFlagsSnapAfter = Int
64
    fromEnum SeekFlags
SeekFlagsSnapNearest = Int
96
    fromEnum SeekFlags
SeekFlagsTrickmodeKeyUnits = Int
128
    fromEnum SeekFlags
SeekFlagsTrickmodeNoAudio = Int
256
    fromEnum (AnotherSeekFlags Int
k) = Int
k

    toEnum :: Int -> SeekFlags
toEnum Int
0 = SeekFlags
SeekFlagsNone
    toEnum Int
1 = SeekFlags
SeekFlagsFlush
    toEnum Int
2 = SeekFlags
SeekFlagsAccurate
    toEnum Int
4 = SeekFlags
SeekFlagsKeyUnit
    toEnum Int
8 = SeekFlags
SeekFlagsSegment
    toEnum Int
16 = SeekFlags
SeekFlagsTrickmode
    toEnum Int
32 = SeekFlags
SeekFlagsSnapBefore
    toEnum Int
64 = SeekFlags
SeekFlagsSnapAfter
    toEnum Int
96 = SeekFlags
SeekFlagsSnapNearest
    toEnum Int
128 = SeekFlags
SeekFlagsTrickmodeKeyUnits
    toEnum Int
256 = SeekFlags
SeekFlagsTrickmodeNoAudio
    toEnum Int
k = Int -> SeekFlags
AnotherSeekFlags Int
k

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

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

foreign import ccall "gst_seek_flags_get_type" c_gst_seek_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SeekFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_seek_flags_get_type

instance B.Types.BoxedFlags SeekFlags

instance IsGFlag SeekFlags

-- Flags SchedulingFlags
-- | The different scheduling flags.
data SchedulingFlags = 
      SchedulingFlagsSeekable
    -- ^ if seeking is possible
    | SchedulingFlagsSequential
    -- ^ if sequential access is recommended
    | SchedulingFlagsBandwidthLimited
    -- ^ if bandwidth is limited and buffering possible (since 1.2)
    | AnotherSchedulingFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SchedulingFlags -> ShowS
[SchedulingFlags] -> ShowS
SchedulingFlags -> String
(Int -> SchedulingFlags -> ShowS)
-> (SchedulingFlags -> String)
-> ([SchedulingFlags] -> ShowS)
-> Show SchedulingFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SchedulingFlags] -> ShowS
$cshowList :: [SchedulingFlags] -> ShowS
show :: SchedulingFlags -> String
$cshow :: SchedulingFlags -> String
showsPrec :: Int -> SchedulingFlags -> ShowS
$cshowsPrec :: Int -> SchedulingFlags -> ShowS
Show, SchedulingFlags -> SchedulingFlags -> Bool
(SchedulingFlags -> SchedulingFlags -> Bool)
-> (SchedulingFlags -> SchedulingFlags -> Bool)
-> Eq SchedulingFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SchedulingFlags -> SchedulingFlags -> Bool
$c/= :: SchedulingFlags -> SchedulingFlags -> Bool
== :: SchedulingFlags -> SchedulingFlags -> Bool
$c== :: SchedulingFlags -> SchedulingFlags -> Bool
Eq)

instance P.Enum SchedulingFlags where
    fromEnum :: SchedulingFlags -> Int
fromEnum SchedulingFlags
SchedulingFlagsSeekable = Int
1
    fromEnum SchedulingFlags
SchedulingFlagsSequential = Int
2
    fromEnum SchedulingFlags
SchedulingFlagsBandwidthLimited = Int
4
    fromEnum (AnotherSchedulingFlags Int
k) = Int
k

    toEnum :: Int -> SchedulingFlags
toEnum Int
1 = SchedulingFlags
SchedulingFlagsSeekable
    toEnum Int
2 = SchedulingFlags
SchedulingFlagsSequential
    toEnum Int
4 = SchedulingFlags
SchedulingFlagsBandwidthLimited
    toEnum Int
k = Int -> SchedulingFlags
AnotherSchedulingFlags Int
k

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

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

foreign import ccall "gst_scheduling_flags_get_type" c_gst_scheduling_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SchedulingFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_scheduling_flags_get_type

instance B.Types.BoxedFlags SchedulingFlags

instance IsGFlag SchedulingFlags

-- Flags QueryTypeFlags
-- | t'GI.Gst.Flags.QueryTypeFlags' indicate the aspects of the different t'GI.Gst.Enums.QueryType'
-- values. You can get the type flags of a t'GI.Gst.Enums.QueryType' with the
-- 'GI.Gst.Functions.queryTypeGetFlags' function.
data QueryTypeFlags = 
      QueryTypeFlagsUpstream
    -- ^ Set if the query can travel upstream.
    | QueryTypeFlagsDownstream
    -- ^ Set if the query can travel downstream.
    | QueryTypeFlagsSerialized
    -- ^ Set if the query should be serialized with data
    --                               flow.
    | AnotherQueryTypeFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> QueryTypeFlags -> ShowS
[QueryTypeFlags] -> ShowS
QueryTypeFlags -> String
(Int -> QueryTypeFlags -> ShowS)
-> (QueryTypeFlags -> String)
-> ([QueryTypeFlags] -> ShowS)
-> Show QueryTypeFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [QueryTypeFlags] -> ShowS
$cshowList :: [QueryTypeFlags] -> ShowS
show :: QueryTypeFlags -> String
$cshow :: QueryTypeFlags -> String
showsPrec :: Int -> QueryTypeFlags -> ShowS
$cshowsPrec :: Int -> QueryTypeFlags -> ShowS
Show, QueryTypeFlags -> QueryTypeFlags -> Bool
(QueryTypeFlags -> QueryTypeFlags -> Bool)
-> (QueryTypeFlags -> QueryTypeFlags -> Bool) -> Eq QueryTypeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: QueryTypeFlags -> QueryTypeFlags -> Bool
$c/= :: QueryTypeFlags -> QueryTypeFlags -> Bool
== :: QueryTypeFlags -> QueryTypeFlags -> Bool
$c== :: QueryTypeFlags -> QueryTypeFlags -> Bool
Eq)

instance P.Enum QueryTypeFlags where
    fromEnum :: QueryTypeFlags -> Int
fromEnum QueryTypeFlags
QueryTypeFlagsUpstream = Int
1
    fromEnum QueryTypeFlags
QueryTypeFlagsDownstream = Int
2
    fromEnum QueryTypeFlags
QueryTypeFlagsSerialized = Int
4
    fromEnum (AnotherQueryTypeFlags Int
k) = Int
k

    toEnum :: Int -> QueryTypeFlags
toEnum Int
1 = QueryTypeFlags
QueryTypeFlagsUpstream
    toEnum Int
2 = QueryTypeFlags
QueryTypeFlagsDownstream
    toEnum Int
4 = QueryTypeFlags
QueryTypeFlagsSerialized
    toEnum Int
k = Int -> QueryTypeFlags
AnotherQueryTypeFlags Int
k

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

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

foreign import ccall "gst_query_type_flags_get_type" c_gst_query_type_flags_get_type :: 
    IO GType

instance B.Types.TypedObject QueryTypeFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_query_type_flags_get_type

instance B.Types.BoxedFlags QueryTypeFlags

instance IsGFlag QueryTypeFlags

-- Flags PluginFlags
-- | The plugin loading state
data PluginFlags = 
      PluginFlagsCached
    -- ^ Temporarily loaded plugins
    | PluginFlagsBlacklisted
    -- ^ The plugin won\'t be scanned (again)
    | AnotherPluginFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PluginFlags -> ShowS
[PluginFlags] -> ShowS
PluginFlags -> String
(Int -> PluginFlags -> ShowS)
-> (PluginFlags -> String)
-> ([PluginFlags] -> ShowS)
-> Show PluginFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PluginFlags] -> ShowS
$cshowList :: [PluginFlags] -> ShowS
show :: PluginFlags -> String
$cshow :: PluginFlags -> String
showsPrec :: Int -> PluginFlags -> ShowS
$cshowsPrec :: Int -> PluginFlags -> ShowS
Show, PluginFlags -> PluginFlags -> Bool
(PluginFlags -> PluginFlags -> Bool)
-> (PluginFlags -> PluginFlags -> Bool) -> Eq PluginFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PluginFlags -> PluginFlags -> Bool
$c/= :: PluginFlags -> PluginFlags -> Bool
== :: PluginFlags -> PluginFlags -> Bool
$c== :: PluginFlags -> PluginFlags -> Bool
Eq)

instance P.Enum PluginFlags where
    fromEnum :: PluginFlags -> Int
fromEnum PluginFlags
PluginFlagsCached = Int
16
    fromEnum PluginFlags
PluginFlagsBlacklisted = Int
32
    fromEnum (AnotherPluginFlags Int
k) = Int
k

    toEnum :: Int -> PluginFlags
toEnum Int
16 = PluginFlags
PluginFlagsCached
    toEnum Int
32 = PluginFlags
PluginFlagsBlacklisted
    toEnum Int
k = Int -> PluginFlags
AnotherPluginFlags Int
k

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

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

foreign import ccall "gst_plugin_flags_get_type" c_gst_plugin_flags_get_type :: 
    IO GType

instance B.Types.TypedObject PluginFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_plugin_flags_get_type

instance B.Types.BoxedFlags PluginFlags

instance IsGFlag PluginFlags

-- Flags PluginDependencyFlags
-- | Flags used in connection with 'GI.Gst.Objects.Plugin.pluginAddDependency'.
data PluginDependencyFlags = 
      PluginDependencyFlagsNone
    -- ^ no special flags
    | PluginDependencyFlagsRecurse
    -- ^ recurse into subdirectories
    | PluginDependencyFlagsPathsAreDefaultOnly
    -- ^ use paths
    --         argument only if none of the environment variables is set
    | PluginDependencyFlagsFileNameIsSuffix
    -- ^ interpret
    --         filename argument as filter suffix and check all matching files in
    --         the directory
    | PluginDependencyFlagsFileNameIsPrefix
    -- ^ interpret
    --         filename argument as filter prefix and check all matching files in
    --         the directory. Since: 1.8.
    | PluginDependencyFlagsPathsAreRelativeToExe
    -- ^ interpret
    --   non-absolute paths as relative to the main executable directory. Since
    --   1.14.
    | AnotherPluginDependencyFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PluginDependencyFlags -> ShowS
[PluginDependencyFlags] -> ShowS
PluginDependencyFlags -> String
(Int -> PluginDependencyFlags -> ShowS)
-> (PluginDependencyFlags -> String)
-> ([PluginDependencyFlags] -> ShowS)
-> Show PluginDependencyFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PluginDependencyFlags] -> ShowS
$cshowList :: [PluginDependencyFlags] -> ShowS
show :: PluginDependencyFlags -> String
$cshow :: PluginDependencyFlags -> String
showsPrec :: Int -> PluginDependencyFlags -> ShowS
$cshowsPrec :: Int -> PluginDependencyFlags -> ShowS
Show, PluginDependencyFlags -> PluginDependencyFlags -> Bool
(PluginDependencyFlags -> PluginDependencyFlags -> Bool)
-> (PluginDependencyFlags -> PluginDependencyFlags -> Bool)
-> Eq PluginDependencyFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PluginDependencyFlags -> PluginDependencyFlags -> Bool
$c/= :: PluginDependencyFlags -> PluginDependencyFlags -> Bool
== :: PluginDependencyFlags -> PluginDependencyFlags -> Bool
$c== :: PluginDependencyFlags -> PluginDependencyFlags -> Bool
Eq)

instance P.Enum PluginDependencyFlags where
    fromEnum :: PluginDependencyFlags -> Int
fromEnum PluginDependencyFlags
PluginDependencyFlagsNone = Int
0
    fromEnum PluginDependencyFlags
PluginDependencyFlagsRecurse = Int
1
    fromEnum PluginDependencyFlags
PluginDependencyFlagsPathsAreDefaultOnly = Int
2
    fromEnum PluginDependencyFlags
PluginDependencyFlagsFileNameIsSuffix = Int
4
    fromEnum PluginDependencyFlags
PluginDependencyFlagsFileNameIsPrefix = Int
8
    fromEnum PluginDependencyFlags
PluginDependencyFlagsPathsAreRelativeToExe = Int
16
    fromEnum (AnotherPluginDependencyFlags Int
k) = Int
k

    toEnum :: Int -> PluginDependencyFlags
toEnum Int
0 = PluginDependencyFlags
PluginDependencyFlagsNone
    toEnum Int
1 = PluginDependencyFlags
PluginDependencyFlagsRecurse
    toEnum Int
2 = PluginDependencyFlags
PluginDependencyFlagsPathsAreDefaultOnly
    toEnum Int
4 = PluginDependencyFlags
PluginDependencyFlagsFileNameIsSuffix
    toEnum Int
8 = PluginDependencyFlags
PluginDependencyFlagsFileNameIsPrefix
    toEnum Int
16 = PluginDependencyFlags
PluginDependencyFlagsPathsAreRelativeToExe
    toEnum Int
k = Int -> PluginDependencyFlags
AnotherPluginDependencyFlags Int
k

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

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

foreign import ccall "gst_plugin_dependency_flags_get_type" c_gst_plugin_dependency_flags_get_type :: 
    IO GType

instance B.Types.TypedObject PluginDependencyFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_plugin_dependency_flags_get_type

instance B.Types.BoxedFlags PluginDependencyFlags

instance IsGFlag PluginDependencyFlags

-- Flags PipelineFlags
-- | Pipeline flags
data PipelineFlags = 
      PipelineFlagsFixedClock
    -- ^ this pipeline works with a fixed clock
    | PipelineFlagsLast
    -- ^ offset to define more flags
    | AnotherPipelineFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PipelineFlags -> ShowS
[PipelineFlags] -> ShowS
PipelineFlags -> String
(Int -> PipelineFlags -> ShowS)
-> (PipelineFlags -> String)
-> ([PipelineFlags] -> ShowS)
-> Show PipelineFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PipelineFlags] -> ShowS
$cshowList :: [PipelineFlags] -> ShowS
show :: PipelineFlags -> String
$cshow :: PipelineFlags -> String
showsPrec :: Int -> PipelineFlags -> ShowS
$cshowsPrec :: Int -> PipelineFlags -> ShowS
Show, PipelineFlags -> PipelineFlags -> Bool
(PipelineFlags -> PipelineFlags -> Bool)
-> (PipelineFlags -> PipelineFlags -> Bool) -> Eq PipelineFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PipelineFlags -> PipelineFlags -> Bool
$c/= :: PipelineFlags -> PipelineFlags -> Bool
== :: PipelineFlags -> PipelineFlags -> Bool
$c== :: PipelineFlags -> PipelineFlags -> Bool
Eq)

instance P.Enum PipelineFlags where
    fromEnum :: PipelineFlags -> Int
fromEnum PipelineFlags
PipelineFlagsFixedClock = Int
524288
    fromEnum PipelineFlags
PipelineFlagsLast = Int
8388608
    fromEnum (AnotherPipelineFlags Int
k) = Int
k

    toEnum :: Int -> PipelineFlags
toEnum Int
524288 = PipelineFlags
PipelineFlagsFixedClock
    toEnum Int
8388608 = PipelineFlags
PipelineFlagsLast
    toEnum Int
k = Int -> PipelineFlags
AnotherPipelineFlags Int
k

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

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

foreign import ccall "gst_pipeline_flags_get_type" c_gst_pipeline_flags_get_type :: 
    IO GType

instance B.Types.TypedObject PipelineFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_pipeline_flags_get_type

instance B.Types.BoxedFlags PipelineFlags

instance IsGFlag PipelineFlags

-- Flags ParseFlags
-- | Parsing options.
data ParseFlags = 
      ParseFlagsNone
    -- ^ Do not use any special parsing options.
    | ParseFlagsFatalErrors
    -- ^ Always return 'P.Nothing' when an error occurs
    --     (default behaviour is to return partially constructed bins or elements
    --      in some cases)
    | ParseFlagsNoSingleElementBins
    -- ^ If a bin only has a single element,
    --     just return the element.
    | ParseFlagsPlaceInBin
    -- ^ If more than one toplevel element is described
    --     by the pipeline description string, put them in a t'GI.Gst.Objects.Bin.Bin' instead of a
    --     t'GI.Gst.Objects.Pipeline.Pipeline'. (Since: 1.10)
    | AnotherParseFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ParseFlags -> ShowS
[ParseFlags] -> ShowS
ParseFlags -> String
(Int -> ParseFlags -> ShowS)
-> (ParseFlags -> String)
-> ([ParseFlags] -> ShowS)
-> Show ParseFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ParseFlags] -> ShowS
$cshowList :: [ParseFlags] -> ShowS
show :: ParseFlags -> String
$cshow :: ParseFlags -> String
showsPrec :: Int -> ParseFlags -> ShowS
$cshowsPrec :: Int -> ParseFlags -> ShowS
Show, ParseFlags -> ParseFlags -> Bool
(ParseFlags -> ParseFlags -> Bool)
-> (ParseFlags -> ParseFlags -> Bool) -> Eq ParseFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ParseFlags -> ParseFlags -> Bool
$c/= :: ParseFlags -> ParseFlags -> Bool
== :: ParseFlags -> ParseFlags -> Bool
$c== :: ParseFlags -> ParseFlags -> Bool
Eq)

instance P.Enum ParseFlags where
    fromEnum :: ParseFlags -> Int
fromEnum ParseFlags
ParseFlagsNone = Int
0
    fromEnum ParseFlags
ParseFlagsFatalErrors = Int
1
    fromEnum ParseFlags
ParseFlagsNoSingleElementBins = Int
2
    fromEnum ParseFlags
ParseFlagsPlaceInBin = Int
4
    fromEnum (AnotherParseFlags Int
k) = Int
k

    toEnum :: Int -> ParseFlags
toEnum Int
0 = ParseFlags
ParseFlagsNone
    toEnum Int
1 = ParseFlags
ParseFlagsFatalErrors
    toEnum Int
2 = ParseFlags
ParseFlagsNoSingleElementBins
    toEnum Int
4 = ParseFlags
ParseFlagsPlaceInBin
    toEnum Int
k = Int -> ParseFlags
AnotherParseFlags Int
k

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

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

foreign import ccall "gst_parse_flags_get_type" c_gst_parse_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ParseFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_parse_flags_get_type

instance B.Types.BoxedFlags ParseFlags

instance IsGFlag ParseFlags

-- Flags PadTemplateFlags
-- | Flags for the padtemplate
data PadTemplateFlags = 
      PadTemplateFlagsLast
    -- ^ first flag that can be used by subclasses.
    | AnotherPadTemplateFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PadTemplateFlags -> ShowS
[PadTemplateFlags] -> ShowS
PadTemplateFlags -> String
(Int -> PadTemplateFlags -> ShowS)
-> (PadTemplateFlags -> String)
-> ([PadTemplateFlags] -> ShowS)
-> Show PadTemplateFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PadTemplateFlags] -> ShowS
$cshowList :: [PadTemplateFlags] -> ShowS
show :: PadTemplateFlags -> String
$cshow :: PadTemplateFlags -> String
showsPrec :: Int -> PadTemplateFlags -> ShowS
$cshowsPrec :: Int -> PadTemplateFlags -> ShowS
Show, PadTemplateFlags -> PadTemplateFlags -> Bool
(PadTemplateFlags -> PadTemplateFlags -> Bool)
-> (PadTemplateFlags -> PadTemplateFlags -> Bool)
-> Eq PadTemplateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PadTemplateFlags -> PadTemplateFlags -> Bool
$c/= :: PadTemplateFlags -> PadTemplateFlags -> Bool
== :: PadTemplateFlags -> PadTemplateFlags -> Bool
$c== :: PadTemplateFlags -> PadTemplateFlags -> Bool
Eq)

instance P.Enum PadTemplateFlags where
    fromEnum :: PadTemplateFlags -> Int
fromEnum PadTemplateFlags
PadTemplateFlagsLast = Int
256
    fromEnum (AnotherPadTemplateFlags Int
k) = Int
k

    toEnum :: Int -> PadTemplateFlags
toEnum Int
256 = PadTemplateFlags
PadTemplateFlagsLast
    toEnum Int
k = Int -> PadTemplateFlags
AnotherPadTemplateFlags Int
k

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

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

foreign import ccall "gst_pad_template_flags_get_type" c_gst_pad_template_flags_get_type :: 
    IO GType

instance B.Types.TypedObject PadTemplateFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_pad_template_flags_get_type

instance B.Types.BoxedFlags PadTemplateFlags

instance IsGFlag PadTemplateFlags

-- Flags PadProbeType
-- | The different probing types that can occur. When either one of
-- /@gSTPADPROBETYPEIDLE@/ or /@gSTPADPROBETYPEBLOCK@/ is used, the probe will be a
-- blocking probe.
data PadProbeType = 
      PadProbeTypeInvalid
    -- ^ invalid probe type
    | PadProbeTypeIdle
    -- ^ probe idle pads and block while the callback is called
    | PadProbeTypeBlock
    -- ^ probe and block pads
    | PadProbeTypeBuffer
    -- ^ probe buffers
    | PadProbeTypeBufferList
    -- ^ probe buffer lists
    | PadProbeTypeEventDownstream
    -- ^ probe downstream events
    | PadProbeTypeEventUpstream
    -- ^ probe upstream events
    | PadProbeTypeEventFlush
    -- ^ probe flush events. This probe has to be
    --     explicitly enabled and is not included in the
    --     \@/@gSTPADPROBETYPEEVENTDOWNSTREAM@/ or
    --     \@/@gSTPADPROBETYPEEVENTUPSTREAM@/ probe types.
    | PadProbeTypeQueryDownstream
    -- ^ probe downstream queries
    | PadProbeTypeQueryUpstream
    -- ^ probe upstream queries
    | PadProbeTypePush
    -- ^ probe push
    | PadProbeTypePull
    -- ^ probe pull
    | PadProbeTypeBlocking
    -- ^ probe and block at the next opportunity, at data flow or when idle
    | PadProbeTypeDataDownstream
    -- ^ probe downstream data (buffers, buffer lists, and events)
    | PadProbeTypeDataUpstream
    -- ^ probe upstream data (events)
    | PadProbeTypeDataBoth
    -- ^ probe upstream and downstream data (buffers, buffer lists, and events)
    | PadProbeTypeBlockDownstream
    -- ^ probe and block downstream data (buffers, buffer lists, and events)
    | PadProbeTypeBlockUpstream
    -- ^ probe and block upstream data (events)
    | PadProbeTypeEventBoth
    -- ^ probe upstream and downstream events
    | PadProbeTypeQueryBoth
    -- ^ probe upstream and downstream queries
    | PadProbeTypeAllBoth
    -- ^ probe upstream events and queries and downstream buffers, buffer lists, events and queries
    | PadProbeTypeScheduling
    -- ^ probe push and pull
    | AnotherPadProbeType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PadProbeType -> ShowS
[PadProbeType] -> ShowS
PadProbeType -> String
(Int -> PadProbeType -> ShowS)
-> (PadProbeType -> String)
-> ([PadProbeType] -> ShowS)
-> Show PadProbeType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PadProbeType] -> ShowS
$cshowList :: [PadProbeType] -> ShowS
show :: PadProbeType -> String
$cshow :: PadProbeType -> String
showsPrec :: Int -> PadProbeType -> ShowS
$cshowsPrec :: Int -> PadProbeType -> ShowS
Show, PadProbeType -> PadProbeType -> Bool
(PadProbeType -> PadProbeType -> Bool)
-> (PadProbeType -> PadProbeType -> Bool) -> Eq PadProbeType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PadProbeType -> PadProbeType -> Bool
$c/= :: PadProbeType -> PadProbeType -> Bool
== :: PadProbeType -> PadProbeType -> Bool
$c== :: PadProbeType -> PadProbeType -> Bool
Eq)

instance P.Enum PadProbeType where
    fromEnum :: PadProbeType -> Int
fromEnum PadProbeType
PadProbeTypeInvalid = Int
0
    fromEnum PadProbeType
PadProbeTypeIdle = Int
1
    fromEnum PadProbeType
PadProbeTypeBlock = Int
2
    fromEnum PadProbeType
PadProbeTypeBuffer = Int
16
    fromEnum PadProbeType
PadProbeTypeBufferList = Int
32
    fromEnum PadProbeType
PadProbeTypeEventDownstream = Int
64
    fromEnum PadProbeType
PadProbeTypeEventUpstream = Int
128
    fromEnum PadProbeType
PadProbeTypeEventFlush = Int
256
    fromEnum PadProbeType
PadProbeTypeQueryDownstream = Int
512
    fromEnum PadProbeType
PadProbeTypeQueryUpstream = Int
1024
    fromEnum PadProbeType
PadProbeTypePush = Int
4096
    fromEnum PadProbeType
PadProbeTypePull = Int
8192
    fromEnum PadProbeType
PadProbeTypeBlocking = Int
3
    fromEnum PadProbeType
PadProbeTypeDataDownstream = Int
112
    fromEnum PadProbeType
PadProbeTypeDataUpstream = Int
128
    fromEnum PadProbeType
PadProbeTypeDataBoth = Int
240
    fromEnum PadProbeType
PadProbeTypeBlockDownstream = Int
114
    fromEnum PadProbeType
PadProbeTypeBlockUpstream = Int
130
    fromEnum PadProbeType
PadProbeTypeEventBoth = Int
192
    fromEnum PadProbeType
PadProbeTypeQueryBoth = Int
1536
    fromEnum PadProbeType
PadProbeTypeAllBoth = Int
1776
    fromEnum PadProbeType
PadProbeTypeScheduling = Int
12288
    fromEnum (AnotherPadProbeType Int
k) = Int
k

    toEnum :: Int -> PadProbeType
toEnum Int
0 = PadProbeType
PadProbeTypeInvalid
    toEnum Int
1 = PadProbeType
PadProbeTypeIdle
    toEnum Int
2 = PadProbeType
PadProbeTypeBlock
    toEnum Int
16 = PadProbeType
PadProbeTypeBuffer
    toEnum Int
32 = PadProbeType
PadProbeTypeBufferList
    toEnum Int
64 = PadProbeType
PadProbeTypeEventDownstream
    toEnum Int
128 = PadProbeType
PadProbeTypeEventUpstream
    toEnum Int
256 = PadProbeType
PadProbeTypeEventFlush
    toEnum Int
512 = PadProbeType
PadProbeTypeQueryDownstream
    toEnum Int
1024 = PadProbeType
PadProbeTypeQueryUpstream
    toEnum Int
4096 = PadProbeType
PadProbeTypePush
    toEnum Int
8192 = PadProbeType
PadProbeTypePull
    toEnum Int
3 = PadProbeType
PadProbeTypeBlocking
    toEnum Int
112 = PadProbeType
PadProbeTypeDataDownstream
    toEnum Int
240 = PadProbeType
PadProbeTypeDataBoth
    toEnum Int
114 = PadProbeType
PadProbeTypeBlockDownstream
    toEnum Int
130 = PadProbeType
PadProbeTypeBlockUpstream
    toEnum Int
192 = PadProbeType
PadProbeTypeEventBoth
    toEnum Int
1536 = PadProbeType
PadProbeTypeQueryBoth
    toEnum Int
1776 = PadProbeType
PadProbeTypeAllBoth
    toEnum Int
12288 = PadProbeType
PadProbeTypeScheduling
    toEnum Int
k = Int -> PadProbeType
AnotherPadProbeType Int
k

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

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

foreign import ccall "gst_pad_probe_type_get_type" c_gst_pad_probe_type_get_type :: 
    IO GType

instance B.Types.TypedObject PadProbeType where
    glibType :: IO GType
glibType = IO GType
c_gst_pad_probe_type_get_type

instance B.Types.BoxedFlags PadProbeType

instance IsGFlag PadProbeType

-- Flags PadLinkCheck
-- | The amount of checking to be done when linking pads. /@gSTPADLINKCHECKCAPS@/
-- and /@gSTPADLINKCHECKTEMPLATECAPS@/ are mutually exclusive. If both are
-- specified, expensive but safe /@gSTPADLINKCHECKCAPS@/ are performed.
-- 
-- > Only disable some of the checks if you are 100% certain you know the link
-- > will not fail because of hierarchy\/caps compatibility failures. If uncertain,
-- > use the default checks ('GI.Gst.Flags.PadLinkCheckDefault') or the regular methods
-- > for linking the pads.
data PadLinkCheck = 
      PadLinkCheckNothing
    -- ^ Don\'t check hierarchy or caps compatibility.
    | PadLinkCheckHierarchy
    -- ^ Check the pads have same parents\/grandparents.
    --   Could be omitted if it is already known that the two elements that own the
    --   pads are in the same bin.
    | PadLinkCheckTemplateCaps
    -- ^ Check if the pads are compatible by using
    --   their template caps. This is much faster than /@gSTPADLINKCHECKCAPS@/, but
    --   would be unsafe e.g. if one pad has @/GST_CAPS_ANY/@.
    | PadLinkCheckCaps
    -- ^ Check if the pads are compatible by comparing the
    --   caps returned by 'GI.Gst.Objects.Pad.padQueryCaps'.
    | PadLinkCheckNoReconfigure
    -- ^ Disables pushing a reconfigure event when pads are
    --   linked.
    | PadLinkCheckDefault
    -- ^ The default checks done when linking
    --   pads (i.e. the ones used by 'GI.Gst.Objects.Pad.padLink').
    | AnotherPadLinkCheck Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PadLinkCheck -> ShowS
[PadLinkCheck] -> ShowS
PadLinkCheck -> String
(Int -> PadLinkCheck -> ShowS)
-> (PadLinkCheck -> String)
-> ([PadLinkCheck] -> ShowS)
-> Show PadLinkCheck
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PadLinkCheck] -> ShowS
$cshowList :: [PadLinkCheck] -> ShowS
show :: PadLinkCheck -> String
$cshow :: PadLinkCheck -> String
showsPrec :: Int -> PadLinkCheck -> ShowS
$cshowsPrec :: Int -> PadLinkCheck -> ShowS
Show, PadLinkCheck -> PadLinkCheck -> Bool
(PadLinkCheck -> PadLinkCheck -> Bool)
-> (PadLinkCheck -> PadLinkCheck -> Bool) -> Eq PadLinkCheck
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PadLinkCheck -> PadLinkCheck -> Bool
$c/= :: PadLinkCheck -> PadLinkCheck -> Bool
== :: PadLinkCheck -> PadLinkCheck -> Bool
$c== :: PadLinkCheck -> PadLinkCheck -> Bool
Eq)

instance P.Enum PadLinkCheck where
    fromEnum :: PadLinkCheck -> Int
fromEnum PadLinkCheck
PadLinkCheckNothing = Int
0
    fromEnum PadLinkCheck
PadLinkCheckHierarchy = Int
1
    fromEnum PadLinkCheck
PadLinkCheckTemplateCaps = Int
2
    fromEnum PadLinkCheck
PadLinkCheckCaps = Int
4
    fromEnum PadLinkCheck
PadLinkCheckNoReconfigure = Int
8
    fromEnum PadLinkCheck
PadLinkCheckDefault = Int
5
    fromEnum (AnotherPadLinkCheck Int
k) = Int
k

    toEnum :: Int -> PadLinkCheck
toEnum Int
0 = PadLinkCheck
PadLinkCheckNothing
    toEnum Int
1 = PadLinkCheck
PadLinkCheckHierarchy
    toEnum Int
2 = PadLinkCheck
PadLinkCheckTemplateCaps
    toEnum Int
4 = PadLinkCheck
PadLinkCheckCaps
    toEnum Int
8 = PadLinkCheck
PadLinkCheckNoReconfigure
    toEnum Int
5 = PadLinkCheck
PadLinkCheckDefault
    toEnum Int
k = Int -> PadLinkCheck
AnotherPadLinkCheck Int
k

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

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

foreign import ccall "gst_pad_link_check_get_type" c_gst_pad_link_check_get_type :: 
    IO GType

instance B.Types.TypedObject PadLinkCheck where
    glibType :: IO GType
glibType = IO GType
c_gst_pad_link_check_get_type

instance B.Types.BoxedFlags PadLinkCheck

instance IsGFlag PadLinkCheck

-- Flags PadFlags
-- | Pad state flags
data PadFlags = 
      PadFlagsBlocked
    -- ^ is dataflow on a pad blocked
    | PadFlagsFlushing
    -- ^ is pad flushing
    | PadFlagsEos
    -- ^ is pad in EOS state
    | PadFlagsBlocking
    -- ^ is pad currently blocking on a buffer or event
    | PadFlagsNeedParent
    -- ^ ensure that there is a parent object before calling
    --                       into the pad callbacks.
    | PadFlagsNeedReconfigure
    -- ^ the pad should be reconfigured\/renegotiated.
    --                            The flag has to be unset manually after
    --                            reconfiguration happened.
    | PadFlagsPendingEvents
    -- ^ the pad has pending events
    | PadFlagsFixedCaps
    -- ^ the pad is using fixed caps. This means that
    --     once the caps are set on the pad, the default caps query function
    --     will only return those caps.
    | PadFlagsProxyCaps
    -- ^ the default event and query handler will forward
    --                      all events and queries to the internally linked pads
    --                      instead of discarding them.
    | PadFlagsProxyAllocation
    -- ^ the default query handler will forward
    --                      allocation queries to the internally linked pads
    --                      instead of discarding them.
    | PadFlagsProxyScheduling
    -- ^ the default query handler will forward
    --                      scheduling queries to the internally linked pads
    --                      instead of discarding them.
    | PadFlagsAcceptIntersect
    -- ^ the default accept-caps handler will check
    --                      it the caps intersect the query-caps result instead
    --                      of checking for a subset. This is interesting for
    --                      parsers that can accept incompletely specified caps.
    | PadFlagsAcceptTemplate
    -- ^ the default accept-caps handler will use
    --                      the template pad caps instead of query caps to
    --                      compare with the accept caps. Use this in combination
    --                      with 'GI.Gst.Flags.PadFlagsAcceptIntersect'. (Since: 1.6)
    | PadFlagsLast
    -- ^ offset to define more flags
    | AnotherPadFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PadFlags -> ShowS
[PadFlags] -> ShowS
PadFlags -> String
(Int -> PadFlags -> ShowS)
-> (PadFlags -> String) -> ([PadFlags] -> ShowS) -> Show PadFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PadFlags] -> ShowS
$cshowList :: [PadFlags] -> ShowS
show :: PadFlags -> String
$cshow :: PadFlags -> String
showsPrec :: Int -> PadFlags -> ShowS
$cshowsPrec :: Int -> PadFlags -> ShowS
Show, PadFlags -> PadFlags -> Bool
(PadFlags -> PadFlags -> Bool)
-> (PadFlags -> PadFlags -> Bool) -> Eq PadFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PadFlags -> PadFlags -> Bool
$c/= :: PadFlags -> PadFlags -> Bool
== :: PadFlags -> PadFlags -> Bool
$c== :: PadFlags -> PadFlags -> Bool
Eq)

instance P.Enum PadFlags where
    fromEnum :: PadFlags -> Int
fromEnum PadFlags
PadFlagsBlocked = Int
16
    fromEnum PadFlags
PadFlagsFlushing = Int
32
    fromEnum PadFlags
PadFlagsEos = Int
64
    fromEnum PadFlags
PadFlagsBlocking = Int
128
    fromEnum PadFlags
PadFlagsNeedParent = Int
256
    fromEnum PadFlags
PadFlagsNeedReconfigure = Int
512
    fromEnum PadFlags
PadFlagsPendingEvents = Int
1024
    fromEnum PadFlags
PadFlagsFixedCaps = Int
2048
    fromEnum PadFlags
PadFlagsProxyCaps = Int
4096
    fromEnum PadFlags
PadFlagsProxyAllocation = Int
8192
    fromEnum PadFlags
PadFlagsProxyScheduling = Int
16384
    fromEnum PadFlags
PadFlagsAcceptIntersect = Int
32768
    fromEnum PadFlags
PadFlagsAcceptTemplate = Int
65536
    fromEnum PadFlags
PadFlagsLast = Int
1048576
    fromEnum (AnotherPadFlags Int
k) = Int
k

    toEnum :: Int -> PadFlags
toEnum Int
16 = PadFlags
PadFlagsBlocked
    toEnum Int
32 = PadFlags
PadFlagsFlushing
    toEnum Int
64 = PadFlags
PadFlagsEos
    toEnum Int
128 = PadFlags
PadFlagsBlocking
    toEnum Int
256 = PadFlags
PadFlagsNeedParent
    toEnum Int
512 = PadFlags
PadFlagsNeedReconfigure
    toEnum Int
1024 = PadFlags
PadFlagsPendingEvents
    toEnum Int
2048 = PadFlags
PadFlagsFixedCaps
    toEnum Int
4096 = PadFlags
PadFlagsProxyCaps
    toEnum Int
8192 = PadFlags
PadFlagsProxyAllocation
    toEnum Int
16384 = PadFlags
PadFlagsProxyScheduling
    toEnum Int
32768 = PadFlags
PadFlagsAcceptIntersect
    toEnum Int
65536 = PadFlags
PadFlagsAcceptTemplate
    toEnum Int
1048576 = PadFlags
PadFlagsLast
    toEnum Int
k = Int -> PadFlags
AnotherPadFlags Int
k

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

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

foreign import ccall "gst_pad_flags_get_type" c_gst_pad_flags_get_type :: 
    IO GType

instance B.Types.TypedObject PadFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_pad_flags_get_type

instance B.Types.BoxedFlags PadFlags

instance IsGFlag PadFlags

-- Flags ObjectFlags
-- | The standard flags that an gstobject may have.
data ObjectFlags = 
      ObjectFlagsMayBeLeaked
    -- ^ the object is expected to stay alive even
    -- after 'GI.Gst.Functions.deinit' has been called and so should be ignored by leak
    -- detection tools. (Since: 1.10)
    | ObjectFlagsLast
    -- ^ subclasses can add additional flags starting from this flag
    | AnotherObjectFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ObjectFlags -> ShowS
[ObjectFlags] -> ShowS
ObjectFlags -> String
(Int -> ObjectFlags -> ShowS)
-> (ObjectFlags -> String)
-> ([ObjectFlags] -> ShowS)
-> Show ObjectFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ObjectFlags] -> ShowS
$cshowList :: [ObjectFlags] -> ShowS
show :: ObjectFlags -> String
$cshow :: ObjectFlags -> String
showsPrec :: Int -> ObjectFlags -> ShowS
$cshowsPrec :: Int -> ObjectFlags -> ShowS
Show, ObjectFlags -> ObjectFlags -> Bool
(ObjectFlags -> ObjectFlags -> Bool)
-> (ObjectFlags -> ObjectFlags -> Bool) -> Eq ObjectFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjectFlags -> ObjectFlags -> Bool
$c/= :: ObjectFlags -> ObjectFlags -> Bool
== :: ObjectFlags -> ObjectFlags -> Bool
$c== :: ObjectFlags -> ObjectFlags -> Bool
Eq)

instance P.Enum ObjectFlags where
    fromEnum :: ObjectFlags -> Int
fromEnum ObjectFlags
ObjectFlagsMayBeLeaked = Int
1
    fromEnum ObjectFlags
ObjectFlagsLast = Int
16
    fromEnum (AnotherObjectFlags Int
k) = Int
k

    toEnum :: Int -> ObjectFlags
toEnum Int
1 = ObjectFlags
ObjectFlagsMayBeLeaked
    toEnum Int
16 = ObjectFlags
ObjectFlagsLast
    toEnum Int
k = Int -> ObjectFlags
AnotherObjectFlags Int
k

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

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

foreign import ccall "gst_object_flags_get_type" c_gst_object_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ObjectFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_object_flags_get_type

instance B.Types.BoxedFlags ObjectFlags

instance IsGFlag ObjectFlags

-- Flags MiniObjectFlags
-- | Flags for the mini object
data MiniObjectFlags = 
      MiniObjectFlagsLockable
    -- ^ the object can be locked and unlocked with
    -- 'GI.Gst.Structs.MiniObject.miniObjectLock' and 'GI.Gst.Structs.MiniObject.miniObjectUnlock'.
    | MiniObjectFlagsLockReadonly
    -- ^ the object is permanently locked in
    -- READONLY mode. Only read locks can be performed on the object.
    | MiniObjectFlagsMayBeLeaked
    -- ^ the object is expected to stay alive
    -- even after 'GI.Gst.Functions.deinit' has been called and so should be ignored by leak
    -- detection tools. (Since: 1.10)
    | MiniObjectFlagsLast
    -- ^ first flag that can be used by subclasses.
    | AnotherMiniObjectFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MiniObjectFlags -> ShowS
[MiniObjectFlags] -> ShowS
MiniObjectFlags -> String
(Int -> MiniObjectFlags -> ShowS)
-> (MiniObjectFlags -> String)
-> ([MiniObjectFlags] -> ShowS)
-> Show MiniObjectFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MiniObjectFlags] -> ShowS
$cshowList :: [MiniObjectFlags] -> ShowS
show :: MiniObjectFlags -> String
$cshow :: MiniObjectFlags -> String
showsPrec :: Int -> MiniObjectFlags -> ShowS
$cshowsPrec :: Int -> MiniObjectFlags -> ShowS
Show, MiniObjectFlags -> MiniObjectFlags -> Bool
(MiniObjectFlags -> MiniObjectFlags -> Bool)
-> (MiniObjectFlags -> MiniObjectFlags -> Bool)
-> Eq MiniObjectFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MiniObjectFlags -> MiniObjectFlags -> Bool
$c/= :: MiniObjectFlags -> MiniObjectFlags -> Bool
== :: MiniObjectFlags -> MiniObjectFlags -> Bool
$c== :: MiniObjectFlags -> MiniObjectFlags -> Bool
Eq)

instance P.Enum MiniObjectFlags where
    fromEnum :: MiniObjectFlags -> Int
fromEnum MiniObjectFlags
MiniObjectFlagsLockable = Int
1
    fromEnum MiniObjectFlags
MiniObjectFlagsLockReadonly = Int
2
    fromEnum MiniObjectFlags
MiniObjectFlagsMayBeLeaked = Int
4
    fromEnum MiniObjectFlags
MiniObjectFlagsLast = Int
16
    fromEnum (AnotherMiniObjectFlags Int
k) = Int
k

    toEnum :: Int -> MiniObjectFlags
toEnum Int
1 = MiniObjectFlags
MiniObjectFlagsLockable
    toEnum Int
2 = MiniObjectFlags
MiniObjectFlagsLockReadonly
    toEnum Int
4 = MiniObjectFlags
MiniObjectFlagsMayBeLeaked
    toEnum Int
16 = MiniObjectFlags
MiniObjectFlagsLast
    toEnum Int
k = Int -> MiniObjectFlags
AnotherMiniObjectFlags Int
k

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

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

foreign import ccall "gst_mini_object_flags_get_type" c_gst_mini_object_flags_get_type :: 
    IO GType

instance B.Types.TypedObject MiniObjectFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_mini_object_flags_get_type

instance B.Types.BoxedFlags MiniObjectFlags

instance IsGFlag MiniObjectFlags

-- Flags MetaFlags
-- | Extra metadata flags.
data MetaFlags = 
      MetaFlagsNone
    -- ^ no flags
    | MetaFlagsReadonly
    -- ^ metadata should not be modified
    | MetaFlagsPooled
    -- ^ metadata is managed by a bufferpool
    | MetaFlagsLocked
    -- ^ metadata should not be removed
    | MetaFlagsLast
    -- ^ additional flags can be added starting from this flag.
    | AnotherMetaFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MetaFlags -> ShowS
[MetaFlags] -> ShowS
MetaFlags -> String
(Int -> MetaFlags -> ShowS)
-> (MetaFlags -> String)
-> ([MetaFlags] -> ShowS)
-> Show MetaFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MetaFlags] -> ShowS
$cshowList :: [MetaFlags] -> ShowS
show :: MetaFlags -> String
$cshow :: MetaFlags -> String
showsPrec :: Int -> MetaFlags -> ShowS
$cshowsPrec :: Int -> MetaFlags -> ShowS
Show, MetaFlags -> MetaFlags -> Bool
(MetaFlags -> MetaFlags -> Bool)
-> (MetaFlags -> MetaFlags -> Bool) -> Eq MetaFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MetaFlags -> MetaFlags -> Bool
$c/= :: MetaFlags -> MetaFlags -> Bool
== :: MetaFlags -> MetaFlags -> Bool
$c== :: MetaFlags -> MetaFlags -> Bool
Eq)

instance P.Enum MetaFlags where
    fromEnum :: MetaFlags -> Int
fromEnum MetaFlags
MetaFlagsNone = Int
0
    fromEnum MetaFlags
MetaFlagsReadonly = Int
1
    fromEnum MetaFlags
MetaFlagsPooled = Int
2
    fromEnum MetaFlags
MetaFlagsLocked = Int
4
    fromEnum MetaFlags
MetaFlagsLast = Int
65536
    fromEnum (AnotherMetaFlags Int
k) = Int
k

    toEnum :: Int -> MetaFlags
toEnum Int
0 = MetaFlags
MetaFlagsNone
    toEnum Int
1 = MetaFlags
MetaFlagsReadonly
    toEnum Int
2 = MetaFlags
MetaFlagsPooled
    toEnum Int
4 = MetaFlags
MetaFlagsLocked
    toEnum Int
65536 = MetaFlags
MetaFlagsLast
    toEnum Int
k = Int -> MetaFlags
AnotherMetaFlags Int
k

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

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

foreign import ccall "gst_meta_flags_get_type" c_gst_meta_flags_get_type :: 
    IO GType

instance B.Types.TypedObject MetaFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_meta_flags_get_type

instance B.Types.BoxedFlags MetaFlags

instance IsGFlag MetaFlags

-- Flags MessageType
-- | The different message types that are available.
data MessageType = 
      MessageTypeUnknown
    -- ^ an undefined message
    | MessageTypeEos
    -- ^ end-of-stream reached in a pipeline. The application will
    -- only receive this message in the PLAYING state and every time it sets a
    -- pipeline to PLAYING that is in the EOS state. The application can perform a
    -- flushing seek in the pipeline, which will undo the EOS state again.
    | MessageTypeError
    -- ^ an error occurred. When the application receives an error
    -- message it should stop playback of the pipeline and not assume that more
    -- data will be played.
    | MessageTypeWarning
    -- ^ a warning occurred.
    | MessageTypeInfo
    -- ^ an info message occurred
    | MessageTypeTag
    -- ^ a tag was found.
    | MessageTypeBuffering
    -- ^ the pipeline is buffering. When the application
    -- receives a buffering message in the PLAYING state for a non-live pipeline it
    -- must PAUSE the pipeline until the buffering completes, when the percentage
    -- field in the message is 100%. For live pipelines, no action must be
    -- performed and the buffering percentage can be used to inform the user about
    -- the progress.
    | MessageTypeStateChanged
    -- ^ a state change happened
    | MessageTypeStateDirty
    -- ^ an element changed state in a streaming thread.
    -- This message is deprecated.
    | MessageTypeStepDone
    -- ^ a stepping operation finished.
    | MessageTypeClockProvide
    -- ^ an element notifies its capability of providing
    --                             a clock. This message is used internally and
    --                             never forwarded to the application.
    | MessageTypeClockLost
    -- ^ The current clock as selected by the pipeline became
    --                          unusable. The pipeline will select a new clock on
    --                          the next PLAYING state change. The application
    --                          should set the pipeline to PAUSED and back to
    --                          PLAYING when this message is received.
    | MessageTypeNewClock
    -- ^ a new clock was selected in the pipeline.
    | MessageTypeStructureChange
    -- ^ the structure of the pipeline changed. This
    -- message is used internally and never forwarded to the application.
    | MessageTypeStreamStatus
    -- ^ status about a stream, emitted when it starts,
    --                             stops, errors, etc..
    | MessageTypeApplication
    -- ^ message posted by the application, possibly
    --                           via an application-specific element.
    | MessageTypeElement
    -- ^ element-specific message, see the specific element\'s
    --                       documentation
    | MessageTypeSegmentStart
    -- ^ pipeline started playback of a segment. This
    -- message is used internally and never forwarded to the application.
    | MessageTypeSegmentDone
    -- ^ pipeline completed playback of a segment. This
    -- message is forwarded to the application after all elements that posted
    -- /@gSTMESSAGESEGMENTSTART@/ posted a GST_MESSAGE_SEGMENT_DONE message.
    | MessageTypeDurationChanged
    -- ^ The duration of a pipeline changed. The
    -- application can get the new duration with a duration query.
    | MessageTypeLatency
    -- ^ Posted by elements when their latency changes. The
    -- application should recalculate and distribute a new latency.
    | MessageTypeAsyncStart
    -- ^ Posted by elements when they start an ASYNC
    -- t'GI.Gst.Enums.StateChange'. This message is not forwarded to the application but is used
    -- internally.
    | MessageTypeAsyncDone
    -- ^ Posted by elements when they complete an ASYNC
    -- t'GI.Gst.Enums.StateChange'. The application will only receive this message from the toplevel
    -- pipeline.
    | MessageTypeRequestState
    -- ^ Posted by elements when they want the pipeline to
    -- change state. This message is a suggestion to the application which can
    -- decide to perform the state change on (part of) the pipeline.
    | MessageTypeStepStart
    -- ^ A stepping operation was started.
    | MessageTypeQos
    -- ^ A buffer was dropped or an element changed its processing
    -- strategy for Quality of Service reasons.
    | MessageTypeProgress
    -- ^ A progress message.
    | MessageTypeToc
    -- ^ A new table of contents (TOC) was found or previously found TOC
    -- was updated.
    | MessageTypeResetTime
    -- ^ Message to request resetting the pipeline\'s
    --     running time from the pipeline. This is an internal message which
    --     applications will likely never receive.
    | MessageTypeStreamStart
    -- ^ Message indicating start of a new stream. Useful
    --     e.g. when using playbin in gapless playback mode, to get notified when
    --     the next title actually starts playing (which will be some time after
    --     the URI for the next title has been set).
    | MessageTypeNeedContext
    -- ^ Message indicating that an element wants a specific context (Since: 1.2)
    | MessageTypeHaveContext
    -- ^ Message indicating that an element created a context (Since: 1.2)
    | MessageTypeExtended
    -- ^ Message is an extended message type (see below).
    --     These extended message IDs can\'t be used directly with mask-based API
    --     like 'GI.Gst.Objects.Bus.busPoll' or 'GI.Gst.Objects.Bus.busTimedPopFiltered', but you can still
    --     filter for GST_MESSAGE_EXTENDED and then check the result for the
    --     specific type. (Since: 1.4)
    | MessageTypeDeviceAdded
    -- ^ Message indicating a t'GI.Gst.Objects.Device.Device' was added to
    --     a t'GI.Gst.Objects.DeviceProvider.DeviceProvider' (Since: 1.4)
    | MessageTypeDeviceRemoved
    -- ^ Message indicating a t'GI.Gst.Objects.Device.Device' was removed
    --     from a t'GI.Gst.Objects.DeviceProvider.DeviceProvider' (Since: 1.4)
    | MessageTypePropertyNotify
    -- ^ Message indicating a t'GI.GObject.Objects.Object.Object' property has
    --     changed (Since: 1.10)
    | MessageTypeStreamCollection
    -- ^ Message indicating a new t'GI.Gst.Objects.StreamCollection.StreamCollection'
    --     is available (Since: 1.10)
    | MessageTypeStreamsSelected
    -- ^ Message indicating the active selection of
    --     @/GstStreams/@ has changed (Since: 1.10)
    | MessageTypeRedirect
    -- ^ Message indicating to request the application to
    --     try to play the given URL(s). Useful if for example a HTTP 302\/303
    --     response is received with a non-HTTP URL inside. (Since: 1.10)
    | MessageTypeDeviceChanged
    -- ^ Message indicating a t'GI.Gst.Objects.Device.Device' was changed
    --     a t'GI.Gst.Objects.DeviceProvider.DeviceProvider' (Since: 1.16)
    | MessageTypeAny
    -- ^ mask for all of the above messages.
    | AnotherMessageType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MessageType -> ShowS
[MessageType] -> ShowS
MessageType -> String
(Int -> MessageType -> ShowS)
-> (MessageType -> String)
-> ([MessageType] -> ShowS)
-> Show MessageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MessageType] -> ShowS
$cshowList :: [MessageType] -> ShowS
show :: MessageType -> String
$cshow :: MessageType -> String
showsPrec :: Int -> MessageType -> ShowS
$cshowsPrec :: Int -> MessageType -> ShowS
Show, MessageType -> MessageType -> Bool
(MessageType -> MessageType -> Bool)
-> (MessageType -> MessageType -> Bool) -> Eq MessageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageType -> MessageType -> Bool
$c/= :: MessageType -> MessageType -> Bool
== :: MessageType -> MessageType -> Bool
$c== :: MessageType -> MessageType -> Bool
Eq)

instance P.Enum MessageType where
    fromEnum :: MessageType -> Int
fromEnum MessageType
MessageTypeUnknown = Int
0
    fromEnum MessageType
MessageTypeEos = Int
1
    fromEnum MessageType
MessageTypeError = Int
2
    fromEnum MessageType
MessageTypeWarning = Int
4
    fromEnum MessageType
MessageTypeInfo = Int
8
    fromEnum MessageType
MessageTypeTag = Int
16
    fromEnum MessageType
MessageTypeBuffering = Int
32
    fromEnum MessageType
MessageTypeStateChanged = Int
64
    fromEnum MessageType
MessageTypeStateDirty = Int
128
    fromEnum MessageType
MessageTypeStepDone = Int
256
    fromEnum MessageType
MessageTypeClockProvide = Int
512
    fromEnum MessageType
MessageTypeClockLost = Int
1024
    fromEnum MessageType
MessageTypeNewClock = Int
2048
    fromEnum MessageType
MessageTypeStructureChange = Int
4096
    fromEnum MessageType
MessageTypeStreamStatus = Int
8192
    fromEnum MessageType
MessageTypeApplication = Int
16384
    fromEnum MessageType
MessageTypeElement = Int
32768
    fromEnum MessageType
MessageTypeSegmentStart = Int
65536
    fromEnum MessageType
MessageTypeSegmentDone = Int
131072
    fromEnum MessageType
MessageTypeDurationChanged = Int
262144
    fromEnum MessageType
MessageTypeLatency = Int
524288
    fromEnum MessageType
MessageTypeAsyncStart = Int
1048576
    fromEnum MessageType
MessageTypeAsyncDone = Int
2097152
    fromEnum MessageType
MessageTypeRequestState = Int
4194304
    fromEnum MessageType
MessageTypeStepStart = Int
8388608
    fromEnum MessageType
MessageTypeQos = Int
16777216
    fromEnum MessageType
MessageTypeProgress = Int
33554432
    fromEnum MessageType
MessageTypeToc = Int
67108864
    fromEnum MessageType
MessageTypeResetTime = Int
134217728
    fromEnum MessageType
MessageTypeStreamStart = Int
268435456
    fromEnum MessageType
MessageTypeNeedContext = Int
536870912
    fromEnum MessageType
MessageTypeHaveContext = Int
1073741824
    fromEnum MessageType
MessageTypeExtended = Int
2147483648
    fromEnum MessageType
MessageTypeDeviceAdded = Int
2147483649
    fromEnum MessageType
MessageTypeDeviceRemoved = Int
2147483650
    fromEnum MessageType
MessageTypePropertyNotify = Int
2147483651
    fromEnum MessageType
MessageTypeStreamCollection = Int
2147483652
    fromEnum MessageType
MessageTypeStreamsSelected = Int
2147483653
    fromEnum MessageType
MessageTypeRedirect = Int
2147483654
    fromEnum MessageType
MessageTypeDeviceChanged = Int
2147483655
    fromEnum MessageType
MessageTypeAny = Int
4294967295
    fromEnum (AnotherMessageType Int
k) = Int
k

    toEnum :: Int -> MessageType
toEnum Int
0 = MessageType
MessageTypeUnknown
    toEnum Int
1 = MessageType
MessageTypeEos
    toEnum Int
2 = MessageType
MessageTypeError
    toEnum Int
4 = MessageType
MessageTypeWarning
    toEnum Int
8 = MessageType
MessageTypeInfo
    toEnum Int
16 = MessageType
MessageTypeTag
    toEnum Int
32 = MessageType
MessageTypeBuffering
    toEnum Int
64 = MessageType
MessageTypeStateChanged
    toEnum Int
128 = MessageType
MessageTypeStateDirty
    toEnum Int
256 = MessageType
MessageTypeStepDone
    toEnum Int
512 = MessageType
MessageTypeClockProvide
    toEnum Int
1024 = MessageType
MessageTypeClockLost
    toEnum Int
2048 = MessageType
MessageTypeNewClock
    toEnum Int
4096 = MessageType
MessageTypeStructureChange
    toEnum Int
8192 = MessageType
MessageTypeStreamStatus
    toEnum Int
16384 = MessageType
MessageTypeApplication
    toEnum Int
32768 = MessageType
MessageTypeElement
    toEnum Int
65536 = MessageType
MessageTypeSegmentStart
    toEnum Int
131072 = MessageType
MessageTypeSegmentDone
    toEnum Int
262144 = MessageType
MessageTypeDurationChanged
    toEnum Int
524288 = MessageType
MessageTypeLatency
    toEnum Int
1048576 = MessageType
MessageTypeAsyncStart
    toEnum Int
2097152 = MessageType
MessageTypeAsyncDone
    toEnum Int
4194304 = MessageType
MessageTypeRequestState
    toEnum Int
8388608 = MessageType
MessageTypeStepStart
    toEnum Int
16777216 = MessageType
MessageTypeQos
    toEnum Int
33554432 = MessageType
MessageTypeProgress
    toEnum Int
67108864 = MessageType
MessageTypeToc
    toEnum Int
134217728 = MessageType
MessageTypeResetTime
    toEnum Int
268435456 = MessageType
MessageTypeStreamStart
    toEnum Int
536870912 = MessageType
MessageTypeNeedContext
    toEnum Int
1073741824 = MessageType
MessageTypeHaveContext
    toEnum Int
2147483648 = MessageType
MessageTypeExtended
    toEnum Int
2147483649 = MessageType
MessageTypeDeviceAdded
    toEnum Int
2147483650 = MessageType
MessageTypeDeviceRemoved
    toEnum Int
2147483651 = MessageType
MessageTypePropertyNotify
    toEnum Int
2147483652 = MessageType
MessageTypeStreamCollection
    toEnum Int
2147483653 = MessageType
MessageTypeStreamsSelected
    toEnum Int
2147483654 = MessageType
MessageTypeRedirect
    toEnum Int
2147483655 = MessageType
MessageTypeDeviceChanged
    toEnum Int
4294967295 = MessageType
MessageTypeAny
    toEnum Int
k = Int -> MessageType
AnotherMessageType Int
k

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

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

foreign import ccall "gst_message_type_get_type" c_gst_message_type_get_type :: 
    IO GType

instance B.Types.TypedObject MessageType where
    glibType :: IO GType
glibType = IO GType
c_gst_message_type_get_type

instance B.Types.BoxedFlags MessageType

instance IsGFlag MessageType

-- Flags MemoryFlags
-- | Flags for wrapped memory.
data MemoryFlags = 
      MemoryFlagsReadonly
    -- ^ memory is readonly. It is not allowed to map the
    -- memory with @/GST_MAP_WRITE/@.
    | MemoryFlagsNoShare
    -- ^ memory must not be shared. Copies will have to be
    -- made when this memory needs to be shared between buffers.
    | MemoryFlagsZeroPrefixed
    -- ^ the memory prefix is filled with 0 bytes
    | MemoryFlagsZeroPadded
    -- ^ the memory padding is filled with 0 bytes
    | MemoryFlagsPhysicallyContiguous
    -- ^ the memory is physically contiguous. (Since: 1.2)
    | MemoryFlagsNotMappable
    -- ^ the memory can\'t be mapped via 'GI.Gst.Structs.Memory.memoryMap' without any preconditions. (Since: 1.2)
    | MemoryFlagsLast
    -- ^ first flag that can be used for custom purposes
    | AnotherMemoryFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MemoryFlags -> ShowS
[MemoryFlags] -> ShowS
MemoryFlags -> String
(Int -> MemoryFlags -> ShowS)
-> (MemoryFlags -> String)
-> ([MemoryFlags] -> ShowS)
-> Show MemoryFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MemoryFlags] -> ShowS
$cshowList :: [MemoryFlags] -> ShowS
show :: MemoryFlags -> String
$cshow :: MemoryFlags -> String
showsPrec :: Int -> MemoryFlags -> ShowS
$cshowsPrec :: Int -> MemoryFlags -> ShowS
Show, MemoryFlags -> MemoryFlags -> Bool
(MemoryFlags -> MemoryFlags -> Bool)
-> (MemoryFlags -> MemoryFlags -> Bool) -> Eq MemoryFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MemoryFlags -> MemoryFlags -> Bool
$c/= :: MemoryFlags -> MemoryFlags -> Bool
== :: MemoryFlags -> MemoryFlags -> Bool
$c== :: MemoryFlags -> MemoryFlags -> Bool
Eq)

instance P.Enum MemoryFlags where
    fromEnum :: MemoryFlags -> Int
fromEnum MemoryFlags
MemoryFlagsReadonly = Int
2
    fromEnum MemoryFlags
MemoryFlagsNoShare = Int
16
    fromEnum MemoryFlags
MemoryFlagsZeroPrefixed = Int
32
    fromEnum MemoryFlags
MemoryFlagsZeroPadded = Int
64
    fromEnum MemoryFlags
MemoryFlagsPhysicallyContiguous = Int
128
    fromEnum MemoryFlags
MemoryFlagsNotMappable = Int
256
    fromEnum MemoryFlags
MemoryFlagsLast = Int
1048576
    fromEnum (AnotherMemoryFlags Int
k) = Int
k

    toEnum :: Int -> MemoryFlags
toEnum Int
2 = MemoryFlags
MemoryFlagsReadonly
    toEnum Int
16 = MemoryFlags
MemoryFlagsNoShare
    toEnum Int
32 = MemoryFlags
MemoryFlagsZeroPrefixed
    toEnum Int
64 = MemoryFlags
MemoryFlagsZeroPadded
    toEnum Int
128 = MemoryFlags
MemoryFlagsPhysicallyContiguous
    toEnum Int
256 = MemoryFlags
MemoryFlagsNotMappable
    toEnum Int
1048576 = MemoryFlags
MemoryFlagsLast
    toEnum Int
k = Int -> MemoryFlags
AnotherMemoryFlags Int
k

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

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

foreign import ccall "gst_memory_flags_get_type" c_gst_memory_flags_get_type :: 
    IO GType

instance B.Types.TypedObject MemoryFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_memory_flags_get_type

instance B.Types.BoxedFlags MemoryFlags

instance IsGFlag MemoryFlags

-- Flags MapFlags
-- | Flags used when mapping memory
data MapFlags = 
      MapFlagsRead
    -- ^ map for read access
    | MapFlagsWrite
    -- ^ map for write access
    | MapFlagsFlagLast
    -- ^ first flag that can be used for custom purposes
    | AnotherMapFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MapFlags -> ShowS
[MapFlags] -> ShowS
MapFlags -> String
(Int -> MapFlags -> ShowS)
-> (MapFlags -> String) -> ([MapFlags] -> ShowS) -> Show MapFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MapFlags] -> ShowS
$cshowList :: [MapFlags] -> ShowS
show :: MapFlags -> String
$cshow :: MapFlags -> String
showsPrec :: Int -> MapFlags -> ShowS
$cshowsPrec :: Int -> MapFlags -> ShowS
Show, MapFlags -> MapFlags -> Bool
(MapFlags -> MapFlags -> Bool)
-> (MapFlags -> MapFlags -> Bool) -> Eq MapFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MapFlags -> MapFlags -> Bool
$c/= :: MapFlags -> MapFlags -> Bool
== :: MapFlags -> MapFlags -> Bool
$c== :: MapFlags -> MapFlags -> Bool
Eq)

instance P.Enum MapFlags where
    fromEnum :: MapFlags -> Int
fromEnum MapFlags
MapFlagsRead = Int
1
    fromEnum MapFlags
MapFlagsWrite = Int
2
    fromEnum MapFlags
MapFlagsFlagLast = Int
65536
    fromEnum (AnotherMapFlags Int
k) = Int
k

    toEnum :: Int -> MapFlags
toEnum Int
1 = MapFlags
MapFlagsRead
    toEnum Int
2 = MapFlags
MapFlagsWrite
    toEnum Int
65536 = MapFlags
MapFlagsFlagLast
    toEnum Int
k = Int -> MapFlags
AnotherMapFlags Int
k

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

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

foreign import ccall "gst_map_flags_get_type" c_gst_map_flags_get_type :: 
    IO GType

instance B.Types.TypedObject MapFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_map_flags_get_type

instance B.Types.BoxedFlags MapFlags

instance IsGFlag MapFlags

-- Flags LockFlags
-- | Flags used when locking miniobjects
data LockFlags = 
      LockFlagsRead
    -- ^ lock for read access
    | LockFlagsWrite
    -- ^ lock for write access
    | LockFlagsExclusive
    -- ^ lock for exclusive access
    | LockFlagsLast
    -- ^ first flag that can be used for custom purposes
    | AnotherLockFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> LockFlags -> ShowS
[LockFlags] -> ShowS
LockFlags -> String
(Int -> LockFlags -> ShowS)
-> (LockFlags -> String)
-> ([LockFlags] -> ShowS)
-> Show LockFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LockFlags] -> ShowS
$cshowList :: [LockFlags] -> ShowS
show :: LockFlags -> String
$cshow :: LockFlags -> String
showsPrec :: Int -> LockFlags -> ShowS
$cshowsPrec :: Int -> LockFlags -> ShowS
Show, LockFlags -> LockFlags -> Bool
(LockFlags -> LockFlags -> Bool)
-> (LockFlags -> LockFlags -> Bool) -> Eq LockFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LockFlags -> LockFlags -> Bool
$c/= :: LockFlags -> LockFlags -> Bool
== :: LockFlags -> LockFlags -> Bool
$c== :: LockFlags -> LockFlags -> Bool
Eq)

instance P.Enum LockFlags where
    fromEnum :: LockFlags -> Int
fromEnum LockFlags
LockFlagsRead = Int
1
    fromEnum LockFlags
LockFlagsWrite = Int
2
    fromEnum LockFlags
LockFlagsExclusive = Int
4
    fromEnum LockFlags
LockFlagsLast = Int
256
    fromEnum (AnotherLockFlags Int
k) = Int
k

    toEnum :: Int -> LockFlags
toEnum Int
1 = LockFlags
LockFlagsRead
    toEnum Int
2 = LockFlags
LockFlagsWrite
    toEnum Int
4 = LockFlags
LockFlagsExclusive
    toEnum Int
256 = LockFlags
LockFlagsLast
    toEnum Int
k = Int -> LockFlags
AnotherLockFlags Int
k

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

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

foreign import ccall "gst_lock_flags_get_type" c_gst_lock_flags_get_type :: 
    IO GType

instance B.Types.TypedObject LockFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_lock_flags_get_type

instance B.Types.BoxedFlags LockFlags

instance IsGFlag LockFlags

-- Flags EventTypeFlags
-- | t'GI.Gst.Flags.EventTypeFlags' indicate the aspects of the different t'GI.Gst.Enums.EventType'
-- values. You can get the type flags of a t'GI.Gst.Enums.EventType' with the
-- 'GI.Gst.Functions.eventTypeGetFlags' function.
data EventTypeFlags = 
      EventTypeFlagsUpstream
    -- ^ Set if the event can travel upstream.
    | EventTypeFlagsDownstream
    -- ^ Set if the event can travel downstream.
    | EventTypeFlagsSerialized
    -- ^ Set if the event should be serialized with data
    --                               flow.
    | EventTypeFlagsSticky
    -- ^ Set if the event is sticky on the pads.
    | EventTypeFlagsStickyMulti
    -- ^ Multiple sticky events can be on a pad, each
    --                               identified by the event name.
    | AnotherEventTypeFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> EventTypeFlags -> ShowS
[EventTypeFlags] -> ShowS
EventTypeFlags -> String
(Int -> EventTypeFlags -> ShowS)
-> (EventTypeFlags -> String)
-> ([EventTypeFlags] -> ShowS)
-> Show EventTypeFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EventTypeFlags] -> ShowS
$cshowList :: [EventTypeFlags] -> ShowS
show :: EventTypeFlags -> String
$cshow :: EventTypeFlags -> String
showsPrec :: Int -> EventTypeFlags -> ShowS
$cshowsPrec :: Int -> EventTypeFlags -> ShowS
Show, EventTypeFlags -> EventTypeFlags -> Bool
(EventTypeFlags -> EventTypeFlags -> Bool)
-> (EventTypeFlags -> EventTypeFlags -> Bool) -> Eq EventTypeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventTypeFlags -> EventTypeFlags -> Bool
$c/= :: EventTypeFlags -> EventTypeFlags -> Bool
== :: EventTypeFlags -> EventTypeFlags -> Bool
$c== :: EventTypeFlags -> EventTypeFlags -> Bool
Eq)

instance P.Enum EventTypeFlags where
    fromEnum :: EventTypeFlags -> Int
fromEnum EventTypeFlags
EventTypeFlagsUpstream = Int
1
    fromEnum EventTypeFlags
EventTypeFlagsDownstream = Int
2
    fromEnum EventTypeFlags
EventTypeFlagsSerialized = Int
4
    fromEnum EventTypeFlags
EventTypeFlagsSticky = Int
8
    fromEnum EventTypeFlags
EventTypeFlagsStickyMulti = Int
16
    fromEnum (AnotherEventTypeFlags Int
k) = Int
k

    toEnum :: Int -> EventTypeFlags
toEnum Int
1 = EventTypeFlags
EventTypeFlagsUpstream
    toEnum Int
2 = EventTypeFlags
EventTypeFlagsDownstream
    toEnum Int
4 = EventTypeFlags
EventTypeFlagsSerialized
    toEnum Int
8 = EventTypeFlags
EventTypeFlagsSticky
    toEnum Int
16 = EventTypeFlags
EventTypeFlagsStickyMulti
    toEnum Int
k = Int -> EventTypeFlags
AnotherEventTypeFlags Int
k

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

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

foreign import ccall "gst_event_type_flags_get_type" c_gst_event_type_flags_get_type :: 
    IO GType

instance B.Types.TypedObject EventTypeFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_event_type_flags_get_type

instance B.Types.BoxedFlags EventTypeFlags

instance IsGFlag EventTypeFlags

-- Flags ElementFlags
-- | The standard flags that an element may have.
data ElementFlags = 
      ElementFlagsLockedState
    -- ^ ignore state changes from parent
    | ElementFlagsSink
    -- ^ the element is a sink
    | ElementFlagsSource
    -- ^ the element is a source.
    | ElementFlagsProvideClock
    -- ^ the element can provide a clock
    | ElementFlagsRequireClock
    -- ^ the element requires a clock
    | ElementFlagsIndexable
    -- ^ the element can use an index
    | ElementFlagsLast
    -- ^ offset to define more flags
    | AnotherElementFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ElementFlags -> ShowS
[ElementFlags] -> ShowS
ElementFlags -> String
(Int -> ElementFlags -> ShowS)
-> (ElementFlags -> String)
-> ([ElementFlags] -> ShowS)
-> Show ElementFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ElementFlags] -> ShowS
$cshowList :: [ElementFlags] -> ShowS
show :: ElementFlags -> String
$cshow :: ElementFlags -> String
showsPrec :: Int -> ElementFlags -> ShowS
$cshowsPrec :: Int -> ElementFlags -> ShowS
Show, ElementFlags -> ElementFlags -> Bool
(ElementFlags -> ElementFlags -> Bool)
-> (ElementFlags -> ElementFlags -> Bool) -> Eq ElementFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ElementFlags -> ElementFlags -> Bool
$c/= :: ElementFlags -> ElementFlags -> Bool
== :: ElementFlags -> ElementFlags -> Bool
$c== :: ElementFlags -> ElementFlags -> Bool
Eq)

instance P.Enum ElementFlags where
    fromEnum :: ElementFlags -> Int
fromEnum ElementFlags
ElementFlagsLockedState = Int
16
    fromEnum ElementFlags
ElementFlagsSink = Int
32
    fromEnum ElementFlags
ElementFlagsSource = Int
64
    fromEnum ElementFlags
ElementFlagsProvideClock = Int
128
    fromEnum ElementFlags
ElementFlagsRequireClock = Int
256
    fromEnum ElementFlags
ElementFlagsIndexable = Int
512
    fromEnum ElementFlags
ElementFlagsLast = Int
16384
    fromEnum (AnotherElementFlags Int
k) = Int
k

    toEnum :: Int -> ElementFlags
toEnum Int
16 = ElementFlags
ElementFlagsLockedState
    toEnum Int
32 = ElementFlags
ElementFlagsSink
    toEnum Int
64 = ElementFlags
ElementFlagsSource
    toEnum Int
128 = ElementFlags
ElementFlagsProvideClock
    toEnum Int
256 = ElementFlags
ElementFlagsRequireClock
    toEnum Int
512 = ElementFlags
ElementFlagsIndexable
    toEnum Int
16384 = ElementFlags
ElementFlagsLast
    toEnum Int
k = Int -> ElementFlags
AnotherElementFlags Int
k

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

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

foreign import ccall "gst_element_flags_get_type" c_gst_element_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ElementFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_element_flags_get_type

instance B.Types.BoxedFlags ElementFlags

instance IsGFlag ElementFlags

-- Flags DebugGraphDetails
-- | Available details for pipeline graphs produced by @/GST_DEBUG_BIN_TO_DOT_FILE()/@
-- and @/GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS()/@.
data DebugGraphDetails = 
      DebugGraphDetailsMediaType
    -- ^ show caps-name on edges
    | DebugGraphDetailsCapsDetails
    -- ^ show caps-details on edges
    | DebugGraphDetailsNonDefaultParams
    -- ^ show modified parameters on
    --                                           elements
    | DebugGraphDetailsStates
    -- ^ show element states
    | DebugGraphDetailsFullParams
    -- ^ show full element parameter values even
    --                                    if they are very long
    | DebugGraphDetailsAll
    -- ^ show all the typical details that one might want
    | DebugGraphDetailsVerbose
    -- ^ show all details regardless of how large or
    --                                verbose they make the resulting output
    | AnotherDebugGraphDetails Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DebugGraphDetails -> ShowS
[DebugGraphDetails] -> ShowS
DebugGraphDetails -> String
(Int -> DebugGraphDetails -> ShowS)
-> (DebugGraphDetails -> String)
-> ([DebugGraphDetails] -> ShowS)
-> Show DebugGraphDetails
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DebugGraphDetails] -> ShowS
$cshowList :: [DebugGraphDetails] -> ShowS
show :: DebugGraphDetails -> String
$cshow :: DebugGraphDetails -> String
showsPrec :: Int -> DebugGraphDetails -> ShowS
$cshowsPrec :: Int -> DebugGraphDetails -> ShowS
Show, DebugGraphDetails -> DebugGraphDetails -> Bool
(DebugGraphDetails -> DebugGraphDetails -> Bool)
-> (DebugGraphDetails -> DebugGraphDetails -> Bool)
-> Eq DebugGraphDetails
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DebugGraphDetails -> DebugGraphDetails -> Bool
$c/= :: DebugGraphDetails -> DebugGraphDetails -> Bool
== :: DebugGraphDetails -> DebugGraphDetails -> Bool
$c== :: DebugGraphDetails -> DebugGraphDetails -> Bool
Eq)

instance P.Enum DebugGraphDetails where
    fromEnum :: DebugGraphDetails -> Int
fromEnum DebugGraphDetails
DebugGraphDetailsMediaType = Int
1
    fromEnum DebugGraphDetails
DebugGraphDetailsCapsDetails = Int
2
    fromEnum DebugGraphDetails
DebugGraphDetailsNonDefaultParams = Int
4
    fromEnum DebugGraphDetails
DebugGraphDetailsStates = Int
8
    fromEnum DebugGraphDetails
DebugGraphDetailsFullParams = Int
16
    fromEnum DebugGraphDetails
DebugGraphDetailsAll = Int
15
    fromEnum DebugGraphDetails
DebugGraphDetailsVerbose = Int
4294967295
    fromEnum (AnotherDebugGraphDetails Int
k) = Int
k

    toEnum :: Int -> DebugGraphDetails
toEnum Int
1 = DebugGraphDetails
DebugGraphDetailsMediaType
    toEnum Int
2 = DebugGraphDetails
DebugGraphDetailsCapsDetails
    toEnum Int
4 = DebugGraphDetails
DebugGraphDetailsNonDefaultParams
    toEnum Int
8 = DebugGraphDetails
DebugGraphDetailsStates
    toEnum Int
16 = DebugGraphDetails
DebugGraphDetailsFullParams
    toEnum Int
15 = DebugGraphDetails
DebugGraphDetailsAll
    toEnum Int
4294967295 = DebugGraphDetails
DebugGraphDetailsVerbose
    toEnum Int
k = Int -> DebugGraphDetails
AnotherDebugGraphDetails Int
k

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

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

foreign import ccall "gst_debug_graph_details_get_type" c_gst_debug_graph_details_get_type :: 
    IO GType

instance B.Types.TypedObject DebugGraphDetails where
    glibType :: IO GType
glibType = IO GType
c_gst_debug_graph_details_get_type

instance B.Types.BoxedFlags DebugGraphDetails

instance IsGFlag DebugGraphDetails

-- Flags DebugColorFlags
-- | These are some terminal style flags you can use when creating your
-- debugging categories to make them stand out in debugging output.
data DebugColorFlags = 
      DebugColorFlagsFgBlack
    -- ^ Use black as foreground color.
    | DebugColorFlagsFgRed
    -- ^ Use red as foreground color.
    | DebugColorFlagsFgGreen
    -- ^ Use green as foreground color.
    | DebugColorFlagsFgYellow
    -- ^ Use yellow as foreground color.
    | DebugColorFlagsFgBlue
    -- ^ Use blue as foreground color.
    | DebugColorFlagsFgMagenta
    -- ^ Use magenta as foreground color.
    | DebugColorFlagsFgCyan
    -- ^ Use cyan as foreground color.
    | DebugColorFlagsFgWhite
    -- ^ Use white as foreground color.
    | DebugColorFlagsBgBlack
    -- ^ Use black as background color.
    | DebugColorFlagsBgRed
    -- ^ Use red as background color.
    | DebugColorFlagsBgGreen
    -- ^ Use green as background color.
    | DebugColorFlagsBgYellow
    -- ^ Use yellow as background color.
    | DebugColorFlagsBgBlue
    -- ^ Use blue as background color.
    | DebugColorFlagsBgMagenta
    -- ^ Use magenta as background color.
    | DebugColorFlagsBgCyan
    -- ^ Use cyan as background color.
    | DebugColorFlagsBgWhite
    -- ^ Use white as background color.
    | DebugColorFlagsBold
    -- ^ Make the output bold.
    | DebugColorFlagsUnderline
    -- ^ Underline the output.
    | AnotherDebugColorFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DebugColorFlags -> ShowS
[DebugColorFlags] -> ShowS
DebugColorFlags -> String
(Int -> DebugColorFlags -> ShowS)
-> (DebugColorFlags -> String)
-> ([DebugColorFlags] -> ShowS)
-> Show DebugColorFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DebugColorFlags] -> ShowS
$cshowList :: [DebugColorFlags] -> ShowS
show :: DebugColorFlags -> String
$cshow :: DebugColorFlags -> String
showsPrec :: Int -> DebugColorFlags -> ShowS
$cshowsPrec :: Int -> DebugColorFlags -> ShowS
Show, DebugColorFlags -> DebugColorFlags -> Bool
(DebugColorFlags -> DebugColorFlags -> Bool)
-> (DebugColorFlags -> DebugColorFlags -> Bool)
-> Eq DebugColorFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DebugColorFlags -> DebugColorFlags -> Bool
$c/= :: DebugColorFlags -> DebugColorFlags -> Bool
== :: DebugColorFlags -> DebugColorFlags -> Bool
$c== :: DebugColorFlags -> DebugColorFlags -> Bool
Eq)

instance P.Enum DebugColorFlags where
    fromEnum :: DebugColorFlags -> Int
fromEnum DebugColorFlags
DebugColorFlagsFgBlack = Int
0
    fromEnum DebugColorFlags
DebugColorFlagsFgRed = Int
1
    fromEnum DebugColorFlags
DebugColorFlagsFgGreen = Int
2
    fromEnum DebugColorFlags
DebugColorFlagsFgYellow = Int
3
    fromEnum DebugColorFlags
DebugColorFlagsFgBlue = Int
4
    fromEnum DebugColorFlags
DebugColorFlagsFgMagenta = Int
5
    fromEnum DebugColorFlags
DebugColorFlagsFgCyan = Int
6
    fromEnum DebugColorFlags
DebugColorFlagsFgWhite = Int
7
    fromEnum DebugColorFlags
DebugColorFlagsBgBlack = Int
0
    fromEnum DebugColorFlags
DebugColorFlagsBgRed = Int
16
    fromEnum DebugColorFlags
DebugColorFlagsBgGreen = Int
32
    fromEnum DebugColorFlags
DebugColorFlagsBgYellow = Int
48
    fromEnum DebugColorFlags
DebugColorFlagsBgBlue = Int
64
    fromEnum DebugColorFlags
DebugColorFlagsBgMagenta = Int
80
    fromEnum DebugColorFlags
DebugColorFlagsBgCyan = Int
96
    fromEnum DebugColorFlags
DebugColorFlagsBgWhite = Int
112
    fromEnum DebugColorFlags
DebugColorFlagsBold = Int
256
    fromEnum DebugColorFlags
DebugColorFlagsUnderline = Int
512
    fromEnum (AnotherDebugColorFlags Int
k) = Int
k

    toEnum :: Int -> DebugColorFlags
toEnum Int
0 = DebugColorFlags
DebugColorFlagsFgBlack
    toEnum Int
1 = DebugColorFlags
DebugColorFlagsFgRed
    toEnum Int
2 = DebugColorFlags
DebugColorFlagsFgGreen
    toEnum Int
3 = DebugColorFlags
DebugColorFlagsFgYellow
    toEnum Int
4 = DebugColorFlags
DebugColorFlagsFgBlue
    toEnum Int
5 = DebugColorFlags
DebugColorFlagsFgMagenta
    toEnum Int
6 = DebugColorFlags
DebugColorFlagsFgCyan
    toEnum Int
7 = DebugColorFlags
DebugColorFlagsFgWhite
    toEnum Int
16 = DebugColorFlags
DebugColorFlagsBgRed
    toEnum Int
32 = DebugColorFlags
DebugColorFlagsBgGreen
    toEnum Int
48 = DebugColorFlags
DebugColorFlagsBgYellow
    toEnum Int
64 = DebugColorFlags
DebugColorFlagsBgBlue
    toEnum Int
80 = DebugColorFlags
DebugColorFlagsBgMagenta
    toEnum Int
96 = DebugColorFlags
DebugColorFlagsBgCyan
    toEnum Int
112 = DebugColorFlags
DebugColorFlagsBgWhite
    toEnum Int
256 = DebugColorFlags
DebugColorFlagsBold
    toEnum Int
512 = DebugColorFlags
DebugColorFlagsUnderline
    toEnum Int
k = Int -> DebugColorFlags
AnotherDebugColorFlags Int
k

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

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

foreign import ccall "gst_debug_color_flags_get_type" c_gst_debug_color_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DebugColorFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_debug_color_flags_get_type

instance B.Types.BoxedFlags DebugColorFlags

instance IsGFlag DebugColorFlags

-- Flags ClockFlags
-- | The capabilities of this clock
data ClockFlags = 
      ClockFlagsCanDoSingleSync
    -- ^ clock can do a single sync timeout request
    | ClockFlagsCanDoSingleAsync
    -- ^ clock can do a single async timeout request
    | ClockFlagsCanDoPeriodicSync
    -- ^ clock can do sync periodic timeout requests
    | ClockFlagsCanDoPeriodicAsync
    -- ^ clock can do async periodic timeout callbacks
    | ClockFlagsCanSetResolution
    -- ^ clock\'s resolution can be changed
    | ClockFlagsCanSetMaster
    -- ^ clock can be slaved to a master clock
    | ClockFlagsNeedsStartupSync
    -- ^ clock needs to be synced before it can be used
    --     (Since: 1.6)
    | ClockFlagsLast
    -- ^ subclasses can add additional flags starting from this flag
    | AnotherClockFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ClockFlags -> ShowS
[ClockFlags] -> ShowS
ClockFlags -> String
(Int -> ClockFlags -> ShowS)
-> (ClockFlags -> String)
-> ([ClockFlags] -> ShowS)
-> Show ClockFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ClockFlags] -> ShowS
$cshowList :: [ClockFlags] -> ShowS
show :: ClockFlags -> String
$cshow :: ClockFlags -> String
showsPrec :: Int -> ClockFlags -> ShowS
$cshowsPrec :: Int -> ClockFlags -> ShowS
Show, ClockFlags -> ClockFlags -> Bool
(ClockFlags -> ClockFlags -> Bool)
-> (ClockFlags -> ClockFlags -> Bool) -> Eq ClockFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClockFlags -> ClockFlags -> Bool
$c/= :: ClockFlags -> ClockFlags -> Bool
== :: ClockFlags -> ClockFlags -> Bool
$c== :: ClockFlags -> ClockFlags -> Bool
Eq)

instance P.Enum ClockFlags where
    fromEnum :: ClockFlags -> Int
fromEnum ClockFlags
ClockFlagsCanDoSingleSync = Int
16
    fromEnum ClockFlags
ClockFlagsCanDoSingleAsync = Int
32
    fromEnum ClockFlags
ClockFlagsCanDoPeriodicSync = Int
64
    fromEnum ClockFlags
ClockFlagsCanDoPeriodicAsync = Int
128
    fromEnum ClockFlags
ClockFlagsCanSetResolution = Int
256
    fromEnum ClockFlags
ClockFlagsCanSetMaster = Int
512
    fromEnum ClockFlags
ClockFlagsNeedsStartupSync = Int
1024
    fromEnum ClockFlags
ClockFlagsLast = Int
4096
    fromEnum (AnotherClockFlags Int
k) = Int
k

    toEnum :: Int -> ClockFlags
toEnum Int
16 = ClockFlags
ClockFlagsCanDoSingleSync
    toEnum Int
32 = ClockFlags
ClockFlagsCanDoSingleAsync
    toEnum Int
64 = ClockFlags
ClockFlagsCanDoPeriodicSync
    toEnum Int
128 = ClockFlags
ClockFlagsCanDoPeriodicAsync
    toEnum Int
256 = ClockFlags
ClockFlagsCanSetResolution
    toEnum Int
512 = ClockFlags
ClockFlagsCanSetMaster
    toEnum Int
1024 = ClockFlags
ClockFlagsNeedsStartupSync
    toEnum Int
4096 = ClockFlags
ClockFlagsLast
    toEnum Int
k = Int -> ClockFlags
AnotherClockFlags Int
k

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

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

foreign import ccall "gst_clock_flags_get_type" c_gst_clock_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ClockFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_clock_flags_get_type

instance B.Types.BoxedFlags ClockFlags

instance IsGFlag ClockFlags

-- Flags CapsFlags
-- | Extra flags for a caps.
data CapsFlags = 
      CapsFlagsAny
    -- ^ Caps has no specific content, but can contain
    --    anything.
    | AnotherCapsFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CapsFlags -> ShowS
[CapsFlags] -> ShowS
CapsFlags -> String
(Int -> CapsFlags -> ShowS)
-> (CapsFlags -> String)
-> ([CapsFlags] -> ShowS)
-> Show CapsFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CapsFlags] -> ShowS
$cshowList :: [CapsFlags] -> ShowS
show :: CapsFlags -> String
$cshow :: CapsFlags -> String
showsPrec :: Int -> CapsFlags -> ShowS
$cshowsPrec :: Int -> CapsFlags -> ShowS
Show, CapsFlags -> CapsFlags -> Bool
(CapsFlags -> CapsFlags -> Bool)
-> (CapsFlags -> CapsFlags -> Bool) -> Eq CapsFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CapsFlags -> CapsFlags -> Bool
$c/= :: CapsFlags -> CapsFlags -> Bool
== :: CapsFlags -> CapsFlags -> Bool
$c== :: CapsFlags -> CapsFlags -> Bool
Eq)

instance P.Enum CapsFlags where
    fromEnum :: CapsFlags -> Int
fromEnum CapsFlags
CapsFlagsAny = Int
16
    fromEnum (AnotherCapsFlags Int
k) = Int
k

    toEnum :: Int -> CapsFlags
toEnum Int
16 = CapsFlags
CapsFlagsAny
    toEnum Int
k = Int -> CapsFlags
AnotherCapsFlags Int
k

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

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

foreign import ccall "gst_caps_flags_get_type" c_gst_caps_flags_get_type :: 
    IO GType

instance B.Types.TypedObject CapsFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_caps_flags_get_type

instance B.Types.BoxedFlags CapsFlags

instance IsGFlag CapsFlags

-- Flags BusFlags
-- | The standard flags that a bus may have.
data BusFlags = 
      BusFlagsFlushing
    -- ^ The bus is currently dropping all messages
    | BusFlagsFlagLast
    -- ^ offset to define more flags
    | AnotherBusFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BusFlags -> ShowS
[BusFlags] -> ShowS
BusFlags -> String
(Int -> BusFlags -> ShowS)
-> (BusFlags -> String) -> ([BusFlags] -> ShowS) -> Show BusFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BusFlags] -> ShowS
$cshowList :: [BusFlags] -> ShowS
show :: BusFlags -> String
$cshow :: BusFlags -> String
showsPrec :: Int -> BusFlags -> ShowS
$cshowsPrec :: Int -> BusFlags -> ShowS
Show, BusFlags -> BusFlags -> Bool
(BusFlags -> BusFlags -> Bool)
-> (BusFlags -> BusFlags -> Bool) -> Eq BusFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BusFlags -> BusFlags -> Bool
$c/= :: BusFlags -> BusFlags -> Bool
== :: BusFlags -> BusFlags -> Bool
$c== :: BusFlags -> BusFlags -> Bool
Eq)

instance P.Enum BusFlags where
    fromEnum :: BusFlags -> Int
fromEnum BusFlags
BusFlagsFlushing = Int
16
    fromEnum BusFlags
BusFlagsFlagLast = Int
32
    fromEnum (AnotherBusFlags Int
k) = Int
k

    toEnum :: Int -> BusFlags
toEnum Int
16 = BusFlags
BusFlagsFlushing
    toEnum Int
32 = BusFlags
BusFlagsFlagLast
    toEnum Int
k = Int -> BusFlags
AnotherBusFlags Int
k

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

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

foreign import ccall "gst_bus_flags_get_type" c_gst_bus_flags_get_type :: 
    IO GType

instance B.Types.TypedObject BusFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_bus_flags_get_type

instance B.Types.BoxedFlags BusFlags

instance IsGFlag BusFlags

-- Flags BufferPoolAcquireFlags
-- | Additional flags to control the allocation of a buffer
data BufferPoolAcquireFlags = 
      BufferPoolAcquireFlagsNone
    -- ^ no flags
    | BufferPoolAcquireFlagsKeyUnit
    -- ^ buffer is keyframe
    | BufferPoolAcquireFlagsDontwait
    -- ^ when the bufferpool is empty, acquire_buffer
    -- will by default block until a buffer is released into the pool again. Setting
    -- this flag makes acquire_buffer return @/GST_FLOW_EOS/@ instead of blocking.
    | BufferPoolAcquireFlagsDiscont
    -- ^ buffer is discont
    | BufferPoolAcquireFlagsLast
    -- ^ last flag, subclasses can use private flags
    --    starting from this value.
    | AnotherBufferPoolAcquireFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BufferPoolAcquireFlags -> ShowS
[BufferPoolAcquireFlags] -> ShowS
BufferPoolAcquireFlags -> String
(Int -> BufferPoolAcquireFlags -> ShowS)
-> (BufferPoolAcquireFlags -> String)
-> ([BufferPoolAcquireFlags] -> ShowS)
-> Show BufferPoolAcquireFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BufferPoolAcquireFlags] -> ShowS
$cshowList :: [BufferPoolAcquireFlags] -> ShowS
show :: BufferPoolAcquireFlags -> String
$cshow :: BufferPoolAcquireFlags -> String
showsPrec :: Int -> BufferPoolAcquireFlags -> ShowS
$cshowsPrec :: Int -> BufferPoolAcquireFlags -> ShowS
Show, BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool
(BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool)
-> (BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool)
-> Eq BufferPoolAcquireFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool
$c/= :: BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool
== :: BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool
$c== :: BufferPoolAcquireFlags -> BufferPoolAcquireFlags -> Bool
Eq)

instance P.Enum BufferPoolAcquireFlags where
    fromEnum :: BufferPoolAcquireFlags -> Int
fromEnum BufferPoolAcquireFlags
BufferPoolAcquireFlagsNone = Int
0
    fromEnum BufferPoolAcquireFlags
BufferPoolAcquireFlagsKeyUnit = Int
1
    fromEnum BufferPoolAcquireFlags
BufferPoolAcquireFlagsDontwait = Int
2
    fromEnum BufferPoolAcquireFlags
BufferPoolAcquireFlagsDiscont = Int
4
    fromEnum BufferPoolAcquireFlags
BufferPoolAcquireFlagsLast = Int
65536
    fromEnum (AnotherBufferPoolAcquireFlags Int
k) = Int
k

    toEnum :: Int -> BufferPoolAcquireFlags
toEnum Int
0 = BufferPoolAcquireFlags
BufferPoolAcquireFlagsNone
    toEnum Int
1 = BufferPoolAcquireFlags
BufferPoolAcquireFlagsKeyUnit
    toEnum Int
2 = BufferPoolAcquireFlags
BufferPoolAcquireFlagsDontwait
    toEnum Int
4 = BufferPoolAcquireFlags
BufferPoolAcquireFlagsDiscont
    toEnum Int
65536 = BufferPoolAcquireFlags
BufferPoolAcquireFlagsLast
    toEnum Int
k = Int -> BufferPoolAcquireFlags
AnotherBufferPoolAcquireFlags Int
k

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

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

foreign import ccall "gst_buffer_pool_acquire_flags_get_type" c_gst_buffer_pool_acquire_flags_get_type :: 
    IO GType

instance B.Types.TypedObject BufferPoolAcquireFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_buffer_pool_acquire_flags_get_type

instance B.Types.BoxedFlags BufferPoolAcquireFlags

instance IsGFlag BufferPoolAcquireFlags

-- Flags BufferFlags
-- | A set of buffer flags used to describe properties of a t'GI.Gst.Structs.Buffer.Buffer'.
data BufferFlags = 
      BufferFlagsLive
    -- ^ the buffer is live data and should be discarded in
    --                                 the PAUSED state.
    | BufferFlagsDecodeOnly
    -- ^ the buffer contains data that should be dropped
    --                                 because it will be clipped against the segment
    --                                 boundaries or because it does not contain data
    --                                 that should be shown to the user.
    | BufferFlagsDiscont
    -- ^ the buffer marks a data discontinuity in the stream.
    --                                 This typically occurs after a seek or a dropped buffer
    --                                 from a live or network source.
    | BufferFlagsResync
    -- ^ the buffer timestamps might have a discontinuity
    --                                 and this buffer is a good point to resynchronize.
    | BufferFlagsCorrupted
    -- ^ the buffer data is corrupted.
    | BufferFlagsMarker
    -- ^ the buffer contains a media specific marker. for
    --                                 video this is typically the end of a frame boundary, for audio
    --                                 this is usually the start of a talkspurt.
    | BufferFlagsHeader
    -- ^ the buffer contains header information that is
    --                                 needed to decode the following data.
    | BufferFlagsGap
    -- ^ the buffer has been created to fill a gap in the
    --                                 stream and contains media neutral data (elements can
    --                                 switch to optimized code path that ignores the buffer
    --                                 content).
    | BufferFlagsDroppable
    -- ^ the buffer can be dropped without breaking the
    --                                 stream, for example to reduce bandwidth.
    | BufferFlagsDeltaUnit
    -- ^ this unit cannot be decoded independently.
    | BufferFlagsTagMemory
    -- ^ this flag is set when memory of the buffer
    --                                 is added\/removed
    | BufferFlagsSyncAfter
    -- ^ Elements which write to disk or permanent
    -- 				 storage should ensure the data is synced after
    -- 				 writing the contents of this buffer. (Since: 1.6)
    | BufferFlagsNonDroppable
    -- ^ This buffer is important and should not be dropped.
    --                                 This can be used to mark important buffers, e.g. to flag
    --                                 RTP packets carrying keyframes or codec setup data for RTP
    --                                 Forward Error Correction purposes, or to prevent still video
    --                                 frames from being dropped by elements due to QoS. (Since: 1.14)
    | BufferFlagsLast
    -- ^ additional media specific flags can be added starting from
    --                                 this flag.
    | AnotherBufferFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BufferFlags -> ShowS
[BufferFlags] -> ShowS
BufferFlags -> String
(Int -> BufferFlags -> ShowS)
-> (BufferFlags -> String)
-> ([BufferFlags] -> ShowS)
-> Show BufferFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BufferFlags] -> ShowS
$cshowList :: [BufferFlags] -> ShowS
show :: BufferFlags -> String
$cshow :: BufferFlags -> String
showsPrec :: Int -> BufferFlags -> ShowS
$cshowsPrec :: Int -> BufferFlags -> ShowS
Show, BufferFlags -> BufferFlags -> Bool
(BufferFlags -> BufferFlags -> Bool)
-> (BufferFlags -> BufferFlags -> Bool) -> Eq BufferFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BufferFlags -> BufferFlags -> Bool
$c/= :: BufferFlags -> BufferFlags -> Bool
== :: BufferFlags -> BufferFlags -> Bool
$c== :: BufferFlags -> BufferFlags -> Bool
Eq)

instance P.Enum BufferFlags where
    fromEnum :: BufferFlags -> Int
fromEnum BufferFlags
BufferFlagsLive = Int
16
    fromEnum BufferFlags
BufferFlagsDecodeOnly = Int
32
    fromEnum BufferFlags
BufferFlagsDiscont = Int
64
    fromEnum BufferFlags
BufferFlagsResync = Int
128
    fromEnum BufferFlags
BufferFlagsCorrupted = Int
256
    fromEnum BufferFlags
BufferFlagsMarker = Int
512
    fromEnum BufferFlags
BufferFlagsHeader = Int
1024
    fromEnum BufferFlags
BufferFlagsGap = Int
2048
    fromEnum BufferFlags
BufferFlagsDroppable = Int
4096
    fromEnum BufferFlags
BufferFlagsDeltaUnit = Int
8192
    fromEnum BufferFlags
BufferFlagsTagMemory = Int
16384
    fromEnum BufferFlags
BufferFlagsSyncAfter = Int
32768
    fromEnum BufferFlags
BufferFlagsNonDroppable = Int
65536
    fromEnum BufferFlags
BufferFlagsLast = Int
1048576
    fromEnum (AnotherBufferFlags Int
k) = Int
k

    toEnum :: Int -> BufferFlags
toEnum Int
16 = BufferFlags
BufferFlagsLive
    toEnum Int
32 = BufferFlags
BufferFlagsDecodeOnly
    toEnum Int
64 = BufferFlags
BufferFlagsDiscont
    toEnum Int
128 = BufferFlags
BufferFlagsResync
    toEnum Int
256 = BufferFlags
BufferFlagsCorrupted
    toEnum Int
512 = BufferFlags
BufferFlagsMarker
    toEnum Int
1024 = BufferFlags
BufferFlagsHeader
    toEnum Int
2048 = BufferFlags
BufferFlagsGap
    toEnum Int
4096 = BufferFlags
BufferFlagsDroppable
    toEnum Int
8192 = BufferFlags
BufferFlagsDeltaUnit
    toEnum Int
16384 = BufferFlags
BufferFlagsTagMemory
    toEnum Int
32768 = BufferFlags
BufferFlagsSyncAfter
    toEnum Int
65536 = BufferFlags
BufferFlagsNonDroppable
    toEnum Int
1048576 = BufferFlags
BufferFlagsLast
    toEnum Int
k = Int -> BufferFlags
AnotherBufferFlags Int
k

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

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

foreign import ccall "gst_buffer_flags_get_type" c_gst_buffer_flags_get_type :: 
    IO GType

instance B.Types.TypedObject BufferFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_buffer_flags_get_type

instance B.Types.BoxedFlags BufferFlags

instance IsGFlag BufferFlags

-- Flags BufferCopyFlags
-- | A set of flags that can be provided to the 'GI.Gst.Structs.Buffer.bufferCopyInto'
-- function to specify which items should be copied.
data BufferCopyFlags = 
      BufferCopyFlagsNone
    -- ^ copy nothing
    | BufferCopyFlagsFlags
    -- ^ flag indicating that buffer flags should be copied
    | BufferCopyFlagsTimestamps
    -- ^ flag indicating that buffer pts, dts,
    --   duration, offset and offset_end should be copied
    | BufferCopyFlagsMeta
    -- ^ flag indicating that buffer meta should be
    --   copied
    | BufferCopyFlagsMemory
    -- ^ flag indicating that buffer memory should be reffed
    --   and appended to already existing memory. Unless the memory is marked as
    --   NO_SHARE, no actual copy of the memory is made but it is simply reffed.
    --   Add /@gSTBUFFERCOPYDEEP@/ to force a real copy.
    | BufferCopyFlagsMerge
    -- ^ flag indicating that buffer memory should be
    --   merged
    | BufferCopyFlagsDeep
    -- ^ flag indicating that memory should always be
    --   copied instead of reffed (Since: 1.2)
    | AnotherBufferCopyFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BufferCopyFlags -> ShowS
[BufferCopyFlags] -> ShowS
BufferCopyFlags -> String
(Int -> BufferCopyFlags -> ShowS)
-> (BufferCopyFlags -> String)
-> ([BufferCopyFlags] -> ShowS)
-> Show BufferCopyFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BufferCopyFlags] -> ShowS
$cshowList :: [BufferCopyFlags] -> ShowS
show :: BufferCopyFlags -> String
$cshow :: BufferCopyFlags -> String
showsPrec :: Int -> BufferCopyFlags -> ShowS
$cshowsPrec :: Int -> BufferCopyFlags -> ShowS
Show, BufferCopyFlags -> BufferCopyFlags -> Bool
(BufferCopyFlags -> BufferCopyFlags -> Bool)
-> (BufferCopyFlags -> BufferCopyFlags -> Bool)
-> Eq BufferCopyFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BufferCopyFlags -> BufferCopyFlags -> Bool
$c/= :: BufferCopyFlags -> BufferCopyFlags -> Bool
== :: BufferCopyFlags -> BufferCopyFlags -> Bool
$c== :: BufferCopyFlags -> BufferCopyFlags -> Bool
Eq)

instance P.Enum BufferCopyFlags where
    fromEnum :: BufferCopyFlags -> Int
fromEnum BufferCopyFlags
BufferCopyFlagsNone = Int
0
    fromEnum BufferCopyFlags
BufferCopyFlagsFlags = Int
1
    fromEnum BufferCopyFlags
BufferCopyFlagsTimestamps = Int
2
    fromEnum BufferCopyFlags
BufferCopyFlagsMeta = Int
4
    fromEnum BufferCopyFlags
BufferCopyFlagsMemory = Int
8
    fromEnum BufferCopyFlags
BufferCopyFlagsMerge = Int
16
    fromEnum BufferCopyFlags
BufferCopyFlagsDeep = Int
32
    fromEnum (AnotherBufferCopyFlags Int
k) = Int
k

    toEnum :: Int -> BufferCopyFlags
toEnum Int
0 = BufferCopyFlags
BufferCopyFlagsNone
    toEnum Int
1 = BufferCopyFlags
BufferCopyFlagsFlags
    toEnum Int
2 = BufferCopyFlags
BufferCopyFlagsTimestamps
    toEnum Int
4 = BufferCopyFlags
BufferCopyFlagsMeta
    toEnum Int
8 = BufferCopyFlags
BufferCopyFlagsMemory
    toEnum Int
16 = BufferCopyFlags
BufferCopyFlagsMerge
    toEnum Int
32 = BufferCopyFlags
BufferCopyFlagsDeep
    toEnum Int
k = Int -> BufferCopyFlags
AnotherBufferCopyFlags Int
k

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

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

foreign import ccall "gst_buffer_copy_flags_get_type" c_gst_buffer_copy_flags_get_type :: 
    IO GType

instance B.Types.TypedObject BufferCopyFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_buffer_copy_flags_get_type

instance B.Types.BoxedFlags BufferCopyFlags

instance IsGFlag BufferCopyFlags

-- Flags BinFlags
-- | GstBinFlags are a set of flags specific to bins. Most are set\/used
-- internally. They can be checked using the GST_OBJECT_FLAG_IS_SET () macro,
-- and (un)set using GST_OBJECT_FLAG_SET () and GST_OBJECT_FLAG_UNSET ().
data BinFlags = 
      BinFlagsNoResync
    -- ^ don\'t resync a state change when elements are
    --             added or linked in the bin (Since: 1.0.5)
    | BinFlagsStreamsAware
    -- ^ Indicates whether the bin can handle elements
    --             that add\/remove source pads at any point in time without
    --             first posting a no-more-pads signal (Since: 1.10)
    | BinFlagsLast
    -- ^ the last enum in the series of flags for bins.
    -- Derived classes can use this as first value in a list of flags.
    | AnotherBinFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BinFlags -> ShowS
[BinFlags] -> ShowS
BinFlags -> String
(Int -> BinFlags -> ShowS)
-> (BinFlags -> String) -> ([BinFlags] -> ShowS) -> Show BinFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BinFlags] -> ShowS
$cshowList :: [BinFlags] -> ShowS
show :: BinFlags -> String
$cshow :: BinFlags -> String
showsPrec :: Int -> BinFlags -> ShowS
$cshowsPrec :: Int -> BinFlags -> ShowS
Show, BinFlags -> BinFlags -> Bool
(BinFlags -> BinFlags -> Bool)
-> (BinFlags -> BinFlags -> Bool) -> Eq BinFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BinFlags -> BinFlags -> Bool
$c/= :: BinFlags -> BinFlags -> Bool
== :: BinFlags -> BinFlags -> Bool
$c== :: BinFlags -> BinFlags -> Bool
Eq)

instance P.Enum BinFlags where
    fromEnum :: BinFlags -> Int
fromEnum BinFlags
BinFlagsNoResync = Int
16384
    fromEnum BinFlags
BinFlagsStreamsAware = Int
32768
    fromEnum BinFlags
BinFlagsLast = Int
524288
    fromEnum (AnotherBinFlags Int
k) = Int
k

    toEnum :: Int -> BinFlags
toEnum Int
16384 = BinFlags
BinFlagsNoResync
    toEnum Int
32768 = BinFlags
BinFlagsStreamsAware
    toEnum Int
524288 = BinFlags
BinFlagsLast
    toEnum Int
k = Int -> BinFlags
AnotherBinFlags Int
k

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

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

foreign import ccall "gst_bin_flags_get_type" c_gst_bin_flags_get_type :: 
    IO GType

instance B.Types.TypedObject BinFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_bin_flags_get_type

instance B.Types.BoxedFlags BinFlags

instance IsGFlag BinFlags

-- Flags AllocatorFlags
-- | Flags for allocators.
data AllocatorFlags = 
      AllocatorFlagsCustomAlloc
    -- ^ The allocator has a custom alloc function.
    | AllocatorFlagsLast
    -- ^ first flag that can be used for custom purposes
    | AnotherAllocatorFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AllocatorFlags -> ShowS
[AllocatorFlags] -> ShowS
AllocatorFlags -> String
(Int -> AllocatorFlags -> ShowS)
-> (AllocatorFlags -> String)
-> ([AllocatorFlags] -> ShowS)
-> Show AllocatorFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AllocatorFlags] -> ShowS
$cshowList :: [AllocatorFlags] -> ShowS
show :: AllocatorFlags -> String
$cshow :: AllocatorFlags -> String
showsPrec :: Int -> AllocatorFlags -> ShowS
$cshowsPrec :: Int -> AllocatorFlags -> ShowS
Show, AllocatorFlags -> AllocatorFlags -> Bool
(AllocatorFlags -> AllocatorFlags -> Bool)
-> (AllocatorFlags -> AllocatorFlags -> Bool) -> Eq AllocatorFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AllocatorFlags -> AllocatorFlags -> Bool
$c/= :: AllocatorFlags -> AllocatorFlags -> Bool
== :: AllocatorFlags -> AllocatorFlags -> Bool
$c== :: AllocatorFlags -> AllocatorFlags -> Bool
Eq)

instance P.Enum AllocatorFlags where
    fromEnum :: AllocatorFlags -> Int
fromEnum AllocatorFlags
AllocatorFlagsCustomAlloc = Int
16
    fromEnum AllocatorFlags
AllocatorFlagsLast = Int
1048576
    fromEnum (AnotherAllocatorFlags Int
k) = Int
k

    toEnum :: Int -> AllocatorFlags
toEnum Int
16 = AllocatorFlags
AllocatorFlagsCustomAlloc
    toEnum Int
1048576 = AllocatorFlags
AllocatorFlagsLast
    toEnum Int
k = Int -> AllocatorFlags
AnotherAllocatorFlags Int
k

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

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

foreign import ccall "gst_allocator_flags_get_type" c_gst_allocator_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AllocatorFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_allocator_flags_get_type

instance B.Types.BoxedFlags AllocatorFlags

instance IsGFlag AllocatorFlags