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

 -- * Flags


-- ** VideoBufferFlags #flag:VideoBufferFlags#

    VideoBufferFlags(..)                    ,


-- ** VideoChromaFlags #flag:VideoChromaFlags#

    VideoChromaFlags(..)                    ,


-- ** VideoChromaSite #flag:VideoChromaSite#

    VideoChromaSite(..)                     ,


-- ** VideoCodecFrameFlags #flag:VideoCodecFrameFlags#

    VideoCodecFrameFlags(..)                ,


-- ** VideoDitherFlags #flag:VideoDitherFlags#

    VideoDitherFlags(..)                    ,


-- ** VideoFlags #flag:VideoFlags#

    VideoFlags(..)                          ,


-- ** VideoFormatFlags #flag:VideoFormatFlags#

    VideoFormatFlags(..)                    ,


-- ** VideoFrameFlags #flag:VideoFrameFlags#

    VideoFrameFlags(..)                     ,


-- ** VideoFrameMapFlags #flag:VideoFrameMapFlags#

    VideoFrameMapFlags(..)                  ,


-- ** VideoMultiviewFlags #flag:VideoMultiviewFlags#

    VideoMultiviewFlags(..)                 ,


-- ** VideoOverlayFormatFlags #flag:VideoOverlayFormatFlags#

    VideoOverlayFormatFlags(..)             ,


-- ** VideoPackFlags #flag:VideoPackFlags#

    VideoPackFlags(..)                      ,


-- ** VideoResamplerFlags #flag:VideoResamplerFlags#

    VideoResamplerFlags(..)                 ,


-- ** VideoScalerFlags #flag:VideoScalerFlags#

    VideoScalerFlags(..)                    ,


-- ** VideoTimeCodeFlags #flag:VideoTimeCodeFlags#

    VideoTimeCodeFlags(..)                  ,




    ) where

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

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


-- Flags VideoTimeCodeFlags
-- | Flags related to the time code information.
-- For drop frame, only 30000\/1001 and 60000\/1001 frame rates are supported.
-- 
-- /Since: 1.10/
data VideoTimeCodeFlags = 
      VideoTimeCodeFlagsNone
    -- ^ No flags
    | VideoTimeCodeFlagsDropFrame
    -- ^ Whether we have drop frame rate
    | VideoTimeCodeFlagsInterlaced
    -- ^ Whether we have interlaced video
    | AnotherVideoTimeCodeFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoTimeCodeFlags -> ShowS
[VideoTimeCodeFlags] -> ShowS
VideoTimeCodeFlags -> String
(Int -> VideoTimeCodeFlags -> ShowS)
-> (VideoTimeCodeFlags -> String)
-> ([VideoTimeCodeFlags] -> ShowS)
-> Show VideoTimeCodeFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoTimeCodeFlags] -> ShowS
$cshowList :: [VideoTimeCodeFlags] -> ShowS
show :: VideoTimeCodeFlags -> String
$cshow :: VideoTimeCodeFlags -> String
showsPrec :: Int -> VideoTimeCodeFlags -> ShowS
$cshowsPrec :: Int -> VideoTimeCodeFlags -> ShowS
Show, VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool
(VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool)
-> (VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool)
-> Eq VideoTimeCodeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool
$c/= :: VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool
== :: VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool
$c== :: VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool
Eq)

instance P.Enum VideoTimeCodeFlags where
    fromEnum :: VideoTimeCodeFlags -> Int
fromEnum VideoTimeCodeFlags
VideoTimeCodeFlagsNone = Int
0
    fromEnum VideoTimeCodeFlags
VideoTimeCodeFlagsDropFrame = Int
1
    fromEnum VideoTimeCodeFlags
VideoTimeCodeFlagsInterlaced = Int
2
    fromEnum (AnotherVideoTimeCodeFlags Int
k) = Int
k

    toEnum :: Int -> VideoTimeCodeFlags
toEnum Int
0 = VideoTimeCodeFlags
VideoTimeCodeFlagsNone
    toEnum Int
1 = VideoTimeCodeFlags
VideoTimeCodeFlagsDropFrame
    toEnum Int
2 = VideoTimeCodeFlags
VideoTimeCodeFlagsInterlaced
    toEnum Int
k = Int -> VideoTimeCodeFlags
AnotherVideoTimeCodeFlags Int
k

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

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

foreign import ccall "gst_video_time_code_flags_get_type" c_gst_video_time_code_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VideoTimeCodeFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_video_time_code_flags_get_type

instance B.Types.BoxedFlags VideoTimeCodeFlags

instance IsGFlag VideoTimeCodeFlags

-- Flags VideoScalerFlags
-- | Different scale flags.
data VideoScalerFlags = 
      VideoScalerFlagsNone
    -- ^ no flags
    | VideoScalerFlagsInterlaced
    -- ^ Set up a scaler for interlaced content
    | AnotherVideoScalerFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoScalerFlags -> ShowS
[VideoScalerFlags] -> ShowS
VideoScalerFlags -> String
(Int -> VideoScalerFlags -> ShowS)
-> (VideoScalerFlags -> String)
-> ([VideoScalerFlags] -> ShowS)
-> Show VideoScalerFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoScalerFlags] -> ShowS
$cshowList :: [VideoScalerFlags] -> ShowS
show :: VideoScalerFlags -> String
$cshow :: VideoScalerFlags -> String
showsPrec :: Int -> VideoScalerFlags -> ShowS
$cshowsPrec :: Int -> VideoScalerFlags -> ShowS
Show, VideoScalerFlags -> VideoScalerFlags -> Bool
(VideoScalerFlags -> VideoScalerFlags -> Bool)
-> (VideoScalerFlags -> VideoScalerFlags -> Bool)
-> Eq VideoScalerFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoScalerFlags -> VideoScalerFlags -> Bool
$c/= :: VideoScalerFlags -> VideoScalerFlags -> Bool
== :: VideoScalerFlags -> VideoScalerFlags -> Bool
$c== :: VideoScalerFlags -> VideoScalerFlags -> Bool
Eq)

instance P.Enum VideoScalerFlags where
    fromEnum :: VideoScalerFlags -> Int
fromEnum VideoScalerFlags
VideoScalerFlagsNone = Int
0
    fromEnum VideoScalerFlags
VideoScalerFlagsInterlaced = Int
1
    fromEnum (AnotherVideoScalerFlags Int
k) = Int
k

    toEnum :: Int -> VideoScalerFlags
toEnum Int
0 = VideoScalerFlags
VideoScalerFlagsNone
    toEnum Int
1 = VideoScalerFlags
VideoScalerFlagsInterlaced
    toEnum Int
k = Int -> VideoScalerFlags
AnotherVideoScalerFlags Int
k

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

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

