{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.GstVideo.Enums
    (

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

    ColorBalanceType(..)                    ,


-- ** NavigationCommand #enum:NavigationCommand#

    NavigationCommand(..)                   ,


-- ** NavigationEventType #enum:NavigationEventType#

    NavigationEventType(..)                 ,


-- ** NavigationMessageType #enum:NavigationMessageType#

    NavigationMessageType(..)               ,


-- ** NavigationQueryType #enum:NavigationQueryType#

    NavigationQueryType(..)                 ,


-- ** VideoAlphaMode #enum:VideoAlphaMode#

    VideoAlphaMode(..)                      ,


-- ** VideoAncillaryDID #enum:VideoAncillaryDID#

    VideoAncillaryDID(..)                   ,


-- ** VideoAncillaryDID16 #enum:VideoAncillaryDID16#

    VideoAncillaryDID16(..)                 ,


-- ** VideoCaptionType #enum:VideoCaptionType#

    VideoCaptionType(..)                    ,


-- ** VideoChromaMethod #enum:VideoChromaMethod#

    VideoChromaMethod(..)                   ,


-- ** VideoChromaMode #enum:VideoChromaMode#

    VideoChromaMode(..)                     ,


-- ** VideoColorMatrix #enum:VideoColorMatrix#

    VideoColorMatrix(..)                    ,


-- ** VideoColorPrimaries #enum:VideoColorPrimaries#

    VideoColorPrimaries(..)                 ,


-- ** VideoColorRange #enum:VideoColorRange#

    VideoColorRange(..)                     ,


-- ** VideoDitherMethod #enum:VideoDitherMethod#

    VideoDitherMethod(..)                   ,


-- ** VideoFieldOrder #enum:VideoFieldOrder#

    VideoFieldOrder(..)                     ,


-- ** VideoFormat #enum:VideoFormat#

    VideoFormat(..)                         ,


-- ** VideoGLTextureOrientation #enum:VideoGLTextureOrientation#

    VideoGLTextureOrientation(..)           ,


-- ** VideoGLTextureType #enum:VideoGLTextureType#

    VideoGLTextureType(..)                  ,


-- ** VideoGammaMode #enum:VideoGammaMode#

    VideoGammaMode(..)                      ,


-- ** VideoInterlaceMode #enum:VideoInterlaceMode#

    VideoInterlaceMode(..)                  ,


-- ** VideoMatrixMode #enum:VideoMatrixMode#

    VideoMatrixMode(..)                     ,


-- ** VideoMultiviewFramePacking #enum:VideoMultiviewFramePacking#

    VideoMultiviewFramePacking(..)          ,


-- ** VideoMultiviewMode #enum:VideoMultiviewMode#

    VideoMultiviewMode(..)                  ,


-- ** VideoOrientationMethod #enum:VideoOrientationMethod#

    VideoOrientationMethod(..)              ,


-- ** VideoPrimariesMode #enum:VideoPrimariesMode#

    VideoPrimariesMode(..)                  ,


-- ** VideoResamplerMethod #enum:VideoResamplerMethod#

    VideoResamplerMethod(..)                ,


-- ** VideoTileMode #enum:VideoTileMode#

    VideoTileMode(..)                       ,


-- ** VideoTileType #enum:VideoTileType#

    VideoTileType(..)                       ,


-- ** VideoTransferFunction #enum:VideoTransferFunction#

    VideoTransferFunction(..)               ,


-- ** VideoVBIParserResult #enum:VideoVBIParserResult#

    VideoVBIParserResult(..)                ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL


-- Enum VideoVBIParserResult
{- |
Return values for 'GI.GstVideo.Structs.VideoVBIParser.VideoVBIParser'

/Since: 1.16/
-}
data VideoVBIParserResult =
      VideoVBIParserResultDone
    {- ^
    No line were provided, or no more Ancillary data was found.
    -}
    | VideoVBIParserResultOk
    {- ^
    A 'GI.GstVideo.Structs.VideoAncillary.VideoAncillary' was found.
    -}
    | VideoVBIParserResultError
    {- ^
    An error occured
    -}
    | AnotherVideoVBIParserResult Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoVBIParserResultDone
    toEnum 1 = VideoVBIParserResultOk
    toEnum 2 = VideoVBIParserResultError
    toEnum k = AnotherVideoVBIParserResult k

instance P.Ord VideoVBIParserResult where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_vbi_parser_result_get_type" c_gst_video_vbi_parser_result_get_type ::
    IO GType

instance BoxedEnum VideoVBIParserResult where
    boxedEnumType _ = c_gst_video_vbi_parser_result_get_type

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

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

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

instance P.Ord VideoTransferFunction where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_transfer_function_get_type" c_gst_video_transfer_function_get_type ::
    IO GType

instance BoxedEnum VideoTransferFunction where
    boxedEnumType _ = c_gst_video_transfer_function_get_type

-- Enum VideoTileType
{- |
Enum value describing the most common tiling types.
-}
data VideoTileType =
      VideoTileTypeIndexed
    {- ^
    Tiles are indexed. Use
      gst_video_tile_get_index () to retrieve the tile at the requested
      coordinates.
    -}
    | AnotherVideoTileType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum VideoTileType where
    fromEnum VideoTileTypeIndexed = 0
    fromEnum (AnotherVideoTileType k) = k

    toEnum 0 = VideoTileTypeIndexed
    toEnum k = AnotherVideoTileType k

instance P.Ord VideoTileType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_tile_type_get_type" c_gst_video_tile_type_get_type ::
    IO GType

instance BoxedEnum VideoTileType where
    boxedEnumType _ = c_gst_video_tile_type_get_type

-- Enum VideoTileMode
{- |
Enum value describing the available tiling modes.
-}
data VideoTileMode =
      VideoTileModeUnknown
    {- ^
    Unknown or unset tile mode
    -}
    | VideoTileModeZflipz2x2
    {- ^
    Every four adjacent blocks - two
       horizontally and two vertically are grouped together and are located
       in memory in Z or flipped Z order. In case of odd rows, the last row
       of blocks is arranged in linear order.
    -}
    | AnotherVideoTileMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoTileModeUnknown
    toEnum 65536 = VideoTileModeZflipz2x2
    toEnum k = AnotherVideoTileMode k

instance P.Ord VideoTileMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_tile_mode_get_type" c_gst_video_tile_mode_get_type ::
    IO GType

instance BoxedEnum VideoTileMode where
    boxedEnumType _ = c_gst_video_tile_mode_get_type

-- Enum VideoResamplerMethod
{- |
Different subsampling and upsampling methods

/Since: 1.6/
-}
data VideoResamplerMethod =
      VideoResamplerMethodNearest
    {- ^
    Duplicates the samples when
       upsampling and drops when downsampling
    -}
    | VideoResamplerMethodLinear
    {- ^
    Uses linear interpolation to reconstruct
       missing samples and averaging to downsample
    -}
    | VideoResamplerMethodCubic
    {- ^
    Uses cubic interpolation
    -}
    | VideoResamplerMethodSinc
    {- ^
    Uses sinc interpolation
    -}
    | VideoResamplerMethodLanczos
    {- ^
    Uses lanczos interpolation
    -}
    | AnotherVideoResamplerMethod Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoResamplerMethodNearest
    toEnum 1 = VideoResamplerMethodLinear
    toEnum 2 = VideoResamplerMethodCubic
    toEnum 3 = VideoResamplerMethodSinc
    toEnum 4 = VideoResamplerMethodLanczos
    toEnum k = AnotherVideoResamplerMethod k

instance P.Ord VideoResamplerMethod where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_resampler_method_get_type" c_gst_video_resampler_method_get_type ::
    IO GType

instance BoxedEnum VideoResamplerMethod where
    boxedEnumType _ = c_gst_video_resampler_method_get_type

-- Enum VideoPrimariesMode
{- |
Different primaries conversion modes

/Since: 1.6/
-}
data VideoPrimariesMode =
      VideoPrimariesModeNone
    {- ^
    disable conversion between primaries
    -}
    | VideoPrimariesModeMergeOnly
    {- ^
    do conversion between primaries only
      when it can be merged with color matrix conversion.
    -}
    | VideoPrimariesModeFast
    {- ^
    fast conversion between primaries
    -}
    | AnotherVideoPrimariesMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoPrimariesModeNone
    toEnum 1 = VideoPrimariesModeMergeOnly
    toEnum 2 = VideoPrimariesModeFast
    toEnum k = AnotherVideoPrimariesMode k

instance P.Ord VideoPrimariesMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_primaries_mode_get_type" c_gst_video_primaries_mode_get_type ::
    IO GType

instance BoxedEnum VideoPrimariesMode where
    boxedEnumType _ = c_gst_video_primaries_mode_get_type

-- Enum VideoOrientationMethod
{- |
The different video orientation methods.

/Since: 1.10/
-}
data VideoOrientationMethod =
      VideoOrientationMethodIdentity
    {- ^
    Identity (no rotation)
    -}
    | VideoOrientationMethod90r
    {- ^
    Rotate clockwise 90 degrees
    -}
    | VideoOrientationMethod180
    {- ^
    Rotate 180 degrees
    -}
    | VideoOrientationMethod90l
    {- ^
    Rotate counter-clockwise 90 degrees
    -}
    | VideoOrientationMethodHoriz
    {- ^
    Flip horizontally
    -}
    | VideoOrientationMethodVert
    {- ^
    Flip vertically
    -}
    | VideoOrientationMethodUlLr
    {- ^
    Flip across upper left\/lower right diagonal
    -}
    | VideoOrientationMethodUrLl
    {- ^
    Flip across upper right\/lower left diagonal
    -}
    | VideoOrientationMethodAuto
    {- ^
    Select flip method based on image-orientation tag
    -}
    | VideoOrientationMethodCustom
    {- ^
    Current status depends on plugin internal setup
    -}
    | AnotherVideoOrientationMethod Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

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

instance P.Ord VideoOrientationMethod where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_orientation_method_get_type" c_gst_video_orientation_method_get_type ::
    IO GType

instance BoxedEnum VideoOrientationMethod where
    boxedEnumType _ = c_gst_video_orientation_method_get_type

-- Enum VideoMultiviewMode
{- |
All possible stereoscopic 3D and multiview representations.
In conjunction with '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 'GI.GstVideo.Structs.VideoMeta.VideoMeta'(s) on raw video buffers.
    -}
    | VideoMultiviewModeSeparated
    {- ^
    Multiple views are
    provided as separate 'GI.Gst.Structs.Memory.Memory' framebuffers attached to each
    'GI.Gst.Structs.Buffer.Buffer', described by the @/GstVideoMultiviewMeta/@
    and 'GI.GstVideo.Structs.VideoMeta.VideoMeta'(s)
    -}
    | AnotherVideoMultiviewMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

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

instance P.Ord VideoMultiviewMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_multiview_mode_get_type" c_gst_video_multiview_mode_get_type ::
    IO GType

instance BoxedEnum VideoMultiviewMode where
    boxedEnumType _ = c_gst_video_multiview_mode_get_type

-- Enum VideoMultiviewFramePacking
{- |
'GI.GstVideo.Enums.VideoMultiviewFramePacking' represents the subset of '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 '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 (Show, Eq)

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

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

instance P.Ord VideoMultiviewFramePacking where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_multiview_frame_packing_get_type" c_gst_video_multiview_frame_packing_get_type ::
    IO GType

instance BoxedEnum VideoMultiviewFramePacking where
    boxedEnumType _ = c_gst_video_multiview_frame_packing_get_type

-- Enum VideoMatrixMode
{- |
Different color matrix conversion modes

/Since: 1.6/
-}
data VideoMatrixMode =
      VideoMatrixModeFull
    {- ^
    do conversion between color matrices
    -}
    | VideoMatrixModeInputOnly
    {- ^
    use the input color matrix to convert
      to and from R\'G\'B
    -}
    | VideoMatrixModeOutputOnly
    {- ^
    use the output color matrix to convert
      to and from R\'G\'B
    -}
    | VideoMatrixModeNone
    {- ^
    disable color matrix conversion.
    -}
    | AnotherVideoMatrixMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoMatrixModeFull
    toEnum 1 = VideoMatrixModeInputOnly
    toEnum 2 = VideoMatrixModeOutputOnly
    toEnum 3 = VideoMatrixModeNone
    toEnum k = AnotherVideoMatrixMode k

instance P.Ord VideoMatrixMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_matrix_mode_get_type" c_gst_video_matrix_mode_get_type ::
    IO GType

instance BoxedEnum VideoMatrixMode where
    boxedEnumType _ = c_gst_video_matrix_mode_get_type

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

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

    toEnum 0 = VideoInterlaceModeProgressive
    toEnum 1 = VideoInterlaceModeInterleaved
    toEnum 2 = VideoInterlaceModeMixed
    toEnum 3 = VideoInterlaceModeFields
    toEnum 4 = VideoInterlaceModeAlternate
    toEnum k = AnotherVideoInterlaceMode k

instance P.Ord VideoInterlaceMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_interlace_mode_get_type" c_gst_video_interlace_mode_get_type ::
    IO GType

instance BoxedEnum VideoInterlaceMode where
    boxedEnumType _ = c_gst_video_interlace_mode_get_type

-- Enum VideoGammaMode
{- |
/No description available in the introspection data./

/Since: 1.6/
-}
data VideoGammaMode =
      VideoGammaModeNone
    {- ^
    disable gamma handling
    -}
    | VideoGammaModeRemap
    {- ^
    convert between input and output gamma
    Different gamma conversion modes
    -}
    | AnotherVideoGammaMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoGammaModeNone
    toEnum 1 = VideoGammaModeRemap
    toEnum k = AnotherVideoGammaMode k

instance P.Ord VideoGammaMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_gamma_mode_get_type" c_gst_video_gamma_mode_get_type ::
    IO GType

instance BoxedEnum VideoGammaMode where
    boxedEnumType _ = c_gst_video_gamma_mode_get_type

-- Enum VideoGLTextureType
{- |
The GL texture type.
-}
data VideoGLTextureType =
      VideoGLTextureTypeLuminance
    {- ^
    Luminance texture, GL_LUMINANCE
    -}
    | VideoGLTextureTypeLuminanceAlpha
    {- ^
    Luminance-alpha texture, GL_LUMINANCE_ALPHA
    -}
    | VideoGLTextureTypeRgb16
    {- ^
    RGB 565 texture, GL_RGB
    -}
    | VideoGLTextureTypeRgb
    {- ^
    RGB texture, GL_RGB
    -}
    | VideoGLTextureTypeRgba
    {- ^
    RGBA texture, GL_RGBA
    -}
    | VideoGLTextureTypeR
    {- ^
    R texture, GL_RED_EXT
    -}
    | VideoGLTextureTypeRg
    {- ^
    RG texture, GL_RG_EXT
    -}
    | AnotherVideoGLTextureType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoGLTextureTypeLuminance
    toEnum 1 = VideoGLTextureTypeLuminanceAlpha
    toEnum 2 = VideoGLTextureTypeRgb16
    toEnum 3 = VideoGLTextureTypeRgb
    toEnum 4 = VideoGLTextureTypeRgba
    toEnum 5 = VideoGLTextureTypeR
    toEnum 6 = VideoGLTextureTypeRg
    toEnum k = AnotherVideoGLTextureType k

instance P.Ord VideoGLTextureType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

-- Enum VideoGLTextureOrientation
{- |
The orientation of the GL texture.
-}
data VideoGLTextureOrientation =
      VideoGLTextureOrientationNormalYNormal
    {- ^
    Top line first in memory, left row first
    -}
    | VideoGLTextureOrientationNormalYFlip
    {- ^
    Bottom line first in memory, left row first
    -}
    | VideoGLTextureOrientationFlipYNormal
    {- ^
    Top line first in memory, right row first
    -}
    | VideoGLTextureOrientationFlipYFlip
    {- ^
    Bottom line first in memory, right row first
    -}
    | AnotherVideoGLTextureOrientation Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoGLTextureOrientationNormalYNormal
    toEnum 1 = VideoGLTextureOrientationNormalYFlip
    toEnum 2 = VideoGLTextureOrientationFlipYNormal
    toEnum 3 = VideoGLTextureOrientationFlipYFlip
    toEnum k = AnotherVideoGLTextureOrientation k

instance P.Ord VideoGLTextureOrientation where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

-- Enum VideoFormat
{- |
Enum value describing the most common video formats.

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

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

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

instance P.Ord VideoFormat where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_format_get_type" c_gst_video_format_get_type ::
    IO GType

instance BoxedEnum VideoFormat where
    boxedEnumType _ = c_gst_video_format_get_type

-- Enum VideoFieldOrder
{- |
Field order of interlaced content. This is only valid for
interlace-mode=interleaved and not interlace-mode=mixed. In the case of
mixed or GST_VIDEO_FIELD_ORDER_UNKOWN, the field order is signalled via
buffer flags.

/Since: 1.12/
-}
data VideoFieldOrder =
      VideoFieldOrderUnknown
    {- ^
    unknown field order for interlaced content.
        The actual field order is signalled via buffer flags.
    -}
    | VideoFieldOrderTopFieldFirst
    {- ^
    top field is first
    -}
    | VideoFieldOrderBottomFieldFirst
    {- ^
    bottom field is first
    -}
    | AnotherVideoFieldOrder Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoFieldOrderUnknown
    toEnum 1 = VideoFieldOrderTopFieldFirst
    toEnum 2 = VideoFieldOrderBottomFieldFirst
    toEnum k = AnotherVideoFieldOrder k

instance P.Ord VideoFieldOrder where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_field_order_get_type" c_gst_video_field_order_get_type ::
    IO GType

instance BoxedEnum VideoFieldOrder where
    boxedEnumType _ = c_gst_video_field_order_get_type

-- Enum VideoDitherMethod
{- |
Different dithering methods to use.
-}
data VideoDitherMethod =
      VideoDitherMethodNone
    {- ^
    no dithering
    -}
    | VideoDitherMethodVerterr
    {- ^
    propagate rounding errors downwards
    -}
    | VideoDitherMethodFloydSteinberg
    {- ^
    Dither with floyd-steinberg error diffusion
    -}
    | VideoDitherMethodSierraLite
    {- ^
    Dither with Sierra Lite error diffusion
    -}
    | VideoDitherMethodBayer
    {- ^
    ordered dither using a bayer pattern
    -}
    | AnotherVideoDitherMethod Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoDitherMethodNone
    toEnum 1 = VideoDitherMethodVerterr
    toEnum 2 = VideoDitherMethodFloydSteinberg
    toEnum 3 = VideoDitherMethodSierraLite
    toEnum 4 = VideoDitherMethodBayer
    toEnum k = AnotherVideoDitherMethod k

instance P.Ord VideoDitherMethod where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_dither_method_get_type" c_gst_video_dither_method_get_type ::
    IO GType

instance BoxedEnum VideoDitherMethod where
    boxedEnumType _ = c_gst_video_dither_method_get_type

-- Enum VideoColorRange
{- |
Possible color range values. These constants are defined for 8 bit color
values and can be scaled for other bit depths.
-}
data VideoColorRange =
      VideoColorRangeUnknown
    {- ^
    unknown range
    -}
    | VideoColorRange0255
    {- ^
    [0..255] for 8 bit components
    -}
    | VideoColorRange16235
    {- ^
    [16..235] for 8 bit components. Chroma has
                    [16..240] range.
    -}
    | AnotherVideoColorRange Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoColorRangeUnknown
    toEnum 1 = VideoColorRange0255
    toEnum 2 = VideoColorRange16235
    toEnum k = AnotherVideoColorRange k

instance P.Ord VideoColorRange where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_color_range_get_type" c_gst_video_color_range_get_type ::
    IO GType

instance BoxedEnum VideoColorRange where
    boxedEnumType _ = c_gst_video_color_range_get_type

-- Enum VideoColorPrimaries
{- |
The color primaries define the how to transform linear RGB values to and from
the CIE XYZ colorspace.
-}
data VideoColorPrimaries =
      VideoColorPrimariesUnknown
    {- ^
    unknown color primaries
    -}
    | VideoColorPrimariesBt709
    {- ^
    BT709 primaries
    -}
    | VideoColorPrimariesBt470m
    {- ^
    BT470M primaries
    -}
    | VideoColorPrimariesBt470bg
    {- ^
    BT470BG primaries
    -}
    | VideoColorPrimariesSmpte170m
    {- ^
    SMPTE170M primaries
    -}
    | VideoColorPrimariesSmpte240m
    {- ^
    SMPTE240M primaries
    -}
    | VideoColorPrimariesFilm
    {- ^
    Generic film
    -}
    | VideoColorPrimariesBt2020
    {- ^
    BT2020 primaries. Since: 1.6
    -}
    | VideoColorPrimariesAdobergb
    {- ^
    Adobe RGB primaries. Since: 1.8
    -}
    | VideoColorPrimariesSmptest428
    {- ^
    SMPTE ST 428 primaries. Since: 1.16
    -}
    | VideoColorPrimariesSmpterp431
    {- ^
    SMPTE RP 431 primaries. Since: 1.16
    -}
    | VideoColorPrimariesSmpteeg432
    {- ^
    SMPTE EG 432 primaries. Since: 1.16
    -}
    | VideoColorPrimariesEbu3213
    {- ^
    EBU 3213 primaries. Since: 1.16
    -}
    | AnotherVideoColorPrimaries Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

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

instance P.Ord VideoColorPrimaries where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_color_primaries_get_type" c_gst_video_color_primaries_get_type ::
    IO GType

instance BoxedEnum VideoColorPrimaries where
    boxedEnumType _ = c_gst_video_color_primaries_get_type

-- Enum VideoColorMatrix
{- |
The color matrix is used to convert between Y\'PbPr and
non-linear RGB (R\'G\'B\')
-}
data VideoColorMatrix =
      VideoColorMatrixUnknown
    {- ^
    unknown matrix
    -}
    | VideoColorMatrixRgb
    {- ^
    identity matrix
    -}
    | VideoColorMatrixFcc
    {- ^
    FCC color matrix
    -}
    | VideoColorMatrixBt709
    {- ^
    ITU-R BT.709 color matrix
    -}
    | VideoColorMatrixBt601
    {- ^
    ITU-R BT.601 color matrix
    -}
    | VideoColorMatrixSmpte240m
    {- ^
    SMPTE 240M color matrix
    -}
    | VideoColorMatrixBt2020
    {- ^
    ITU-R BT.2020 color matrix. Since: 1.6
    -}
    | AnotherVideoColorMatrix Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoColorMatrixUnknown
    toEnum 1 = VideoColorMatrixRgb
    toEnum 2 = VideoColorMatrixFcc
    toEnum 3 = VideoColorMatrixBt709
    toEnum 4 = VideoColorMatrixBt601
    toEnum 5 = VideoColorMatrixSmpte240m
    toEnum 6 = VideoColorMatrixBt2020
    toEnum k = AnotherVideoColorMatrix k

instance P.Ord VideoColorMatrix where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_color_matrix_get_type" c_gst_video_color_matrix_get_type ::
    IO GType

instance BoxedEnum VideoColorMatrix where
    boxedEnumType _ = c_gst_video_color_matrix_get_type

-- Enum VideoChromaMode
{- |
Different chroma downsampling and upsampling modes

/Since: 1.6/
-}
data VideoChromaMode =
      VideoChromaModeFull
    {- ^
    do full chroma up and down sampling
    -}
    | VideoChromaModeUpsampleOnly
    {- ^
    only perform chroma upsampling
    -}
    | VideoChromaModeDownsampleOnly
    {- ^
    only perform chroma downsampling
    -}
    | VideoChromaModeNone
    {- ^
    disable chroma resampling
    -}
    | AnotherVideoChromaMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoChromaModeFull
    toEnum 1 = VideoChromaModeUpsampleOnly
    toEnum 2 = VideoChromaModeDownsampleOnly
    toEnum 3 = VideoChromaModeNone
    toEnum k = AnotherVideoChromaMode k

instance P.Ord VideoChromaMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_chroma_mode_get_type" c_gst_video_chroma_mode_get_type ::
    IO GType

instance BoxedEnum VideoChromaMode where
    boxedEnumType _ = c_gst_video_chroma_mode_get_type

-- Enum VideoChromaMethod
{- |
Different subsampling and upsampling methods
-}
data VideoChromaMethod =
      VideoChromaMethodNearest
    {- ^
    Duplicates the chroma samples when
       upsampling and drops when subsampling
    -}
    | VideoChromaMethodLinear
    {- ^
    Uses linear interpolation to reconstruct
       missing chroma and averaging to subsample
    -}
    | AnotherVideoChromaMethod Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoChromaMethodNearest
    toEnum 1 = VideoChromaMethodLinear
    toEnum k = AnotherVideoChromaMethod k

instance P.Ord VideoChromaMethod where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_chroma_method_get_type" c_gst_video_chroma_method_get_type ::
    IO GType

instance BoxedEnum VideoChromaMethod where
    boxedEnumType _ = c_gst_video_chroma_method_get_type

-- Enum VideoCaptionType
{- |
The various known types of Closed Caption (CC).

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

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

    toEnum 0 = VideoCaptionTypeUnknown
    toEnum 1 = VideoCaptionTypeCea608Raw
    toEnum 2 = VideoCaptionTypeCea608S3341a
    toEnum 3 = VideoCaptionTypeCea708Raw
    toEnum 4 = VideoCaptionTypeCea708Cdp
    toEnum k = AnotherVideoCaptionType k

instance P.Ord VideoCaptionType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_caption_type_get_type" c_gst_video_caption_type_get_type ::
    IO GType

instance BoxedEnum VideoCaptionType where
    boxedEnumType _ = c_gst_video_caption_type_get_type

-- Enum VideoAncillaryDID16
{- |
Some know types of Ancillary Data identifiers.

/Since: 1.16/
-}
data VideoAncillaryDID16 =
      VideoAncillaryDID16708
    {- ^
    CEA 708 Ancillary data according to SMPTE 334
    -}
    | VideoAncillaryDID16608
    {- ^
    CEA 608 Ancillary data according to SMPTE 334
    -}
    | AnotherVideoAncillaryDID16 Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 24833 = VideoAncillaryDID16708
    toEnum 24834 = VideoAncillaryDID16608
    toEnum k = AnotherVideoAncillaryDID16 k

instance P.Ord VideoAncillaryDID16 where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_ancillary_di_d16_get_type" c_gst_video_ancillary_di_d16_get_type ::
    IO GType

instance BoxedEnum VideoAncillaryDID16 where
    boxedEnumType _ = c_gst_video_ancillary_di_d16_get_type

-- Enum VideoAncillaryDID
{- |
/No description available in the introspection data./
-}
data VideoAncillaryDID =
      VideoAncillaryDIDUndefined
    {- ^
    /No description available in the introspection data./
    -}
    | VideoAncillaryDIDDeletion
    {- ^
    /No description available in the introspection data./
    -}
    | VideoAncillaryDIDHanc3gAudioDataFirst
    {- ^
    /No description available in the introspection data./
    -}
    | VideoAncillaryDIDHanc3gAudioDataLast
    {- ^
    /No description available in the introspection data./
    -}
    | VideoAncillaryDIDHancHdtvAudioDataFirst
    {- ^
    /No description available in the introspection data./
    -}
    | VideoAncillaryDIDHancHdtvAudioDataLast
    {- ^
    /No description available in the introspection data./
    -}
    | VideoAncillaryDIDHancSdtvAudioData1First
    {- ^
    /No description available in the introspection data./
    -}
    | VideoAncillaryDIDHancSdtvAudioData1Last
    {- ^
    /No description available in the introspection data./
    -}
    | VideoAncillaryDIDCameraPosition
    {- ^
    /No description available in the introspection data./
    -}
    | VideoAncillaryDIDHancErrorDetection
    {- ^
    /No description available in the introspection data./
    -}
    | VideoAncillaryDIDHancSdtvAudioData2First
    {- ^
    /No description available in the introspection data./
    -}
    | VideoAncillaryDIDHancSdtvAudioData2Last
    {- ^
    /No description available in the introspection data./
    -}
    | AnotherVideoAncillaryDID Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

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

instance P.Ord VideoAncillaryDID where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_ancillary_did_get_type" c_gst_video_ancillary_did_get_type ::
    IO GType

instance BoxedEnum VideoAncillaryDID where
    boxedEnumType _ = c_gst_video_ancillary_did_get_type

-- Enum VideoAlphaMode
{- |
Different alpha modes.

/Since: 1.6/
-}
data VideoAlphaMode =
      VideoAlphaModeCopy
    {- ^
    When input and output have alpha, it will be copied.
            When the input has no alpha, alpha will be set to
            'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_ALPHA_VALUE'
    -}
    | VideoAlphaModeSet
    {- ^
    set all alpha to
       'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_ALPHA_VALUE'
    -}
    | VideoAlphaModeMult
    {- ^
    multiply all alpha with
            'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_ALPHA_VALUE'.
            When the input format has no alpha but the output format has, the
            alpha value will be set to 'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_ALPHA_VALUE'
    -}
    | AnotherVideoAlphaMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = VideoAlphaModeCopy
    toEnum 1 = VideoAlphaModeSet
    toEnum 2 = VideoAlphaModeMult
    toEnum k = AnotherVideoAlphaMode k

instance P.Ord VideoAlphaMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_video_alpha_mode_get_type" c_gst_video_alpha_mode_get_type ::
    IO GType

instance BoxedEnum VideoAlphaMode where
    boxedEnumType _ = c_gst_video_alpha_mode_get_type

-- Enum NavigationQueryType
{- |
Tyoes of navigation interface queries.
-}
data NavigationQueryType =
      NavigationQueryTypeInvalid
    {- ^
    invalid query
    -}
    | NavigationQueryTypeCommands
    {- ^
    command query
    -}
    | NavigationQueryTypeAngles
    {- ^
    viewing angle query
    -}
    | AnotherNavigationQueryType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = NavigationQueryTypeInvalid
    toEnum 1 = NavigationQueryTypeCommands
    toEnum 2 = NavigationQueryTypeAngles
    toEnum k = AnotherNavigationQueryType k

instance P.Ord NavigationQueryType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_navigation_query_type_get_type" c_gst_navigation_query_type_get_type ::
    IO GType

instance BoxedEnum NavigationQueryType where
    boxedEnumType _ = c_gst_navigation_query_type_get_type

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

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

    toEnum 0 = NavigationMessageTypeInvalid
    toEnum 1 = NavigationMessageTypeMouseOver
    toEnum 2 = NavigationMessageTypeCommandsChanged
    toEnum 3 = NavigationMessageTypeAnglesChanged
    toEnum 4 = NavigationMessageTypeEvent
    toEnum k = AnotherNavigationMessageType k

instance P.Ord NavigationMessageType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_navigation_message_type_get_type" c_gst_navigation_message_type_get_type ::
    IO GType

instance BoxedEnum NavigationMessageType where
    boxedEnumType _ = c_gst_navigation_message_type_get_type

-- Enum NavigationEventType
{- |
Enum values for the various events that an element implementing the
GstNavigation interface might send up the pipeline.
-}
data NavigationEventType =
      NavigationEventTypeInvalid
    {- ^
    Returned from
    'GI.GstVideo.Functions.navigationEventGetType' when the passed event is not a navigation event.
    -}
    | NavigationEventTypeKeyPress
    {- ^
    A key press event. Use
    'GI.GstVideo.Functions.navigationEventParseKeyEvent' to extract the details from the event.
    -}
    | NavigationEventTypeKeyRelease
    {- ^
    A key release event. Use
    'GI.GstVideo.Functions.navigationEventParseKeyEvent' to extract the details from the event.
    -}
    | NavigationEventTypeMouseButtonPress
    {- ^
    A mouse button press event. Use
    'GI.GstVideo.Functions.navigationEventParseMouseButtonEvent' to extract the details from the
    event.
    -}
    | NavigationEventTypeMouseButtonRelease
    {- ^
    A mouse button release event. Use
    'GI.GstVideo.Functions.navigationEventParseMouseButtonEvent' to extract the details from the
    event.
    -}
    | NavigationEventTypeMouseMove
    {- ^
    A mouse movement event. Use
    'GI.GstVideo.Functions.navigationEventParseMouseMoveEvent' to extract the details from the
    event.
    -}
    | NavigationEventTypeCommand
    {- ^
    A navigation command event. Use
    'GI.GstVideo.Functions.navigationEventParseCommand' to extract the details from the event.
    -}
    | AnotherNavigationEventType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = NavigationEventTypeInvalid
    toEnum 1 = NavigationEventTypeKeyPress
    toEnum 2 = NavigationEventTypeKeyRelease
    toEnum 3 = NavigationEventTypeMouseButtonPress
    toEnum 4 = NavigationEventTypeMouseButtonRelease
    toEnum 5 = NavigationEventTypeMouseMove
    toEnum 6 = NavigationEventTypeCommand
    toEnum k = AnotherNavigationEventType k

instance P.Ord NavigationEventType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_navigation_event_type_get_type" c_gst_navigation_event_type_get_type ::
    IO GType

instance BoxedEnum NavigationEventType where
    boxedEnumType _ = c_gst_navigation_event_type_get_type

-- Enum NavigationCommand
{- |
A set of commands that may be issued to an element providing the
'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 (Show, Eq)

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

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

instance P.Ord NavigationCommand where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_navigation_command_get_type" c_gst_navigation_command_get_type ::
    IO GType

instance BoxedEnum NavigationCommand where
    boxedEnumType _ = c_gst_navigation_command_get_type

-- Enum ColorBalanceType
{- |
An enumeration indicating whether an element implements color balancing
operations in software or in dedicated hardware. In general, dedicated
hardware implementations (such as those provided by xvimagesink) are
preferred.
-}
data ColorBalanceType =
      ColorBalanceTypeHardware
    {- ^
    Color balance is implemented with dedicated
            hardware.
    -}
    | ColorBalanceTypeSoftware
    {- ^
    Color balance is implemented via software
            processing.
    -}
    | AnotherColorBalanceType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = ColorBalanceTypeHardware
    toEnum 1 = ColorBalanceTypeSoftware
    toEnum k = AnotherColorBalanceType k

instance P.Ord ColorBalanceType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gst_color_balance_type_get_type" c_gst_color_balance_type_get_type ::
    IO GType

instance BoxedEnum ColorBalanceType where
    boxedEnumType _ = c_gst_color_balance_type_get_type