-- | 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.Enums
    ( 

 -- * Enumerations
-- ** ColorBalanceType #enum:ColorBalanceType#

    ColorBalanceType(..)                    ,


-- ** NavigationCommand #enum:NavigationCommand#

    NavigationCommand(..)                   ,


-- ** NavigationEventType #enum:NavigationEventType#

    NavigationEventType(..)                 ,


-- ** NavigationMessageType #enum:NavigationMessageType#

    NavigationMessageType(..)               ,


-- ** NavigationQueryType #enum:NavigationQueryType#

    NavigationQueryType(..)                 ,


-- ** VideoAlphaMode #enum:VideoAlphaMode#

    VideoAlphaMode(..)                      ,


-- ** VideoAncillaryDID #enum:VideoAncillaryDID#

    VideoAncillaryDID(..)                   ,


-- ** VideoAncillaryDID16 #enum:VideoAncillaryDID16#

    VideoAncillaryDID16(..)                 ,


-- ** VideoCaptionType #enum:VideoCaptionType#

    VideoCaptionType(..)                    ,


-- ** VideoChromaMethod #enum:VideoChromaMethod#

    VideoChromaMethod(..)                   ,


-- ** VideoChromaMode #enum:VideoChromaMode#

    VideoChromaMode(..)                     ,


-- ** VideoColorMatrix #enum:VideoColorMatrix#

    VideoColorMatrix(..)                    ,


-- ** VideoColorPrimaries #enum:VideoColorPrimaries#

    VideoColorPrimaries(..)                 ,


-- ** VideoColorRange #enum:VideoColorRange#

    VideoColorRange(..)                     ,


-- ** VideoDitherMethod #enum:VideoDitherMethod#

    VideoDitherMethod(..)                   ,


-- ** VideoFieldOrder #enum:VideoFieldOrder#

    VideoFieldOrder(..)                     ,


-- ** VideoFormat #enum:VideoFormat#

    VideoFormat(..)                         ,


-- ** VideoGLTextureOrientation #enum:VideoGLTextureOrientation#

    VideoGLTextureOrientation(..)           ,


-- ** VideoGLTextureType #enum:VideoGLTextureType#

    VideoGLTextureType(..)                  ,


-- ** VideoGammaMode #enum:VideoGammaMode#

    VideoGammaMode(..)                      ,


-- ** VideoInterlaceMode #enum:VideoInterlaceMode#

    VideoInterlaceMode(..)                  ,


-- ** VideoMatrixMode #enum:VideoMatrixMode#

    VideoMatrixMode(..)                     ,


-- ** VideoMultiviewFramePacking #enum:VideoMultiviewFramePacking#

    VideoMultiviewFramePacking(..)          ,


-- ** VideoMultiviewMode #enum:VideoMultiviewMode#

    VideoMultiviewMode(..)                  ,


-- ** VideoOrientationMethod #enum:VideoOrientationMethod#

    VideoOrientationMethod(..)              ,


-- ** VideoPrimariesMode #enum:VideoPrimariesMode#

    VideoPrimariesMode(..)                  ,


-- ** VideoResamplerMethod #enum:VideoResamplerMethod#

    VideoResamplerMethod(..)                ,


-- ** VideoTileMode #enum:VideoTileMode#

    VideoTileMode(..)                       ,


-- ** VideoTileType #enum:VideoTileType#

    VideoTileType(..)                       ,


-- ** VideoTransferFunction #enum:VideoTransferFunction#

    VideoTransferFunction(..)               ,


-- ** VideoVBIParserResult #enum:VideoVBIParserResult#

    VideoVBIParserResult(..)                ,




    ) 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


-- Enum VideoVBIParserResult
-- | Return values for t'GI.GstVideo.Structs.VideoVBIParser.VideoVBIParser'
-- 
-- /Since: 1.16/
data VideoVBIParserResult = 
      VideoVBIParserResultDone
    -- ^ No line were provided, or no more Ancillary data was found.
    | VideoVBIParserResultOk
    -- ^ A t'GI.GstVideo.Structs.VideoAncillary.VideoAncillary' was found.
    | VideoVBIParserResultError
    -- ^ An error occured
    | AnotherVideoVBIParserResult Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoVBIParserResult -> ShowS
[VideoVBIParserResult] -> ShowS
VideoVBIParserResult -> String
(Int -> VideoVBIParserResult -> ShowS)
-> (VideoVBIParserResult -> String)
-> ([VideoVBIParserResult] -> ShowS)
-> Show VideoVBIParserResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoVBIParserResult] -> ShowS
$cshowList :: [VideoVBIParserResult] -> ShowS
show :: VideoVBIParserResult -> String
$cshow :: VideoVBIParserResult -> String
showsPrec :: Int -> VideoVBIParserResult -> ShowS
$cshowsPrec :: Int -> VideoVBIParserResult -> ShowS
Show, VideoVBIParserResult -> VideoVBIParserResult -> Bool
(VideoVBIParserResult -> VideoVBIParserResult -> Bool)
-> (VideoVBIParserResult -> VideoVBIParserResult -> Bool)
-> Eq VideoVBIParserResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoVBIParserResult -> VideoVBIParserResult -> Bool
$c/= :: VideoVBIParserResult -> VideoVBIParserResult -> Bool
== :: VideoVBIParserResult -> VideoVBIParserResult -> Bool
$c== :: VideoVBIParserResult -> VideoVBIParserResult -> Bool
Eq)

instance P.Enum VideoVBIParserResult where
    fromEnum :: VideoVBIParserResult -> Int
fromEnum VideoVBIParserResultDone = 0
    fromEnum VideoVBIParserResultOk = 1
    fromEnum VideoVBIParserResultError = 2
    fromEnum (AnotherVideoVBIParserResult k :: Int
k) = Int
k

    toEnum :: Int -> VideoVBIParserResult
toEnum 0 = VideoVBIParserResult
VideoVBIParserResultDone
    toEnum 1 = VideoVBIParserResult
VideoVBIParserResultOk
    toEnum 2 = VideoVBIParserResult
VideoVBIParserResultError
    toEnum k :: Int
k = Int -> VideoVBIParserResult
AnotherVideoVBIParserResult Int
k

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

foreign import ccall "gst_video_vbi_parser_result_get_type" c_gst_video_vbi_parser_result_get_type :: 
    IO GType

instance BoxedEnum VideoVBIParserResult where
    boxedEnumType :: VideoVBIParserResult -> IO GType
boxedEnumType _ = IO GType
c_gst_video_vbi_parser_result_get_type

-- Enum VideoTransferFunction
-- | The video transfer function defines the formula for converting between
-- non-linear RGB (R\'G\'B\') and linear RGB
data VideoTransferFunction = 
      VideoTransferFunctionUnknown
    -- ^ unknown transfer function
    | VideoTransferFunctionGamma10
    -- ^ linear RGB, gamma 1.0 curve
    | VideoTransferFunctionGamma18
    -- ^ Gamma 1.8 curve
    | VideoTransferFunctionGamma20
    -- ^ Gamma 2.0 curve
    | VideoTransferFunctionGamma22
    -- ^ Gamma 2.2 curve
    | VideoTransferFunctionBt709
    -- ^ Gamma 2.2 curve with a linear segment in the lower
    --                           range
    | VideoTransferFunctionSmpte240m
    -- ^ Gamma 2.2 curve with a linear segment in the
    --                               lower range
    | VideoTransferFunctionSrgb
    -- ^ Gamma 2.4 curve with a linear segment in the lower
    --                          range
    | VideoTransferFunctionGamma28
    -- ^ Gamma 2.8 curve
    | VideoTransferFunctionLog100
    -- ^ Logarithmic transfer characteristic
    --                             100:1 range
    | VideoTransferFunctionLog316
    -- ^ Logarithmic transfer characteristic
    --                             316.22777:1 range
    | VideoTransferFunctionBt202012
    -- ^ Gamma 2.2 curve with a linear segment in the lower
    --                                range. Used for BT.2020 with 12 bits per
    --                                component. Since: 1.6
    | VideoTransferFunctionAdobergb
    -- ^ Gamma 2.19921875. Since: 1.8
    | AnotherVideoTransferFunction Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoTransferFunction -> ShowS
[VideoTransferFunction] -> ShowS
VideoTransferFunction -> String
(Int -> VideoTransferFunction -> ShowS)
-> (VideoTransferFunction -> String)
-> ([VideoTransferFunction] -> ShowS)
-> Show VideoTransferFunction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoTransferFunction] -> ShowS
$cshowList :: [VideoTransferFunction] -> ShowS
show :: VideoTransferFunction -> String
$cshow :: VideoTransferFunction -> String
showsPrec :: Int -> VideoTransferFunction -> ShowS
$cshowsPrec :: Int -> VideoTransferFunction -> ShowS
Show, VideoTransferFunction -> VideoTransferFunction -> Bool
(VideoTransferFunction -> VideoTransferFunction -> Bool)
-> (VideoTransferFunction -> VideoTransferFunction -> Bool)
-> Eq VideoTransferFunction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoTransferFunction -> VideoTransferFunction -> Bool
$c/= :: VideoTransferFunction -> VideoTransferFunction -> Bool
== :: VideoTransferFunction -> VideoTransferFunction -> Bool
$c== :: VideoTransferFunction -> VideoTransferFunction -> Bool
Eq)

instance P.Enum VideoTransferFunction where
    fromEnum :: VideoTransferFunction -> Int
fromEnum VideoTransferFunctionUnknown = 0
    fromEnum VideoTransferFunctionGamma10 = 1
    fromEnum VideoTransferFunctionGamma18 = 2
    fromEnum VideoTransferFunctionGamma20 = 3
    fromEnum VideoTransferFunctionGamma22 = 4
    fromEnum VideoTransferFunctionBt709 = 5
    fromEnum VideoTransferFunctionSmpte240m = 6
    fromEnum VideoTransferFunctionSrgb = 7
    fromEnum VideoTransferFunctionGamma28 = 8
    fromEnum VideoTransferFunctionLog100 = 9
    fromEnum VideoTransferFunctionLog316 = 10
    fromEnum VideoTransferFunctionBt202012 = 11
    fromEnum VideoTransferFunctionAdobergb = 12
    fromEnum (AnotherVideoTransferFunction k :: Int
k) = Int
k

    toEnum :: Int -> VideoTransferFunction
toEnum 0 = VideoTransferFunction
VideoTransferFunctionUnknown
    toEnum 1 = VideoTransferFunction
VideoTransferFunctionGamma10
    toEnum 2 = VideoTransferFunction
VideoTransferFunctionGamma18
    toEnum 3 = VideoTransferFunction
VideoTransferFunctionGamma20
    toEnum 4 = VideoTransferFunction
VideoTransferFunctionGamma22
    toEnum 5 = VideoTransferFunction
VideoTransferFunctionBt709
    toEnum 6 = VideoTransferFunction
VideoTransferFunctionSmpte240m
    toEnum 7 = VideoTransferFunction
VideoTransferFunctionSrgb
    toEnum 8 = VideoTransferFunction
VideoTransferFunctionGamma28
    toEnum 9 = VideoTransferFunction
VideoTransferFunctionLog100
    toEnum 10 = VideoTransferFunction
VideoTransferFunctionLog316
    toEnum 11 = VideoTransferFunction
VideoTransferFunctionBt202012
    toEnum 12 = VideoTransferFunction
VideoTransferFunctionAdobergb
    toEnum k :: Int
k = Int -> VideoTransferFunction
AnotherVideoTransferFunction Int
k

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

foreign import ccall "gst_video_transfer_function_get_type" c_gst_video_transfer_function_get_type :: 
    IO GType

instance BoxedEnum VideoTransferFunction where
    boxedEnumType :: VideoTransferFunction -> IO GType
boxedEnumType _ = IO GType
c_gst_video_transfer_function_get_type

-- Enum VideoTileType
-- | Enum value describing the most common tiling types.
data VideoTileType = 
      VideoTileTypeIndexed
    -- ^ Tiles are indexed. Use
    --   gst_video_tile_get_index () to retrieve the tile at the requested
    --   coordinates.
    | AnotherVideoTileType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoTileType -> ShowS
[VideoTileType] -> ShowS
VideoTileType -> String
(Int -> VideoTileType -> ShowS)
-> (VideoTileType -> String)
-> ([VideoTileType] -> ShowS)
-> Show VideoTileType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoTileType] -> ShowS
$cshowList :: [VideoTileType] -> ShowS
show :: VideoTileType -> String
$cshow :: VideoTileType -> String
showsPrec :: Int -> VideoTileType -> ShowS
$cshowsPrec :: Int -> VideoTileType -> ShowS
Show, VideoTileType -> VideoTileType -> Bool
(VideoTileType -> VideoTileType -> Bool)
-> (VideoTileType -> VideoTileType -> Bool) -> Eq VideoTileType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoTileType -> VideoTileType -> Bool
$c/= :: VideoTileType -> VideoTileType -> Bool
== :: VideoTileType -> VideoTileType -> Bool
$c== :: VideoTileType -> VideoTileType -> Bool
Eq)

instance P.Enum VideoTileType where
    fromEnum :: VideoTileType -> Int
fromEnum VideoTileTypeIndexed = 0
    fromEnum (AnotherVideoTileType k :: Int
k) = Int
k

    toEnum :: Int -> VideoTileType
toEnum 0 = VideoTileType
VideoTileTypeIndexed
    toEnum k :: Int
k = Int -> VideoTileType
AnotherVideoTileType Int
k

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

foreign import ccall "gst_video_tile_type_get_type" c_gst_video_tile_type_get_type :: 
    IO GType

instance BoxedEnum VideoTileType where
    boxedEnumType :: VideoTileType -> IO GType
boxedEnumType _ = IO GType
c_gst_video_tile_type_get_type

-- Enum VideoTileMode
-- | Enum value describing the available tiling modes.
data VideoTileMode = 
      VideoTileModeUnknown
    -- ^ Unknown or unset tile mode
    | VideoTileModeZflipz2x2
    -- ^ Every four adjacent blocks - two
    --    horizontally and two vertically are grouped together and are located
    --    in memory in Z or flipped Z order. In case of odd rows, the last row
    --    of blocks is arranged in linear order.
    | AnotherVideoTileMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoTileMode -> ShowS
[VideoTileMode] -> ShowS
VideoTileMode -> String
(Int -> VideoTileMode -> ShowS)
-> (VideoTileMode -> String)
-> ([VideoTileMode] -> ShowS)
-> Show VideoTileMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoTileMode] -> ShowS
$cshowList :: [VideoTileMode] -> ShowS
show :: VideoTileMode -> String
$cshow :: VideoTileMode -> String
showsPrec :: Int -> VideoTileMode -> ShowS
$cshowsPrec :: Int -> VideoTileMode -> ShowS
Show, VideoTileMode -> VideoTileMode -> Bool
(VideoTileMode -> VideoTileMode -> Bool)
-> (VideoTileMode -> VideoTileMode -> Bool) -> Eq VideoTileMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoTileMode -> VideoTileMode -> Bool
$c/= :: VideoTileMode -> VideoTileMode -> Bool
== :: VideoTileMode -> VideoTileMode -> Bool
$c== :: VideoTileMode -> VideoTileMode -> Bool
Eq)

instance P.Enum VideoTileMode where
    fromEnum :: VideoTileMode -> Int
fromEnum VideoTileModeUnknown = 0
    fromEnum VideoTileModeZflipz2x2 = 65536
    fromEnum (AnotherVideoTileMode k :: Int
k) = Int
k

    toEnum :: Int -> VideoTileMode
toEnum 0 = VideoTileMode
VideoTileModeUnknown
    toEnum 65536 = VideoTileMode
VideoTileModeZflipz2x2
    toEnum k :: Int
k = Int -> VideoTileMode
AnotherVideoTileMode Int
k

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

foreign import ccall "gst_video_tile_mode_get_type" c_gst_video_tile_mode_get_type :: 
    IO GType

instance BoxedEnum VideoTileMode where
    boxedEnumType :: VideoTileMode -> IO GType
boxedEnumType _ = IO GType
c_gst_video_tile_mode_get_type

-- Enum VideoResamplerMethod
-- | Different subsampling and upsampling methods
-- 
-- /Since: 1.6/
data VideoResamplerMethod = 
      VideoResamplerMethodNearest
    -- ^ Duplicates the samples when
    --    upsampling and drops when downsampling
    | VideoResamplerMethodLinear
    -- ^ Uses linear interpolation to reconstruct
    --    missing samples and averaging to downsample
    | VideoResamplerMethodCubic
    -- ^ Uses cubic interpolation
    | VideoResamplerMethodSinc
    -- ^ Uses sinc interpolation
    | VideoResamplerMethodLanczos
    -- ^ Uses lanczos interpolation
    | AnotherVideoResamplerMethod Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoResamplerMethod -> ShowS