foreign import ccall "gst_video_scaler_flags_get_type" c_gst_video_scaler_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VideoScalerFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_video_scaler_flags_get_type

instance B.Types.BoxedFlags VideoScalerFlags

instance IsGFlag VideoScalerFlags

-- Flags VideoResamplerFlags
-- | Different resampler flags.
-- 
-- /Since: 1.6/
data VideoResamplerFlags = 
      VideoResamplerFlagsNone
    -- ^ no flags
    | VideoResamplerFlagsHalfTaps
    -- ^ when no taps are given, half the
    --              number of calculated taps. This can be used when making scalers
    --              for the different fields of an interlaced picture. Since: 1.10
    | AnotherVideoResamplerFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoResamplerFlags -> ShowS
[VideoResamplerFlags] -> ShowS
VideoResamplerFlags -> String
(Int -> VideoResamplerFlags -> ShowS)
-> (VideoResamplerFlags -> String)
-> ([VideoResamplerFlags] -> ShowS)
-> Show VideoResamplerFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoResamplerFlags] -> ShowS
$cshowList :: [VideoResamplerFlags] -> ShowS
show :: VideoResamplerFlags -> String
$cshow :: VideoResamplerFlags -> String
showsPrec :: Int -> VideoResamplerFlags -> ShowS
$cshowsPrec :: Int -> VideoResamplerFlags -> ShowS
Show, VideoResamplerFlags -> VideoResamplerFlags -> Bool
(VideoResamplerFlags -> VideoResamplerFlags -> Bool)
-> (VideoResamplerFlags -> VideoResamplerFlags -> Bool)
-> Eq VideoResamplerFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoResamplerFlags -> VideoResamplerFlags -> Bool
$c/= :: VideoResamplerFlags -> VideoResamplerFlags -> Bool
== :: VideoResamplerFlags -> VideoResamplerFlags -> Bool
$c== :: VideoResamplerFlags -> VideoResamplerFlags -> Bool
Eq)

instance P.Enum VideoResamplerFlags where
    fromEnum :: VideoResamplerFlags -> Int
fromEnum VideoResamplerFlags
VideoResamplerFlagsNone = Int
0
    fromEnum VideoResamplerFlags
VideoResamplerFlagsHalfTaps = Int
1
    fromEnum (AnotherVideoResamplerFlags Int
k) = Int
k

    toEnum :: Int -> VideoResamplerFlags
toEnum Int
0 = VideoResamplerFlags
VideoResamplerFlagsNone
    toEnum Int
1 = VideoResamplerFlags
VideoResamplerFlagsHalfTaps
    toEnum Int
k = Int -> VideoResamplerFlags
AnotherVideoResamplerFlags Int
k

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

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

foreign import ccall "gst_video_resampler_flags_get_type" c_gst_video_resampler_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VideoResamplerFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_video_resampler_flags_get_type

instance B.Types.BoxedFlags VideoResamplerFlags

instance IsGFlag VideoResamplerFlags

-- Flags VideoPackFlags
-- | The different flags that can be used when packing and unpacking.
data VideoPackFlags = 
      VideoPackFlagsNone
    -- ^ No flag
    | VideoPackFlagsTruncateRange
    -- ^ When the source has a smaller depth
    --   than the target format, set the least significant bits of the target
    --   to 0. This is likely slightly faster but less accurate. When this flag
    --   is not specified, the most significant bits of the source are duplicated
    --   in the least significant bits of the destination.
    | VideoPackFlagsInterlaced
    -- ^ The source is interlaced. The unpacked
    --   format will be interlaced as well with each line containing
    --   information from alternating fields. (Since: 1.2)
    | AnotherVideoPackFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoPackFlags -> ShowS
[VideoPackFlags] -> ShowS
VideoPackFlags -> String
(Int -> VideoPackFlags -> ShowS)
-> (VideoPackFlags -> String)
-> ([VideoPackFlags] -> ShowS)
-> Show VideoPackFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoPackFlags] -> ShowS
$cshowList :: [VideoPackFlags] -> ShowS
show :: VideoPackFlags -> String
$cshow :: VideoPackFlags -> String
showsPrec :: Int -> VideoPackFlags -> ShowS
$cshowsPrec :: Int -> VideoPackFlags -> ShowS
Show, VideoPackFlags -> VideoPackFlags -> Bool
(VideoPackFlags -> VideoPackFlags -> Bool)
-> (VideoPackFlags -> VideoPackFlags -> Bool) -> Eq VideoPackFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoPackFlags -> VideoPackFlags -> Bool
$c/= :: VideoPackFlags -> VideoPackFlags -> Bool
== :: VideoPackFlags -> VideoPackFlags -> Bool
$c== :: VideoPackFlags -> VideoPackFlags -> Bool
Eq)

instance P.Enum VideoPackFlags where
    fromEnum :: VideoPackFlags -> Int
fromEnum VideoPackFlags
VideoPackFlagsNone = Int
0
    fromEnum VideoPackFlags
VideoPackFlagsTruncateRange = Int
1
    fromEnum VideoPackFlags
VideoPackFlagsInterlaced = Int
2
    fromEnum (AnotherVideoPackFlags Int
k) = Int
k

    toEnum :: Int -> VideoPackFlags
toEnum Int
0 = VideoPackFlags
VideoPackFlagsNone
    toEnum Int
1 = VideoPackFlags
VideoPackFlagsTruncateRange
    toEnum Int
2 = VideoPackFlags
VideoPackFlagsInterlaced
    toEnum Int
k = Int -> VideoPackFlags
AnotherVideoPackFlags Int
k

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

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

foreign import ccall "gst_video_pack_flags_get_type" c_gst_video_pack_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VideoPackFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_video_pack_flags_get_type

instance B.Types.BoxedFlags VideoPackFlags

instance IsGFlag VideoPackFlags

-- Flags VideoOverlayFormatFlags
-- | Overlay format flags.
data VideoOverlayFormatFlags = 
      VideoOverlayFormatFlagsNone
    -- ^ no flags
    | VideoOverlayFormatFlagsPremultipliedAlpha
    -- ^ RGB are premultiplied by A\/255.
    | VideoOverlayFormatFlagsGlobalAlpha
    -- ^ a global-alpha value != 1 is set.
    | AnotherVideoOverlayFormatFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoOverlayFormatFlags -> ShowS
[VideoOverlayFormatFlags] -> ShowS
VideoOverlayFormatFlags -> String
(Int -> VideoOverlayFormatFlags -> ShowS)
-> (VideoOverlayFormatFlags -> String)
-> ([VideoOverlayFormatFlags] -> ShowS)
-> Show VideoOverlayFormatFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoOverlayFormatFlags] -> ShowS
$cshowList :: [VideoOverlayFormatFlags] -> ShowS
show :: VideoOverlayFormatFlags -> String
$cshow :: VideoOverlayFormatFlags -> String
showsPrec :: Int -> VideoOverlayFormatFlags -> ShowS
$cshowsPrec :: Int -> VideoOverlayFormatFlags -> ShowS
Show, VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool
(VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool)
-> (VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool)
-> Eq VideoOverlayFormatFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool
$c/= :: VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool
== :: VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool
$c== :: VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool
Eq)

