-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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(..)                 ,


-- ** VideoAFDSpec #enum:VideoAFDSpec#

    VideoAFDSpec(..)                        ,


-- ** VideoAFDValue #enum:VideoAFDValue#

    VideoAFDValue(..)                       ,


-- ** 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R


-- 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 occurred
    | 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 VideoVBIParserResult
VideoVBIParserResultDone = Int
0
    fromEnum VideoVBIParserResult
VideoVBIParserResultOk = Int
1
    fromEnum VideoVBIParserResult
VideoVBIParserResultError = Int
2
    fromEnum (AnotherVideoVBIParserResult Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_vbi_parser_result_get_type" c_gst_video_vbi_parser_result_get_type :: 
    IO GType

instance B.Types.TypedObject VideoVBIParserResult where
    glibType :: IO GType
glibType = IO GType
c_gst_video_vbi_parser_result_get_type

instance B.Types.BoxedEnum VideoVBIParserResult

-- 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, also ITU-R BT470M \/ ITU-R BT1700 625 PAL &
    --                           SECAM \/ ITU-R BT1361
    | 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. IEC 61966-2-1 (sRGB or sYCC)
    | VideoTransferFunctionGamma28
    -- ^ Gamma 2.8 curve, also ITU-R BT470BG
    | VideoTransferFunctionLog100
    -- ^ Logarithmic transfer characteristic
    --                             100:1 range
    | VideoTransferFunctionLog316
    -- ^ Logarithmic transfer characteristic
    --                             316.22777:1 range (100 * sqrt(10) : 1)
    | 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
    | VideoTransferFunctionBt202010
    -- ^ Rec. ITU-R BT.2020-2 with 10 bits per component.
    --                                (functionally the same as the values
    --                                GST_VIDEO_TRANSFER_BT709 and GST_VIDEO_TRANSFER_BT601).
    --                                Since: 1.18
    | VideoTransferFunctionSmpte2084
    -- ^ SMPTE ST 2084 for 10, 12, 14, and 16-bit systems.
    --                                Known as perceptual quantization (PQ)
    --                                Since: 1.18
    | VideoTransferFunctionAribStdB67
    -- ^ Association of Radio Industries and Businesses (ARIB)
    --                                   STD-B67 and Rec. ITU-R BT.2100-1 hybrid loggamma (HLG) system
    --                                   Since: 1.18
    | VideoTransferFunctionBt601
    -- ^ also known as SMPTE170M \/ ITU-R BT1358 525 or 625 \/ ITU-R BT1700 NTSC
    -- 
    -- /Since: 1.18/
    | 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 VideoTransferFunction
VideoTransferFunctionUnknown = Int
0
    fromEnum VideoTransferFunction
VideoTransferFunctionGamma10 = Int
1
    fromEnum VideoTransferFunction
VideoTransferFunctionGamma18 = Int
2
    fromEnum VideoTransferFunction
VideoTransferFunctionGamma20 = Int
3
    fromEnum VideoTransferFunction
VideoTransferFunctionGamma22 = Int
4
    fromEnum VideoTransferFunction
VideoTransferFunctionBt709 = Int
5
    fromEnum VideoTransferFunction
VideoTransferFunctionSmpte240m = Int
6
    fromEnum VideoTransferFunction
VideoTransferFunctionSrgb = Int
7
    fromEnum VideoTransferFunction
VideoTransferFunctionGamma28 = Int
8
    fromEnum VideoTransferFunction
VideoTransferFunctionLog100 = Int
9
    fromEnum VideoTransferFunction
VideoTransferFunctionLog316 = Int
10
    fromEnum VideoTransferFunction
VideoTransferFunctionBt202012 = Int
11
    fromEnum VideoTransferFunction
VideoTransferFunctionAdobergb = Int
12
    fromEnum VideoTransferFunction
VideoTransferFunctionBt202010 = Int
13
    fromEnum VideoTransferFunction
VideoTransferFunctionSmpte2084 = Int
14
    fromEnum VideoTransferFunction
VideoTransferFunctionAribStdB67 = Int
15
    fromEnum VideoTransferFunction
VideoTransferFunctionBt601 = Int
16
    fromEnum (AnotherVideoTransferFunction Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_transfer_function_get_type" c_gst_video_transfer_function_get_type :: 
    IO GType

instance B.Types.TypedObject VideoTransferFunction where
    glibType :: IO GType
glibType = IO GType
c_gst_video_transfer_function_get_type

instance B.Types.BoxedEnum VideoTransferFunction

-- 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 VideoTileType
VideoTileTypeIndexed = Int
0
    fromEnum (AnotherVideoTileType Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_tile_type_get_type" c_gst_video_tile_type_get_type :: 
    IO GType

instance B.Types.TypedObject VideoTileType where
    glibType :: IO GType
glibType = IO GType
c_gst_video_tile_type_get_type

instance B.Types.BoxedEnum VideoTileType

-- 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.
    | VideoTileModeLinear
    -- ^ Tiles are in row order.
    -- 
    -- /Since: 1.18/
    | 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 VideoTileMode
VideoTileModeUnknown = Int
0
    fromEnum VideoTileMode
VideoTileModeZflipz2x2 = Int
65536
    fromEnum VideoTileMode
VideoTileModeLinear = Int
131072
    fromEnum (AnotherVideoTileMode Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_tile_mode_get_type" c_gst_video_tile_mode_get_type :: 
    IO GType

instance B.Types.TypedObject VideoTileMode where
    glibType :: IO GType
glibType = IO GType
c_gst_video_tile_mode_get_type

instance B.Types.BoxedEnum VideoTileMode

-- 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 VideoResamplerMethod
VideoResamplerMethodNearest = Int
0
    fromEnum VideoResamplerMethod
VideoResamplerMethodLinear = Int
1
    fromEnum VideoResamplerMethod
VideoResamplerMethodCubic = Int
2
    fromEnum VideoResamplerMethod
VideoResamplerMethodSinc = Int
3
    fromEnum VideoResamplerMethod
VideoResamplerMethodLanczos = Int
4
    fromEnum (AnotherVideoResamplerMethod Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_resampler_method_get_type" c_gst_video_resampler_method_get_type :: 
    IO GType

instance B.Types.TypedObject VideoResamplerMethod where
    glibType :: IO GType
glibType = IO GType
c_gst_video_resampler_method_get_type

instance B.Types.BoxedEnum VideoResamplerMethod

-- 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 VideoPrimariesMode
VideoPrimariesModeNone = Int
0
    fromEnum VideoPrimariesMode
VideoPrimariesModeMergeOnly = Int
1
    fromEnum VideoPrimariesMode
VideoPrimariesModeFast = Int
2
    fromEnum (AnotherVideoPrimariesMode Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_primaries_mode_get_type" c_gst_video_primaries_mode_get_type :: 
    IO GType

instance B.Types.TypedObject VideoPrimariesMode where
    glibType :: IO GType
glibType = IO GType
c_gst_video_primaries_mode_get_type

instance B.Types.BoxedEnum VideoPrimariesMode

-- 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 VideoOrientationMethod
VideoOrientationMethodIdentity = Int
0
    fromEnum VideoOrientationMethod
VideoOrientationMethod90r = Int
1
    fromEnum VideoOrientationMethod
VideoOrientationMethod180 = Int
2
    fromEnum VideoOrientationMethod
VideoOrientationMethod90l = Int
3
    fromEnum VideoOrientationMethod
VideoOrientationMethodHoriz = Int
4
    fromEnum VideoOrientationMethod
VideoOrientationMethodVert = Int
5
    fromEnum VideoOrientationMethod
VideoOrientationMethodUlLr = Int
6
    fromEnum VideoOrientationMethod
VideoOrientationMethodUrLl = Int
7
    fromEnum VideoOrientationMethod
VideoOrientationMethodAuto = Int
8
    fromEnum VideoOrientationMethod
VideoOrientationMethodCustom = Int
9
    fromEnum (AnotherVideoOrientationMethod Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_orientation_method_get_type" c_gst_video_orientation_method_get_type :: 
    IO GType

instance B.Types.TypedObject VideoOrientationMethod where
    glibType :: IO GType
glibType = IO GType
c_gst_video_orientation_method_get_type

instance B.Types.BoxedEnum VideoOrientationMethod

-- 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 VideoMultiviewMode
VideoMultiviewModeNone = Int
-1
    fromEnum VideoMultiviewMode
VideoMultiviewModeMono = Int
0
    fromEnum VideoMultiviewMode
VideoMultiviewModeLeft = Int
1
    fromEnum VideoMultiviewMode
VideoMultiviewModeRight = Int
2
    fromEnum VideoMultiviewMode
VideoMultiviewModeSideBySide = Int
3
    fromEnum VideoMultiviewMode
VideoMultiviewModeSideBySideQuincunx = Int
4
    fromEnum VideoMultiviewMode
VideoMultiviewModeColumnInterleaved = Int
5
    fromEnum VideoMultiviewMode
VideoMultiviewModeRowInterleaved = Int
6
    fromEnum VideoMultiviewMode
VideoMultiviewModeTopBottom = Int
7
    fromEnum VideoMultiviewMode
VideoMultiviewModeCheckerboard = Int
8
    fromEnum VideoMultiviewMode
VideoMultiviewModeFrameByFrame = Int
32
    fromEnum VideoMultiviewMode
VideoMultiviewModeMultiviewFrameByFrame = Int
33
    fromEnum VideoMultiviewMode
VideoMultiviewModeSeparated = Int
34
    fromEnum (AnotherVideoMultiviewMode Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_multiview_mode_get_type" c_gst_video_multiview_mode_get_type :: 
    IO GType

instance B.Types.TypedObject VideoMultiviewMode where
    glibType :: IO GType
glibType = IO GType
c_gst_video_multiview_mode_get_type

instance B.Types.BoxedEnum VideoMultiviewMode

-- 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 VideoMultiviewFramePacking
VideoMultiviewFramePackingNone = Int
-1
    fromEnum VideoMultiviewFramePacking
VideoMultiviewFramePackingMono = Int
0
    fromEnum VideoMultiviewFramePacking
VideoMultiviewFramePackingLeft = Int
1
    fromEnum VideoMultiviewFramePacking
VideoMultiviewFramePackingRight = Int
2
    fromEnum VideoMultiviewFramePacking
VideoMultiviewFramePackingSideBySide = Int
3
    fromEnum VideoMultiviewFramePacking
VideoMultiviewFramePackingSideBySideQuincunx = Int
4
    fromEnum VideoMultiviewFramePacking
VideoMultiviewFramePackingColumnInterleaved = Int
5
    fromEnum VideoMultiviewFramePacking
VideoMultiviewFramePackingRowInterleaved = Int
6
    fromEnum VideoMultiviewFramePacking
VideoMultiviewFramePackingTopBottom = Int
7
    fromEnum VideoMultiviewFramePacking
VideoMultiviewFramePackingCheckerboard = Int
8
    fromEnum (AnotherVideoMultiviewFramePacking Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_multiview_frame_packing_get_type" c_gst_video_multiview_frame_packing_get_type :: 
    IO GType

instance B.Types.TypedObject VideoMultiviewFramePacking where
    glibType :: IO GType
glibType = IO GType
c_gst_video_multiview_frame_packing_get_type

instance B.Types.BoxedEnum VideoMultiviewFramePacking

-- 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 VideoMatrixMode
VideoMatrixModeFull = Int
0
    fromEnum VideoMatrixMode
VideoMatrixModeInputOnly = Int
1
    fromEnum VideoMatrixMode
VideoMatrixModeOutputOnly = Int
2
    fromEnum VideoMatrixMode
VideoMatrixModeNone = Int
3
    fromEnum (AnotherVideoMatrixMode Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_matrix_mode_get_type" c_gst_video_matrix_mode_get_type :: 
    IO GType

instance B.Types.TypedObject VideoMatrixMode where
    glibType :: IO GType
glibType = IO GType
c_gst_video_matrix_mode_get_type

instance B.Types.BoxedEnum VideoMatrixMode

-- 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 must 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 VideoInterlaceMode
VideoInterlaceModeProgressive = Int
0
    fromEnum VideoInterlaceMode
VideoInterlaceModeInterleaved = Int
1
    fromEnum VideoInterlaceMode
VideoInterlaceModeMixed = Int
2
    fromEnum VideoInterlaceMode
VideoInterlaceModeFields = Int
3
    fromEnum VideoInterlaceMode
VideoInterlaceModeAlternate = Int
4
    fromEnum (AnotherVideoInterlaceMode Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_interlace_mode_get_type" c_gst_video_interlace_mode_get_type :: 
    IO GType

instance B.Types.TypedObject VideoInterlaceMode where
    glibType :: IO GType
glibType = IO GType
c_gst_video_interlace_mode_get_type

instance B.Types.BoxedEnum VideoInterlaceMode

-- 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 VideoGammaMode
VideoGammaModeNone = Int
0
    fromEnum VideoGammaMode
VideoGammaModeRemap = Int
1
    fromEnum (AnotherVideoGammaMode Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_gamma_mode_get_type" c_gst_video_gamma_mode_get_type :: 
    IO GType

instance B.Types.TypedObject VideoGammaMode where
    glibType :: IO GType
glibType = IO GType
c_gst_video_gamma_mode_get_type

instance B.Types.BoxedEnum VideoGammaMode

-- 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 VideoGLTextureType
VideoGLTextureTypeLuminance = Int
0
    fromEnum VideoGLTextureType
VideoGLTextureTypeLuminanceAlpha = Int
1
    fromEnum VideoGLTextureType
VideoGLTextureTypeRgb16 = Int
2
    fromEnum VideoGLTextureType
VideoGLTextureTypeRgb = Int
3
    fromEnum VideoGLTextureType
VideoGLTextureTypeRgba = Int
4
    fromEnum VideoGLTextureType
VideoGLTextureTypeR = Int
5
    fromEnum VideoGLTextureType
VideoGLTextureTypeRg = Int
6
    fromEnum (AnotherVideoGLTextureType Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_gl_texture_type_get_type" c_gst_video_gl_texture_type_get_type :: 
    IO GType

instance B.Types.TypedObject VideoGLTextureType where
    glibType :: IO GType
glibType = IO GType
c_gst_video_gl_texture_type_get_type

instance B.Types.BoxedEnum VideoGLTextureType

-- 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 VideoGLTextureOrientation
VideoGLTextureOrientationNormalYNormal = Int
0
    fromEnum VideoGLTextureOrientation
VideoGLTextureOrientationNormalYFlip = Int
1
    fromEnum VideoGLTextureOrientation
VideoGLTextureOrientationFlipYNormal = Int
2
    fromEnum VideoGLTextureOrientation
VideoGLTextureOrientationFlipYFlip = Int
3
    fromEnum (AnotherVideoGLTextureOrientation Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_gl_texture_orientation_get_type" c_gst_video_gl_texture_orientation_get_type :: 
    IO GType

instance B.Types.TypedObject VideoGLTextureOrientation where
    glibType :: IO GType
glibType = IO GType
c_gst_video_gl_texture_orientation_get_type

instance B.Types.BoxedEnum VideoGLTextureOrientation

-- Enum VideoFormat
-- | Enum value describing the most common video formats.
-- 
-- See the <https://gstreamer.freedesktop.org/documentation/additional/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)
    | VideoFormatRgb10a2Le
    -- ^ packed 4:4:4 RGB with alpha channel(R-G-B-A), 10 bits for R\/G\/B channel and MSB 2 bits for alpha channel (Since: 1.18)
    | VideoFormatY44416be
    -- ^ planar 4:4:4 YUV, 16 bits per channel (Since: 1.18)
    | VideoFormatY44416le
    -- ^ planar 4:4:4 YUV, 16 bits per channel (Since: 1.18)
    | VideoFormatP016Be
    -- ^ planar 4:2:0 YUV with interleaved UV plane, 16 bits per channel (Since: 1.18)
    | VideoFormatP016Le
    -- ^ planar 4:2:0 YUV with interleaved UV plane, 16 bits per channel (Since: 1.18)
    | VideoFormatP012Be
    -- ^ planar 4:2:0 YUV with interleaved UV plane, 12 bits per channel (Since: 1.18)
    | VideoFormatP012Le
    -- ^ planar 4:2:0 YUV with interleaved UV plane, 12 bits per channel (Since: 1.18)
    | VideoFormatY212Be
    -- ^ packed 4:2:2 YUV, 12 bits per channel (Y-U-Y-V) (Since: 1.18)
    | VideoFormatY212Le
    -- ^ packed 4:2:2 YUV, 12 bits per channel (Y-U-Y-V) (Since: 1.18)
    | VideoFormatY412Be
    -- ^ packed 4:4:4:4 YUV, 12 bits per channel(U-Y-V-A...) (Since: 1.18)
    | VideoFormatY412Le
    -- ^ packed 4:4:4:4 YUV, 12 bits per channel(U-Y-V-A...) (Since: 1.18)
    | VideoFormatNv124l4
    -- ^ NV12 with 4x4 tiles in linear order.
    -- 
    -- /Since: 1.18/
    | VideoFormatNv1232l32
    -- ^ NV12 with 32x32 tiles in linear order.
    -- 
    -- /Since: 1.18/
    | VideoFormatRgbp
    -- ^ Planar 4:4:4 RGB, R-G-B order
    -- 
    -- /Since: 1.20/
    | VideoFormatBgrp
    -- ^ Planar 4:4:4 RGB, B-G-R order
    -- 
    -- /Since: 1.20/
    | VideoFormatAv12
    -- ^ Planar 4:2:0 YUV with interleaved UV plane with alpha as
    -- 3rd plane.
    -- 
    -- /Since: 1.20/
    | 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 VideoFormat
VideoFormatUnknown = Int
0
    fromEnum VideoFormat
VideoFormatEncoded = Int
1
    fromEnum VideoFormat
VideoFormatI420 = Int
2
    fromEnum VideoFormat
VideoFormatYv12 = Int
3
    fromEnum VideoFormat
VideoFormatYuy2 = Int
4
    fromEnum VideoFormat
VideoFormatUyvy = Int
5
    fromEnum VideoFormat
VideoFormatAyuv = Int
6
    fromEnum VideoFormat
VideoFormatRgbx = Int
7
    fromEnum VideoFormat
VideoFormatBgrx = Int
8
    fromEnum VideoFormat
VideoFormatXrgb = Int
9
    fromEnum VideoFormat
VideoFormatXbgr = Int
10
    fromEnum VideoFormat
VideoFormatRgba = Int
11
    fromEnum VideoFormat
VideoFormatBgra = Int
12
    fromEnum VideoFormat
VideoFormatArgb = Int
13
    fromEnum VideoFormat
VideoFormatAbgr = Int
14
    fromEnum VideoFormat
VideoFormatRgb = Int
15
    fromEnum VideoFormat
VideoFormatBgr = Int
16
    fromEnum VideoFormat
VideoFormatY41b = Int
17
    fromEnum VideoFormat
VideoFormatY42b = Int
18
    fromEnum VideoFormat
VideoFormatYvyu = Int
19
    fromEnum VideoFormat
VideoFormatY444 = Int
20
    fromEnum VideoFormat
VideoFormatV210 = Int
21
    fromEnum VideoFormat
VideoFormatV216 = Int
22
    fromEnum VideoFormat
VideoFormatNv12 = Int
23
    fromEnum VideoFormat
VideoFormatNv21 = Int
24
    fromEnum VideoFormat
VideoFormatGray8 = Int
25
    fromEnum VideoFormat
VideoFormatGray16Be = Int
26
    fromEnum VideoFormat
VideoFormatGray16Le = Int
27
    fromEnum VideoFormat
VideoFormatV308 = Int
28
    fromEnum VideoFormat
VideoFormatRgb16 = Int
29
    fromEnum VideoFormat
VideoFormatBgr16 = Int
30
    fromEnum VideoFormat
VideoFormatRgb15 = Int
31
    fromEnum VideoFormat
VideoFormatBgr15 = Int
32
    fromEnum VideoFormat
VideoFormatUyvp = Int
33
    fromEnum VideoFormat
VideoFormatA420 = Int
34
    fromEnum VideoFormat
VideoFormatRgb8p = Int
35
    fromEnum VideoFormat
VideoFormatYuv9 = Int
36
    fromEnum VideoFormat
VideoFormatYvu9 = Int
37
    fromEnum VideoFormat
VideoFormatIyu1 = Int
38
    fromEnum VideoFormat
VideoFormatArgb64 = Int
39
    fromEnum VideoFormat
VideoFormatAyuv64 = Int
40
    fromEnum VideoFormat
VideoFormatR210 = Int
41
    fromEnum VideoFormat
VideoFormatI42010be = Int
42
    fromEnum VideoFormat
VideoFormatI42010le = Int
43
    fromEnum VideoFormat
VideoFormatI42210be = Int
44
    fromEnum VideoFormat
VideoFormatI42210le = Int
45
    fromEnum VideoFormat
VideoFormatY44410be = Int
46
    fromEnum VideoFormat
VideoFormatY44410le = Int
47
    fromEnum VideoFormat
VideoFormatGbr = Int
48
    fromEnum VideoFormat
VideoFormatGbr10be = Int
49
    fromEnum VideoFormat
VideoFormatGbr10le = Int
50
    fromEnum VideoFormat
VideoFormatNv16 = Int
51
    fromEnum VideoFormat
VideoFormatNv24 = Int
52
    fromEnum VideoFormat
VideoFormatNv1264z32 = Int
53
    fromEnum VideoFormat
VideoFormatA42010be = Int
54
    fromEnum VideoFormat
VideoFormatA42010le = Int
55
    fromEnum VideoFormat
VideoFormatA42210be = Int
56
    fromEnum VideoFormat
VideoFormatA42210le = Int
57
    fromEnum VideoFormat
VideoFormatA44410be = Int
58
    fromEnum VideoFormat
VideoFormatA44410le = Int
59
    fromEnum VideoFormat
VideoFormatNv61 = Int
60
    fromEnum VideoFormat
VideoFormatP01010be = Int
61
    fromEnum VideoFormat
VideoFormatP01010le = Int
62
    fromEnum VideoFormat
VideoFormatIyu2 = Int
63
    fromEnum VideoFormat
VideoFormatVyuy = Int
64
    fromEnum VideoFormat
VideoFormatGbra = Int
65
    fromEnum VideoFormat
VideoFormatGbra10be = Int
66
    fromEnum VideoFormat
VideoFormatGbra10le = Int
67
    fromEnum VideoFormat
VideoFormatGbr12be = Int
68
    fromEnum VideoFormat
VideoFormatGbr12le = Int
69
    fromEnum VideoFormat
VideoFormatGbra12be = Int
70
    fromEnum VideoFormat
VideoFormatGbra12le = Int
71
    fromEnum VideoFormat
VideoFormatI42012be = Int
72
    fromEnum VideoFormat
VideoFormatI42012le = Int
73
    fromEnum VideoFormat
VideoFormatI42212be = Int
74
    fromEnum VideoFormat
VideoFormatI42212le = Int
75
    fromEnum VideoFormat
VideoFormatY44412be = Int
76
    fromEnum VideoFormat
VideoFormatY44412le = Int
77
    fromEnum VideoFormat
VideoFormatGray10Le32 = Int
78
    fromEnum VideoFormat
VideoFormatNv1210le32 = Int
79
    fromEnum VideoFormat
VideoFormatNv1610le32 = Int
80
    fromEnum VideoFormat
VideoFormatNv1210le40 = Int
81
    fromEnum VideoFormat
VideoFormatY210 = Int
82
    fromEnum VideoFormat
VideoFormatY410 = Int
83
    fromEnum VideoFormat
VideoFormatVuya = Int
84
    fromEnum VideoFormat
VideoFormatBgr10a2Le = Int
85
    fromEnum VideoFormat
VideoFormatRgb10a2Le = Int
86
    fromEnum VideoFormat
VideoFormatY44416be = Int
87
    fromEnum VideoFormat
VideoFormatY44416le = Int
88
    fromEnum VideoFormat
VideoFormatP016Be = Int
89
    fromEnum VideoFormat
VideoFormatP016Le = Int
90
    fromEnum VideoFormat
VideoFormatP012Be = Int
91
    fromEnum VideoFormat
VideoFormatP012Le = Int
92
    fromEnum VideoFormat
VideoFormatY212Be = Int
93
    fromEnum VideoFormat
VideoFormatY212Le = Int
94
    fromEnum VideoFormat
VideoFormatY412Be = Int
95
    fromEnum VideoFormat
VideoFormatY412Le = Int
96
    fromEnum VideoFormat
VideoFormatNv124l4 = Int
97
    fromEnum VideoFormat
VideoFormatNv1232l32 = Int
98
    fromEnum VideoFormat
VideoFormatRgbp = Int
99
    fromEnum VideoFormat
VideoFormatBgrp = Int
100
    fromEnum VideoFormat
VideoFormatAv12 = Int
101
    fromEnum (AnotherVideoFormat Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_format_get_type" c_gst_video_format_get_type :: 
    IO GType

instance B.Types.TypedObject VideoFormat where
    glibType :: IO GType
glibType = IO GType
c_gst_video_format_get_type

instance B.Types.BoxedEnum VideoFormat

-- 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 VideoFieldOrder
VideoFieldOrderUnknown = Int
0
    fromEnum VideoFieldOrder
VideoFieldOrderTopFieldFirst = Int
1
    fromEnum VideoFieldOrder
VideoFieldOrderBottomFieldFirst = Int
2
    fromEnum (AnotherVideoFieldOrder Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_field_order_get_type" c_gst_video_field_order_get_type :: 
    IO GType

instance B.Types.TypedObject VideoFieldOrder where
    glibType :: IO GType
glibType = IO GType
c_gst_video_field_order_get_type

instance B.Types.BoxedEnum VideoFieldOrder

-- 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 VideoDitherMethod
VideoDitherMethodNone = Int
0
    fromEnum VideoDitherMethod
VideoDitherMethodVerterr = Int
1
    fromEnum VideoDitherMethod
VideoDitherMethodFloydSteinberg = Int
2
    fromEnum VideoDitherMethod
VideoDitherMethodSierraLite = Int
3
    fromEnum VideoDitherMethod
VideoDitherMethodBayer = Int
4
    fromEnum (AnotherVideoDitherMethod Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_dither_method_get_type" c_gst_video_dither_method_get_type :: 
    IO GType

instance B.Types.TypedObject VideoDitherMethod where
    glibType :: IO GType
glibType = IO GType
c_gst_video_dither_method_get_type

instance B.Types.BoxedEnum VideoDitherMethod

-- 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 VideoColorRange
VideoColorRangeUnknown = Int
0
    fromEnum VideoColorRange
VideoColorRange0255 = Int
1
    fromEnum VideoColorRange
VideoColorRange16235 = Int
2
    fromEnum (AnotherVideoColorRange Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_color_range_get_type" c_gst_video_color_range_get_type :: 
    IO GType

instance B.Types.TypedObject VideoColorRange where
    glibType :: IO GType
glibType = IO GType
c_gst_video_color_range_get_type

instance B.Types.BoxedEnum VideoColorRange

-- 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, also ITU-R BT1361 \/ IEC
    -- 61966-2-4 \/ SMPTE RP177 Annex B
    | VideoColorPrimariesBt470m
    -- ^ BT470M primaries, also FCC Title 47 Code
    -- of Federal Regulations 73.682 (a)(20)
    | VideoColorPrimariesBt470bg
    -- ^ BT470BG primaries, also ITU-R BT601-6
    -- 625 \/ ITU-R BT1358 625 \/ ITU-R BT1700 625 PAL & SECAM
    | VideoColorPrimariesSmpte170m
    -- ^ SMPTE170M primaries, also ITU-R
    -- BT601-6 525 \/ ITU-R BT1358 525 \/ ITU-R BT1700 NTSC
    | VideoColorPrimariesSmpte240m
    -- ^ SMPTE240M primaries
    | VideoColorPrimariesFilm
    -- ^ Generic film (colour filters using
    -- Illuminant C)
    | VideoColorPrimariesBt2020
    -- ^ ITU-R BT2020 primaries. Since: 1.6
    | VideoColorPrimariesAdobergb
    -- ^ Adobe RGB primaries. Since: 1.8
    | VideoColorPrimariesSmptest428
    -- ^ SMPTE ST 428 primaries (CIE 1931
    -- XYZ). Since: 1.16
    | VideoColorPrimariesSmpterp431
    -- ^ SMPTE RP 431 primaries (ST 431-2
    -- (2011) \/ DCI P3). Since: 1.16
    | VideoColorPrimariesSmpteeg432
    -- ^ SMPTE EG 432 primaries (ST 432-1
    -- (2010) \/ P3 D65). Since: 1.16
    | VideoColorPrimariesEbu3213
    -- ^ EBU 3213 primaries (JEDEC P22
    -- phosphors). 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 VideoColorPrimaries
VideoColorPrimariesUnknown = Int
0
    fromEnum VideoColorPrimaries
VideoColorPrimariesBt709 = Int
1
    fromEnum VideoColorPrimaries
VideoColorPrimariesBt470m = Int
2
    fromEnum VideoColorPrimaries
VideoColorPrimariesBt470bg = Int
3
    fromEnum VideoColorPrimaries
VideoColorPrimariesSmpte170m = Int
4
    fromEnum VideoColorPrimaries
VideoColorPrimariesSmpte240m = Int
5
    fromEnum VideoColorPrimaries
VideoColorPrimariesFilm = Int
6
    fromEnum VideoColorPrimaries
VideoColorPrimariesBt2020 = Int
7
    fromEnum VideoColorPrimaries
VideoColorPrimariesAdobergb = Int
8
    fromEnum VideoColorPrimaries
VideoColorPrimariesSmptest428 = Int
9
    fromEnum VideoColorPrimaries
VideoColorPrimariesSmpterp431 = Int
10
    fromEnum VideoColorPrimaries
VideoColorPrimariesSmpteeg432 = Int
11
    fromEnum VideoColorPrimaries
VideoColorPrimariesEbu3213 = Int
12
    fromEnum (AnotherVideoColorPrimaries Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_color_primaries_get_type" c_gst_video_color_primaries_get_type :: 
    IO GType

instance B.Types.TypedObject VideoColorPrimaries where
    glibType :: IO GType
glibType = IO GType
c_gst_video_color_primaries_get_type

instance B.Types.BoxedEnum VideoColorPrimaries

-- 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. Order of coefficients is
    -- actually GBR, also IEC 61966-2-1 (sRGB)
    | VideoColorMatrixFcc
    -- ^ FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
    | VideoColorMatrixBt709
    -- ^ ITU-R BT.709 color matrix, also ITU-R BT1361
    -- \/ IEC 61966-2-4 xvYCC709 \/ SMPTE RP177 Annex B
    | VideoColorMatrixBt601
    -- ^ ITU-R BT.601 color matrix, also SMPTE170M \/ ITU-R BT1358 525 \/ ITU-R BT1700 NTSC
    | 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 VideoColorMatrix
VideoColorMatrixUnknown = Int
0
    fromEnum VideoColorMatrix
VideoColorMatrixRgb = Int
1
    fromEnum VideoColorMatrix
VideoColorMatrixFcc = Int
2
    fromEnum VideoColorMatrix
VideoColorMatrixBt709 = Int
3
    fromEnum VideoColorMatrix
VideoColorMatrixBt601 = Int
4
    fromEnum VideoColorMatrix
VideoColorMatrixSmpte240m = Int
5
    fromEnum VideoColorMatrix
VideoColorMatrixBt2020 = Int
6
    fromEnum (AnotherVideoColorMatrix Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_color_matrix_get_type" c_gst_video_color_matrix_get_type :: 
    IO GType

instance B.Types.TypedObject VideoColorMatrix where
    glibType :: IO GType
glibType = IO GType
c_gst_video_color_matrix_get_type

instance B.Types.BoxedEnum VideoColorMatrix

-- 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 VideoChromaMode
VideoChromaModeFull = Int
0
    fromEnum VideoChromaMode
VideoChromaModeUpsampleOnly = Int
1
    fromEnum VideoChromaMode
VideoChromaModeDownsampleOnly = Int
2
    fromEnum VideoChromaMode
VideoChromaModeNone = Int
3
    fromEnum (AnotherVideoChromaMode Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_chroma_mode_get_type" c_gst_video_chroma_mode_get_type :: 
    IO GType

instance B.Types.TypedObject VideoChromaMode where
    glibType :: IO GType
glibType = IO GType
c_gst_video_chroma_mode_get_type

instance B.Types.BoxedEnum VideoChromaMode

-- 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 VideoChromaMethod
VideoChromaMethodNearest = Int
0
    fromEnum VideoChromaMethod
VideoChromaMethodLinear = Int
1
    fromEnum (AnotherVideoChromaMethod Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_chroma_method_get_type" c_gst_video_chroma_method_get_type :: 
    IO GType

instance B.Types.TypedObject VideoChromaMethod where
    glibType :: IO GType
glibType = IO GType
c_gst_video_chroma_method_get_type

instance B.Types.BoxedEnum VideoChromaMethod

-- 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 VideoCaptionType
VideoCaptionTypeUnknown = Int
0
    fromEnum VideoCaptionType
VideoCaptionTypeCea608Raw = Int
1
    fromEnum VideoCaptionType
VideoCaptionTypeCea608S3341a = Int
2
    fromEnum VideoCaptionType
VideoCaptionTypeCea708Raw = Int
3
    fromEnum VideoCaptionType
VideoCaptionTypeCea708Cdp = Int
4
    fromEnum (AnotherVideoCaptionType Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_caption_type_get_type" c_gst_video_caption_type_get_type :: 
    IO GType

instance B.Types.TypedObject VideoCaptionType where
    glibType :: IO GType
glibType = IO GType
c_gst_video_caption_type_get_type

instance B.Types.BoxedEnum VideoCaptionType

-- Enum VideoAncillaryDID16
-- | Some know types of Ancillary Data identifiers.
-- 
-- /Since: 1.16/
data VideoAncillaryDID16 = 
      VideoAncillaryDID16S334Eia708
    -- ^ CEA 708 Ancillary data according to SMPTE 334
    | VideoAncillaryDID16S334Eia608
    -- ^ CEA 608 Ancillary data according to SMPTE 334
    | VideoAncillaryDID16S20163AfdBar
    -- ^ AFD\/Bar Ancillary data according to SMPTE 2016-3 (Since: 1.18)
    | 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 VideoAncillaryDID16
VideoAncillaryDID16S334Eia708 = Int
24833
    fromEnum VideoAncillaryDID16
VideoAncillaryDID16S334Eia608 = Int
24834
    fromEnum VideoAncillaryDID16
VideoAncillaryDID16S20163AfdBar = Int
16645
    fromEnum (AnotherVideoAncillaryDID16 Int
k) = Int
k

    toEnum :: Int -> VideoAncillaryDID16
toEnum Int
24833 = VideoAncillaryDID16
VideoAncillaryDID16S334Eia708
    toEnum Int
24834 = VideoAncillaryDID16
VideoAncillaryDID16S334Eia608
    toEnum Int
16645 = VideoAncillaryDID16
VideoAncillaryDID16S20163AfdBar
    toEnum Int
k = Int -> VideoAncillaryDID16
AnotherVideoAncillaryDID16 Int
k

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

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

foreign import ccall "gst_video_ancillary_di_d16_get_type" c_gst_video_ancillary_di_d16_get_type :: 
    IO GType

instance B.Types.TypedObject VideoAncillaryDID16 where
    glibType :: IO GType
glibType = IO GType
c_gst_video_ancillary_di_d16_get_type

instance B.Types.BoxedEnum VideoAncillaryDID16

-- Enum VideoAncillaryDID
-- | /No description available in the introspection data./
-- 
-- /Since: 1.16/
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 VideoAncillaryDID
VideoAncillaryDIDUndefined = Int
0
    fromEnum VideoAncillaryDID
VideoAncillaryDIDDeletion = Int
128
    fromEnum VideoAncillaryDID
VideoAncillaryDIDHanc3gAudioDataFirst = Int
160
    fromEnum VideoAncillaryDID
VideoAncillaryDIDHanc3gAudioDataLast = Int
167
    fromEnum VideoAncillaryDID
VideoAncillaryDIDHancHdtvAudioDataFirst = Int
224
    fromEnum VideoAncillaryDID
VideoAncillaryDIDHancHdtvAudioDataLast = Int
231
    fromEnum VideoAncillaryDID
VideoAncillaryDIDHancSdtvAudioData1First = Int
236
    fromEnum VideoAncillaryDID
VideoAncillaryDIDHancSdtvAudioData1Last = Int
239
    fromEnum VideoAncillaryDID
VideoAncillaryDIDCameraPosition = Int
240
    fromEnum VideoAncillaryDID
VideoAncillaryDIDHancErrorDetection = Int
244
    fromEnum VideoAncillaryDID
VideoAncillaryDIDHancSdtvAudioData2First = Int
248
    fromEnum VideoAncillaryDID
VideoAncillaryDIDHancSdtvAudioData2Last = Int
255
    fromEnum (AnotherVideoAncillaryDID Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_ancillary_did_get_type" c_gst_video_ancillary_did_get_type :: 
    IO GType

instance B.Types.TypedObject VideoAncillaryDID where
    glibType :: IO GType
glibType = IO GType
c_gst_video_ancillary_did_get_type

instance B.Types.BoxedEnum VideoAncillaryDID

-- 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 VideoAlphaMode
VideoAlphaModeCopy = Int
0
    fromEnum VideoAlphaMode
VideoAlphaModeSet = Int
1
    fromEnum VideoAlphaMode
VideoAlphaModeMult = Int
2
    fromEnum (AnotherVideoAlphaMode Int
k) = Int
k

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

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

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

foreign import ccall "gst_video_alpha_mode_get_type" c_gst_video_alpha_mode_get_type :: 
    IO GType

instance B.Types.TypedObject VideoAlphaMode where
    glibType :: IO GType
glibType = IO GType
c_gst_video_alpha_mode_get_type

instance B.Types.BoxedEnum VideoAlphaMode

-- Enum VideoAFDValue
-- | Enumeration of the various values for Active Format Description (AFD)
-- 
-- AFD should be included in video user data whenever the rectangular
-- picture area containing useful information does not extend to the full height or width of the coded
-- frame. AFD data may also be included in user data when the rectangular picture area containing
-- useful information extends to the full height and width of the coded frame.
-- 
-- For details, see Table 6.14 Active Format in:
-- 
-- ATSC Digital Television Standard:
-- Part 4 – MPEG-2 Video System Characteristics
-- 
-- https:\/\/www.atsc.org\/wp-content\/uploads\/2015\/03\/a_53-Part-4-2009.pdf
-- 
-- and Active Format Description in Complete list of AFD codes
-- 
-- https:\/\/en.wikipedia.org\/wiki\/Active_Format_Description@/Complete_list_of_AFD_codes/@
-- 
-- and SMPTE ST2016-1
-- 
-- Notes:
-- 
-- 1) AFD 0 is undefined for ATSC and SMPTE ST2016-1, indicating that AFD data is not available:
-- If Bar Data is not present, AFD \'0000\' indicates that exact information
-- is not available and the active image should be assumed to be the same as the coded frame. AFD \'0000\'.
-- AFD \'0000\' accompanied by Bar Data signals that the active image’s aspect ratio is narrower than 16:9,
-- but is not 4:3 or 14:9. As the exact aspect ratio cannot be conveyed by AFD alone, wherever possible,
-- AFD ‘0000’ should be accompanied by Bar Data to define the exact vertical or horizontal extent
-- of the active image.
-- 2) AFD 0 is reserved for DVB\/ETSI
-- 3) values 1, 5, 6, 7, and 12 are reserved for both ATSC and DVB\/ETSI
-- 4) values 2 and 3 are not recommended for ATSC, but are valid for DVB\/ETSI
-- 
-- /Since: 1.18/
data VideoAFDValue = 
      VideoAFDValueUnavailable
    -- ^ Unavailable (see note 0 below).
    | VideoAFDValue169TopAligned
    -- ^ For 4:3 coded frame, letterbox 16:9 image,
    --      at top of the coded frame. For 16:9 coded frame, full frame 16:9 image,
    --      the same as the coded frame.
    | VideoAFDValue149TopAligned
    -- ^ For 4:3 coded frame, letterbox 14:9 image,
    --      at top of the coded frame. For 16:9 coded frame, pillarbox 14:9 image,
    --      horizontally centered in the coded frame.
    | VideoAFDValueGreaterThan169
    -- ^ For 4:3 coded frame, letterbox image with an aspect ratio
    --      greater than 16:9, vertically centered in the coded frame. For 16:9 coded frame,
    --      letterbox image with an aspect ratio greater than 16:9.
    | VideoAFDValue43Full169Full
    -- ^ For 4:3 coded frame, full frame 4:3 image,
    --      the same as the coded frame. For 16:9 coded frame, full frame 16:9 image, the same as
    --      the coded frame.
    | VideoAFDValue43Full43Pillar
    -- ^ For 4:3 coded frame, full frame 4:3 image, the same as
    --      the coded frame. For 16:9 coded frame, pillarbox 4:3 image, horizontally centered in the
    --      coded frame.
    | VideoAFDValue169Letter169Full
    -- ^ For 4:3 coded frame, letterbox 16:9 image, vertically centered in
    --      the coded frame with all image areas protected. For 16:9 coded frame, full frame 16:9 image,
    --      with all image areas protected.
    | VideoAFDValue149Letter149Pillar
    -- ^ For 4:3 coded frame, letterbox 14:9 image, vertically centered in
    --      the coded frame. For 16:9 coded frame, pillarbox 14:9 image, horizontally centered in the
    --      coded frame.
    | VideoAFDValue43Full149Center
    -- ^ For 4:3 coded frame, full frame 4:3 image, with alternative 14:9
    --      center. For 16:9 coded frame, pillarbox 4:3 image, with alternative 14:9 center.
    | VideoAFDValue169Letter149Center
    -- ^ For 4:3 coded frame, letterbox 16:9 image, with alternative 14:9
    --      center. For 16:9 coded frame, full frame 16:9 image, with alternative 14:9 center.
    | VideoAFDValue169Letter43Center
    -- ^ For 4:3 coded frame, letterbox 16:9 image, with alternative 4:3
    --      center. For 16:9 coded frame, full frame 16:9 image, with alternative 4:3 center.
    | AnotherVideoAFDValue Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoAFDValue -> ShowS
[VideoAFDValue] -> ShowS
VideoAFDValue -> String
(Int -> VideoAFDValue -> ShowS)
-> (VideoAFDValue -> String)
-> ([VideoAFDValue] -> ShowS)
-> Show VideoAFDValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoAFDValue] -> ShowS
$cshowList :: [VideoAFDValue] -> ShowS
show :: VideoAFDValue -> String
$cshow :: VideoAFDValue -> String
showsPrec :: Int -> VideoAFDValue -> ShowS
$cshowsPrec :: Int -> VideoAFDValue -> ShowS
Show, VideoAFDValue -> VideoAFDValue -> Bool
(VideoAFDValue -> VideoAFDValue -> Bool)
-> (VideoAFDValue -> VideoAFDValue -> Bool) -> Eq VideoAFDValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoAFDValue -> VideoAFDValue -> Bool
$c/= :: VideoAFDValue -> VideoAFDValue -> Bool
== :: VideoAFDValue -> VideoAFDValue -> Bool
$c== :: VideoAFDValue -> VideoAFDValue -> Bool
Eq)

instance P.Enum VideoAFDValue where
    fromEnum :: VideoAFDValue -> Int
fromEnum VideoAFDValue
VideoAFDValueUnavailable = Int
0
    fromEnum VideoAFDValue
VideoAFDValue169TopAligned = Int
2
    fromEnum VideoAFDValue
VideoAFDValue149TopAligned = Int
3
    fromEnum VideoAFDValue
VideoAFDValueGreaterThan169 = Int
4
    fromEnum VideoAFDValue
VideoAFDValue43Full169Full = Int
8
    fromEnum VideoAFDValue
VideoAFDValue43Full43Pillar = Int
9
    fromEnum VideoAFDValue
VideoAFDValue169Letter169Full = Int
10
    fromEnum VideoAFDValue
VideoAFDValue149Letter149Pillar = Int
11
    fromEnum VideoAFDValue
VideoAFDValue43Full149Center = Int
13
    fromEnum VideoAFDValue
VideoAFDValue169Letter149Center = Int
14
    fromEnum VideoAFDValue
VideoAFDValue169Letter43Center = Int
15
    fromEnum (AnotherVideoAFDValue Int
k) = Int
k

    toEnum :: Int -> VideoAFDValue
toEnum Int
0 = VideoAFDValue
VideoAFDValueUnavailable
    toEnum Int
2 = VideoAFDValue
VideoAFDValue169TopAligned
    toEnum Int
3 = VideoAFDValue
VideoAFDValue149TopAligned
    toEnum Int
4 = VideoAFDValue
VideoAFDValueGreaterThan169
    toEnum Int
8 = VideoAFDValue
VideoAFDValue43Full169Full
    toEnum Int
9 = VideoAFDValue
VideoAFDValue43Full43Pillar
    toEnum Int
10 = VideoAFDValue
VideoAFDValue169Letter169Full
    toEnum Int
11 = VideoAFDValue
VideoAFDValue149Letter149Pillar
    toEnum Int
13 = VideoAFDValue
VideoAFDValue43Full149Center
    toEnum Int
14 = VideoAFDValue
VideoAFDValue169Letter149Center
    toEnum Int
15 = VideoAFDValue
VideoAFDValue169Letter43Center
    toEnum Int
k = Int -> VideoAFDValue
AnotherVideoAFDValue Int
k

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

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

foreign import ccall "gst_video_afd_value_get_type" c_gst_video_afd_value_get_type :: 
    IO GType

instance B.Types.TypedObject VideoAFDValue where
    glibType :: IO GType
glibType = IO GType
c_gst_video_afd_value_get_type

instance B.Types.BoxedEnum VideoAFDValue

-- Enum VideoAFDSpec
-- | Enumeration of the different standards that may apply to AFD data:
-- 
-- 0) ETSI\/DVB:
-- https:\/\/www.etsi.org\/deliver\/etsi_ts\/101100_101199\/101154\/02.01.01_60\/ts_101154v020101p.pdf
-- 
-- 1) ATSC A\/53:
-- https:\/\/www.atsc.org\/wp-content\/uploads\/2015\/03\/a_53-Part-4-2009.pdf
-- 
-- 2) SMPTE ST2016-1:
-- 
-- /Since: 1.18/
data VideoAFDSpec = 
      VideoAFDSpecDvbEtsi
    -- ^ AFD value is from DVB\/ETSI standard
    | VideoAFDSpecAtscA53
    -- ^ AFD value is from ATSC A\/53 standard
    | VideoAFDSpecSmpteSt20161
    -- ^ /No description available in the introspection data./
    | AnotherVideoAFDSpec Int
    -- ^ Catch-all for unknown values
    deriving (Int -> VideoAFDSpec -> ShowS
[VideoAFDSpec] -> ShowS
VideoAFDSpec -> String
(Int -> VideoAFDSpec -> ShowS)
-> (VideoAFDSpec -> String)
-> ([VideoAFDSpec] -> ShowS)
-> Show VideoAFDSpec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VideoAFDSpec] -> ShowS
$cshowList :: [VideoAFDSpec] -> ShowS
show :: VideoAFDSpec -> String
$cshow :: VideoAFDSpec -> String
showsPrec :: Int -> VideoAFDSpec -> ShowS
$cshowsPrec :: Int -> VideoAFDSpec -> ShowS
Show, VideoAFDSpec -> VideoAFDSpec -> Bool
(VideoAFDSpec -> VideoAFDSpec -> Bool)
-> (VideoAFDSpec -> VideoAFDSpec -> Bool) -> Eq VideoAFDSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoAFDSpec -> VideoAFDSpec -> Bool
$c/= :: VideoAFDSpec -> VideoAFDSpec -> Bool
== :: VideoAFDSpec -> VideoAFDSpec -> Bool
$c== :: VideoAFDSpec -> VideoAFDSpec -> Bool
Eq)

instance P.Enum VideoAFDSpec where
    fromEnum :: VideoAFDSpec -> Int
fromEnum VideoAFDSpec
VideoAFDSpecDvbEtsi = Int
0
    fromEnum VideoAFDSpec
VideoAFDSpecAtscA53 = Int
1
    fromEnum VideoAFDSpec
VideoAFDSpecSmpteSt20161 = Int
2
    fromEnum (AnotherVideoAFDSpec Int
k) = Int
k

    toEnum :: Int -> VideoAFDSpec
toEnum Int
0 = VideoAFDSpec
VideoAFDSpecDvbEtsi
    toEnum Int
1 = VideoAFDSpec
VideoAFDSpecAtscA53
    toEnum Int
2 = VideoAFDSpec
VideoAFDSpecSmpteSt20161
    toEnum Int
k = Int -> VideoAFDSpec
AnotherVideoAFDSpec Int
k

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

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

foreign import ccall "gst_video_afd_spec_get_type" c_gst_video_afd_spec_get_type :: 
    IO GType

instance B.Types.TypedObject VideoAFDSpec where
    glibType :: IO GType
glibType = IO GType
c_gst_video_afd_spec_get_type

instance B.Types.BoxedEnum VideoAFDSpec

-- Enum NavigationQueryType
-- | Types 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 NavigationQueryType
NavigationQueryTypeInvalid = Int
0
    fromEnum NavigationQueryType
NavigationQueryTypeCommands = Int
1
    fromEnum NavigationQueryType
NavigationQueryTypeAngles = Int
2
    fromEnum (AnotherNavigationQueryType Int
k) = Int
k

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

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

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

foreign import ccall "gst_navigation_query_type_get_type" c_gst_navigation_query_type_get_type :: 
    IO GType

instance B.Types.TypedObject NavigationQueryType where
    glibType :: IO GType
glibType = IO GType
c_gst_navigation_query_type_get_type

instance B.Types.BoxedEnum NavigationQueryType

-- 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 NavigationMessageType
NavigationMessageTypeInvalid = Int
0
    fromEnum NavigationMessageType
NavigationMessageTypeMouseOver = Int
1
    fromEnum NavigationMessageType
NavigationMessageTypeCommandsChanged = Int
2
    fromEnum NavigationMessageType
NavigationMessageTypeAnglesChanged = Int
3
    fromEnum NavigationMessageType
NavigationMessageTypeEvent = Int
4
    fromEnum (AnotherNavigationMessageType Int
k) = Int
k

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

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

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

foreign import ccall "gst_navigation_message_type_get_type" c_gst_navigation_message_type_get_type :: 
    IO GType

instance B.Types.TypedObject NavigationMessageType where
    glibType :: IO GType
glibType = IO GType
c_gst_navigation_message_type_get_type

instance B.Types.BoxedEnum NavigationMessageType

-- 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.
    | NavigationEventTypeMouseScroll
    -- ^ A mouse scroll event. Use
    -- 'GI.GstVideo.Functions.navigationEventParseMouseScrollEvent' to extract the details from
    -- the event. (Since: 1.18)
    | 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 NavigationEventType
NavigationEventTypeInvalid = Int
0
    fromEnum NavigationEventType
NavigationEventTypeKeyPress = Int
1
    fromEnum NavigationEventType
NavigationEventTypeKeyRelease = Int
2
    fromEnum NavigationEventType
NavigationEventTypeMouseButtonPress = Int
3
    fromEnum NavigationEventType
NavigationEventTypeMouseButtonRelease = Int
4
    fromEnum NavigationEventType
NavigationEventTypeMouseMove = Int
5
    fromEnum NavigationEventType
NavigationEventTypeCommand = Int
6
    fromEnum NavigationEventType
NavigationEventTypeMouseScroll = Int
7
    fromEnum (AnotherNavigationEventType Int
k) = Int
k

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

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

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

foreign import ccall "gst_navigation_event_type_get_type" c_gst_navigation_event_type_get_type :: 
    IO GType

instance B.Types.TypedObject NavigationEventType where
    glibType :: IO GType
glibType = IO GType
c_gst_navigation_event_type_get_type

instance B.Types.BoxedEnum NavigationEventType

-- 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 NavigationCommand
NavigationCommandInvalid = Int
0
    fromEnum NavigationCommand
NavigationCommandMenu1 = Int
1
    fromEnum NavigationCommand
NavigationCommandMenu2 = Int
2
    fromEnum NavigationCommand
NavigationCommandMenu3 = Int
3
    fromEnum NavigationCommand
NavigationCommandMenu4 = Int
4
    fromEnum NavigationCommand
NavigationCommandMenu5 = Int
5
    fromEnum NavigationCommand
NavigationCommandMenu6 = Int
6
    fromEnum NavigationCommand
NavigationCommandMenu7 = Int
7
    fromEnum NavigationCommand
NavigationCommandLeft = Int
20
    fromEnum NavigationCommand
NavigationCommandRight = Int
21
    fromEnum NavigationCommand
NavigationCommandUp = Int
22
    fromEnum NavigationCommand
NavigationCommandDown = Int
23
    fromEnum NavigationCommand
NavigationCommandActivate = Int
24
    fromEnum NavigationCommand
NavigationCommandPrevAngle = Int
30
    fromEnum NavigationCommand
NavigationCommandNextAngle = Int
31
    fromEnum (AnotherNavigationCommand Int
k) = Int
k

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

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

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

foreign import ccall "gst_navigation_command_get_type" c_gst_navigation_command_get_type :: 
    IO GType

instance B.Types.TypedObject NavigationCommand where
    glibType :: IO GType
glibType = IO GType
c_gst_navigation_command_get_type

instance B.Types.BoxedEnum NavigationCommand

-- 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 ColorBalanceType
ColorBalanceTypeHardware = Int
0
    fromEnum ColorBalanceType
ColorBalanceTypeSoftware = Int
1
    fromEnum (AnotherColorBalanceType Int
k) = Int
k

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

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

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

foreign import ccall "gst_color_balance_type_get_type" c_gst_color_balance_type_get_type :: 
    IO GType

instance B.Types.TypedObject ColorBalanceType where
    glibType :: IO GType
glibType = IO GType
c_gst_color_balance_type_get_type

instance B.Types.BoxedEnum ColorBalanceType