[VideoResamplerMethod] -> ShowS
VideoResamplerMethod -> String
(Int -> VideoResamplerMethod -> ShowS)
-> (VideoResamplerMethod -> String)
-> ([VideoResamplerMethod] -> ShowS)
-> Show VideoResamplerMethod
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoResamplerMethod] -> ShowS
$cshowList :: [VideoResamplerMethod] -> ShowS
show :: VideoResamplerMethod -> String
$cshow :: VideoResamplerMethod -> String
showsPrec :: Int -> VideoResamplerMethod -> ShowS
$cshowsPrec :: Int -> VideoResamplerMethod -> ShowS
Show, VideoResamplerMethod -> VideoResamplerMethod -> Bool
(VideoResamplerMethod -> VideoResamplerMethod -> Bool)
-> (VideoResamplerMethod -> VideoResamplerMethod -> Bool)
-> Eq VideoResamplerMethod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoResamplerMethod -> VideoResamplerMethod -> Bool
$c/= :: VideoResamplerMethod -> VideoResamplerMethod -> Bool
== :: VideoResamplerMethod -> VideoResamplerMethod -> Bool
$c== :: VideoResamplerMethod -> VideoResamplerMethod -> Bool
Eq)

instance P.Enum VideoResamplerMethod where
    fromEnum :: VideoResamplerMethod -> Int
fromEnum VideoResamplerMethodNearest = 0
    fromEnum VideoResamplerMethodLinear = 1
    fromEnum VideoResamplerMethodCubic = 2
    fromEnum VideoResamplerMethodSinc = 3
    fromEnum VideoResamplerMethodLanczos = 4
    fromEnum (AnotherVideoResamplerMethod k :: Int
k) = Int
k

    toEnum :: Int -> VideoResamplerMethod
toEnum 0 = VideoResamplerMethod
VideoResamplerMethodNearest
    toEnum 1 = VideoResamplerMethod
VideoResamplerMethodLinear
    toEnum 2 = VideoResamplerMethod
VideoResamplerMethodCubic
    toEnum 3 = VideoResamplerMethod
VideoResamplerMethodSinc
    toEnum 4 = VideoResamplerMethod
VideoResamplerMethodLanczos
    toEnum k :: Int
k = Int -> VideoResamplerMethod
AnotherVideoResamplerMethod Int
k

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

foreign import ccall "gst_video_resampler_method_get_type" c_gst_video_resampler_method_get_type :: 
    IO GType

instance BoxedEnum VideoResamplerMethod where
    boxedEnumType :: VideoResamplerMethod -> IO GType
boxedEnumType _ = IO GType
c_gst_video_resampler_method_get_type

-- Enum VideoPrimariesMode
-- | Different primaries conversion modes
-- 
-- /Since: 1.6/
data VideoPrimariesMode = 
      VideoPrimariesModeNone
    -- ^ disable conversion between primaries
    | VideoPrimariesModeMergeOnly
    -- ^ do conversion between primaries only
    --   when it can be merged with color matrix conversion.
    | VideoPrimariesModeFast
    -- ^ fast conversion between primaries
    | AnotherVideoPrimariesMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoPrimariesMode -> ShowS
[VideoPrimariesMode] -> ShowS
VideoPrimariesMode -> String
(Int -> VideoPrimariesMode -> ShowS)
-> (VideoPrimariesMode -> String)
-> ([VideoPrimariesMode] -> ShowS)
-> Show VideoPrimariesMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoPrimariesMode] -> ShowS
$cshowList :: [VideoPrimariesMode] -> ShowS
show :: VideoPrimariesMode -> String
$cshow :: VideoPrimariesMode -> String
showsPrec :: Int -> VideoPrimariesMode -> ShowS
$cshowsPrec :: Int -> VideoPrimariesMode -> ShowS
Show, VideoPrimariesMode -> VideoPrimariesMode -> Bool
(VideoPrimariesMode -> VideoPrimariesMode -> Bool)
-> (VideoPrimariesMode -> VideoPrimariesMode -> Bool)
-> Eq VideoPrimariesMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoPrimariesMode -> VideoPrimariesMode -> Bool
$c/= :: VideoPrimariesMode -> VideoPrimariesMode -> Bool
== :: VideoPrimariesMode -> VideoPrimariesMode -> Bool
$c== :: VideoPrimariesMode -> VideoPrimariesMode -> Bool
Eq)

instance P.Enum VideoPrimariesMode where
    fromEnum :: VideoPrimariesMode -> Int
fromEnum VideoPrimariesModeNone = 0
    fromEnum VideoPrimariesModeMergeOnly = 1
    fromEnum VideoPrimariesModeFast = 2
    fromEnum (AnotherVideoPrimariesMode k :: Int
k) = Int
k

    toEnum :: Int -> VideoPrimariesMode
toEnum 0 = VideoPrimariesMode
VideoPrimariesModeNone
    toEnum 1 = VideoPrimariesMode
VideoPrimariesModeMergeOnly
    toEnum 2 = VideoPrimariesMode
VideoPrimariesModeFast
    toEnum k :: Int
k = Int -> VideoPrimariesMode
AnotherVideoPrimariesMode Int
k

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

foreign import ccall "gst_video_primaries_mode_get_type" c_gst_video_primaries_mode_get_type :: 
    IO GType

instance BoxedEnum VideoPrimariesMode where
    boxedEnumType :: VideoPrimariesMode -> IO GType
boxedEnumType _ = IO GType
c_gst_video_primaries_mode_get_type

-- Enum VideoOrientationMethod
-- | The different video orientation methods.
-- 
-- /Since: 1.10/
data VideoOrientationMethod = 
      VideoOrientationMethodIdentity
    -- ^ Identity (no rotation)
    | VideoOrientationMethod90r
    -- ^ Rotate clockwise 90 degrees
    | VideoOrientationMethod180
    -- ^ Rotate 180 degrees
    | VideoOrientationMethod90l
    -- ^ Rotate counter-clockwise 90 degrees
    | VideoOrientationMethodHoriz
    -- ^ Flip horizontally
    | VideoOrientationMethodVert
    -- ^ Flip vertically
    | VideoOrientationMethodUlLr
    -- ^ Flip across upper left\/lower right diagonal
    | VideoOrientationMethodUrLl
    -- ^ Flip across upper right\/lower left diagonal
    | VideoOrientationMethodAuto
    -- ^ Select flip method based on image-orientation tag
    | VideoOrientationMethodCustom
    -- ^ Current status depends on plugin internal setup
    | AnotherVideoOrientationMethod Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoOrientationMethod -> ShowS
[VideoOrientationMethod] -> ShowS
VideoOrientationMethod -> String
(Int -> VideoOrientationMethod -> ShowS)
-> (VideoOrientationMethod -> String)
-> ([VideoOrientationMethod] -> ShowS)
-> Show VideoOrientationMethod
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoOrientationMethod] -> ShowS
$cshowList :: [VideoOrientationMethod] -> ShowS
show :: VideoOrientationMethod -> String
$cshow :: VideoOrientationMethod -> String
showsPrec :: Int -> VideoOrientationMethod -> ShowS
$cshowsPrec :: Int -> VideoOrientationMethod -> ShowS
Show, VideoOrientationMethod -> VideoOrientationMethod -> Bool
(VideoOrientationMethod -> VideoOrientationMethod -> Bool)
-> (VideoOrientationMethod -> VideoOrientationMethod -> Bool)
-> Eq VideoOrientationMethod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoOrientationMethod -> VideoOrientationMethod -> Bool
$c/= :: VideoOrientationMethod -> VideoOrientationMethod -> Bool
== :: VideoOrientationMethod -> VideoOrientationMethod -> Bool
$c== :: VideoOrientationMethod -> VideoOrientationMethod -> Bool
Eq)

instance P.Enum VideoOrientationMethod where
    fromEnum :: VideoOrientationMethod -> Int
fromEnum VideoOrientationMethodIdentity = 0
    fromEnum VideoOrientationMethod90r = 1
    fromEnum VideoOrientationMethod180 = 2
    fromEnum VideoOrientationMethod90l = 3
    fromEnum VideoOrientationMethodHoriz = 4
    fromEnum VideoOrientationMethodVert = 5
    fromEnum VideoOrientationMethodUlLr = 6
    fromEnum VideoOrientationMethodUrLl = 7
    fromEnum VideoOrientationMethodAuto = 8
    fromEnum VideoOrientationMethodCustom = 9
    fromEnum (AnotherVideoOrientationMethod k :: Int
k) = Int
k

    toEnum :: Int -> VideoOrientationMethod
toEnum 0 = VideoOrientationMethod
VideoOrientationMethodIdentity
    toEnum 1 = VideoOrientationMethod
VideoOrientationMethod90r
    toEnum 2 = VideoOrientationMethod
VideoOrientationMethod180
    toEnum 3 = VideoOrientationMethod
VideoOrientationMethod90l
    toEnum 4 = VideoOrientationMethod
VideoOrientationMethodHoriz
    toEnum 5 = VideoOrientationMethod
VideoOrientationMethodVert
    toEnum 6 = VideoOrientationMethod
VideoOrientationMethodUlLr
    toEnum 7 = VideoOrientationMethod
VideoOrientationMethodUrLl
    toEnum 8 = VideoOrientationMethod
VideoOrientationMethodAuto
    toEnum 9 = VideoOrientationMethod
VideoOrientationMethodCustom
    toEnum k :: Int
k = Int -> VideoOrientationMethod
AnotherVideoOrientationMethod Int
k

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

foreign import ccall "gst_video_orientation_method_get_type" c_gst_video_orientation_method_get_type :: 
    IO GType

instance BoxedEnum VideoOrientationMethod where
    boxedEnumType :: VideoOrientationMethod -> IO GType
boxedEnumType _ = IO GType
c_gst_video_orientation_method_get_type

-- Enum VideoMultiviewMode
-- | All possible stereoscopic 3D and multiview representations.
-- In conjunction with t'GI.GstVideo.Flags.VideoMultiviewFlags', describes how
-- multiview content is being transported in the stream.
data VideoMultiviewMode = 
      VideoMultiviewModeNone
    -- ^ A special value indicating
    -- no multiview information. Used in GstVideoInfo and other places to
    -- indicate that no specific multiview handling has been requested or
    -- provided. This value is never carried on caps.
    | VideoMultiviewModeMono
    -- ^ All frames are monoscopic.
    | VideoMultiviewModeLeft
    -- ^ All frames represent a left-eye view.
    | VideoMultiviewModeRight
    -- ^ All frames represent a right-eye view.
    | VideoMultiviewModeSideBySide
    -- ^ Left and right eye views are
    -- provided in the left and right half of the frame respectively.
    | VideoMultiviewModeSideBySideQuincunx
    -- ^ Left and right eye
    -- views are provided in the left and right half of the frame, but
    -- have been sampled using quincunx method, with half-pixel offset
    -- between the 2 views.
    | VideoMultiviewModeColumnInterleaved
    -- ^ Alternating vertical
    -- columns of pixels represent the left and right eye view respectively.
    | VideoMultiviewModeRowInterleaved
    -- ^ Alternating horizontal
    -- rows of pixels represent the left and right eye view respectively.
    | VideoMultiviewModeTopBottom
    -- ^ The top half of the frame
    -- contains the left eye, and the bottom half the right eye.
    | VideoMultiviewModeCheckerboard
    -- ^ Pixels are arranged with
    -- alternating pixels representing left and right eye views in a
    -- checkerboard fashion.
    | VideoMultiviewModeFrameByFrame
    -- ^ Left and right eye views
    -- are provided in separate frames alternately.
    | VideoMultiviewModeMultiviewFrameByFrame
    -- ^ Multiple
    -- independent views are provided in separate frames in sequence.
    -- This method only applies to raw video buffers at the moment.
    -- Specific view identification is via the @/GstVideoMultiviewMeta/@
    -- and t'GI.GstVideo.Structs.VideoMeta.VideoMeta'(s) on raw video buffers.
    | VideoMultiviewModeSeparated
    -- ^ Multiple views are
    -- provided as separate t'GI.Gst.Structs.Memory.Memory' framebuffers attached to each
    -- t'GI.Gst.Structs.Buffer.Buffer', described by the @/GstVideoMultiviewMeta/@
    -- and t'GI.GstVideo.Structs.VideoMeta.VideoMeta'(s)
    | AnotherVideoMultiviewMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoMultiviewMode -> ShowS
[VideoMultiviewMode] -> ShowS
VideoMultiviewMode -> String
(Int -> VideoMultiviewMode -> ShowS)
-> (VideoMultiviewMode -> String)
-> ([VideoMultiviewMode] -> ShowS)
-> Show VideoMultiviewMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoMultiviewMode] -> ShowS
$cshowList :: [VideoMultiviewMode] -> ShowS
show :: VideoMultiviewMode -> String
$cshow :: VideoMultiviewMode -> String
showsPrec :: Int -> VideoMultiviewMode -> ShowS
$cshowsPrec :: Int -> VideoMultiviewMode -> ShowS
Show, VideoMultiviewMode -> VideoMultiviewMode -> Bool
(VideoMultiviewMode -> VideoMultiviewMode -> Bool)
-> (VideoMultiviewMode -> VideoMultiviewMode -> Bool)
-> Eq VideoMultiviewMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoMultiviewMode -> VideoMultiviewMode -> Bool
$c/= :: VideoMultiviewMode -> VideoMultiviewMode -> Bool
== :: VideoMultiviewMode -> VideoMultiviewMode -> Bool
$c== :: VideoMultiviewMode -> VideoMultiviewMode -> Bool
Eq)

instance P.Enum VideoMultiviewMode where
    fromEnum :: VideoMultiviewMode -> Int
fromEnum VideoMultiviewModeNone = -1
    fromEnum VideoMultiviewModeMono = 0
    fromEnum VideoMultiviewModeLeft = 1
    fromEnum VideoMultiviewModeRight = 2
    fromEnum VideoMultiviewModeSideBySide = 3
    fromEnum VideoMultiviewModeSideBySideQuincunx = 4
    fromEnum VideoMultiviewModeColumnInterleaved = 5
    fromEnum VideoMultiviewModeRowInterleaved = 6
    fromEnum VideoMultiviewModeTopBottom = 7
    fromEnum VideoMultiviewModeCheckerboard = 8
    fromEnum VideoMultiviewModeFrameByFrame = 32
    fromEnum VideoMultiviewModeMultiviewFrameByFrame = 33
    fromEnum VideoMultiviewModeSeparated = 34
    fromEnum (AnotherVideoMultiviewMode k :: Int
k) = Int
k

    toEnum :: Int -> VideoMultiviewMode
toEnum -1 = VideoMultiviewMode
VideoMultiviewModeNone
    toEnum 0 = VideoMultiviewMode
VideoMultiviewModeMono
    toEnum 1 = VideoMultiviewMode
VideoMultiviewModeLeft
    toEnum 2 = VideoMultiviewMode
VideoMultiviewModeRight
    toEnum 3 = VideoMultiviewMode
VideoMultiviewModeSideBySide
    toEnum 4 = VideoMultiviewMode
VideoMultiviewModeSideBySideQuincunx
    toEnum 5 = VideoMultiviewMode
VideoMultiviewModeColumnInterleaved
    toEnum 6 = VideoMultiviewMode
VideoMultiviewModeRowInterleaved
    toEnum 7 = VideoMultiviewMode
VideoMultiviewModeTopBottom
    toEnum 8 = VideoMultiviewMode
VideoMultiviewModeCheckerboard
    toEnum 32 = VideoMultiviewMode
VideoMultiviewModeFrameByFrame
    toEnum 33 = VideoMultiviewMode
VideoMultiviewModeMultiviewFrameByFrame
    toEnum 34 = VideoMultiviewMode
VideoMultiviewModeSeparated
    toEnum k :: Int
k = Int -> VideoMultiviewMode
AnotherVideoMultiviewMode Int
k

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

foreign import ccall "gst_video_multiview_mode_get_type" c_gst_video_multiview_mode_get_type :: 
    IO GType

instance BoxedEnum VideoMultiviewMode where
    boxedEnumType :: VideoMultiviewMode -> IO GType
boxedEnumType _ = IO GType
c_gst_video_multiview_mode_get_type