instance P.Enum VideoOverlayFormatFlags where
    fromEnum :: VideoOverlayFormatFlags -> Int
fromEnum VideoOverlayFormatFlags
VideoOverlayFormatFlagsNone = Int
0
    fromEnum VideoOverlayFormatFlags
VideoOverlayFormatFlagsPremultipliedAlpha = Int
1
    fromEnum VideoOverlayFormatFlags
VideoOverlayFormatFlagsGlobalAlpha = Int
2
    fromEnum (AnotherVideoOverlayFormatFlags Int
k) = Int
k

    toEnum :: Int -> VideoOverlayFormatFlags
toEnum Int
0 = VideoOverlayFormatFlags
VideoOverlayFormatFlagsNone
    toEnum Int
1 = VideoOverlayFormatFlags
VideoOverlayFormatFlagsPremultipliedAlpha
    toEnum Int
2 = VideoOverlayFormatFlags
VideoOverlayFormatFlagsGlobalAlpha
    toEnum Int
k = Int -> VideoOverlayFormatFlags
AnotherVideoOverlayFormatFlags Int
k

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

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

foreign import ccall "gst_video_overlay_format_flags_get_type" c_gst_video_overlay_format_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VideoOverlayFormatFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_video_overlay_format_flags_get_type

instance B.Types.BoxedFlags VideoOverlayFormatFlags

instance IsGFlag VideoOverlayFormatFlags

-- Flags VideoMultiviewFlags
-- | GstVideoMultiviewFlags are used to indicate extra properties of a
-- stereo\/multiview stream beyond the frame layout and buffer mapping
-- that is conveyed in the t'GI.GstVideo.Enums.VideoMultiviewMode'.
data VideoMultiviewFlags = 
      VideoMultiviewFlagsNone
    -- ^ No flags
    | VideoMultiviewFlagsRightViewFirst
    -- ^ For stereo streams, the
    --     normal arrangement of left and right views is reversed.
    | VideoMultiviewFlagsLeftFlipped
    -- ^ The left view is vertically
    --     mirrored.
    | VideoMultiviewFlagsLeftFlopped
    -- ^ The left view is horizontally
    --     mirrored.
    | VideoMultiviewFlagsRightFlipped
    -- ^ The right view is
    --     vertically mirrored.
    | VideoMultiviewFlagsRightFlopped
    -- ^ The right view is
    --     horizontally mirrored.
    | VideoMultiviewFlagsHalfAspect
    -- ^ For frame-packed
    --     multiview modes, indicates that the individual
    --     views have been encoded with half the true width or height
    --     and should be scaled back up for display. This flag
    --     is used for overriding input layout interpretation
    --     by adjusting pixel-aspect-ratio.
    --     For side-by-side, column interleaved or checkerboard packings, the
    --     pixel width will be doubled. For row interleaved and top-bottom
    --     encodings, pixel height will be doubled.
    | VideoMultiviewFlagsMixedMono
    -- ^ The video stream contains both
    --     mono and multiview portions, signalled on each buffer by the
    --     absence or presence of the /@gSTVIDEOBUFFERFLAGMULTIPLEVIEW@/
    --     buffer flag.
    | AnotherVideoMultiviewFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoMultiviewFlags -> ShowS
[VideoMultiviewFlags] -> ShowS
VideoMultiviewFlags -> String
(Int -> VideoMultiviewFlags -> ShowS)
-> (VideoMultiviewFlags -> String)
-> ([VideoMultiviewFlags] -> ShowS)
-> Show VideoMultiviewFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoMultiviewFlags] -> ShowS
$cshowList :: [VideoMultiviewFlags] -> ShowS
show :: VideoMultiviewFlags -> String
$cshow :: VideoMultiviewFlags -> String
showsPrec :: Int -> VideoMultiviewFlags -> ShowS
$cshowsPrec :: Int -> VideoMultiviewFlags -> ShowS
Show, VideoMultiviewFlags -> VideoMultiviewFlags -> Bool
(VideoMultiviewFlags -> VideoMultiviewFlags -> Bool)
-> (VideoMultiviewFlags -> VideoMultiviewFlags -> Bool)
-> Eq VideoMultiviewFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoMultiviewFlags -> VideoMultiviewFlags -> Bool
$c/= :: VideoMultiviewFlags -> VideoMultiviewFlags -> Bool
== :: VideoMultiviewFlags -> VideoMultiviewFlags -> Bool
$c== :: VideoMultiviewFlags -> VideoMultiviewFlags -> Bool
Eq)

instance P.Enum VideoMultiviewFlags where
    fromEnum :: VideoMultiviewFlags -> Int
fromEnum VideoMultiviewFlags
VideoMultiviewFlagsNone = Int
0
    fromEnum VideoMultiviewFlags
VideoMultiviewFlagsRightViewFirst = Int
1
    fromEnum VideoMultiviewFlags
VideoMultiviewFlagsLeftFlipped = Int
2
    fromEnum VideoMultiviewFlags
VideoMultiviewFlagsLeftFlopped = Int
4
    fromEnum VideoMultiviewFlags
VideoMultiviewFlagsRightFlipped = Int
8
    fromEnum VideoMultiviewFlags
VideoMultiviewFlagsRightFlopped = Int
16
    fromEnum VideoMultiviewFlags
VideoMultiviewFlagsHalfAspect = Int
16384
    fromEnum VideoMultiviewFlags
VideoMultiviewFlagsMixedMono = Int
32768
    fromEnum (AnotherVideoMultiviewFlags Int
k) = Int
k

    toEnum :: Int -> VideoMultiviewFlags
toEnum Int
0 = VideoMultiviewFlags
VideoMultiviewFlagsNone
    toEnum Int
1 = VideoMultiviewFlags
VideoMultiviewFlagsRightViewFirst
    toEnum Int
2 = VideoMultiviewFlags
VideoMultiviewFlagsLeftFlipped
    toEnum Int
4 = VideoMultiviewFlags
VideoMultiviewFlagsLeftFlopped
    toEnum Int
8 = VideoMultiviewFlags
VideoMultiviewFlagsRightFlipped
    toEnum Int
16 = VideoMultiviewFlags
VideoMultiviewFlagsRightFlopped
    toEnum Int
16384 = VideoMultiviewFlags
VideoMultiviewFlagsHalfAspect
    toEnum Int
32768 = VideoMultiviewFlags
VideoMultiviewFlagsMixedMono
    toEnum Int
