gi-gstvideo-1.0.18: GI/GstVideo/Enums.hs
{- |
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