-- Enum VideoMultiviewFramePacking
-- | t'GI.GstVideo.Enums.VideoMultiviewFramePacking' represents the subset of t'GI.GstVideo.Enums.VideoMultiviewMode'
-- values that can be applied to any video frame without needing extra metadata.
-- It can be used by elements that provide a property to override the
-- multiview interpretation of a video stream when the video doesn\'t contain
-- any markers.
-- 
-- This enum is used (for example) on playbin, to re-interpret a played
-- video stream as a stereoscopic video. The individual enum values are
-- equivalent to and have the same value as the matching t'GI.GstVideo.Enums.VideoMultiviewMode'.
data VideoMultiviewFramePacking = 
      VideoMultiviewFramePackingNone
    -- ^ A special value indicating
    -- no frame packing info.
    | VideoMultiviewFramePackingMono
    -- ^ All frames are monoscopic.
    | VideoMultiviewFramePackingLeft
    -- ^ All frames represent a left-eye view.
    | VideoMultiviewFramePackingRight
    -- ^ All frames represent a right-eye view.
    | VideoMultiviewFramePackingSideBySide
    -- ^ Left and right eye views are
    -- provided in the left and right half of the frame respectively.
    | VideoMultiviewFramePackingSideBySideQuincunx
    -- ^ Left and right eye
    -- views are provided in the left and right half of the frame, but
    -- have been sampled using quincunx method, with half-pixel offset
    -- between the 2 views.
    | VideoMultiviewFramePackingColumnInterleaved
    -- ^ Alternating vertical
    -- columns of pixels represent the left and right eye view respectively.
    | VideoMultiviewFramePackingRowInterleaved
    -- ^ Alternating horizontal
    -- rows of pixels represent the left and right eye view respectively.
    | VideoMultiviewFramePackingTopBottom
    -- ^ The top half of the frame
    -- contains the left eye, and the bottom half the right eye.
    | VideoMultiviewFramePackingCheckerboard
    -- ^ Pixels are arranged with
    -- alternating pixels representing left and right eye views in a
    -- checkerboard fashion.
    | AnotherVideoMultiviewFramePacking Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoMultiviewFramePacking -> ShowS
[VideoMultiviewFramePacking] -> ShowS
VideoMultiviewFramePacking -> String
(Int -> VideoMultiviewFramePacking -> ShowS)
-> (VideoMultiviewFramePacking -> String)
-> ([VideoMultiviewFramePacking] -> ShowS)
-> Show VideoMultiviewFramePacking
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoMultiviewFramePacking] -> ShowS
$cshowList :: [VideoMultiviewFramePacking] -> ShowS
show :: VideoMultiviewFramePacking -> String
$cshow :: VideoMultiviewFramePacking -> String
showsPrec :: Int -> VideoMultiviewFramePacking -> ShowS
$cshowsPrec :: Int -> VideoMultiviewFramePacking -> ShowS
Show, VideoMultiviewFramePacking -> VideoMultiviewFramePacking -> Bool
(VideoMultiviewFramePacking -> VideoMultiviewFramePacking -> Bool)
-> (VideoMultiviewFramePacking
    -> VideoMultiviewFramePacking -> Bool)
-> Eq VideoMultiviewFramePacking
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoMultiviewFramePacking -> VideoMultiviewFramePacking -> Bool
$c/= :: VideoMultiviewFramePacking -> VideoMultiviewFramePacking -> Bool
== :: VideoMultiviewFramePacking -> VideoMultiviewFramePacking -> Bool
$c== :: VideoMultiviewFramePacking -> VideoMultiviewFramePacking -> Bool
Eq)

instance P.Enum VideoMultiviewFramePacking where
    fromEnum :: VideoMultiviewFramePacking -> Int
fromEnum VideoMultiviewFramePackingNone = -1
    fromEnum VideoMultiviewFramePackingMono = 0
    fromEnum VideoMultiviewFramePackingLeft = 1
    fromEnum VideoMultiviewFramePackingRight = 2
    fromEnum VideoMultiviewFramePackingSideBySide = 3
    fromEnum VideoMultiviewFramePackingSideBySideQuincunx = 4
    fromEnum VideoMultiviewFramePackingColumnInterleaved = 5
    fromEnum VideoMultiviewFramePackingRowInterleaved = 6
    fromEnum VideoMultiviewFramePackingTopBottom = 7
    fromEnum VideoMultiviewFramePackingCheckerboard = 8
    fromEnum (AnotherVideoMultiviewFramePacking k :: Int
k) = Int
k

    toEnum :: Int -> VideoMultiviewFramePacking
toEnum -1 = VideoMultiviewFramePacking
VideoMultiviewFramePackingNone
    toEnum 0 = VideoMultiviewFramePacking
VideoMultiviewFramePackingMono
    toEnum 1 = VideoMultiviewFramePacking
VideoMultiviewFramePackingLeft
    toEnum 2 = VideoMultiviewFramePacking
VideoMultiviewFramePackingRight
    toEnum 3 = VideoMultiviewFramePacking
VideoMultiviewFramePackingSideBySide
    toEnum 4 = VideoMultiviewFramePacking
VideoMultiviewFramePackingSideBySideQuincunx
    toEnum 5 = VideoMultiviewFramePacking
VideoMultiviewFramePackingColumnInterleaved
    toEnum 6 = VideoMultiviewFramePacking
VideoMultiviewFramePackingRowInterleaved
    toEnum 7 = VideoMultiviewFramePacking
VideoMultiviewFramePackingTopBottom
    toEnum 8 = VideoMultiviewFramePacking
VideoMultiviewFramePackingCheckerboard
    toEnum k :: Int
k = Int -> VideoMultiviewFramePacking
AnotherVideoMultiviewFramePacking Int
k

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

foreign import ccall "gst_video_multiview_frame_packing_get_type" c_gst_video_multiview_frame_packing_get_type :: 
    IO GType

instance BoxedEnum VideoMultiviewFramePacking where
    boxedEnumType :: VideoMultiviewFramePacking -> IO GType
boxedEnumType _ = IO GType
c_gst_video_multiview_frame_packing_get_type

-- Enum VideoMatrixMode
-- | Different color matrix conversion modes
-- 
-- /Since: 1.6/
data VideoMatrixMode = 
      VideoMatrixModeFull
    -- ^ do conversion between color matrices
    | VideoMatrixModeInputOnly
    -- ^ use the input color matrix to convert
    --   to and from R\'G\'B
    | VideoMatrixModeOutputOnly
    -- ^ use the output color matrix to convert
    --   to and from R\'G\'B
    | VideoMatrixModeNone
    -- ^ disable color matrix conversion.
    | AnotherVideoMatrixMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoMatrixMode -> ShowS
[VideoMatrixMode] -> ShowS
VideoMatrixMode -> String
(Int -> VideoMatrixMode -> ShowS)
-> (VideoMatrixMode -> String)
-> ([VideoMatrixMode] -> ShowS)
-> Show VideoMatrixMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoMatrixMode] -> ShowS
$cshowList :: [VideoMatrixMode] -> ShowS
show :: VideoMatrixMode -> String
$cshow :: VideoMatrixMode -> String
showsPrec :: Int -> VideoMatrixMode -> ShowS
$cshowsPrec :: Int -> VideoMatrixMode -> ShowS
Show, VideoMatrixMode -> VideoMatrixMode -> Bool
(VideoMatrixMode -> VideoMatrixMode -> Bool)
-> (VideoMatrixMode -> VideoMatrixMode -> Bool)
-> Eq VideoMatrixMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoMatrixMode -> VideoMatrixMode -> Bool
$c/= :: VideoMatrixMode -> VideoMatrixMode -> Bool
== :: VideoMatrixMode -> VideoMatrixMode -> Bool
$c== :: VideoMatrixMode -> VideoMatrixMode -> Bool
Eq)

instance P.Enum VideoMatrixMode where
    fromEnum :: VideoMatrixMode -> Int
fromEnum VideoMatrixModeFull = 0
    fromEnum VideoMatrixModeInputOnly = 1
    fromEnum VideoMatrixModeOutputOnly = 2
    fromEnum VideoMatrixModeNone = 3
    fromEnum (AnotherVideoMatrixMode k :: Int
k) = Int
k

    toEnum :: Int -> VideoMatrixMode
toEnum 0 = VideoMatrixMode
VideoMatrixModeFull
    toEnum 1 = VideoMatrixMode
VideoMatrixModeInputOnly
    toEnum 2 = VideoMatrixMode
VideoMatrixModeOutputOnly
    toEnum 3 = VideoMatrixMode
VideoMatrixModeNone
    toEnum k :: Int
k = Int -> VideoMatrixMode
AnotherVideoMatrixMode Int
k

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

foreign import ccall "gst_video_matrix_mode_get_type" c_gst_video_matrix_mode_get_type :: 
    IO GType

instance BoxedEnum VideoMatrixMode where
    boxedEnumType :: VideoMatrixMode -> IO GType
boxedEnumType _ = IO GType
c_gst_video_matrix_mode_get_type

-- Enum VideoInterlaceMode
-- | The possible values of the t'GI.GstVideo.Enums.VideoInterlaceMode' describing the interlace
-- mode of the stream.
data VideoInterlaceMode = 
      VideoInterlaceModeProgressive
    -- ^ all frames are progressive
    | VideoInterlaceModeInterleaved
    -- ^ 2 fields are interleaved in one video
    --     frame. Extra buffer flags describe the field order.
    | VideoInterlaceModeMixed
    -- ^ frames contains both interlaced and
    --     progressive video, the buffer flags describe the frame and fields.
    | VideoInterlaceModeFields
    -- ^ 2 fields are stored in one buffer, use the
    --     frame ID to get access to the required field. For multiview (the
    --     \'views\' property > 1) the fields of view N can be found at frame ID
    --     (N * 2) and (N * 2) + 1.
    --     Each field has only half the amount of lines as noted in the
    --     height property. This mode requires multiple GstVideoMeta metadata
    --     to describe the fields.
    | VideoInterlaceModeAlternate
    -- ^ 1 field is stored in one buffer,
    --     /@gSTVIDEOBUFFERFLAGTF@/ or /@gSTVIDEOBUFFERFLAGBF@/ indicates if
    --     the buffer is carrying the top or bottom field, respectively. The top and
    --     bottom buffers are expected to alternate in the pipeline, with this mode
    --     (Since: 1.16).
    | AnotherVideoInterlaceMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoInterlaceMode -> ShowS
[VideoInterlaceMode] -> ShowS
VideoInterlaceMode -> String
(Int -> VideoInterlaceMode -> ShowS)
-> (VideoInterlaceMode -> String)
-> ([VideoInterlaceMode] -> ShowS)
-> Show VideoInterlaceMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoInterlaceMode] -> ShowS
$cshowList :: [VideoInterlaceMode] -> ShowS
show :: VideoInterlaceMode -> String
$cshow :: VideoInterlaceMode -> String
showsPrec :: Int -> VideoInterlaceMode -> ShowS
$cshowsPrec :: Int -> VideoInterlaceMode -> ShowS
Show, VideoInterlaceMode -> VideoInterlaceMode -> Bool
(VideoInterlaceMode -> VideoInterlaceMode -> Bool)
-> (VideoInterlaceMode -> VideoInterlaceMode -> Bool)
-> Eq VideoInterlaceMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoInterlaceMode -> VideoInterlaceMode -> Bool
$c/= :: VideoInterlaceMode -> VideoInterlaceMode -> Bool
== :: VideoInterlaceMode -> VideoInterlaceMode -> Bool
$c== :: VideoInterlaceMode -> VideoInterlaceMode -> Bool
Eq)

instance P.Enum VideoInterlaceMode where
    fromEnum :: VideoInterlaceMode -> Int
fromEnum VideoInterlaceModeProgressive = 0
    fromEnum VideoInterlaceModeInterleaved = 1
    fromEnum VideoInterlaceModeMixed = 2
    fromEnum VideoInterlaceModeFields = 3
    fromEnum VideoInterlaceModeAlternate = 4
    fromEnum (AnotherVideoInterlaceMode k :: Int
k) = Int
k

    toEnum :: Int -> VideoInterlaceMode
toEnum 0 = VideoInterlaceMode
VideoInterlaceModeProgressive
    toEnum 1 = VideoInterlaceMode
VideoInterlaceModeInterleaved
    toEnum 2 = VideoInterlaceMode
VideoInterlaceModeMixed
    toEnum 3 = VideoInterlaceMode
VideoInterlaceModeFields
    toEnum 4 = VideoInterlaceMode
VideoInterlaceModeAlternate
    toEnum k :: Int
k = Int -> VideoInterlaceMode
AnotherVideoInterlaceMode Int
k

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

foreign import ccall "gst_video_interlace_mode_get_type" c_gst_video_interlace_mode_get_type :: 
    IO GType

instance BoxedEnum VideoInterlaceMode where
    boxedEnumType :: VideoInterlaceMode -> IO GType
boxedEnumType _ = IO GType
c_gst_video_interlace_mode_get_type

-- Enum VideoGammaMode
-- | /No description available in the introspection data./
-- 
-- /Since: 1.6/
data VideoGammaMode = 
      VideoGammaModeNone
    -- ^ disable gamma handling
    | VideoGammaModeRemap
    -- ^ convert between input and output gamma
    -- Different gamma conversion modes
    | AnotherVideoGammaMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoGammaMode -> ShowS
[VideoGammaMode] -> ShowS
VideoGammaMode -> String
(Int -> VideoGammaMode -> ShowS)
-> (VideoGammaMode -> String)
-> ([VideoGammaMode] -> ShowS)
-> Show VideoGammaMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoGammaMode] -> ShowS
$cshowList :: [VideoGammaMode] -> ShowS
show :: VideoGammaMode -> String
$cshow :: VideoGammaMode -> String
showsPrec :: Int -> VideoGammaMode -> ShowS
$cshowsPrec :: Int -> VideoGammaMode -> ShowS
Show, VideoGammaMode -> VideoGammaMode -> Bool
(VideoGammaMode -> VideoGammaMode -> Bool)
-> (VideoGammaMode -> VideoGammaMode -> Bool) -> Eq VideoGammaMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoGammaMode -> VideoGammaMode -> Bool
$c/= :: VideoGammaMode -> VideoGammaMode -> Bool
== :: VideoGammaMode -> VideoGammaMode -> Bool
$c== :: VideoGammaMode -> VideoGammaMode -> Bool
Eq)

instance P.Enum VideoGammaMode where
    fromEnum :: VideoGammaMode -> Int
fromEnum VideoGammaModeNone = 0
    fromEnum VideoGammaModeRemap = 1
    fromEnum (AnotherVideoGammaMode k :: Int
k) = Int
k

    toEnum :: Int -> VideoGammaMode
toEnum 0 = VideoGammaMode
VideoGammaModeNone
    toEnum 1 = VideoGammaMode
VideoGammaModeRemap
    toEnum k :: Int
k = Int -> VideoGammaMode
AnotherVideoGammaMode Int
k

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

foreign import ccall "gst_video_gamma_mode_get_type" c_gst_video_gamma_mode_get_type :: 
    IO GType

instance BoxedEnum VideoGammaMode where
    boxedEnumType :: VideoGammaMode -> IO GType
boxedEnumType _ = IO GType
c_gst_video_gamma_mode_get_type

-- Enum VideoGLTextureType
-- | The GL texture type.
data VideoGLTextureType = 
      VideoGLTextureTypeLuminance
    -- ^ Luminance texture, GL_LUMINANCE
    | VideoGLTextureTypeLuminanceAlpha
    -- ^ Luminance-alpha texture, GL_LUMINANCE_ALPHA
    | VideoGLTextureTypeRgb16
    -- ^ RGB 565 texture, GL_RGB
    | VideoGLTextureTypeRgb
    -- ^ RGB texture, GL_RGB
    | VideoGLTextureTypeRgba
    -- ^ RGBA texture, GL_RGBA
    | VideoGLTextureTypeR
    -- ^ R texture, GL_RED_EXT
    | VideoGLTextureTypeRg
    -- ^ RG texture, GL_RG_EXT
    | AnotherVideoGLTextureType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoGLTextureType -> ShowS
[VideoGLTextureType] -> ShowS
VideoGLTextureType -> String
(Int -> VideoGLTextureType -> ShowS)
-> (VideoGLTextureType -> String)
-> ([VideoGLTextureType] -> ShowS)
-> Show VideoGLTextureType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoGLTextureType] -> ShowS
$cshowList :: [VideoGLTextureType] -> ShowS
show :: VideoGLTextureType -> String
$cshow :: VideoGLTextureType -> String
showsPrec :: Int -> VideoGLTextureType -> ShowS
$cshowsPrec :: Int -> VideoGLTextureType -> ShowS
Show, VideoGLTextureType -> VideoGLTextureType -> Bool
(VideoGLTextureType -> VideoGLTextureType -> Bool)
-> (VideoGLTextureType -> VideoGLTextureType -> Bool)
-> Eq VideoGLTextureType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoGLTextureType -> VideoGLTextureType -> Bool
$c/= :: VideoGLTextureType -> VideoGLTextureType -> Bool
== :: VideoGLTextureType -> VideoGLTextureType -> Bool
$c== :: VideoGLTextureType -> VideoGLTextureType -> Bool
Eq)