k = Int -> VideoMultiviewFlags
AnotherVideoMultiviewFlags Int
k

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

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

foreign import ccall "gst_video_multiview_flags_get_type" c_gst_video_multiview_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VideoMultiviewFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_video_multiview_flags_get_type

instance B.Types.BoxedFlags VideoMultiviewFlags

instance IsGFlag VideoMultiviewFlags

-- Flags VideoFrameMapFlags
-- | Additional mapping flags for 'GI.GstVideo.Structs.VideoFrame.videoFrameMap'.
-- 
-- /Since: 1.6/
data VideoFrameMapFlags = 
      VideoFrameMapFlagsNoRef
    -- ^ Don\'t take another reference of the buffer and store it in
    --                                    the GstVideoFrame. This makes sure that the buffer stays
    --                                    writable while the frame is mapped, but requires that the
    --                                    buffer reference stays valid until the frame is unmapped again.
    | VideoFrameMapFlagsLast
    -- ^ Offset to define more flags
    | AnotherVideoFrameMapFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoFrameMapFlags -> ShowS
[VideoFrameMapFlags] -> ShowS
VideoFrameMapFlags -> String
(Int -> VideoFrameMapFlags -> ShowS)
-> (VideoFrameMapFlags -> String)
-> ([VideoFrameMapFlags] -> ShowS)
-> Show VideoFrameMapFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoFrameMapFlags] -> ShowS
$cshowList :: [VideoFrameMapFlags] -> ShowS
show :: VideoFrameMapFlags -> String
$cshow :: VideoFrameMapFlags -> String
showsPrec :: Int -> VideoFrameMapFlags -> ShowS
$cshowsPrec :: Int -> VideoFrameMapFlags -> ShowS
Show, VideoFrameMapFlags -> VideoFrameMapFlags -> Bool
(VideoFrameMapFlags -> VideoFrameMapFlags -> Bool)
-> (VideoFrameMapFlags -> VideoFrameMapFlags -> Bool)
-> Eq VideoFrameMapFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoFrameMapFlags -> VideoFrameMapFlags -> Bool
$c/= :: VideoFrameMapFlags -> VideoFrameMapFlags -> Bool
== :: VideoFrameMapFlags -> VideoFrameMapFlags -> Bool
$c== :: VideoFrameMapFlags -> VideoFrameMapFlags -> Bool
Eq)

instance P.Enum VideoFrameMapFlags where
    fromEnum :: VideoFrameMapFlags -> Int
fromEnum VideoFrameMapFlags
VideoFrameMapFlagsNoRef = Int
65536
    fromEnum VideoFrameMapFlags
VideoFrameMapFlagsLast = Int
16777216
    fromEnum (AnotherVideoFrameMapFlags Int
k) = Int
k

    toEnum :: Int -> VideoFrameMapFlags
toEnum Int
65536 = VideoFrameMapFlags
VideoFrameMapFlagsNoRef
    toEnum Int
16777216 = VideoFrameMapFlags
VideoFrameMapFlagsLast
    toEnum Int
k = Int -> VideoFrameMapFlags
AnotherVideoFrameMapFlags Int
k

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

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

foreign import ccall "gst_video_frame_map_flags_get_type" c_gst_video_frame_map_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VideoFrameMapFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_video_frame_map_flags_get_type

instance B.Types.BoxedFlags VideoFrameMapFlags

instance IsGFlag VideoFrameMapFlags

-- Flags VideoFrameFlags
-- | Extra video frame flags
data VideoFrameFlags = 
      VideoFrameFlagsNone
    -- ^ no flags
    | VideoFrameFlagsInterlaced
    -- ^ The video frame is interlaced. In mixed
    --           interlace-mode, this flag specifies if the frame is interlaced or
    --           progressive.
    | VideoFrameFlagsTff
    -- ^ The video frame has the top field first
    | VideoFrameFlagsRff
    -- ^ The video frame has the repeat flag
    | VideoFrameFlagsOnefield
    -- ^ The video frame has one field
    | VideoFrameFlagsMultipleView
    -- ^ The video contains one or
    --     more non-mono views
    | VideoFrameFlagsFirstInBundle
    -- ^ The video frame is the first
    --     in a set of corresponding views provided as sequential frames.
    | VideoFrameFlagsTopField
    -- ^ The video frame has the top field only. This
    --     is the same as GST_VIDEO_FRAME_FLAG_TFF | GST_VIDEO_FRAME_FLAG_ONEFIELD
    --     (Since: 1.16).
    | VideoFrameFlagsBottomField
    -- ^ The video frame has the bottom field
    --     only. This is the same as GST_VIDEO_FRAME_FLAG_ONEFIELD
    --     (GST_VIDEO_FRAME_FLAG_TFF flag unset) (Since: 1.16).
    | AnotherVideoFrameFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoFrameFlags -> ShowS
[VideoFrameFlags] -> ShowS
VideoFrameFlags -> String
(Int -> VideoFrameFlags -> ShowS)
-> (VideoFrameFlags -> String)
-> ([VideoFrameFlags] -> ShowS)
-> Show VideoFrameFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoFrameFlags] -> ShowS
$cshowList :: [VideoFrameFlags] -> ShowS
show :: VideoFrameFlags -> String
$cshow :: VideoFrameFlags -> String
showsPrec :: Int -> VideoFrameFlags -> ShowS
$cshowsPrec :: Int -> VideoFrameFlags -> ShowS
Show, VideoFrameFlags -> VideoFrameFlags -> Bool
(VideoFrameFlags -> VideoFrameFlags -> Bool)
-> (VideoFrameFlags -> VideoFrameFlags -> Bool)
-> Eq VideoFrameFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoFrameFlags -> VideoFrameFlags -> Bool
$c/= :: VideoFrameFlags -> VideoFrameFlags -> Bool
== :: VideoFrameFlags -> VideoFrameFlags -> Bool
$c== :: VideoFrameFlags -> VideoFrameFlags -> Bool
Eq)

instance P.Enum VideoFrameFlags where
    fromEnum :: VideoFrameFlags -> Int
fromEnum VideoFrameFlags
VideoFrameFlagsNone = Int
0
    fromEnum VideoFrameFlags
VideoFrameFlagsInterlaced = Int
1
    fromEnum VideoFrameFlags
VideoFrameFlagsTff = Int
2
    fromEnum VideoFrameFlags
VideoFrameFlagsRff = Int
4
    fromEnum VideoFrameFlags
VideoFrameFlagsOnefield = Int
8
    fromEnum VideoFrameFlags
VideoFrameFlagsMultipleView = Int
16
    fromEnum VideoFrameFlags
VideoFrameFlagsFirstInBundle = Int
32
    fromEnum VideoFrameFlags
VideoFrameFlagsTopField = Int
10
    fromEnum VideoFrameFlags
