-- | 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL


-- Flags 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 TracerValueFlagsNone = 0
    fromEnum TracerValueFlagsOptional = 1
    fromEnum TracerValueFlagsAggregated = 2
    fromEnum (AnotherTracerValueFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_tracer_value_flags_get_type" c_gst_tracer_value_flags_get_type :: 
    IO GType

instance BoxedFlags TracerValueFlags where
    boxedFlagsType :: Proxy TracerValueFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_tracer_value_flags_get_type

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 StreamTypeUnknown = 1
    fromEnum StreamTypeAudio = 2
    fromEnum StreamTypeVideo = 4
    fromEnum StreamTypeContainer = 8
    fromEnum StreamTypeText = 16
    fromEnum (AnotherStreamType k :: Int
k) = Int
k

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

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

foreign import ccall "gst_stream_type_get_type" c_gst_stream_type_get_type :: 
    IO GType

instance BoxedFlags StreamType where
    boxedFlagsType :: Proxy StreamType -> IO GType
boxedFlagsType _ = IO GType
c_gst_stream_type_get_type

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 StreamFlagsNone = 0
    fromEnum StreamFlagsSparse = 1
    fromEnum StreamFlagsSelect = 2
    fromEnum StreamFlagsUnselect = 4
    fromEnum (AnotherStreamFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_stream_flags_get_type" c_gst_stream_flags_get_type :: 
    IO GType

instance BoxedFlags StreamFlags where
    boxedFlagsType :: Proxy StreamFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_stream_flags_get_type

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 StackTraceFlagsFull = 1
    fromEnum (AnotherStackTraceFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_stack_trace_flags_get_type" c_gst_stack_trace_flags_get_type :: 
    IO GType

instance BoxedFlags StackTraceFlags where
    boxedFlagsType :: Proxy StackTraceFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_stack_trace_flags_get_type

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 SegmentFlagsNone = 0
    fromEnum SegmentFlagsReset = 1
    fromEnum SegmentFlagsTrickmode = 16
    fromEnum SegmentFlagsSkip = 16
    fromEnum SegmentFlagsSegment = 8
    fromEnum SegmentFlagsTrickmodeKeyUnits = 128
    fromEnum SegmentFlagsTrickmodeNoAudio = 256
    fromEnum (AnotherSegmentFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_segment_flags_get_type" c_gst_segment_flags_get_type :: 
    IO GType

instance BoxedFlags SegmentFlags where
    boxedFlagsType :: Proxy SegmentFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_segment_flags_get_type

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 SeekFlagsNone = 0
    fromEnum SeekFlagsFlush = 1
    fromEnum SeekFlagsAccurate = 2
    fromEnum SeekFlagsKeyUnit = 4
    fromEnum SeekFlagsSegment = 8
    fromEnum SeekFlagsTrickmode = 16
    fromEnum SeekFlagsSkip = 16
    fromEnum SeekFlagsSnapBefore = 32
    fromEnum SeekFlagsSnapAfter = 64
    fromEnum SeekFlagsSnapNearest = 96
    fromEnum SeekFlagsTrickmodeKeyUnits = 128
    fromEnum SeekFlagsTrickmodeNoAudio = 256
    fromEnum (AnotherSeekFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_seek_flags_get_type" c_gst_seek_flags_get_type :: 
    IO GType

instance BoxedFlags SeekFlags where
    boxedFlagsType :: Proxy SeekFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_seek_flags_get_type

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 SchedulingFlagsSeekable = 1
    fromEnum SchedulingFlagsSequential = 2
    fromEnum SchedulingFlagsBandwidthLimited = 4
    fromEnum (AnotherSchedulingFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_scheduling_flags_get_type" c_gst_scheduling_flags_get_type :: 
    IO GType

instance BoxedFlags SchedulingFlags where
    boxedFlagsType :: Proxy SchedulingFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_scheduling_flags_get_type

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 QueryTypeFlagsUpstream = 1
    fromEnum QueryTypeFlagsDownstream = 2
    fromEnum QueryTypeFlagsSerialized = 4
    fromEnum (AnotherQueryTypeFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_query_type_flags_get_type" c_gst_query_type_flags_get_type :: 
    IO GType

instance BoxedFlags QueryTypeFlags where
    boxedFlagsType :: Proxy QueryTypeFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_query_type_flags_get_type

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 PluginFlagsCached = 16
    fromEnum PluginFlagsBlacklisted = 32
    fromEnum (AnotherPluginFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_plugin_flags_get_type" c_gst_plugin_flags_get_type :: 
    IO GType

instance BoxedFlags PluginFlags where
    boxedFlagsType :: Proxy PluginFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_plugin_flags_get_type

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 PluginDependencyFlagsNone = 0
    fromEnum PluginDependencyFlagsRecurse = 1
    fromEnum PluginDependencyFlagsPathsAreDefaultOnly = 2
    fromEnum PluginDependencyFlagsFileNameIsSuffix = 4
    fromEnum PluginDependencyFlagsFileNameIsPrefix = 8
    fromEnum PluginDependencyFlagsPathsAreRelativeToExe = 16
    fromEnum (AnotherPluginDependencyFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_plugin_dependency_flags_get_type" c_gst_plugin_dependency_flags_get_type :: 
    IO GType

instance BoxedFlags PluginDependencyFlags where
    boxedFlagsType :: Proxy PluginDependencyFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_plugin_dependency_flags_get_type

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 PipelineFlagsFixedClock = 524288
    fromEnum PipelineFlagsLast = 8388608
    fromEnum (AnotherPipelineFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_pipeline_flags_get_type" c_gst_pipeline_flags_get_type :: 
    IO GType

instance BoxedFlags PipelineFlags where
    boxedFlagsType :: Proxy PipelineFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_pipeline_flags_get_type

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 ParseFlagsNone = 0
    fromEnum ParseFlagsFatalErrors = 1
    fromEnum ParseFlagsNoSingleElementBins = 2
    fromEnum ParseFlagsPlaceInBin = 4
    fromEnum (AnotherParseFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_parse_flags_get_type" c_gst_parse_flags_get_type :: 
    IO GType

instance BoxedFlags ParseFlags where
    boxedFlagsType :: Proxy ParseFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_parse_flags_get_type

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 PadTemplateFlagsLast = 256
    fromEnum (AnotherPadTemplateFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_pad_template_flags_get_type" c_gst_pad_template_flags_get_type :: 
    IO GType

instance BoxedFlags PadTemplateFlags where
    boxedFlagsType :: Proxy PadTemplateFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_pad_template_flags_get_type

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

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

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

foreign import ccall "gst_pad_probe_type_get_type" c_gst_pad_probe_type_get_type :: 
    IO GType

instance BoxedFlags PadProbeType where
    boxedFlagsType :: Proxy PadProbeType -> IO GType
boxedFlagsType _ = IO GType
c_gst_pad_probe_type_get_type

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 PadLinkCheckNothing = 0
    fromEnum PadLinkCheckHierarchy = 1
    fromEnum PadLinkCheckTemplateCaps = 2
    fromEnum PadLinkCheckCaps = 4
    fromEnum PadLinkCheckNoReconfigure = 8
    fromEnum PadLinkCheckDefault = 5
    fromEnum (AnotherPadLinkCheck k :: Int
k) = Int
k

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

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

foreign import ccall "gst_pad_link_check_get_type" c_gst_pad_link_check_get_type :: 
    IO GType

instance BoxedFlags PadLinkCheck where
    boxedFlagsType :: Proxy PadLinkCheck -> IO GType
boxedFlagsType _ = IO GType
c_gst_pad_link_check_get_type

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 PadFlagsBlocked = 16
    fromEnum PadFlagsFlushing = 32
    fromEnum PadFlagsEos = 64
    fromEnum PadFlagsBlocking = 128
    fromEnum PadFlagsNeedParent = 256
    fromEnum PadFlagsNeedReconfigure = 512
    fromEnum PadFlagsPendingEvents = 1024
    fromEnum PadFlagsFixedCaps = 2048
    fromEnum PadFlagsProxyCaps = 4096
    fromEnum PadFlagsProxyAllocation = 8192
    fromEnum PadFlagsProxyScheduling = 16384
    fromEnum PadFlagsAcceptIntersect = 32768
    fromEnum PadFlagsAcceptTemplate = 65536
    fromEnum PadFlagsLast = 1048576
    fromEnum (AnotherPadFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_pad_flags_get_type" c_gst_pad_flags_get_type :: 
    IO GType

instance BoxedFlags PadFlags where
    boxedFlagsType :: Proxy PadFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_pad_flags_get_type

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 ObjectFlagsMayBeLeaked = 1
    fromEnum ObjectFlagsLast = 16
    fromEnum (AnotherObjectFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_object_flags_get_type" c_gst_object_flags_get_type :: 
    IO GType

instance BoxedFlags ObjectFlags where
    boxedFlagsType :: Proxy ObjectFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_object_flags_get_type

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 MiniObjectFlagsLockable = 1
    fromEnum MiniObjectFlagsLockReadonly = 2
    fromEnum MiniObjectFlagsMayBeLeaked = 4
    fromEnum MiniObjectFlagsLast = 16
    fromEnum (AnotherMiniObjectFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_mini_object_flags_get_type" c_gst_mini_object_flags_get_type :: 
    IO GType

instance BoxedFlags MiniObjectFlags where
    boxedFlagsType :: Proxy MiniObjectFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_mini_object_flags_get_type

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 MetaFlagsNone = 0
    fromEnum MetaFlagsReadonly = 1
    fromEnum MetaFlagsPooled = 2
    fromEnum MetaFlagsLocked = 4
    fromEnum MetaFlagsLast = 65536
    fromEnum (AnotherMetaFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_meta_flags_get_type" c_gst_meta_flags_get_type :: 
    IO GType

instance BoxedFlags MetaFlags where
    boxedFlagsType :: Proxy MetaFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_meta_flags_get_type

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

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

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

foreign import ccall "gst_message_type_get_type" c_gst_message_type_get_type :: 
    IO GType

instance BoxedFlags MessageType where
    boxedFlagsType :: Proxy MessageType -> IO GType
boxedFlagsType _ = IO GType
c_gst_message_type_get_type

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 MemoryFlagsReadonly = 2
    fromEnum MemoryFlagsNoShare = 16
    fromEnum MemoryFlagsZeroPrefixed = 32
    fromEnum MemoryFlagsZeroPadded = 64
    fromEnum MemoryFlagsPhysicallyContiguous = 128
    fromEnum MemoryFlagsNotMappable = 256
    fromEnum MemoryFlagsLast = 1048576
    fromEnum (AnotherMemoryFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_memory_flags_get_type" c_gst_memory_flags_get_type :: 
    IO GType

instance BoxedFlags MemoryFlags where
    boxedFlagsType :: Proxy MemoryFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_memory_flags_get_type

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 MapFlagsRead = 1
    fromEnum MapFlagsWrite = 2
    fromEnum MapFlagsFlagLast = 65536
    fromEnum (AnotherMapFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_map_flags_get_type" c_gst_map_flags_get_type :: 
    IO GType

instance BoxedFlags MapFlags where
    boxedFlagsType :: Proxy MapFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_map_flags_get_type

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 LockFlagsRead = 1
    fromEnum LockFlagsWrite = 2
    fromEnum LockFlagsExclusive = 4
    fromEnum LockFlagsLast = 256
    fromEnum (AnotherLockFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_lock_flags_get_type" c_gst_lock_flags_get_type :: 
    IO GType

instance BoxedFlags LockFlags where
    boxedFlagsType :: Proxy LockFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_lock_flags_get_type

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 EventTypeFlagsUpstream = 1
    fromEnum EventTypeFlagsDownstream = 2
    fromEnum EventTypeFlagsSerialized = 4
    fromEnum EventTypeFlagsSticky = 8
    fromEnum EventTypeFlagsStickyMulti = 16
    fromEnum (AnotherEventTypeFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_event_type_flags_get_type" c_gst_event_type_flags_get_type :: 
    IO GType

instance BoxedFlags EventTypeFlags where
    boxedFlagsType :: Proxy EventTypeFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_event_type_flags_get_type

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 ElementFlagsLockedState = 16
    fromEnum ElementFlagsSink = 32
    fromEnum ElementFlagsSource = 64
    fromEnum ElementFlagsProvideClock = 128
    fromEnum ElementFlagsRequireClock = 256
    fromEnum ElementFlagsIndexable = 512
    fromEnum ElementFlagsLast = 16384
    fromEnum (AnotherElementFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_element_flags_get_type" c_gst_element_flags_get_type :: 
    IO GType

instance BoxedFlags ElementFlags where
    boxedFlagsType :: Proxy ElementFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_element_flags_get_type

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 DebugGraphDetailsMediaType = 1
    fromEnum DebugGraphDetailsCapsDetails = 2
    fromEnum DebugGraphDetailsNonDefaultParams = 4
    fromEnum DebugGraphDetailsStates = 8
    fromEnum DebugGraphDetailsFullParams = 16
    fromEnum DebugGraphDetailsAll = 15
    fromEnum DebugGraphDetailsVerbose = 4294967295
    fromEnum (AnotherDebugGraphDetails k :: Int
k) = Int
k

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

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

foreign import ccall "gst_debug_graph_details_get_type" c_gst_debug_graph_details_get_type :: 
    IO GType

instance BoxedFlags DebugGraphDetails where
    boxedFlagsType :: Proxy DebugGraphDetails -> IO GType
boxedFlagsType _ = IO GType
c_gst_debug_graph_details_get_type

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

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

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

foreign import ccall "gst_debug_color_flags_get_type" c_gst_debug_color_flags_get_type :: 
    IO GType

instance BoxedFlags DebugColorFlags where
    boxedFlagsType :: Proxy DebugColorFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_debug_color_flags_get_type

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 ClockFlagsCanDoSingleSync = 16
    fromEnum ClockFlagsCanDoSingleAsync = 32
    fromEnum ClockFlagsCanDoPeriodicSync = 64
    fromEnum ClockFlagsCanDoPeriodicAsync = 128
    fromEnum ClockFlagsCanSetResolution = 256
    fromEnum ClockFlagsCanSetMaster = 512
    fromEnum ClockFlagsNeedsStartupSync = 1024
    fromEnum ClockFlagsLast = 4096
    fromEnum (AnotherClockFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_clock_flags_get_type" c_gst_clock_flags_get_type :: 
    IO GType

instance BoxedFlags ClockFlags where
    boxedFlagsType :: Proxy ClockFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_clock_flags_get_type

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 CapsFlagsAny = 16
    fromEnum (AnotherCapsFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_caps_flags_get_type" c_gst_caps_flags_get_type :: 
    IO GType

instance BoxedFlags CapsFlags where
    boxedFlagsType :: Proxy CapsFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_caps_flags_get_type

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 BusFlagsFlushing = 16
    fromEnum BusFlagsFlagLast = 32
    fromEnum (AnotherBusFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_bus_flags_get_type" c_gst_bus_flags_get_type :: 
    IO GType

instance BoxedFlags BusFlags where
    boxedFlagsType :: Proxy BusFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_bus_flags_get_type

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 BufferPoolAcquireFlagsNone = 0
    fromEnum BufferPoolAcquireFlagsKeyUnit = 1
    fromEnum BufferPoolAcquireFlagsDontwait = 2
    fromEnum BufferPoolAcquireFlagsDiscont = 4
    fromEnum BufferPoolAcquireFlagsLast = 65536
    fromEnum (AnotherBufferPoolAcquireFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_buffer_pool_acquire_flags_get_type" c_gst_buffer_pool_acquire_flags_get_type :: 
    IO GType

instance BoxedFlags BufferPoolAcquireFlags where
    boxedFlagsType :: Proxy BufferPoolAcquireFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_buffer_pool_acquire_flags_get_type

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 BufferFlagsLive = 16
    fromEnum BufferFlagsDecodeOnly = 32
    fromEnum BufferFlagsDiscont = 64
    fromEnum BufferFlagsResync = 128
    fromEnum BufferFlagsCorrupted = 256
    fromEnum BufferFlagsMarker = 512
    fromEnum BufferFlagsHeader = 1024
    fromEnum BufferFlagsGap = 2048
    fromEnum BufferFlagsDroppable = 4096
    fromEnum BufferFlagsDeltaUnit = 8192
    fromEnum BufferFlagsTagMemory = 16384
    fromEnum BufferFlagsSyncAfter = 32768
    fromEnum BufferFlagsNonDroppable = 65536
    fromEnum BufferFlagsLast = 1048576
    fromEnum (AnotherBufferFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_buffer_flags_get_type" c_gst_buffer_flags_get_type :: 
    IO GType

instance BoxedFlags BufferFlags where
    boxedFlagsType :: Proxy BufferFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_buffer_flags_get_type

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 BufferCopyFlagsNone = 0
    fromEnum BufferCopyFlagsFlags = 1
    fromEnum BufferCopyFlagsTimestamps = 2
    fromEnum BufferCopyFlagsMeta = 4
    fromEnum BufferCopyFlagsMemory = 8
    fromEnum BufferCopyFlagsMerge = 16
    fromEnum BufferCopyFlagsDeep = 32
    fromEnum (AnotherBufferCopyFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_buffer_copy_flags_get_type" c_gst_buffer_copy_flags_get_type :: 
    IO GType

instance BoxedFlags BufferCopyFlags where
    boxedFlagsType :: Proxy BufferCopyFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_buffer_copy_flags_get_type

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 BinFlagsNoResync = 16384
    fromEnum BinFlagsStreamsAware = 32768
    fromEnum BinFlagsLast = 524288
    fromEnum (AnotherBinFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_bin_flags_get_type" c_gst_bin_flags_get_type :: 
    IO GType

instance BoxedFlags BinFlags where
    boxedFlagsType :: Proxy BinFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_bin_flags_get_type

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 AllocatorFlagsCustomAlloc = 16
    fromEnum AllocatorFlagsLast = 1048576
    fromEnum (AnotherAllocatorFlags k :: Int
k) = Int
k

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

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

foreign import ccall "gst_allocator_flags_get_type" c_gst_allocator_flags_get_type :: 
    IO GType

instance BoxedFlags AllocatorFlags where
    boxedFlagsType :: Proxy AllocatorFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_allocator_flags_get_type

instance IsGFlag AllocatorFlags