instance P.Enum VideoGLTextureType where
    fromEnum :: VideoGLTextureType -> Int
fromEnum VideoGLTextureTypeLuminance = 0
    fromEnum VideoGLTextureTypeLuminanceAlpha = 1
    fromEnum VideoGLTextureTypeRgb16 = 2
    fromEnum VideoGLTextureTypeRgb = 3
    fromEnum VideoGLTextureTypeRgba = 4
    fromEnum VideoGLTextureTypeR = 5
    fromEnum VideoGLTextureTypeRg = 6
    fromEnum (AnotherVideoGLTextureType k :: Int
k) = Int
k

    toEnum :: Int -> VideoGLTextureType
toEnum 0 = VideoGLTextureType
VideoGLTextureTypeLuminance
    toEnum 1 = VideoGLTextureType
VideoGLTextureTypeLuminanceAlpha
    toEnum 2 = VideoGLTextureType
VideoGLTextureTypeRgb16
    toEnum 3 = VideoGLTextureType
VideoGLTextureTypeRgb
    toEnum 4 = VideoGLTextureType
VideoGLTextureTypeRgba
    toEnum 5 = VideoGLTextureType
VideoGLTextureTypeR
    toEnum 6 = VideoGLTextureType
VideoGLTextureTypeRg
    toEnum k :: Int
k = Int -> VideoGLTextureType
AnotherVideoGLTextureType Int
k

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

-- Enum VideoGLTextureOrientation
-- | The orientation of the GL texture.
data VideoGLTextureOrientation = 
      VideoGLTextureOrientationNormalYNormal
    -- ^ Top line first in memory, left row first
    | VideoGLTextureOrientationNormalYFlip
    -- ^ Bottom line first in memory, left row first
    | VideoGLTextureOrientationFlipYNormal
    -- ^ Top line first in memory, right row first
    | VideoGLTextureOrientationFlipYFlip
    -- ^ Bottom line first in memory, right row first
    | AnotherVideoGLTextureOrientation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoGLTextureOrientation -> ShowS
[VideoGLTextureOrientation] -> ShowS
VideoGLTextureOrientation -> String
(Int -> VideoGLTextureOrientation -> ShowS)
-> (VideoGLTextureOrientation -> String)
-> ([VideoGLTextureOrientation] -> ShowS)
-> Show VideoGLTextureOrientation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoGLTextureOrientation] -> ShowS
$cshowList :: [VideoGLTextureOrientation] -> ShowS
show :: VideoGLTextureOrientation -> String
$cshow :: VideoGLTextureOrientation -> String
showsPrec :: Int -> VideoGLTextureOrientation -> ShowS
$cshowsPrec :: Int -> VideoGLTextureOrientation -> ShowS
Show, VideoGLTextureOrientation -> VideoGLTextureOrientation -> Bool
(VideoGLTextureOrientation -> VideoGLTextureOrientation -> Bool)
-> (VideoGLTextureOrientation -> VideoGLTextureOrientation -> Bool)
-> Eq VideoGLTextureOrientation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoGLTextureOrientation -> VideoGLTextureOrientation -> Bool
$c/= :: VideoGLTextureOrientation -> VideoGLTextureOrientation -> Bool
== :: VideoGLTextureOrientation -> VideoGLTextureOrientation -> Bool
$c== :: VideoGLTextureOrientation -> VideoGLTextureOrientation -> Bool
Eq)

instance P.Enum VideoGLTextureOrientation where
    fromEnum :: VideoGLTextureOrientation -> Int
fromEnum VideoGLTextureOrientationNormalYNormal = 0
    fromEnum VideoGLTextureOrientationNormalYFlip = 1
    fromEnum VideoGLTextureOrientationFlipYNormal = 2
    fromEnum VideoGLTextureOrientationFlipYFlip = 3
    fromEnum (AnotherVideoGLTextureOrientation k :: Int
k) = Int
k

    toEnum :: Int -> VideoGLTextureOrientation
toEnum 0 = VideoGLTextureOrientation
VideoGLTextureOrientationNormalYNormal
    toEnum 1 = VideoGLTextureOrientation
VideoGLTextureOrientationNormalYFlip
    toEnum 2 = VideoGLTextureOrientation
VideoGLTextureOrientationFlipYNormal
    toEnum 3 = VideoGLTextureOrientation
VideoGLTextureOrientationFlipYFlip
    toEnum k :: Int
k = Int -> VideoGLTextureOrientation
AnotherVideoGLTextureOrientation Int
k

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

-- Enum VideoFormat
-- | Enum value describing the most common video formats.
-- 
-- See the <https://gstreamer.freedesktop.org/documentation/design/mediatype-video-raw.html#formats GStreamer raw video format design document>
-- for details about the layout and packing of these formats in memory.
data VideoFormat = 
      VideoFormatUnknown
    -- ^ Unknown or unset video format id
    | VideoFormatEncoded
    -- ^ Encoded video format. Only ever use that in caps for
    --                            special video formats in combination with non-system
    --                            memory GstCapsFeatures where it does not make sense
    --                            to specify a real video format.
    | VideoFormatI420
    -- ^ planar 4:2:0 YUV
    | VideoFormatYv12
    -- ^ planar 4:2:0 YVU (like I420 but UV planes swapped)
    | VideoFormatYuy2
    -- ^ packed 4:2:2 YUV (Y0-U0-Y1-V0 Y2-U2-Y3-V2 Y4 ...)
    | VideoFormatUyvy
    -- ^ packed 4:2:2 YUV (U0-Y0-V0-Y1 U2-Y2-V2-Y3 U4 ...)
    | VideoFormatAyuv
    -- ^ packed 4:4:4 YUV with alpha channel (A0-Y0-U0-V0 ...)
    | VideoFormatRgbx
    -- ^ sparse rgb packed into 32 bit, space last
    | VideoFormatBgrx
    -- ^ sparse reverse rgb packed into 32 bit, space last
    | VideoFormatXrgb
    -- ^ sparse rgb packed into 32 bit, space first
    | VideoFormatXbgr
    -- ^ sparse reverse rgb packed into 32 bit, space first
    | VideoFormatRgba
    -- ^ rgb with alpha channel last
    | VideoFormatBgra
    -- ^ reverse rgb with alpha channel last
    | VideoFormatArgb
    -- ^ rgb with alpha channel first
    | VideoFormatAbgr
    -- ^ reverse rgb with alpha channel first
    | VideoFormatRgb
    -- ^ RGB packed into 24 bits without padding (@R-G-B-R-G-B@)
    | VideoFormatBgr
    -- ^ reverse RGB packed into 24 bits without padding (@B-G-R-B-G-R@)
    | VideoFormatY41b
    -- ^ planar 4:1:1 YUV
    | VideoFormatY42b
    -- ^ planar 4:2:2 YUV
    | VideoFormatYvyu
    -- ^ packed 4:2:2 YUV (Y0-V0-Y1-U0 Y2-V2-Y3-U2 Y4 ...)
    | VideoFormatY444
    -- ^ planar 4:4:4 YUV
    | VideoFormatV210
    -- ^ packed 4:2:2 10-bit YUV, complex format
    | VideoFormatV216
    -- ^ packed 4:2:2 16-bit YUV, Y0-U0-Y1-V1 order
    | VideoFormatNv12
    -- ^ planar 4:2:0 YUV with interleaved UV plane
    | VideoFormatNv21
    -- ^ planar 4:2:0 YUV with interleaved VU plane
    | VideoFormatGray8
    -- ^ 8-bit grayscale
    | VideoFormatGray16Be
    -- ^ 16-bit grayscale, most significant byte first
    | VideoFormatGray16Le
    -- ^ 16-bit grayscale, least significant byte first
    | VideoFormatV308
    -- ^ packed 4:4:4 YUV (Y-U-V ...)
    | VideoFormatRgb16
    -- ^ rgb 5-6-5 bits per component
    | VideoFormatBgr16
    -- ^ reverse rgb 5-6-5 bits per component
    | VideoFormatRgb15
    -- ^ rgb 5-5-5 bits per component
    | VideoFormatBgr15
    -- ^ reverse rgb 5-5-5 bits per component
    | VideoFormatUyvp
    -- ^ packed 10-bit 4:2:2 YUV (U0-Y0-V0-Y1 U2-Y2-V2-Y3 U4 ...)
    | VideoFormatA420
    -- ^ planar 4:4:2:0 AYUV
    | VideoFormatRgb8p
    -- ^ 8-bit paletted RGB
    | VideoFormatYuv9
    -- ^ planar 4:1:0 YUV
    | VideoFormatYvu9
    -- ^ planar 4:1:0 YUV (like YUV9 but UV planes swapped)
    | VideoFormatIyu1
    -- ^ packed 4:1:1 YUV (Cb-Y0-Y1-Cr-Y2-Y3 ...)
    | VideoFormatArgb64
    -- ^ rgb with alpha channel first, 16 bits per channel
    | VideoFormatAyuv64
    -- ^ packed 4:4:4 YUV with alpha channel, 16 bits per channel (A0-Y0-U0-V0 ...)
    | VideoFormatR210
    -- ^ packed 4:4:4 RGB, 10 bits per channel
    | VideoFormatI42010be
    -- ^ planar 4:2:0 YUV, 10 bits per channel
    | VideoFormatI42010le
    -- ^ planar 4:2:0 YUV, 10 bits per channel
    | VideoFormatI42210be
    -- ^ planar 4:2:2 YUV, 10 bits per channel
    | VideoFormatI42210le
    -- ^ planar 4:2:2 YUV, 10 bits per channel
    | VideoFormatY44410be
    -- ^ planar 4:4:4 YUV, 10 bits per channel (Since: 1.2)
    | VideoFormatY44410le
    -- ^ planar 4:4:4 YUV, 10 bits per channel (Since: 1.2)
    | VideoFormatGbr
    -- ^ planar 4:4:4 RGB, 8 bits per channel (Since: 1.2)
    | VideoFormatGbr10be
    -- ^ planar 4:4:4 RGB, 10 bits per channel (Since: 1.2)
    | VideoFormatGbr10le
    -- ^ planar 4:4:4 RGB, 10 bits per channel (Since: 1.2)
    | VideoFormatNv16
    -- ^ planar 4:2:2 YUV with interleaved UV plane (Since: 1.2)
    | VideoFormatNv24
    -- ^ planar 4:4:4 YUV with interleaved UV plane (Since: 1.2)
    | VideoFormatNv1264z32
    -- ^ NV12 with 64x32 tiling in zigzag pattern (Since: 1.4)
    | VideoFormatA42010be
    -- ^ planar 4:4:2:0 YUV, 10 bits per channel (Since: 1.6)
    | VideoFormatA42010le
    -- ^ planar 4:4:2:0 YUV, 10 bits per channel (Since: 1.6)
    | VideoFormatA42210be
    -- ^ planar 4:4:2:2 YUV, 10 bits per channel (Since: 1.6)
    | VideoFormatA42210le
    -- ^ planar 4:4:2:2 YUV, 10 bits per channel (Since: 1.6)
    | VideoFormatA44410be
    -- ^ planar 4:4:4:4 YUV, 10 bits per channel (Since: 1.6)
    | VideoFormatA44410le
    -- ^ planar 4:4:4:4 YUV, 10 bits per channel (Since: 1.6)
    | VideoFormatNv61
    -- ^ planar 4:2:2 YUV with interleaved VU plane (Since: 1.6)
    | VideoFormatP01010be
    -- ^ planar 4:2:0 YUV with interleaved UV plane, 10 bits per channel (Since: 1.10)
    | VideoFormatP01010le
    -- ^ planar 4:2:0 YUV with interleaved UV plane, 10 bits per channel (Since: 1.10)
    | VideoFormatIyu2
    -- ^ packed 4:4:4 YUV (U-Y-V ...) (Since 1.10)
    | VideoFormatVyuy
    -- ^ packed 4:2:2 YUV (V0-Y0-U0-Y1 V2-Y2-U2-Y3 V4 ...)
    | VideoFormatGbra
    -- ^ planar 4:4:4:4 ARGB, 8 bits per channel (Since: 1.12)
    | VideoFormatGbra10be
    -- ^ planar 4:4:4:4 ARGB, 10 bits per channel (Since: 1.12)
    | VideoFormatGbra10le
    -- ^ planar 4:4:4:4 ARGB, 10 bits per channel (Since: 1.12)
    | VideoFormatGbr12be
    -- ^ planar 4:4:4 RGB, 12 bits per channel (Since: 1.12)
    | VideoFormatGbr12le
    -- ^ planar 4:4:4 RGB, 12 bits per channel (Since: 1.12)
    | VideoFormatGbra12be
    -- ^ planar 4:4:4:4 ARGB, 12 bits per channel (Since: 1.12)
    | VideoFormatGbra12le
    -- ^ planar 4:4:4:4 ARGB, 12 bits per channel (Since: 1.12)
    | VideoFormatI42012be
    -- ^ planar 4:2:0 YUV, 12 bits per channel (Since: 1.12)
    | VideoFormatI42012le
    -- ^ planar 4:2:0 YUV, 12 bits per channel (Since: 1.12)
    | VideoFormatI42212be
    -- ^ planar 4:2:2 YUV, 12 bits per channel (Since: 1.12)
    | VideoFormatI42212le
    -- ^ planar 4:2:2 YUV, 12 bits per channel (Since: 1.12)
    | VideoFormatY44412be
    -- ^ planar 4:4:4 YUV, 12 bits per channel (Since: 1.12)
    | VideoFormatY44412le
    -- ^ planar 4:4:4 YUV, 12 bits per channel (Since: 1.12)
    | VideoFormatGray10Le32
    -- ^ 10-bit grayscale, packed into 32bit words (2 bits padding) (Since: 1.14)
    | VideoFormatNv1210le32
    -- ^ 10-bit variant of /@gSTVIDEOFORMATNV12@/, packed into 32bit words (MSB 2 bits padding) (Since: 1.14)
    | VideoFormatNv1610le32
    -- ^ 10-bit variant of /@gSTVIDEOFORMATNV16@/, packed into 32bit words (MSB 2 bits padding) (Since: 1.14)
    | VideoFormatNv1210le40
    -- ^ Fully packed variant of NV12_10LE32 (Since: 1.16)
    | VideoFormatY210
    -- ^ packed 4:2:2 YUV, 10 bits per channel (Since: 1.16)
    | VideoFormatY410
    -- ^ packed 4:4:4 YUV, 10 bits per channel(A-V-Y-U...) (Since: 1.16)
    | VideoFormatVuya
    -- ^ packed 4:4:4 YUV with alpha channel (V0-U0-Y0-A0...) (Since: 1.16)
    | VideoFormatBgr10a2Le
    -- ^ packed 4:4:4 RGB with alpha channel(B-G-R-A), 10 bits for R\/G\/B channel and MSB 2 bits for alpha channel (Since: 1.16)
    | AnotherVideoFormat Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoFormat -> ShowS
[VideoFormat] -> ShowS
VideoFormat -> String
(Int -> VideoFormat -> ShowS)
-> (VideoFormat -> String)
-> ([VideoFormat] -> ShowS)
-> Show VideoFormat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoFormat] -> ShowS
$cshowList :: [VideoFormat] -> ShowS
show :: VideoFormat -> String
$cshow :: VideoFormat -> String
showsPrec :: Int -> VideoFormat -> ShowS
$cshowsPrec :: Int -> VideoFormat -> ShowS
Show, VideoFormat -> VideoFormat -> Bool
(VideoFormat -> VideoFormat -> Bool)
-> (VideoFormat -> VideoFormat -> Bool) -> Eq VideoFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoFormat -> VideoFormat -> Bool
$c/= :: VideoFormat -> VideoFormat -> Bool
== :: VideoFormat -> VideoFormat -> Bool
$c== :: VideoFormat -> VideoFormat -> Bool
Eq)

instance P.Enum VideoFormat where
    fromEnum :: VideoFormat -> Int