VideoFrameFlagsBottomField = Int
8
    fromEnum (AnotherVideoFrameFlags Int
k) = Int
k

    toEnum :: Int -> VideoFrameFlags
toEnum Int
0 = VideoFrameFlags
VideoFrameFlagsNone
    toEnum Int
1 = VideoFrameFlags
VideoFrameFlagsInterlaced
    toEnum Int
2 = VideoFrameFlags
VideoFrameFlagsTff
    toEnum Int
4 = VideoFrameFlags
VideoFrameFlagsRff
    toEnum Int
8 = VideoFrameFlags
VideoFrameFlagsOnefield
    toEnum Int
16 = VideoFrameFlags
VideoFrameFlagsMultipleView
    toEnum Int
32 = VideoFrameFlags
VideoFrameFlagsFirstInBundle
    toEnum Int
10 = VideoFrameFlags
VideoFrameFlagsTopField
    toEnum Int
k = Int -> VideoFrameFlags
AnotherVideoFrameFlags Int
k

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

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

foreign import ccall "gst_video_frame_flags_get_type" c_gst_video_frame_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VideoFrameFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_video_frame_flags_get_type

instance B.Types.BoxedFlags VideoFrameFlags

instance IsGFlag VideoFrameFlags

-- Flags VideoFormatFlags
-- | The different video flags that a format info can have.
data VideoFormatFlags = 
      VideoFormatFlagsYuv
    -- ^ The video format is YUV, components are numbered
    --   0=Y, 1=U, 2=V.
    | VideoFormatFlagsRgb
    -- ^ The video format is RGB, components are numbered
    --   0=R, 1=G, 2=B.
    | VideoFormatFlagsGray
    -- ^ The video is gray, there is one gray component
    --   with index 0.
    | VideoFormatFlagsAlpha
    -- ^ The video format has an alpha components with
    --   the number 3.
    | VideoFormatFlagsLe
    -- ^ The video format has data stored in little
    --   endianness.
    | VideoFormatFlagsPalette
    -- ^ The video format has a palette. The palette
    --   is stored in the second plane and indexes are stored in the first plane.
    | VideoFormatFlagsComplex
    -- ^ The video format has a complex layout that
    --   can\'t be described with the usual information in the t'GI.GstVideo.Structs.VideoFormatInfo.VideoFormatInfo'.
    | VideoFormatFlagsUnpack
    -- ^ This format can be used in a
    --   t'GI.GstVideo.Callbacks.VideoFormatUnpack' and t'GI.GstVideo.Callbacks.VideoFormatPack' function.
    | VideoFormatFlagsTiled
    -- ^ The format is tiled, there is tiling information
    --   in the last plane.
    | AnotherVideoFormatFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoFormatFlags -> ShowS
[VideoFormatFlags] -> ShowS
VideoFormatFlags -> String
(Int -> VideoFormatFlags -> ShowS)
-> (VideoFormatFlags -> String)
-> ([VideoFormatFlags] -> ShowS)
-> Show VideoFormatFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoFormatFlags] -> ShowS
$cshowList :: [VideoFormatFlags] -> ShowS
show :: VideoFormatFlags -> String
$cshow :: VideoFormatFlags -> String
showsPrec :: Int -> VideoFormatFlags -> ShowS
$cshowsPrec :: Int -> VideoFormatFlags -> ShowS
Show, VideoFormatFlags -> VideoFormatFlags -> Bool
(VideoFormatFlags -> VideoFormatFlags -> Bool)
-> (VideoFormatFlags -> VideoFormatFlags -> Bool)
-> Eq VideoFormatFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoFormatFlags -> VideoFormatFlags -> Bool
$c/= :: VideoFormatFlags -> VideoFormatFlags -> Bool
== :: VideoFormatFlags -> VideoFormatFlags -> Bool
$c== :: VideoFormatFlags -> VideoFormatFlags -> Bool
Eq)

instance P.Enum VideoFormatFlags where
    fromEnum :: VideoFormatFlags -> Int
fromEnum VideoFormatFlags
VideoFormatFlagsYuv = Int
1
    fromEnum VideoFormatFlags
VideoFormatFlagsRgb = Int
2
    fromEnum VideoFormatFlags
VideoFormatFlagsGray = Int
4
    fromEnum VideoFormatFlags
VideoFormatFlagsAlpha = Int
8
    fromEnum VideoFormatFlags
VideoFormatFlagsLe = Int
16
    fromEnum VideoFormatFlags
VideoFormatFlagsPalette = Int
32
    fromEnum VideoFormatFlags
VideoFormatFlagsComplex = Int
64
    fromEnum VideoFormatFlags
VideoFormatFlagsUnpack = Int
128
    fromEnum VideoFormatFlags
VideoFormatFlagsTiled = Int
256
    fromEnum (AnotherVideoFormatFlags Int
k) = Int
k

    toEnum :: Int -> VideoFormatFlags
toEnum Int
1 = VideoFormatFlags
VideoFormatFlagsYuv
    toEnum Int
2 = VideoFormatFlags
VideoFormatFlagsRgb
    toEnum Int
4 = VideoFormatFlags
VideoFormatFlagsGray
    toEnum Int
8 = VideoFormatFlags
VideoFormatFlagsAlpha
    toEnum Int
16 = VideoFormatFlags
VideoFormatFlagsLe
    toEnum Int
32 = VideoFormatFlags
VideoFormatFlagsPalette
    toEnum Int
64 = VideoFormatFlags
VideoFormatFlagsComplex
    toEnum Int
128 = VideoFormatFlags
VideoFormatFlagsUnpack
    toEnum Int
256 = VideoFormatFlags
VideoFormatFlagsTiled
    toEnum Int
k = Int -> VideoFormatFlags
AnotherVideoFormatFlags Int
k

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

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

foreign import ccall "gst_video_format_flags_get_type" c_gst_video_format_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VideoFormatFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_video_format_flags_get_type

instance B.Types.BoxedFlags VideoFormatFlags

instance IsGFlag VideoFormatFlags

-- Flags VideoFlags
-- | Extra video flags
data VideoFlags = 
      VideoFlagsNone
    -- ^ no flags
    | VideoFlagsVariableFps
    -- ^ a variable fps is selected, fps_n and fps_d
    --     denote the maximum fps of the video
    | VideoFlagsPremultipliedAlpha
    -- ^ Each color has been scaled by the alpha
    --     value.
    | AnotherVideoFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoFlags -> ShowS