fromEnum VideoFormatUnknown = 0
    fromEnum VideoFormatEncoded = 1
    fromEnum VideoFormatI420 = 2
    fromEnum VideoFormatYv12 = 3
    fromEnum VideoFormatYuy2 = 4
    fromEnum VideoFormatUyvy = 5
    fromEnum VideoFormatAyuv = 6
    fromEnum VideoFormatRgbx = 7
    fromEnum VideoFormatBgrx = 8
    fromEnum VideoFormatXrgb = 9
    fromEnum VideoFormatXbgr = 10
    fromEnum VideoFormatRgba = 11
    fromEnum VideoFormatBgra = 12
    fromEnum VideoFormatArgb = 13
    fromEnum VideoFormatAbgr = 14
    fromEnum VideoFormatRgb = 15
    fromEnum VideoFormatBgr = 16
    fromEnum VideoFormatY41b = 17
    fromEnum VideoFormatY42b = 18
    fromEnum VideoFormatYvyu = 19
    fromEnum VideoFormatY444 = 20
    fromEnum VideoFormatV210 = 21
    fromEnum VideoFormatV216 = 22
    fromEnum VideoFormatNv12 = 23
    fromEnum VideoFormatNv21 = 24
    fromEnum VideoFormatGray8 = 25
    fromEnum VideoFormatGray16Be = 26
    fromEnum VideoFormatGray16Le = 27
    fromEnum VideoFormatV308 = 28
    fromEnum VideoFormatRgb16 = 29
    fromEnum VideoFormatBgr16 = 30
    fromEnum VideoFormatRgb15 = 31
    fromEnum VideoFormatBgr15 = 32
    fromEnum VideoFormatUyvp = 33
    fromEnum VideoFormatA420 = 34
    fromEnum VideoFormatRgb8p = 35
    fromEnum VideoFormatYuv9 = 36
    fromEnum VideoFormatYvu9 = 37
    fromEnum VideoFormatIyu1 = 38
    fromEnum VideoFormatArgb64 = 39
    fromEnum VideoFormatAyuv64 = 40
    fromEnum VideoFormatR210 = 41
    fromEnum VideoFormatI42010be = 42
    fromEnum VideoFormatI42010le = 43
    fromEnum VideoFormatI42210be = 44
    fromEnum VideoFormatI42210le = 45
    fromEnum VideoFormatY44410be = 46
    fromEnum VideoFormatY44410le = 47
    fromEnum VideoFormatGbr = 48
    fromEnum VideoFormatGbr10be = 49
    fromEnum VideoFormatGbr10le = 50
    fromEnum VideoFormatNv16 = 51
    fromEnum VideoFormatNv24 = 52
    fromEnum VideoFormatNv1264z32 = 53
    fromEnum VideoFormatA42010be = 54
    fromEnum VideoFormatA42010le = 55
    fromEnum VideoFormatA42210be = 56
    fromEnum VideoFormatA42210le = 57
    fromEnum VideoFormatA44410be = 58
    fromEnum VideoFormatA44410le = 59
    fromEnum VideoFormatNv61 = 60
    fromEnum VideoFormatP01010be = 61
    fromEnum VideoFormatP01010le = 62
    fromEnum VideoFormatIyu2 = 63
    fromEnum VideoFormatVyuy = 64
    fromEnum VideoFormatGbra = 65
    fromEnum VideoFormatGbra10be = 66
    fromEnum VideoFormatGbra10le = 67
    fromEnum VideoFormatGbr12be = 68
    fromEnum VideoFormatGbr12le = 69
    fromEnum VideoFormatGbra12be = 70
    fromEnum VideoFormatGbra12le = 71
    fromEnum VideoFormatI42012be = 72
    fromEnum VideoFormatI42012le = 73
    fromEnum VideoFormatI42212be = 74
    fromEnum VideoFormatI42212le = 75
    fromEnum VideoFormatY44412be = 76
    fromEnum VideoFormatY44412le = 77
    fromEnum VideoFormatGray10Le32 = 78
    fromEnum VideoFormatNv1210le32 = 79
    fromEnum VideoFormatNv1610le32 = 80
    fromEnum VideoFormatNv1210le40 = 81
    fromEnum VideoFormatY210 = 82
    fromEnum VideoFormatY410 = 83
    fromEnum VideoFormatVuya = 84
    fromEnum VideoFormatBgr10a2Le = 85
    fromEnum (AnotherVideoFormat k :: Int
k) = Int
k

    toEnum :: Int -> VideoFormat
toEnum 0 = VideoFormat
VideoFormatUnknown
    toEnum 1 = VideoFormat
VideoFormatEncoded
    toEnum 2 = VideoFormat
VideoFormatI420
    toEnum 3 = VideoFormat
VideoFormatYv12
    toEnum 4 = VideoFormat
VideoFormatYuy2
    toEnum 5 = VideoFormat
VideoFormatUyvy
    toEnum 6 = VideoFormat
VideoFormatAyuv
    toEnum 7 = VideoFormat
VideoFormatRgbx
    toEnum 8 = VideoFormat
VideoFormatBgrx
    toEnum 9 = VideoFormat
VideoFormatXrgb
    toEnum 10 = VideoFormat
VideoFormatXbgr
    toEnum 11 = VideoFormat
VideoFormatRgba
    toEnum 12 = VideoFormat
VideoFormatBgra
    toEnum 13 = VideoFormat
VideoFormatArgb
    toEnum 14 = VideoFormat
VideoFormatAbgr
    toEnum 15 = VideoFormat
VideoFormatRgb
    toEnum 16 = VideoFormat
VideoFormatBgr
    toEnum 17 = VideoFormat
VideoFormatY41b
    toEnum 18 = VideoFormat
VideoFormatY42b
    toEnum 19 = VideoFormat
VideoFormatYvyu
    toEnum 20 = VideoFormat
VideoFormatY444
    toEnum 21 = VideoFormat
VideoFormatV210
    toEnum 22 = VideoFormat
VideoFormatV216
    toEnum 23 = VideoFormat
VideoFormatNv12
    toEnum 24 = VideoFormat
VideoFormatNv21
    toEnum 25 = VideoFormat
VideoFormatGray8
    toEnum 26 = VideoFormat
VideoFormatGray16Be
    toEnum 27 = VideoFormat
VideoFormatGray16Le
    toEnum 28 = VideoFormat
VideoFormatV308
    toEnum 29 = VideoFormat
VideoFormatRgb16
    toEnum 30 = VideoFormat
VideoFormatBgr16
    toEnum 31 = VideoFormat
VideoFormatRgb15
    toEnum 32 = VideoFormat
VideoFormatBgr15
    toEnum 33 = VideoFormat
VideoFormatUyvp
    toEnum 34 = VideoFormat
VideoFormatA420
    toEnum 35 = VideoFormat
VideoFormatRgb8p
    toEnum 36 = VideoFormat
VideoFormatYuv9
    toEnum 37 = VideoFormat
VideoFormatYvu9
    toEnum 38 = VideoFormat
VideoFormatIyu1
    toEnum 39 = VideoFormat
VideoFormatArgb64
    toEnum 40 = VideoFormat
VideoFormatAyuv64
    toEnum 41 = VideoFormat
VideoFormatR210
    toEnum 42 = VideoFormat
VideoFormatI42010be
    toEnum 43 = VideoFormat
VideoFormatI42010le
    toEnum 44 = VideoFormat
VideoFormatI42210be
    toEnum 45 = VideoFormat
VideoFormatI42210le
    toEnum 46 = VideoFormat
VideoFormatY44410be
    toEnum 47 = VideoFormat
VideoFormatY44410le
    toEnum 48 = VideoFormat
VideoFormatGbr
    toEnum 49 = VideoFormat
VideoFormatGbr10be
    toEnum 50 = VideoFormat
VideoFormatGbr10le
    toEnum 51 = VideoFormat
VideoFormatNv16
    toEnum 52 = VideoFormat
VideoFormatNv24
    toEnum 53 = VideoFormat
VideoFormatNv1264z32
    toEnum 54 = VideoFormat
VideoFormatA42010be
    toEnum 55 = VideoFormat
VideoFormatA42010le
    toEnum 56 = VideoFormat
VideoFormatA42210be
    toEnum 57 = VideoFormat
VideoFormatA42210le
    toEnum 58 = VideoFormat
VideoFormatA44410be
    toEnum 59 = VideoFormat
VideoFormatA44410le
    toEnum 60 = VideoFormat
VideoFormatNv61
    toEnum 61 = VideoFormat
VideoFormatP01010be
    toEnum 62 = VideoFormat
VideoFormatP01010le
    toEnum 63 = VideoFormat
VideoFormatIyu2
    toEnum 64 = VideoFormat
VideoFormatVyuy
    toEnum 65 = VideoFormat
VideoFormatGbra
    toEnum 66 = VideoFormat
VideoFormatGbra10be
    toEnum 67 = VideoFormat
VideoFormatGbra10le
    toEnum 68 = VideoFormat
VideoFormatGbr12be
    toEnum 69 = VideoFormat
VideoFormatGbr12le
    toEnum 70 = VideoFormat
VideoFormatGbra12be
    toEnum 71 = VideoFormat
VideoFormatGbra12le
    toEnum 72 = VideoFormat
VideoFormatI42012be
    toEnum 73 = VideoFormat
VideoFormatI42012le
    toEnum 74 = VideoFormat
VideoFormatI42212be
    toEnum 75 = VideoFormat
VideoFormatI42212le
    toEnum 76 = VideoFormat
VideoFormatY44412be
    toEnum 77 = VideoFormat
VideoFormatY44412le
    toEnum 78 = VideoFormat
VideoFormatGray10Le32
    toEnum 79 = VideoFormat
VideoFormatNv1210le32
    toEnum 80 = VideoFormat
VideoFormatNv1610le32
    toEnum 81 = VideoFormat
VideoFormatNv1210le40
    toEnum 82 = VideoFormat
VideoFormatY210
    toEnum 83 = VideoFormat
VideoFormatY410
    toEnum 84 = VideoFormat
VideoFormatVuya
    toEnum 85 = VideoFormat
VideoFormatBgr10a2Le
    toEnum k :: Int
k = Int -> VideoFormat
AnotherVideoFormat Int
k

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

foreign import ccall "gst_video_format_get_type" c_gst_video_format_get_type :: 
    IO GType

instance BoxedEnum VideoFormat where
    boxedEnumType :: VideoFormat -> IO GType
boxedEnumType _ = IO GType
c_gst_video_format_get_type

-- Enum VideoFieldOrder
-- | Field order of interlaced content. This is only valid for
-- interlace-mode=interleaved and not interlace-mode=mixed. In the case of
-- mixed or GST_VIDEO_FIELD_ORDER_UNKOWN, the field order is signalled via
-- buffer flags.
-- 
-- /Since: 1.12/
data VideoFieldOrder = 
      VideoFieldOrderUnknown
    -- ^ unknown field order for interlaced content.
    --     The actual field order is signalled via buffer flags.
    | VideoFieldOrderTopFieldFirst
    -- ^ top field is first
    | VideoFieldOrderBottomFieldFirst
    -- ^ bottom field is first
    | AnotherVideoFieldOrder Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoFieldOrder -> ShowS
[VideoFieldOrder] -> ShowS
VideoFieldOrder -> String
(Int -> VideoFieldOrder -> ShowS)
-> (VideoFieldOrder -> String)
-> ([VideoFieldOrder] -> ShowS)
-> Show VideoFieldOrder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoFieldOrder] -> ShowS
$cshowList :: [VideoFieldOrder] -> ShowS
show :: VideoFieldOrder -> String
$cshow :: VideoFieldOrder -> String
showsPrec :: Int -> VideoFieldOrder -> ShowS
$cshowsPrec :: Int -> VideoFieldOrder -> ShowS
Show, VideoFieldOrder -> VideoFieldOrder -> Bool
(VideoFieldOrder -> VideoFieldOrder -> Bool)
-> (VideoFieldOrder -> VideoFieldOrder -> Bool)
-> Eq VideoFieldOrder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoFieldOrder -> VideoFieldOrder -> Bool
$c/= :: VideoFieldOrder -> VideoFieldOrder -> Bool
== :: VideoFieldOrder -> VideoFieldOrder -> Bool
$c== :: VideoFieldOrder -> VideoFieldOrder -> Bool
Eq)

instance P.Enum VideoFieldOrder where
    fromEnum :: VideoFieldOrder -> Int
fromEnum VideoFieldOrderUnknown = 0
    fromEnum VideoFieldOrderTopFieldFirst = 1
    fromEnum VideoFieldOrderBottomFieldFirst = 2
    fromEnum (AnotherVideoFieldOrder k :: Int
k) = Int
k

    toEnum :: Int -> VideoFieldOrder
toEnum 0 = VideoFieldOrder
VideoFieldOrderUnknown
    toEnum 1 = VideoFieldOrder
VideoFieldOrderTopFieldFirst
    toEnum 2 = VideoFieldOrder
VideoFieldOrderBottomFieldFirst
    toEnum k :: Int
k = Int -> VideoFieldOrder
AnotherVideoFieldOrder Int
k

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

foreign import ccall "gst_video_field_order_get_type" c_gst_video_field_order_get_type :: 
    IO GType

instance BoxedEnum VideoFieldOrder where
    boxedEnumType :: VideoFieldOrder -> IO GType
boxedEnumType _ = IO GType
c_gst_video_field_order_get_type

-- Enum VideoDitherMethod
-- | Different dithering methods to use.
data VideoDitherMethod = 
      VideoDitherMethodNone
    -- ^ no dithering
    | VideoDitherMethodVerterr
    -- ^ propagate rounding errors downwards
    | VideoDitherMethodFloydSteinberg
    -- ^ Dither with floyd-steinberg error diffusion
    | VideoDitherMethodSierraLite
    -- ^ Dither with Sierra Lite error diffusion
    | VideoDitherMethodBayer
    -- ^ ordered dither using a bayer pattern
    | AnotherVideoDitherMethod Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoDitherMethod -> ShowS
[VideoDitherMethod] -> ShowS
VideoDitherMethod -> String
(Int -> VideoDitherMethod -> ShowS)
-> (VideoDitherMethod -> String)
-> ([VideoDitherMethod] -> ShowS)
-> Show VideoDitherMethod
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoDitherMethod] -> ShowS
$cshowList :: [VideoDitherMethod] -> ShowS
show :: VideoDitherMethod -> String
$cshow :: VideoDitherMethod -> String
showsPrec :: Int -> VideoDitherMethod -> ShowS
$cshowsPrec :: Int -> VideoDitherMethod -> ShowS
Show, VideoDitherMethod -> VideoDitherMethod -> Bool
(VideoDitherMethod -> VideoDitherMethod -> Bool)
-> (VideoDitherMethod -> VideoDitherMethod -> Bool)
-> Eq VideoDitherMethod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoDitherMethod -> VideoDitherMethod -> Bool
$c/= :: VideoDitherMethod -> VideoDitherMethod -> Bool
== :: VideoDitherMethod -> VideoDitherMethod -> Bool
$c== :: VideoDitherMethod -> VideoDitherMethod -> Bool
Eq)

instance P.Enum VideoDitherMethod where
    fromEnum :: VideoDitherMethod -> Int
fromEnum VideoDitherMethodNone = 0
    fromEnum VideoDitherMethodVerterr = 1
    fromEnum VideoDitherMethodFloydSteinberg = 2
    fromEnum VideoDitherMethodSierraLite = 3
    fromEnum VideoDitherMethodBayer = 4
    fromEnum (AnotherVideoDitherMethod k :: Int
k) = Int
k

    toEnum :: Int -> VideoDitherMethod
toEnum 0 = VideoDitherMethod
VideoDitherMethodNone
    toEnum 1 = VideoDitherMethod
VideoDitherMethodVerterr
    toEnum 2 = VideoDitherMethod
VideoDitherMethodFloydSteinberg
    toEnum 3 = VideoDitherMethod
VideoDitherMethodSierraLite
    toEnum 4 = VideoDitherMethod
VideoDitherMethodBayer
    toEnum k :: Int
k = Int -> VideoDitherMethod
AnotherVideoDitherMethod Int
k

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

foreign import ccall "gst_video_dither_method_get_type" c_gst_video_dither_method_get_type :: 
    IO GType

instance BoxedEnum VideoDitherMethod where
    boxedEnumType :: VideoDitherMethod -> IO GType
boxedEnumType _ = IO GType
c_gst_video_dither_method_get_type

-- Enum VideoColorRange
-- | Possible color range values. These constants are defined for 8 bit color
-- values and can be scaled for other bit depths.
data VideoColorRange = 
      VideoColorRangeUnknown
    -- ^ unknown range
    | VideoColorRange0255
    -- ^ [0..255] for 8 bit components
    | VideoColorRange16235
    -- ^ [16..235] for 8 bit components. Chroma has
    --                 [16..240] range.
    | AnotherVideoColorRange Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoColorRange -> ShowS
[VideoColorRange] -> ShowS
VideoColorRange -> String
(Int -> VideoColorRange -> ShowS)
-> (VideoColorRange -> String)
-> ([VideoColorRange] -> ShowS)
-> Show VideoColorRange
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoColorRange] -> ShowS
$cshowList :: [VideoColorRange] -> ShowS
show :: VideoColorRange -> String
$cshow :: VideoColorRange -> String
showsPrec :: Int -> VideoColorRange -> ShowS
$cshowsPrec :: Int -> VideoColorRange -> ShowS
Show, VideoColorRange -> VideoColorRange -> Bool
(VideoColorRange -> VideoColorRange -> Bool)
-> (VideoColorRange -> VideoColorRange -> Bool)
-> Eq VideoColorRange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoColorRange -> VideoColorRange -> Bool
$c/= :: VideoColorRange -> VideoColorRange -> Bool
== :: VideoColorRange -> VideoColorRange -> Bool
$c== :: VideoColorRange -> VideoColorRange -> Bool
Eq)