[VideoFlags] -> ShowS
VideoFlags -> String
(Int -> VideoFlags -> ShowS)
-> (VideoFlags -> String)
-> ([VideoFlags] -> ShowS)
-> Show VideoFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoFlags] -> ShowS
$cshowList :: [VideoFlags] -> ShowS
show :: VideoFlags -> String
$cshow :: VideoFlags -> String
showsPrec :: Int -> VideoFlags -> ShowS
$cshowsPrec :: Int -> VideoFlags -> ShowS
Show, VideoFlags -> VideoFlags -> Bool
(VideoFlags -> VideoFlags -> Bool)
-> (VideoFlags -> VideoFlags -> Bool) -> Eq VideoFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoFlags -> VideoFlags -> Bool
$c/= :: VideoFlags -> VideoFlags -> Bool
== :: VideoFlags -> VideoFlags -> Bool
$c== :: VideoFlags -> VideoFlags -> Bool
Eq)

instance P.Enum VideoFlags where
    fromEnum :: VideoFlags -> Int
fromEnum VideoFlags
VideoFlagsNone = Int
0
    fromEnum VideoFlags
VideoFlagsVariableFps = Int
1
    fromEnum VideoFlags
VideoFlagsPremultipliedAlpha = Int
2
    fromEnum (AnotherVideoFlags Int
k) = Int
k

    toEnum :: Int -> VideoFlags
toEnum Int
0 = VideoFlags
VideoFlagsNone
    toEnum Int
1 = VideoFlags
VideoFlagsVariableFps
    toEnum Int
2 = VideoFlags
VideoFlagsPremultipliedAlpha
    toEnum Int
k = Int -> VideoFlags
AnotherVideoFlags Int
k

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

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

foreign import ccall "gst_video_flags_get_type" c_gst_video_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VideoFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_video_flags_get_type

instance B.Types.BoxedFlags VideoFlags

instance IsGFlag VideoFlags

-- Flags VideoDitherFlags
-- | Extra flags that influence the result from @/gst_video_chroma_resample_new()/@.
data VideoDitherFlags = 
      VideoDitherFlagsNone
    -- ^ no flags
    | VideoDitherFlagsInterlaced
    -- ^ the input is interlaced
    | VideoDitherFlagsQuantize
    -- ^ quantize values in addition to adding dither.
    | AnotherVideoDitherFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoDitherFlags -> ShowS
[VideoDitherFlags] -> ShowS
VideoDitherFlags -> String
(Int -> VideoDitherFlags -> ShowS)
-> (VideoDitherFlags -> String)
-> ([VideoDitherFlags] -> ShowS)
-> Show VideoDitherFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoDitherFlags] -> ShowS
$cshowList :: [VideoDitherFlags] -> ShowS
show :: VideoDitherFlags -> String
$cshow :: VideoDitherFlags -> String
showsPrec :: Int -> VideoDitherFlags -> ShowS
$cshowsPrec :: Int -> VideoDitherFlags -> ShowS
Show, VideoDitherFlags -> VideoDitherFlags -> Bool
(VideoDitherFlags -> VideoDitherFlags -> Bool)
-> (VideoDitherFlags -> VideoDitherFlags -> Bool)
-> Eq VideoDitherFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoDitherFlags -> VideoDitherFlags -> Bool
$c/= :: VideoDitherFlags -> VideoDitherFlags -> Bool
== :: VideoDitherFlags -> VideoDitherFlags -> Bool
$c== :: VideoDitherFlags -> VideoDitherFlags -> Bool
Eq)

instance P.Enum VideoDitherFlags where
    fromEnum :: VideoDitherFlags -> Int
fromEnum VideoDitherFlags
VideoDitherFlagsNone = Int
0
    fromEnum VideoDitherFlags
VideoDitherFlagsInterlaced = Int
1
    fromEnum VideoDitherFlags
VideoDitherFlagsQuantize = Int
2
    fromEnum (AnotherVideoDitherFlags Int
k) = Int
k

    toEnum :: Int -> VideoDitherFlags
toEnum Int
0 = VideoDitherFlags
VideoDitherFlagsNone
    toEnum Int
1 = VideoDitherFlags
VideoDitherFlagsInterlaced
    toEnum Int
2 = VideoDitherFlags
VideoDitherFlagsQuantize
    toEnum Int
k = Int -> VideoDitherFlags
AnotherVideoDitherFlags Int
k

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

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

foreign import ccall "gst_video_dither_flags_get_type" c_gst_video_dither_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VideoDitherFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_video_dither_flags_get_type

instance B.Types.BoxedFlags VideoDitherFlags

instance IsGFlag VideoDitherFlags

-- Flags VideoCodecFrameFlags
-- | Flags for t'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame'
data VideoCodecFrameFlags = 
      VideoCodecFrameFlagsDecodeOnly
    -- ^ is the frame only meant to be decoded
    | VideoCodecFrameFlagsSyncPoint
    -- ^ is the frame a synchronization point (keyframe)
    | VideoCodecFrameFlagsForceKeyframe
    -- ^ should the output frame be made a keyframe
    | VideoCodecFrameFlagsForceKeyframeHeaders
    -- ^ should the encoder output stream headers
    | AnotherVideoCodecFrameFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoCodecFrameFlags -> ShowS
[VideoCodecFrameFlags] -> ShowS
VideoCodecFrameFlags -> String
(Int -> VideoCodecFrameFlags -> ShowS)
-> (VideoCodecFrameFlags -> String)
-> ([VideoCodecFrameFlags] -> ShowS)
-> Show VideoCodecFrameFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoCodecFrameFlags] -> ShowS
$cshowList :: [VideoCodecFrameFlags] -> ShowS
show :: VideoCodecFrameFlags -> String
$cshow :: VideoCodecFrameFlags -> String
showsPrec :: Int -> VideoCodecFrameFlags -> ShowS
$cshowsPrec :: Int -> VideoCodecFrameFlags -> ShowS
Show, VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool
(VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool)
-> (VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool)
-> Eq VideoCodecFrameFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool
$c/= :: VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool
== :: VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool
$c== :: VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool
Eq)

instance P.Enum VideoCodecFrameFlags where
    fromEnum :: VideoCodecFrameFlags -> Int
fromEnum VideoCodecFrameFlags
VideoCodecFrameFlagsDecodeOnly = Int
1
    fromEnum VideoCodecFrameFlags
VideoCodecFrameFlagsSyncPoint = Int
2
    fromEnum VideoCodecFrameFlags
VideoCodecFrameFlagsForceKeyframe = Int
4
    fromEnum VideoCodecFrameFlags
VideoCodecFrameFlagsForceKeyframeHeaders = Int
8
    fromEnum (AnotherVideoCodecFrameFlags Int
k) = Int
k

    toEnum :: Int -> VideoCodecFrameFlags
toEnum Int
1 = VideoCodecFrameFlags
VideoCodecFrameFlagsDecodeOnly
    toEnum Int
2 = VideoCodecFrameFlags
VideoCodecFrameFlagsSyncPoint
    toEnum Int
4 = VideoCodecFrameFlags
VideoCodecFrameFlagsForceKeyframe
    toEnum Int