instance P.Enum VideoColorRange where
    fromEnum :: VideoColorRange -> Int
fromEnum VideoColorRangeUnknown = 0
    fromEnum VideoColorRange0255 = 1
    fromEnum VideoColorRange16235 = 2
    fromEnum (AnotherVideoColorRange k :: Int
k) = Int
k

    toEnum :: Int -> VideoColorRange
toEnum 0 = VideoColorRange
VideoColorRangeUnknown
    toEnum 1 = VideoColorRange
VideoColorRange0255
    toEnum 2 = VideoColorRange
VideoColorRange16235
    toEnum k :: Int
k = Int -> VideoColorRange
AnotherVideoColorRange Int
k

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

foreign import ccall "gst_video_color_range_get_type" c_gst_video_color_range_get_type :: 
    IO GType

instance BoxedEnum VideoColorRange where
    boxedEnumType :: VideoColorRange -> IO GType
boxedEnumType _ = IO GType
c_gst_video_color_range_get_type

-- Enum VideoColorPrimaries
-- | The color primaries define the how to transform linear RGB values to and from
-- the CIE XYZ colorspace.
data VideoColorPrimaries = 
      VideoColorPrimariesUnknown
    -- ^ unknown color primaries
    | VideoColorPrimariesBt709
    -- ^ BT709 primaries
    | VideoColorPrimariesBt470m
    -- ^ BT470M primaries
    | VideoColorPrimariesBt470bg
    -- ^ BT470BG primaries
    | VideoColorPrimariesSmpte170m
    -- ^ SMPTE170M primaries
    | VideoColorPrimariesSmpte240m
    -- ^ SMPTE240M primaries
    | VideoColorPrimariesFilm
    -- ^ Generic film
    | VideoColorPrimariesBt2020
    -- ^ BT2020 primaries. Since: 1.6
    | VideoColorPrimariesAdobergb
    -- ^ Adobe RGB primaries. Since: 1.8
    | VideoColorPrimariesSmptest428
    -- ^ SMPTE ST 428 primaries. Since: 1.16
    | VideoColorPrimariesSmpterp431
    -- ^ SMPTE RP 431 primaries. Since: 1.16
    | VideoColorPrimariesSmpteeg432
    -- ^ SMPTE EG 432 primaries. Since: 1.16
    | VideoColorPrimariesEbu3213
    -- ^ EBU 3213 primaries. Since: 1.16
    | AnotherVideoColorPrimaries Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoColorPrimaries -> ShowS
[VideoColorPrimaries] -> ShowS
VideoColorPrimaries -> String
(Int -> VideoColorPrimaries -> ShowS)
-> (VideoColorPrimaries -> String)
-> ([VideoColorPrimaries] -> ShowS)
-> Show VideoColorPrimaries
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoColorPrimaries] -> ShowS
$cshowList :: [VideoColorPrimaries] -> ShowS
show :: VideoColorPrimaries -> String
$cshow :: VideoColorPrimaries -> String
showsPrec :: Int -> VideoColorPrimaries -> ShowS
$cshowsPrec :: Int -> VideoColorPrimaries -> ShowS
Show, VideoColorPrimaries -> VideoColorPrimaries -> Bool
(VideoColorPrimaries -> VideoColorPrimaries -> Bool)
-> (VideoColorPrimaries -> VideoColorPrimaries -> Bool)
-> Eq VideoColorPrimaries
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoColorPrimaries -> VideoColorPrimaries -> Bool
$c/= :: VideoColorPrimaries -> VideoColorPrimaries -> Bool
== :: VideoColorPrimaries -> VideoColorPrimaries -> Bool
$c== :: VideoColorPrimaries -> VideoColorPrimaries -> Bool
Eq)

instance P.Enum VideoColorPrimaries where
    fromEnum :: VideoColorPrimaries -> Int
fromEnum VideoColorPrimariesUnknown = 0
    fromEnum VideoColorPrimariesBt709 = 1
    fromEnum VideoColorPrimariesBt470m = 2
    fromEnum VideoColorPrimariesBt470bg = 3
    fromEnum VideoColorPrimariesSmpte170m = 4
    fromEnum VideoColorPrimariesSmpte240m = 5
    fromEnum VideoColorPrimariesFilm = 6
    fromEnum VideoColorPrimariesBt2020 = 7
    fromEnum VideoColorPrimariesAdobergb = 8
    fromEnum VideoColorPrimariesSmptest428 = 9
    fromEnum VideoColorPrimariesSmpterp431 = 10
    fromEnum VideoColorPrimariesSmpteeg432 = 11
    fromEnum VideoColorPrimariesEbu3213 = 12
    fromEnum (AnotherVideoColorPrimaries k :: Int
k) = Int
k

    toEnum :: Int -> VideoColorPrimaries
toEnum 0 = VideoColorPrimaries
VideoColorPrimariesUnknown
    toEnum 1 = VideoColorPrimaries
VideoColorPrimariesBt709
    toEnum 2 = VideoColorPrimaries
VideoColorPrimariesBt470m
    toEnum 3 = VideoColorPrimaries
VideoColorPrimariesBt470bg
    toEnum 4 = VideoColorPrimaries
VideoColorPrimariesSmpte170m
    toEnum 5 = VideoColorPrimaries
VideoColorPrimariesSmpte240m
    toEnum 6 = VideoColorPrimaries
VideoColorPrimariesFilm
    toEnum 7 = VideoColorPrimaries
VideoColorPrimariesBt2020
    toEnum 8 = VideoColorPrimaries
VideoColorPrimariesAdobergb
    toEnum 9 = VideoColorPrimaries
VideoColorPrimariesSmptest428
    toEnum 10 = VideoColorPrimaries
VideoColorPrimariesSmpterp431
    toEnum 11 = VideoColorPrimaries
VideoColorPrimariesSmpteeg432
    toEnum 12 = VideoColorPrimaries
VideoColorPrimariesEbu3213
    toEnum k :: Int
k = Int -> VideoColorPrimaries
AnotherVideoColorPrimaries Int
k

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

foreign import ccall "gst_video_color_primaries_get_type" c_gst_video_color_primaries_get_type :: 
    IO GType

instance BoxedEnum VideoColorPrimaries where
    boxedEnumType :: VideoColorPrimaries -> IO GType
boxedEnumType _ = IO GType
c_gst_video_color_primaries_get_type

-- Enum VideoColorMatrix
-- | The color matrix is used to convert between Y\'PbPr and
-- non-linear RGB (R\'G\'B\')
data VideoColorMatrix = 
      VideoColorMatrixUnknown
    -- ^ unknown matrix
    | VideoColorMatrixRgb
    -- ^ identity matrix
    | VideoColorMatrixFcc
    -- ^ FCC color matrix
    | VideoColorMatrixBt709
    -- ^ ITU-R BT.709 color matrix
    | VideoColorMatrixBt601
    -- ^ ITU-R BT.601 color matrix
    | VideoColorMatrixSmpte240m
    -- ^ SMPTE 240M color matrix
    | VideoColorMatrixBt2020
    -- ^ ITU-R BT.2020 color matrix. Since: 1.6
    | AnotherVideoColorMatrix Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoColorMatrix -> ShowS
[VideoColorMatrix] -> ShowS
VideoColorMatrix -> String
(Int -> VideoColorMatrix -> ShowS)
-> (VideoColorMatrix -> String)
-> ([VideoColorMatrix] -> ShowS)
-> Show VideoColorMatrix
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoColorMatrix] -> ShowS
$cshowList :: [VideoColorMatrix] -> ShowS
show :: VideoColorMatrix -> String
$cshow :: VideoColorMatrix -> String
showsPrec :: Int -> VideoColorMatrix -> ShowS
$cshowsPrec :: Int -> VideoColorMatrix -> ShowS
Show, VideoColorMatrix -> VideoColorMatrix -> Bool
(VideoColorMatrix -> VideoColorMatrix -> Bool)
-> (VideoColorMatrix -> VideoColorMatrix -> Bool)
-> Eq VideoColorMatrix
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoColorMatrix -> VideoColorMatrix -> Bool
$c/= :: VideoColorMatrix -> VideoColorMatrix -> Bool
== :: VideoColorMatrix -> VideoColorMatrix -> Bool
$c== :: VideoColorMatrix -> VideoColorMatrix -> Bool
Eq)

instance P.Enum VideoColorMatrix where
    fromEnum :: VideoColorMatrix -> Int
fromEnum VideoColorMatrixUnknown = 0
    fromEnum VideoColorMatrixRgb = 1
    fromEnum VideoColorMatrixFcc = 2
    fromEnum VideoColorMatrixBt709 = 3
    fromEnum VideoColorMatrixBt601 = 4
    fromEnum VideoColorMatrixSmpte240m = 5
    fromEnum VideoColorMatrixBt2020 = 6
    fromEnum (AnotherVideoColorMatrix k :: Int
k) = Int
k

    toEnum :: Int -> VideoColorMatrix
toEnum 0 = VideoColorMatrix
VideoColorMatrixUnknown
    toEnum 1 = VideoColorMatrix
VideoColorMatrixRgb
    toEnum 2 = VideoColorMatrix
VideoColorMatrixFcc
    toEnum 3 = VideoColorMatrix
VideoColorMatrixBt709
    toEnum 4 = VideoColorMatrix
VideoColorMatrixBt601
    toEnum 5 = VideoColorMatrix
VideoColorMatrixSmpte240m
    toEnum 6 = VideoColorMatrix
VideoColorMatrixBt2020
    toEnum k :: Int
k = Int -> VideoColorMatrix
AnotherVideoColorMatrix Int
k

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

foreign import ccall "gst_video_color_matrix_get_type" c_gst_video_color_matrix_get_type :: 
    IO GType

instance BoxedEnum VideoColorMatrix where
    boxedEnumType :: VideoColorMatrix -> IO GType
boxedEnumType _ = IO GType
c_gst_video_color_matrix_get_type

-- Enum VideoChromaMode
-- | Different chroma downsampling and upsampling modes
-- 
-- /Since: 1.6/
data VideoChromaMode = 
      VideoChromaModeFull
    -- ^ do full chroma up and down sampling
    | VideoChromaModeUpsampleOnly
    -- ^ only perform chroma upsampling
    | VideoChromaModeDownsampleOnly
    -- ^ only perform chroma downsampling
    | VideoChromaModeNone
    -- ^ disable chroma resampling
    | AnotherVideoChromaMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoChromaMode -> ShowS
[VideoChromaMode] -> ShowS
VideoChromaMode -> String
(Int -> VideoChromaMode -> ShowS)
-> (VideoChromaMode -> String)
-> ([VideoChromaMode] -> ShowS)
-> Show VideoChromaMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoChromaMode] -> ShowS
$cshowList :: [VideoChromaMode] -> ShowS
show :: VideoChromaMode -> String
$cshow :: VideoChromaMode -> String
showsPrec :: Int -> VideoChromaMode -> ShowS
$cshowsPrec :: Int -> VideoChromaMode -> ShowS
Show, VideoChromaMode -> VideoChromaMode -> Bool
(VideoChromaMode -> VideoChromaMode -> Bool)
-> (VideoChromaMode -> VideoChromaMode -> Bool)
-> Eq VideoChromaMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoChromaMode -> VideoChromaMode -> Bool
$c/= :: VideoChromaMode -> VideoChromaMode -> Bool
== :: VideoChromaMode -> VideoChromaMode -> Bool
$c== :: VideoChromaMode -> VideoChromaMode -> Bool
Eq)

instance P.Enum VideoChromaMode where
    fromEnum :: VideoChromaMode -> Int
fromEnum VideoChromaModeFull = 0
    fromEnum VideoChromaModeUpsampleOnly = 1
    fromEnum VideoChromaModeDownsampleOnly = 2
    fromEnum VideoChromaModeNone = 3
    fromEnum (AnotherVideoChromaMode k :: Int
k) = Int
k

    toEnum :: Int -> VideoChromaMode
toEnum 0 = VideoChromaMode
VideoChromaModeFull
    toEnum 1 = VideoChromaMode
VideoChromaModeUpsampleOnly
    toEnum 2 = VideoChromaMode
VideoChromaModeDownsampleOnly
    toEnum 3 = VideoChromaMode
VideoChromaModeNone
    toEnum k :: Int
k = Int -> VideoChromaMode
AnotherVideoChromaMode Int
k

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

foreign import ccall "gst_video_chroma_mode_get_type" c_gst_video_chroma_mode_get_type :: 
    IO GType

instance BoxedEnum VideoChromaMode where
    boxedEnumType :: VideoChromaMode -> IO GType
boxedEnumType _ = IO GType
c_gst_video_chroma_mode_get_type

-- Enum VideoChromaMethod
-- | Different subsampling and upsampling methods
data VideoChromaMethod = 
      VideoChromaMethodNearest
    -- ^ Duplicates the chroma samples when
    --    upsampling and drops when subsampling
    | VideoChromaMethodLinear
    -- ^ Uses linear interpolation to reconstruct
    --    missing chroma and averaging to subsample
    | AnotherVideoChromaMethod Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoChromaMethod -> ShowS
[VideoChromaMethod] -> ShowS
VideoChromaMethod -> String
(Int -> VideoChromaMethod -> ShowS)
-> (VideoChromaMethod -> String)
-> ([VideoChromaMethod] -> ShowS)
-> Show VideoChromaMethod
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoChromaMethod] -> ShowS
$cshowList :: [VideoChromaMethod] -> ShowS
show :: VideoChromaMethod -> String
$cshow :: VideoChromaMethod -> String
showsPrec :: Int -> VideoChromaMethod -> ShowS
$cshowsPrec :: Int -> VideoChromaMethod -> ShowS
Show, VideoChromaMethod -> VideoChromaMethod -> Bool
(VideoChromaMethod -> VideoChromaMethod -> Bool)
-> (VideoChromaMethod -> VideoChromaMethod -> Bool)
-> Eq VideoChromaMethod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoChromaMethod -> VideoChromaMethod -> Bool
$c/= :: VideoChromaMethod -> VideoChromaMethod -> Bool
== :: VideoChromaMethod -> VideoChromaMethod -> Bool
$c== :: VideoChromaMethod -> VideoChromaMethod -> Bool
Eq)

instance P.Enum VideoChromaMethod where
    fromEnum :: VideoChromaMethod -> Int
fromEnum VideoChromaMethodNearest = 0
    fromEnum VideoChromaMethodLinear = 1
    fromEnum (AnotherVideoChromaMethod k :: Int
k) = Int
k

    toEnum :: Int -> VideoChromaMethod
toEnum 0 = VideoChromaMethod
VideoChromaMethodNearest
    toEnum 1 = VideoChromaMethod
VideoChromaMethodLinear
    toEnum k :: Int
k = Int -> VideoChromaMethod
AnotherVideoChromaMethod Int
k

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

foreign import ccall "gst_video_chroma_method_get_type" c_gst_video_chroma_method_get_type :: 
    IO GType

instance BoxedEnum VideoChromaMethod where
    boxedEnumType :: VideoChromaMethod -> IO GType
boxedEnumType _ = IO GType
c_gst_video_chroma_method_get_type

-- Enum VideoCaptionType
-- | The various known types of Closed Caption (CC).
-- 
-- /Since: 1.16/
data VideoCaptionType = 
      VideoCaptionTypeUnknown
    -- ^ Unknown type of CC
    | VideoCaptionTypeCea608Raw
    -- ^ CEA-608 as byte pairs. Note that
    --      this format is not recommended since is does not specify to
    --      which field the caption comes from and therefore assumes
    --      it comes from the first field (and that there is no information
    --      on the second field). Use /@gSTVIDEOCAPTIONTYPECEA708RAW@/
    --      if you wish to store CEA-608 from two fields and prefix each byte pair
    --      with 0xFC for the first field and 0xFD for the second field.
    | VideoCaptionTypeCea608S3341a
    -- ^ CEA-608 as byte triplets as defined
    --      in SMPTE S334-1 Annex A. The second and third byte of the byte triplet
    --      is the raw CEA608 data, the first byte is a bitfield: The top\/7th bit is
    --      0 for the second field, 1 for the first field, bit 6 and 5 are 0 and
    --      bits 4 to 0 are a 5 bit unsigned integer that represents the line
    --      offset relative to the base-line of the original image format (line 9
    --      for 525-line field 1, line 272 for 525-line field 2, line 5 for
    --      625-line field 1 and line 318 for 625-line field 2).
    | VideoCaptionTypeCea708Raw
    -- ^ CEA-708 as cc_data byte triplets. They
    --      can also contain 608-in-708 and the first byte of each triplet has to
    --      be inspected for detecting the type.
    | VideoCaptionTypeCea708Cdp
    -- ^ CEA-708 (and optionally CEA-608) in
    --      a CDP (Caption Distribution Packet) defined by SMPTE S-334-2.
    --      Contains the whole CDP (starting with 0x9669).
    | AnotherVideoCaptionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoCaptionType -> ShowS