8 = VideoCodecFrameFlags
VideoCodecFrameFlagsForceKeyframeHeaders
    toEnum Int
k = Int -> VideoCodecFrameFlags
AnotherVideoCodecFrameFlags Int
k

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

instance IsGFlag VideoCodecFrameFlags

-- Flags VideoChromaSite
-- | Various Chroma sitings.
data VideoChromaSite = 
      VideoChromaSiteUnknown
    -- ^ unknown cositing
    | VideoChromaSiteNone
    -- ^ no cositing
    | VideoChromaSiteHCosited
    -- ^ chroma is horizontally cosited
    | VideoChromaSiteVCosited
    -- ^ chroma is vertically cosited
    | VideoChromaSiteAltLine
    -- ^ choma samples are sited on alternate lines
    | VideoChromaSiteCosited
    -- ^ chroma samples cosited with luma samples
    | VideoChromaSiteJpeg
    -- ^ jpeg style cositing, also for mpeg1 and mjpeg
    | VideoChromaSiteMpeg2
    -- ^ mpeg2 style cositing
    | VideoChromaSiteDv
    -- ^ DV style cositing
    | AnotherVideoChromaSite Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoChromaSite -> ShowS
[VideoChromaSite] -> ShowS
VideoChromaSite -> String
(Int -> VideoChromaSite -> ShowS)
-> (VideoChromaSite -> String)
-> ([VideoChromaSite] -> ShowS)
-> Show VideoChromaSite
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoChromaSite] -> ShowS
$cshowList :: [VideoChromaSite] -> ShowS
show :: VideoChromaSite -> String
$cshow :: VideoChromaSite -> String
showsPrec :: Int -> VideoChromaSite -> ShowS
$cshowsPrec :: Int -> VideoChromaSite -> ShowS
Show, VideoChromaSite -> VideoChromaSite -> Bool
(VideoChromaSite -> VideoChromaSite -> Bool)
-> (VideoChromaSite -> VideoChromaSite -> Bool)
-> Eq VideoChromaSite
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoChromaSite -> VideoChromaSite -> Bool
$c/= :: VideoChromaSite -> VideoChromaSite -> Bool
== :: VideoChromaSite -> VideoChromaSite -> Bool
$c== :: VideoChromaSite -> VideoChromaSite -> Bool
Eq)

instance P.Enum VideoChromaSite where
    fromEnum :: VideoChromaSite -> Int
fromEnum VideoChromaSite
VideoChromaSiteUnknown = Int
0
    fromEnum VideoChromaSite
VideoChromaSiteNone = Int
1
    fromEnum VideoChromaSite
VideoChromaSiteHCosited = Int
2
    fromEnum VideoChromaSite
VideoChromaSiteVCosited = Int
4
    fromEnum VideoChromaSite
VideoChromaSiteAltLine = Int
8
    fromEnum VideoChromaSite
VideoChromaSiteCosited = Int
6
    fromEnum VideoChromaSite
VideoChromaSiteJpeg = Int
1
    fromEnum VideoChromaSite
VideoChromaSiteMpeg2 = Int
2
    fromEnum VideoChromaSite
VideoChromaSiteDv = Int
14
    fromEnum (AnotherVideoChromaSite Int
k) = Int
k

    toEnum :: Int -> VideoChromaSite
toEnum Int
0 = VideoChromaSite
VideoChromaSiteUnknown
    toEnum Int
1 = VideoChromaSite
VideoChromaSiteNone
    toEnum Int
2 = VideoChromaSite
VideoChromaSiteHCosited
    toEnum Int
4 = VideoChromaSite
VideoChromaSiteVCosited
    toEnum Int
8 = VideoChromaSite
VideoChromaSiteAltLine
    toEnum Int
6 = VideoChromaSite
VideoChromaSiteCosited
    toEnum Int
14 = VideoChromaSite
VideoChromaSiteDv
    toEnum Int
k = Int -> VideoChromaSite
AnotherVideoChromaSite Int
k

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

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

foreign import ccall "gst_video_chroma_site_get_type" c_gst_video_chroma_site_get_type :: 
    IO GType

instance B.Types.TypedObject VideoChromaSite where
    glibType :: IO GType
glibType = IO GType
c_gst_video_chroma_site_get_type

instance B.Types.BoxedFlags VideoChromaSite

instance IsGFlag VideoChromaSite

-- Flags VideoChromaFlags
-- | Extra flags that influence the result from @/gst_video_chroma_resample_new()/@.
data VideoChromaFlags = 
      VideoChromaFlagsNone
    -- ^ no flags
    | VideoChromaFlagsInterlaced
    -- ^ the input is interlaced
    | AnotherVideoChromaFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoChromaFlags -> ShowS
[VideoChromaFlags] -> ShowS
VideoChromaFlags -> String
(Int -> VideoChromaFlags -> ShowS)
-> (VideoChromaFlags -> String)
-> ([VideoChromaFlags] -> ShowS)
-> Show VideoChromaFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoChromaFlags] -> ShowS
$cshowList :: [VideoChromaFlags] -> ShowS
show :: VideoChromaFlags -> String
$cshow :: VideoChromaFlags -> String
showsPrec :: Int -> VideoChromaFlags -> ShowS
$cshowsPrec :: Int -> VideoChromaFlags -> ShowS
Show, VideoChromaFlags -> VideoChromaFlags -> Bool
(VideoChromaFlags -> VideoChromaFlags -> Bool)
-> (VideoChromaFlags -> VideoChromaFlags -> Bool)
-> Eq VideoChromaFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoChromaFlags -> VideoChromaFlags -> Bool
$c/= :: VideoChromaFlags -> VideoChromaFlags -> Bool
== :: VideoChromaFlags -> VideoChromaFlags -> Bool
$c== :: VideoChromaFlags -> VideoChromaFlags -> Bool
Eq)

instance P.Enum VideoChromaFlags where
    fromEnum :: VideoChromaFlags -> Int
fromEnum VideoChromaFlags
VideoChromaFlagsNone = Int
0
    fromEnum VideoChromaFlags
VideoChromaFlagsInterlaced = Int
1
    fromEnum (AnotherVideoChromaFlags Int
k) = Int
k

    toEnum :: Int -> VideoChromaFlags
toEnum Int
0 = VideoChromaFlags
VideoChromaFlagsNone
    toEnum Int
1 = VideoChromaFlags
VideoChromaFlagsInterlaced
    toEnum Int
k = Int -> VideoChromaFlags
AnotherVideoChromaFlags Int
k

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

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

foreign import ccall "gst_video_chroma_flags_get_type" c_gst_video_chroma_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VideoChromaFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_video_chroma_flags_get_type

instance B.Types.BoxedFlags VideoChromaFlags

instance IsGFlag VideoChromaFlags