[VideoCaptionType] -> ShowS
VideoCaptionType -> String
(Int -> VideoCaptionType -> ShowS)
-> (VideoCaptionType -> String)
-> ([VideoCaptionType] -> ShowS)
-> Show VideoCaptionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoCaptionType] -> ShowS
$cshowList :: [VideoCaptionType] -> ShowS
show :: VideoCaptionType -> String
$cshow :: VideoCaptionType -> String
showsPrec :: Int -> VideoCaptionType -> ShowS
$cshowsPrec :: Int -> VideoCaptionType -> ShowS
Show, VideoCaptionType -> VideoCaptionType -> Bool
(VideoCaptionType -> VideoCaptionType -> Bool)
-> (VideoCaptionType -> VideoCaptionType -> Bool)
-> Eq VideoCaptionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoCaptionType -> VideoCaptionType -> Bool
$c/= :: VideoCaptionType -> VideoCaptionType -> Bool
== :: VideoCaptionType -> VideoCaptionType -> Bool
$c== :: VideoCaptionType -> VideoCaptionType -> Bool
Eq)

instance P.Enum VideoCaptionType where
    fromEnum :: VideoCaptionType -> Int
fromEnum VideoCaptionTypeUnknown = 0
    fromEnum VideoCaptionTypeCea608Raw = 1
    fromEnum VideoCaptionTypeCea608S3341a = 2
    fromEnum VideoCaptionTypeCea708Raw = 3
    fromEnum VideoCaptionTypeCea708Cdp = 4
    fromEnum (AnotherVideoCaptionType k :: Int
k) = Int
k

    toEnum :: Int -> VideoCaptionType
toEnum 0 = VideoCaptionType
VideoCaptionTypeUnknown
    toEnum 1 = VideoCaptionType
VideoCaptionTypeCea608Raw
    toEnum 2 = VideoCaptionType
VideoCaptionTypeCea608S3341a
    toEnum 3 = VideoCaptionType
VideoCaptionTypeCea708Raw
    toEnum 4 = VideoCaptionType
VideoCaptionTypeCea708Cdp
    toEnum k :: Int
k = Int -> VideoCaptionType
AnotherVideoCaptionType Int
k

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

foreign import ccall "gst_video_caption_type_get_type" c_gst_video_caption_type_get_type :: 
    IO GType

instance BoxedEnum VideoCaptionType where
    boxedEnumType :: VideoCaptionType -> IO GType
boxedEnumType _ = IO GType
c_gst_video_caption_type_get_type

-- Enum VideoAncillaryDID16
-- | Some know types of Ancillary Data identifiers.
-- 
-- /Since: 1.16/
data VideoAncillaryDID16 = 
      VideoAncillaryDID16708
    -- ^ CEA 708 Ancillary data according to SMPTE 334
    | VideoAncillaryDID16608
    -- ^ CEA 608 Ancillary data according to SMPTE 334
    | AnotherVideoAncillaryDID16 Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoAncillaryDID16 -> ShowS
[VideoAncillaryDID16] -> ShowS
VideoAncillaryDID16 -> String
(Int -> VideoAncillaryDID16 -> ShowS)
-> (VideoAncillaryDID16 -> String)
-> ([VideoAncillaryDID16] -> ShowS)
-> Show VideoAncillaryDID16
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoAncillaryDID16] -> ShowS
$cshowList :: [VideoAncillaryDID16] -> ShowS
show :: VideoAncillaryDID16 -> String
$cshow :: VideoAncillaryDID16 -> String
showsPrec :: Int -> VideoAncillaryDID16 -> ShowS
$cshowsPrec :: Int -> VideoAncillaryDID16 -> ShowS
Show, VideoAncillaryDID16 -> VideoAncillaryDID16 -> Bool
(VideoAncillaryDID16 -> VideoAncillaryDID16 -> Bool)
-> (VideoAncillaryDID16 -> VideoAncillaryDID16 -> Bool)
-> Eq VideoAncillaryDID16
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoAncillaryDID16 -> VideoAncillaryDID16 -> Bool
$c/= :: VideoAncillaryDID16 -> VideoAncillaryDID16 -> Bool
== :: VideoAncillaryDID16 -> VideoAncillaryDID16 -> Bool
$c== :: VideoAncillaryDID16 -> VideoAncillaryDID16 -> Bool
Eq)

instance P.Enum VideoAncillaryDID16 where
    fromEnum :: VideoAncillaryDID16 -> Int
fromEnum VideoAncillaryDID16708 = 24833
    fromEnum VideoAncillaryDID16608 = 24834
    fromEnum (AnotherVideoAncillaryDID16 k :: Int
k) = Int
k

    toEnum :: Int -> VideoAncillaryDID16
toEnum 24833 = VideoAncillaryDID16
VideoAncillaryDID16708
    toEnum 24834 = VideoAncillaryDID16
VideoAncillaryDID16608
    toEnum k :: Int
k = Int -> VideoAncillaryDID16
AnotherVideoAncillaryDID16 Int
k

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

foreign import ccall "gst_video_ancillary_di_d16_get_type" c_gst_video_ancillary_di_d16_get_type :: 
    IO GType

instance BoxedEnum VideoAncillaryDID16 where
    boxedEnumType :: VideoAncillaryDID16 -> IO GType
boxedEnumType _ = IO GType
c_gst_video_ancillary_di_d16_get_type

-- Enum VideoAncillaryDID
-- | /No description available in the introspection data./
data VideoAncillaryDID = 
      VideoAncillaryDIDUndefined
    -- ^ /No description available in the introspection data./
    | VideoAncillaryDIDDeletion
    -- ^ /No description available in the introspection data./
    | VideoAncillaryDIDHanc3gAudioDataFirst
    -- ^ /No description available in the introspection data./
    | VideoAncillaryDIDHanc3gAudioDataLast
    -- ^ /No description available in the introspection data./
    | VideoAncillaryDIDHancHdtvAudioDataFirst
    -- ^ /No description available in the introspection data./
    | VideoAncillaryDIDHancHdtvAudioDataLast
    -- ^ /No description available in the introspection data./
    | VideoAncillaryDIDHancSdtvAudioData1First
    -- ^ /No description available in the introspection data./
    | VideoAncillaryDIDHancSdtvAudioData1Last
    -- ^ /No description available in the introspection data./
    | VideoAncillaryDIDCameraPosition
    -- ^ /No description available in the introspection data./
    | VideoAncillaryDIDHancErrorDetection
    -- ^ /No description available in the introspection data./
    | VideoAncillaryDIDHancSdtvAudioData2First
    -- ^ /No description available in the introspection data./
    | VideoAncillaryDIDHancSdtvAudioData2Last
    -- ^ /No description available in the introspection data./
    | AnotherVideoAncillaryDID Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoAncillaryDID -> ShowS
[VideoAncillaryDID] -> ShowS
VideoAncillaryDID -> String
(Int -> VideoAncillaryDID -> ShowS)
-> (VideoAncillaryDID -> String)
-> ([VideoAncillaryDID] -> ShowS)
-> Show VideoAncillaryDID
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoAncillaryDID] -> ShowS
$cshowList :: [VideoAncillaryDID] -> ShowS
show :: VideoAncillaryDID -> String
$cshow :: VideoAncillaryDID -> String
showsPrec :: Int -> VideoAncillaryDID -> ShowS
$cshowsPrec :: Int -> VideoAncillaryDID -> ShowS
Show, VideoAncillaryDID -> VideoAncillaryDID -> Bool
(VideoAncillaryDID -> VideoAncillaryDID -> Bool)
-> (VideoAncillaryDID -> VideoAncillaryDID -> Bool)
-> Eq VideoAncillaryDID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoAncillaryDID -> VideoAncillaryDID -> Bool
$c/= :: VideoAncillaryDID -> VideoAncillaryDID -> Bool
== :: VideoAncillaryDID -> VideoAncillaryDID -> Bool
$c== :: VideoAncillaryDID -> VideoAncillaryDID -> Bool
Eq)

instance P.Enum VideoAncillaryDID where
    fromEnum :: VideoAncillaryDID -> Int
fromEnum VideoAncillaryDIDUndefined = 0
    fromEnum VideoAncillaryDIDDeletion = 128
    fromEnum VideoAncillaryDIDHanc3gAudioDataFirst = 160
    fromEnum VideoAncillaryDIDHanc3gAudioDataLast = 167
    fromEnum VideoAncillaryDIDHancHdtvAudioDataFirst = 224
    fromEnum VideoAncillaryDIDHancHdtvAudioDataLast = 231
    fromEnum VideoAncillaryDIDHancSdtvAudioData1First = 236
    fromEnum VideoAncillaryDIDHancSdtvAudioData1Last = 239
    fromEnum VideoAncillaryDIDCameraPosition = 240
    fromEnum VideoAncillaryDIDHancErrorDetection = 244
    fromEnum VideoAncillaryDIDHancSdtvAudioData2First = 248
    fromEnum VideoAncillaryDIDHancSdtvAudioData2Last = 255
    fromEnum (AnotherVideoAncillaryDID k :: Int
k) = Int
k

    toEnum :: Int -> VideoAncillaryDID
toEnum 0 = VideoAncillaryDID
VideoAncillaryDIDUndefined
    toEnum 128 = VideoAncillaryDID
VideoAncillaryDIDDeletion
    toEnum 160 = VideoAncillaryDID
VideoAncillaryDIDHanc3gAudioDataFirst
    toEnum 167 = VideoAncillaryDID
VideoAncillaryDIDHanc3gAudioDataLast
    toEnum 224 = VideoAncillaryDID
VideoAncillaryDIDHancHdtvAudioDataFirst
    toEnum 231 = VideoAncillaryDID
VideoAncillaryDIDHancHdtvAudioDataLast
    toEnum 236 = VideoAncillaryDID
VideoAncillaryDIDHancSdtvAudioData1First
    toEnum 239 = VideoAncillaryDID
VideoAncillaryDIDHancSdtvAudioData1Last
    toEnum 240 = VideoAncillaryDID
VideoAncillaryDIDCameraPosition
    toEnum 244 = VideoAncillaryDID
VideoAncillaryDIDHancErrorDetection
    toEnum 248 = VideoAncillaryDID
VideoAncillaryDIDHancSdtvAudioData2First
    toEnum 255 = VideoAncillaryDID
VideoAncillaryDIDHancSdtvAudioData2Last
    toEnum k :: Int
k = Int -> VideoAncillaryDID
AnotherVideoAncillaryDID Int
k

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

foreign import ccall "gst_video_ancillary_did_get_type" c_gst_video_ancillary_did_get_type :: 
    IO GType

instance BoxedEnum VideoAncillaryDID where
    boxedEnumType :: VideoAncillaryDID -> IO GType
boxedEnumType _ = IO GType
c_gst_video_ancillary_did_get_type

-- Enum VideoAlphaMode
-- | Different alpha modes.
-- 
-- /Since: 1.6/
data VideoAlphaMode = 
      VideoAlphaModeCopy
    -- ^ When input and output have alpha, it will be copied.
    --         When the input has no alpha, alpha will be set to
    --         'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_ALPHA_VALUE'
    | VideoAlphaModeSet
    -- ^ set all alpha to
    --    'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_ALPHA_VALUE'
    | VideoAlphaModeMult
    -- ^ multiply all alpha with
    --         'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_ALPHA_VALUE'.
    --         When the input format has no alpha but the output format has, the
    --         alpha value will be set to 'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_ALPHA_VALUE'
    | AnotherVideoAlphaMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoAlphaMode -> ShowS
[VideoAlphaMode] -> ShowS
VideoAlphaMode -> String
(Int -> VideoAlphaMode -> ShowS)
-> (VideoAlphaMode -> String)
-> ([VideoAlphaMode] -> ShowS)
-> Show VideoAlphaMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoAlphaMode] -> ShowS
$cshowList :: [VideoAlphaMode] -> ShowS
show :: VideoAlphaMode -> String
$cshow :: VideoAlphaMode -> String
showsPrec :: Int -> VideoAlphaMode -> ShowS
$cshowsPrec :: Int -> VideoAlphaMode -> ShowS
Show, VideoAlphaMode -> VideoAlphaMode -> Bool
(VideoAlphaMode -> VideoAlphaMode -> Bool)
-> (VideoAlphaMode -> VideoAlphaMode -> Bool) -> Eq VideoAlphaMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoAlphaMode -> VideoAlphaMode -> Bool
$c/= :: VideoAlphaMode -> VideoAlphaMode -> Bool
== :: VideoAlphaMode -> VideoAlphaMode -> Bool
$c== :: VideoAlphaMode -> VideoAlphaMode -> Bool
Eq)

instance P.Enum VideoAlphaMode where
    fromEnum :: VideoAlphaMode -> Int
fromEnum VideoAlphaModeCopy = 0
    fromEnum VideoAlphaModeSet = 1
    fromEnum VideoAlphaModeMult = 2
    fromEnum (AnotherVideoAlphaMode k :: Int
k) = Int
k

    toEnum :: Int -> VideoAlphaMode
toEnum 0 = VideoAlphaMode
VideoAlphaModeCopy
    toEnum 1 = VideoAlphaMode
VideoAlphaModeSet
    toEnum 2 = VideoAlphaMode
VideoAlphaModeMult
    toEnum k :: Int
k = Int -> VideoAlphaMode
AnotherVideoAlphaMode Int
k

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

foreign import ccall "gst_video_alpha_mode_get_type" c_gst_video_alpha_mode_get_type :: 
    IO GType

instance BoxedEnum VideoAlphaMode where
    boxedEnumType :: VideoAlphaMode -> IO GType
boxedEnumType _ = IO GType
c_gst_video_alpha_mode_get_type

-- Enum NavigationQueryType
-- | Tyoes of navigation interface queries.
data NavigationQueryType = 
      NavigationQueryTypeInvalid
    -- ^ invalid query
    | NavigationQueryTypeCommands
    -- ^ command query
    | NavigationQueryTypeAngles
    -- ^ viewing angle query
    | AnotherNavigationQueryType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NavigationQueryType -> ShowS
[NavigationQueryType] -> ShowS
NavigationQueryType -> String
(Int -> NavigationQueryType -> ShowS)
-> (NavigationQueryType -> String)
-> ([NavigationQueryType] -> ShowS)
-> Show NavigationQueryType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NavigationQueryType] -> ShowS
$cshowList :: [NavigationQueryType] -> ShowS
show :: NavigationQueryType -> String
$cshow :: NavigationQueryType -> String
showsPrec :: Int -> NavigationQueryType -> ShowS
$cshowsPrec :: Int -> NavigationQueryType -> ShowS
Show, NavigationQueryType -> NavigationQueryType -> Bool
(NavigationQueryType -> NavigationQueryType -> Bool)
-> (NavigationQueryType -> NavigationQueryType -> Bool)
-> Eq NavigationQueryType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NavigationQueryType -> NavigationQueryType -> Bool
$c/= :: NavigationQueryType -> NavigationQueryType -> Bool
== :: NavigationQueryType -> NavigationQueryType -> Bool
$c== :: NavigationQueryType -> NavigationQueryType -> Bool
Eq)

instance P.Enum NavigationQueryType where
    fromEnum :: NavigationQueryType -> Int
fromEnum NavigationQueryTypeInvalid = 0
    fromEnum NavigationQueryTypeCommands = 1
    fromEnum NavigationQueryTypeAngles = 2
    fromEnum (AnotherNavigationQueryType k :: Int
k) = Int
k

    toEnum :: Int -> NavigationQueryType
toEnum 0 = NavigationQueryType
NavigationQueryTypeInvalid
    toEnum 1 = NavigationQueryType
NavigationQueryTypeCommands
    toEnum 2 = NavigationQueryType
NavigationQueryTypeAngles
    toEnum k :: Int
k = Int -> NavigationQueryType
AnotherNavigationQueryType Int
k

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

foreign import ccall "gst_navigation_query_type_get_type" c_gst_navigation_query_type_get_type :: 
    IO GType

instance BoxedEnum NavigationQueryType where
    boxedEnumType :: NavigationQueryType -> IO GType
boxedEnumType _ = IO GType
c_gst_navigation_query_type_get_type

-- Enum NavigationMessageType
-- | A set of notifications that may be received on the bus when navigation
-- related status changes.
data NavigationMessageType = 
      NavigationMessageTypeInvalid
    -- ^ Returned from
    -- 'GI.GstVideo.Functions.navigationMessageGetType' when the passed message is not a
    -- navigation message.
    | NavigationMessageTypeMouseOver
    -- ^ Sent when the mouse moves over or leaves a
    -- clickable region of the output, such as a DVD menu button.
    | NavigationMessageTypeCommandsChanged
    -- ^ Sent when the set of available commands
    -- changes and should re-queried by interested applications.
    | NavigationMessageTypeAnglesChanged
    -- ^ Sent when display angles in a multi-angle
    -- feature (such as a multiangle DVD) change - either angles have appeared or
    -- disappeared.
    | NavigationMessageTypeEvent
    -- ^ Sent when a navigation event was not handled
    -- by any element in the pipeline (Since 1.6)
    | AnotherNavigationMessageType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NavigationMessageType -> ShowS
[NavigationMessageType] -> ShowS
NavigationMessageType -> String
(Int -> NavigationMessageType -> ShowS)
-> (NavigationMessageType -> String)
-> ([NavigationMessageType] -> ShowS)
-> Show NavigationMessageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NavigationMessageType] -> ShowS
$cshowList :: [NavigationMessageType] -> ShowS
show :: NavigationMessageType -> String
$cshow :: NavigationMessageType -> String
showsPrec :: Int -> NavigationMessageType -> ShowS
$cshowsPrec :: Int -> NavigationMessageType -> ShowS
Show, NavigationMessageType -> NavigationMessageType -> Bool
(NavigationMessageType -> NavigationMessageType -> Bool)
-> (NavigationMessageType -> NavigationMessageType -> Bool)
-> Eq NavigationMessageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NavigationMessageType -> NavigationMessageType -> Bool
$c/= :: NavigationMessageType -> NavigationMessageType -> Bool
== :: NavigationMessageType -> NavigationMessageType -> Bool
$c== :: NavigationMessageType -> NavigationMessageType -> Bool
Eq)

instance P.Enum NavigationMessageType where
    fromEnum :: NavigationMessageType -> Int
fromEnum NavigationMessageTypeInvalid = 0
    fromEnum NavigationMessageTypeMouseOver = 1
    fromEnum NavigationMessageTypeCommandsChanged = 2
    fromEnum NavigationMessageTypeAnglesChanged = 3
    fromEnum NavigationMessageTypeEvent = 4
    fromEnum (AnotherNavigationMessageType k :: Int
k) = Int
k

    toEnum :: Int -> NavigationMessageType
toEnum 0 = NavigationMessageType
NavigationMessageTypeInvalid
    toEnum 1 = NavigationMessageType
NavigationMessageTypeMouseOver
    toEnum 2 = NavigationMessageType
NavigationMessageTypeCommandsChanged
    toEnum 3 = NavigationMessageType
NavigationMessageTypeAnglesChanged
    toEnum 4 = NavigationMessageType
NavigationMessageTypeEvent
    toEnum k :: Int
k = Int -> NavigationMessageType
AnotherNavigationMessageType Int
k

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

foreign import ccall "gst_navigation_message_type_get_type" c_gst_navigation_message_type_get_type :: 
    IO GType

instance BoxedEnum NavigationMessageType where
    boxedEnumType :: NavigationMessageType -> IO GType
boxedEnumType _ = IO GType
c_gst_navigation_message_type_get_type

-- Enum NavigationEventType
-- | Enum values for the various events that an element implementing the
-- GstNavigation interface might send up the pipeline.
data NavigationEventType = 
      NavigationEventTypeInvalid
    -- ^ Returned from
    -- 'GI.GstVideo.Functions.navigationEventGetType' when the passed event is not a navigation event.
    | NavigationEventTypeKeyPress
    -- ^ A key press event. Use
    -- 'GI.GstVideo.Functions.navigationEventParseKeyEvent' to extract the details from the event.
    | NavigationEventTypeKeyRelease
    -- ^ A key release event. Use
    -- 'GI.GstVideo.Functions.navigationEventParseKeyEvent' to extract the details from the event.
    | NavigationEventTypeMouseButtonPress
    -- ^ A mouse button press event. Use
    -- 'GI.GstVideo.Functions.navigationEventParseMouseButtonEvent' to extract the details from the
    -- event.
    | NavigationEventTypeMouseButtonRelease
    -- ^ A mouse button release event. Use
    -- 'GI.GstVideo.Functions.navigationEventParseMouseButtonEvent' to extract the details from the
    -- event.
    | NavigationEventTypeMouseMove
    -- ^ A mouse movement event. Use
    -- 'GI.GstVideo.Functions.navigationEventParseMouseMoveEvent' to extract the details from the
    -- event.
    | NavigationEventTypeCommand
    -- ^ A navigation command event. Use
    -- 'GI.GstVideo.Functions.navigationEventParseCommand' to extract the details from the event.
    | AnotherNavigationEventType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NavigationEventType -> ShowS
[NavigationEventType] -> ShowS
NavigationEventType -> String
(Int -> NavigationEventType -> ShowS)
-> (NavigationEventType -> String)
-> ([NavigationEventType] -> ShowS)
-> Show NavigationEventType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NavigationEventType] -> ShowS
$cshowList :: [NavigationEventType] -> ShowS
show :: NavigationEventType -> String
$cshow :: NavigationEventType -> String
showsPrec :: Int -> NavigationEventType -> ShowS
$cshowsPrec :: Int -> NavigationEventType -> ShowS
Show, NavigationEventType -> NavigationEventType -> Bool
(NavigationEventType -> NavigationEventType -> Bool)
-> (NavigationEventType -> NavigationEventType -> Bool)
-> Eq NavigationEventType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NavigationEventType -> NavigationEventType -> Bool
$c/= :: NavigationEventType -> NavigationEventType -> Bool
== :: NavigationEventType -> NavigationEventType -> Bool
$c== :: NavigationEventType -> NavigationEventType -> Bool
Eq)

instance P.Enum NavigationEventType where
    fromEnum :: NavigationEventType -> Int
fromEnum NavigationEventTypeInvalid = 0
    fromEnum NavigationEventTypeKeyPress = 1
    fromEnum NavigationEventTypeKeyRelease = 2
    fromEnum NavigationEventTypeMouseButtonPress = 3
    fromEnum NavigationEventTypeMouseButtonRelease = 4
    fromEnum NavigationEventTypeMouseMove = 5
    fromEnum NavigationEventTypeCommand = 6
    fromEnum (AnotherNavigationEventType k :: Int
k) = Int
k

    toEnum :: Int -> NavigationEventType
toEnum 0 = NavigationEventType
NavigationEventTypeInvalid
    toEnum 1 = NavigationEventType
NavigationEventTypeKeyPress
    toEnum 2 = NavigationEventType
NavigationEventTypeKeyRelease
    toEnum 3 = NavigationEventType
NavigationEventTypeMouseButtonPress
    toEnum 4 = NavigationEventType
NavigationEventTypeMouseButtonRelease
    toEnum 5 = NavigationEventType
NavigationEventTypeMouseMove
    toEnum 6 = NavigationEventType
NavigationEventTypeCommand
    toEnum k :: Int
k = Int -> NavigationEventType
AnotherNavigationEventType Int
k

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

foreign import ccall "gst_navigation_event_type_get_type" c_gst_navigation_event_type_get_type :: 
    IO GType

instance BoxedEnum NavigationEventType where
    boxedEnumType :: NavigationEventType -> IO GType
boxedEnumType _ = IO GType
c_gst_navigation_event_type_get_type

-- Enum NavigationCommand
-- | A set of commands that may be issued to an element providing the
-- t'GI.GstVideo.Interfaces.Navigation.Navigation' interface. The available commands can be queried via
-- the 'GI.GstVideo.Functions.navigationQueryNewCommands' query.
-- 
-- For convenience in handling DVD navigation, the MENU commands are aliased as:
--    GST_NAVIGATION_COMMAND_DVD_MENU            = /@gSTNAVIGATIONCOMMANDMENU1@/
--    GST_NAVIGATION_COMMAND_DVD_TITLE_MENU      = /@gSTNAVIGATIONCOMMANDMENU2@/
--    GST_NAVIGATION_COMMAND_DVD_ROOT_MENU       = /@gSTNAVIGATIONCOMMANDMENU3@/
--    GST_NAVIGATION_COMMAND_DVD_SUBPICTURE_MENU = /@gSTNAVIGATIONCOMMANDMENU4@/
--    GST_NAVIGATION_COMMAND_DVD_AUDIO_MENU      = /@gSTNAVIGATIONCOMMANDMENU5@/
--    GST_NAVIGATION_COMMAND_DVD_ANGLE_MENU      = /@gSTNAVIGATIONCOMMANDMENU6@/
--    GST_NAVIGATION_COMMAND_DVD_CHAPTER_MENU    = /@gSTNAVIGATIONCOMMANDMENU7@/
data NavigationCommand = 
      NavigationCommandInvalid
    -- ^ An invalid command entry
    | NavigationCommandMenu1
    -- ^ Execute navigation menu command 1. For DVD,
    -- this enters the DVD root menu, or exits back to the title from the menu.
    | NavigationCommandMenu2
    -- ^ Execute navigation menu command 2. For DVD,
    -- this jumps to the DVD title menu.
    | NavigationCommandMenu3
    -- ^ Execute navigation menu command 3. For DVD,
    -- this jumps into the DVD root menu.
    | NavigationCommandMenu4
    -- ^ Execute navigation menu command 4. For DVD,
    -- this jumps to the Subpicture menu.
    | NavigationCommandMenu5
    -- ^ Execute navigation menu command 5. For DVD,
    -- the jumps to the audio menu.
    | NavigationCommandMenu6
    -- ^ Execute navigation menu command 6. For DVD,
    -- this jumps to the angles menu.
    | NavigationCommandMenu7
    -- ^ Execute navigation menu command 7. For DVD,
    -- this jumps to the chapter menu.
    | NavigationCommandLeft
    -- ^ Select the next button to the left in a menu,
    -- if such a button exists.
    | NavigationCommandRight
    -- ^ Select the next button to the right in a menu,
    -- if such a button exists.
    | NavigationCommandUp
    -- ^ Select the button above the current one in a
    -- menu, if such a button exists.
    | NavigationCommandDown
    -- ^ Select the button below the current one in a
    -- menu, if such a button exists.
    | NavigationCommandActivate
    -- ^ Activate (click) the currently selected
    -- button in a menu, if such a button exists.
    | NavigationCommandPrevAngle
    -- ^ Switch to the previous angle in a
    -- multiangle feature.
    | NavigationCommandNextAngle
    -- ^ Switch to the next angle in a multiangle
    -- feature.
    | AnotherNavigationCommand Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NavigationCommand -> ShowS
[NavigationCommand] -> ShowS
NavigationCommand -> String
(Int -> NavigationCommand -> ShowS)
-> (NavigationCommand -> String)
-> ([NavigationCommand] -> ShowS)
-> Show NavigationCommand
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NavigationCommand] -> ShowS
$cshowList :: [NavigationCommand] -> ShowS
show :: NavigationCommand -> String
$cshow :: NavigationCommand -> String
showsPrec :: Int -> NavigationCommand -> ShowS
$cshowsPrec :: Int -> NavigationCommand -> ShowS
Show, NavigationCommand -> NavigationCommand -> Bool
(NavigationCommand -> NavigationCommand -> Bool)
-> (NavigationCommand -> NavigationCommand -> Bool)
-> Eq NavigationCommand
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NavigationCommand -> NavigationCommand -> Bool
$c/= :: NavigationCommand -> NavigationCommand -> Bool
== :: NavigationCommand -> NavigationCommand -> Bool
$c== :: NavigationCommand -> NavigationCommand -> Bool
Eq)

instance P.Enum NavigationCommand where
    fromEnum :: NavigationCommand -> Int
fromEnum NavigationCommandInvalid = 0
    fromEnum NavigationCommandMenu1 = 1
    fromEnum NavigationCommandMenu2 = 2
    fromEnum NavigationCommandMenu3 = 3
    fromEnum NavigationCommandMenu4 = 4
    fromEnum NavigationCommandMenu5 = 5
    fromEnum NavigationCommandMenu6 = 6
    fromEnum NavigationCommandMenu7 = 7
    fromEnum NavigationCommandLeft = 20
    fromEnum NavigationCommandRight = 21
    fromEnum NavigationCommandUp = 22
    fromEnum NavigationCommandDown = 23
    fromEnum NavigationCommandActivate = 24
    fromEnum NavigationCommandPrevAngle = 30
    fromEnum NavigationCommandNextAngle = 31
    fromEnum (AnotherNavigationCommand k :: Int
k) = Int
k

    toEnum :: Int -> NavigationCommand
toEnum 0 = NavigationCommand
NavigationCommandInvalid
    toEnum 1 = NavigationCommand
NavigationCommandMenu1
    toEnum 2 = NavigationCommand
NavigationCommandMenu2
    toEnum 3 = NavigationCommand
NavigationCommandMenu3
    toEnum 4 = NavigationCommand
NavigationCommandMenu4
    toEnum 5 = NavigationCommand
NavigationCommandMenu5
    toEnum 6 = NavigationCommand
NavigationCommandMenu6
    toEnum 7 = NavigationCommand
NavigationCommandMenu7
    toEnum 20 = NavigationCommand
NavigationCommandLeft
    toEnum 21 = NavigationCommand
NavigationCommandRight
    toEnum 22 = NavigationCommand
NavigationCommandUp
    toEnum 23 = NavigationCommand
NavigationCommandDown
    toEnum 24 = NavigationCommand
NavigationCommandActivate
    toEnum 30 = NavigationCommand
NavigationCommandPrevAngle
    toEnum 31 = NavigationCommand
NavigationCommandNextAngle
    toEnum k :: Int
k = Int -> NavigationCommand
AnotherNavigationCommand Int
k

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

foreign import ccall "gst_navigation_command_get_type" c_gst_navigation_command_get_type :: 
    IO GType

instance BoxedEnum NavigationCommand where
    boxedEnumType :: NavigationCommand -> IO GType
boxedEnumType _ = IO GType
c_gst_navigation_command_get_type

-- Enum ColorBalanceType
-- | An enumeration indicating whether an element implements color balancing
-- operations in software or in dedicated hardware. In general, dedicated
-- hardware implementations (such as those provided by xvimagesink) are
-- preferred.
data ColorBalanceType = 
      ColorBalanceTypeHardware
    -- ^ Color balance is implemented with dedicated
    --         hardware.
    | ColorBalanceTypeSoftware
    -- ^ Color balance is implemented via software
    --         processing.
    | AnotherColorBalanceType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ColorBalanceType -> ShowS
[ColorBalanceType] -> ShowS
ColorBalanceType -> String
(Int -> ColorBalanceType -> ShowS)
-> (ColorBalanceType -> String)
-> ([ColorBalanceType] -> ShowS)
-> Show ColorBalanceType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ColorBalanceType] -> ShowS
$cshowList :: [ColorBalanceType] -> ShowS
show :: ColorBalanceType -> String
$cshow :: ColorBalanceType -> String
showsPrec :: Int -> ColorBalanceType -> ShowS
$cshowsPrec :: Int -> ColorBalanceType -> ShowS
Show, ColorBalanceType -> ColorBalanceType -> Bool
(ColorBalanceType -> ColorBalanceType -> Bool)
-> (ColorBalanceType -> ColorBalanceType -> Bool)
-> Eq ColorBalanceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ColorBalanceType -> ColorBalanceType -> Bool
$c/= :: ColorBalanceType -> ColorBalanceType -> Bool
== :: ColorBalanceType -> ColorBalanceType -> Bool
$c== :: ColorBalanceType -> ColorBalanceType -> Bool
Eq)

instance P.Enum ColorBalanceType where
    fromEnum :: ColorBalanceType -> Int
fromEnum ColorBalanceTypeHardware = 0
    fromEnum ColorBalanceTypeSoftware = 1
    fromEnum (AnotherColorBalanceType k :: Int
k) = Int
k

    toEnum :: Int -> ColorBalanceType
toEnum 0 = ColorBalanceType
ColorBalanceTypeHardware
    toEnum 1 = ColorBalanceType
ColorBalanceTypeSoftware
    toEnum k :: Int
k = Int -> ColorBalanceType
AnotherColorBalanceType Int
k

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

foreign import ccall "gst_color_balance_type_get_type" c_gst_color_balance_type_get_type :: 
    IO GType

instance BoxedEnum ColorBalanceType where
    boxedEnumType :: ColorBalanceType -> IO GType
boxedEnumType _ = IO GType
c_gst_color_balance_type_get_type