-- Flags VideoBufferFlags
-- | Additional video buffer flags. These flags can potentially be used on any
-- buffers carrying closed caption data, or video data - even encoded data.
-- 
-- Note that these are only valid for t'GI.Gst.Structs.Caps.Caps' of type: video\/... and caption\/...
-- They can conflict with other extended buffer flags.
data VideoBufferFlags = 
      VideoBufferFlagsInterlaced
    -- ^ If the t'GI.Gst.Structs.Buffer.Buffer' is interlaced. In mixed
    --                                     interlace-mode, this flags specifies if the frame is
    --                                     interlaced or progressive.
    | VideoBufferFlagsTff
    -- ^ If the t'GI.Gst.Structs.Buffer.Buffer' is interlaced, then the first field
    --                                     in the video frame is the top field.  If unset, the
    --                                     bottom field is first.
    | VideoBufferFlagsRff
    -- ^ If the t'GI.Gst.Structs.Buffer.Buffer' is interlaced, then the first field
    --                                     (as defined by the 'GI.GstVideo.Flags.VideoBufferFlagsTff' flag setting)
    --                                     is repeated.
    | VideoBufferFlagsOnefield
    -- ^ If the t'GI.Gst.Structs.Buffer.Buffer' is interlaced, then only the
    --                                     first field (as defined by the 'GI.GstVideo.Flags.VideoBufferFlagsTff'
    --                                     flag setting) is to be displayed (Since: 1.16).
    | VideoBufferFlagsMultipleView
    -- ^ The t'GI.Gst.Structs.Buffer.Buffer' contains one or more specific views,
    --                                     such as left or right eye view. This flags is set on
    --                                     any buffer that contains non-mono content - even for
    --                                     streams that contain only a single viewpoint. In mixed
    --                                     mono \/ non-mono streams, the absence of the flag marks
    --                                     mono buffers.
    | VideoBufferFlagsFirstInBundle
    -- ^ When conveying stereo\/multiview content with
    --                                     frame-by-frame methods, this flag marks the first buffer
    --                                      in a bundle of frames that belong together.
    | VideoBufferFlagsTopField
    -- ^ The video frame has the top field only. This is the
    --                                     same as GST_VIDEO_BUFFER_FLAG_TFF |
    --                                     GST_VIDEO_BUFFER_FLAG_ONEFIELD (Since: 1.16).
    --                                     Use @/GST_VIDEO_BUFFER_IS_TOP_FIELD()/@ to check for this flag.
    | VideoBufferFlagsBottomField
    -- ^ The video frame has the bottom field only. This is
    --                                     the same as GST_VIDEO_BUFFER_FLAG_ONEFIELD
    --                                     (GST_VIDEO_BUFFER_FLAG_TFF flag unset) (Since: 1.16).
    --                                     Use @/GST_VIDEO_BUFFER_IS_BOTTOM_FIELD()/@ to check for this flag.
    | VideoBufferFlagsMarker
    -- ^ The t'GI.Gst.Structs.Buffer.Buffer' contains the end of a video field or frame
    --                                     boundary such as the last subframe or packet (Since: 1.18).
    | VideoBufferFlagsLast
    -- ^ Offset to define more flags
    | AnotherVideoBufferFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoBufferFlags -> ShowS
[VideoBufferFlags] -> ShowS
VideoBufferFlags -> String
(Int -> VideoBufferFlags -> ShowS)
-> (VideoBufferFlags -> String)
-> ([VideoBufferFlags] -> ShowS)
-> Show VideoBufferFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoBufferFlags] -> ShowS
$cshowList :: [VideoBufferFlags] -> ShowS
show :: VideoBufferFlags -> String
$cshow :: VideoBufferFlags -> String
showsPrec :: Int -> VideoBufferFlags -> ShowS
$cshowsPrec :: Int -> VideoBufferFlags -> ShowS
Show, VideoBufferFlags -> VideoBufferFlags -> Bool
(VideoBufferFlags -> VideoBufferFlags -> Bool)
-> (VideoBufferFlags -> VideoBufferFlags -> Bool)
-> Eq VideoBufferFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoBufferFlags -> VideoBufferFlags -> Bool
$c/= :: VideoBufferFlags -> VideoBufferFlags -> Bool
== :: VideoBufferFlags -> VideoBufferFlags -> Bool
$c== :: VideoBufferFlags -> VideoBufferFlags -> Bool
Eq)

instance P.Enum VideoBufferFlags where
    fromEnum :: VideoBufferFlags -> Int
fromEnum VideoBufferFlags
VideoBufferFlagsInterlaced = Int
1048576
    fromEnum VideoBufferFlags
VideoBufferFlagsTff = Int
2097152
    fromEnum VideoBufferFlags
VideoBufferFlagsRff = Int
4194304
    fromEnum VideoBufferFlags
VideoBufferFlagsOnefield = Int
8388608
    fromEnum VideoBufferFlags
VideoBufferFlagsMultipleView = Int
16777216
    fromEnum VideoBufferFlags
VideoBufferFlagsFirstInBundle = Int
33554432
    fromEnum VideoBufferFlags
VideoBufferFlagsTopField = Int
10485760
    fromEnum VideoBufferFlags
VideoBufferFlagsBottomField = Int
8388608
    fromEnum VideoBufferFlags
VideoBufferFlagsMarker = Int
512
    fromEnum VideoBufferFlags
VideoBufferFlagsLast = Int
268435456
    fromEnum (AnotherVideoBufferFlags Int
k) = Int
k

    toEnum :: Int -> VideoBufferFlags
toEnum Int
1048576 = VideoBufferFlags
VideoBufferFlagsInterlaced
    toEnum Int
2097152 = VideoBufferFlags
VideoBufferFlagsTff
    toEnum Int
4194304 = VideoBufferFlags
VideoBufferFlagsRff
    toEnum Int
8388608 = VideoBufferFlags
VideoBufferFlagsOnefield
    toEnum Int
16777216 = VideoBufferFlags
VideoBufferFlagsMultipleView
    toEnum Int
33554432 = VideoBufferFlags
VideoBufferFlagsFirstInBundle
    toEnum Int
10485760 = VideoBufferFlags
VideoBufferFlagsTopField
    toEnum Int
512 = VideoBufferFlags
VideoBufferFlagsMarker
    toEnum Int
268435456 = VideoBufferFlags
VideoBufferFlagsLast
    toEnum Int
k = Int -> VideoBufferFlags
AnotherVideoBufferFlags Int
k

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

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

foreign import ccall "gst_video_buffer_flags_get_type" c_gst_video_buffer_flags_get_type :: 
    IO GType

instance B.Types.TypedObject VideoBufferFlags where
    glibType :: IO GType
glibType = IO GType
c_gst_video_buffer_flags_get_type

instance B.Types.BoxedFlags VideoBufferFlags

instance IsGFlag VideoBufferFlags