#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstVideo.Flags
(
NavigationModifierType(..) ,
VideoBufferFlags(..) ,
VideoChromaFlags(..) ,
VideoChromaSite(..) ,
VideoCodecFrameFlags(..) ,
VideoDecoderRequestSyncPointFlags(..) ,
VideoDitherFlags(..) ,
VideoFlags(..) ,
VideoFormatFlags(..) ,
VideoFrameFlags(..) ,
VideoFrameMapFlags(..) ,
VideoMultiviewFlags(..) ,
VideoOverlayFormatFlags(..) ,
VideoPackFlags(..) ,
VideoResamplerFlags(..) ,
VideoScalerFlags(..) ,
VideoTimeCodeFlags(..) ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
data VideoTimeCodeFlags =
VideoTimeCodeFlagsNone
| VideoTimeCodeFlagsDropFrame
| VideoTimeCodeFlagsInterlaced
| AnotherVideoTimeCodeFlags Int
deriving (Int -> VideoTimeCodeFlags -> ShowS
[VideoTimeCodeFlags] -> ShowS
VideoTimeCodeFlags -> String
(Int -> VideoTimeCodeFlags -> ShowS)
-> (VideoTimeCodeFlags -> String)
-> ([VideoTimeCodeFlags] -> ShowS)
-> Show VideoTimeCodeFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoTimeCodeFlags -> ShowS
showsPrec :: Int -> VideoTimeCodeFlags -> ShowS
$cshow :: VideoTimeCodeFlags -> String
show :: VideoTimeCodeFlags -> String
$cshowList :: [VideoTimeCodeFlags] -> ShowS
showList :: [VideoTimeCodeFlags] -> ShowS
Show, VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool
(VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool)
-> (VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool)
-> Eq VideoTimeCodeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool
== :: VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool
$c/= :: VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool
/= :: VideoTimeCodeFlags -> VideoTimeCodeFlags -> Bool
Eq)
instance P.Enum VideoTimeCodeFlags where
fromEnum :: VideoTimeCodeFlags -> Int
fromEnum VideoTimeCodeFlags
VideoTimeCodeFlagsNone = Int
0
fromEnum VideoTimeCodeFlags
VideoTimeCodeFlagsDropFrame = Int
1
fromEnum VideoTimeCodeFlags
VideoTimeCodeFlagsInterlaced = Int
2
fromEnum (AnotherVideoTimeCodeFlags Int
k) = Int
k
toEnum :: Int -> VideoTimeCodeFlags
toEnum Int
0 = VideoTimeCodeFlags
VideoTimeCodeFlagsNone
toEnum Int
1 = VideoTimeCodeFlags
VideoTimeCodeFlagsDropFrame
toEnum Int
2 = VideoTimeCodeFlags
VideoTimeCodeFlagsInterlaced
toEnum Int
k = Int -> VideoTimeCodeFlags
AnotherVideoTimeCodeFlags Int
k
instance P.Ord VideoTimeCodeFlags where
compare :: VideoTimeCodeFlags -> VideoTimeCodeFlags -> Ordering
compare VideoTimeCodeFlags
a VideoTimeCodeFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoTimeCodeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoTimeCodeFlags
a) (VideoTimeCodeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoTimeCodeFlags
b)
type instance O.ParentTypes VideoTimeCodeFlags = '[]
instance O.HasParentTypes VideoTimeCodeFlags
foreign import ccall "gst_video_time_code_flags_get_type" c_gst_video_time_code_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoTimeCodeFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_time_code_flags_get_type
instance B.Types.BoxedFlags VideoTimeCodeFlags
instance IsGFlag VideoTimeCodeFlags
data VideoScalerFlags =
VideoScalerFlagsNone
| VideoScalerFlagsInterlaced
| AnotherVideoScalerFlags Int
deriving (Int -> VideoScalerFlags -> ShowS
[VideoScalerFlags] -> ShowS
VideoScalerFlags -> String
(Int -> VideoScalerFlags -> ShowS)
-> (VideoScalerFlags -> String)
-> ([VideoScalerFlags] -> ShowS)
-> Show VideoScalerFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoScalerFlags -> ShowS
showsPrec :: Int -> VideoScalerFlags -> ShowS
$cshow :: VideoScalerFlags -> String
show :: VideoScalerFlags -> String
$cshowList :: [VideoScalerFlags] -> ShowS
showList :: [VideoScalerFlags] -> ShowS
Show, VideoScalerFlags -> VideoScalerFlags -> Bool
(VideoScalerFlags -> VideoScalerFlags -> Bool)
-> (VideoScalerFlags -> VideoScalerFlags -> Bool)
-> Eq VideoScalerFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoScalerFlags -> VideoScalerFlags -> Bool
== :: VideoScalerFlags -> VideoScalerFlags -> Bool
$c/= :: VideoScalerFlags -> VideoScalerFlags -> Bool
/= :: VideoScalerFlags -> VideoScalerFlags -> Bool
Eq)
instance P.Enum VideoScalerFlags where
fromEnum :: VideoScalerFlags -> Int
fromEnum VideoScalerFlags
VideoScalerFlagsNone = Int
0
fromEnum VideoScalerFlags
VideoScalerFlagsInterlaced = Int
1
fromEnum (AnotherVideoScalerFlags Int
k) = Int
k
toEnum :: Int -> VideoScalerFlags
toEnum Int
0 = VideoScalerFlags
VideoScalerFlagsNone
toEnum Int
1 = VideoScalerFlags
VideoScalerFlagsInterlaced
toEnum Int
k = Int -> VideoScalerFlags
AnotherVideoScalerFlags Int
k
instance P.Ord VideoScalerFlags where
compare :: VideoScalerFlags -> VideoScalerFlags -> Ordering
compare VideoScalerFlags
a VideoScalerFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoScalerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoScalerFlags
a) (VideoScalerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoScalerFlags
b)
type instance O.ParentTypes VideoScalerFlags = '[]
instance O.HasParentTypes VideoScalerFlags
foreign import ccall "gst_video_scaler_flags_get_type" c_gst_video_scaler_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoScalerFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_scaler_flags_get_type
instance B.Types.BoxedFlags VideoScalerFlags
instance IsGFlag VideoScalerFlags
data VideoResamplerFlags =
VideoResamplerFlagsNone
| VideoResamplerFlagsHalfTaps
| AnotherVideoResamplerFlags Int
deriving (Int -> VideoResamplerFlags -> ShowS
[VideoResamplerFlags] -> ShowS
VideoResamplerFlags -> String
(Int -> VideoResamplerFlags -> ShowS)
-> (VideoResamplerFlags -> String)
-> ([VideoResamplerFlags] -> ShowS)
-> Show VideoResamplerFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoResamplerFlags -> ShowS
showsPrec :: Int -> VideoResamplerFlags -> ShowS
$cshow :: VideoResamplerFlags -> String
show :: VideoResamplerFlags -> String
$cshowList :: [VideoResamplerFlags] -> ShowS
showList :: [VideoResamplerFlags] -> ShowS
Show, VideoResamplerFlags -> VideoResamplerFlags -> Bool
(VideoResamplerFlags -> VideoResamplerFlags -> Bool)
-> (VideoResamplerFlags -> VideoResamplerFlags -> Bool)
-> Eq VideoResamplerFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoResamplerFlags -> VideoResamplerFlags -> Bool
== :: VideoResamplerFlags -> VideoResamplerFlags -> Bool
$c/= :: VideoResamplerFlags -> VideoResamplerFlags -> Bool
/= :: VideoResamplerFlags -> VideoResamplerFlags -> Bool
Eq)
instance P.Enum VideoResamplerFlags where
fromEnum :: VideoResamplerFlags -> Int
fromEnum VideoResamplerFlags
VideoResamplerFlagsNone = Int
0
fromEnum VideoResamplerFlags
VideoResamplerFlagsHalfTaps = Int
1
fromEnum (AnotherVideoResamplerFlags Int
k) = Int
k
toEnum :: Int -> VideoResamplerFlags
toEnum Int
0 = VideoResamplerFlags
VideoResamplerFlagsNone
toEnum Int
1 = VideoResamplerFlags
VideoResamplerFlagsHalfTaps
toEnum Int
k = Int -> VideoResamplerFlags
AnotherVideoResamplerFlags Int
k
instance P.Ord VideoResamplerFlags where
compare :: VideoResamplerFlags -> VideoResamplerFlags -> Ordering
compare VideoResamplerFlags
a VideoResamplerFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoResamplerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoResamplerFlags
a) (VideoResamplerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoResamplerFlags
b)
type instance O.ParentTypes VideoResamplerFlags = '[]
instance O.HasParentTypes VideoResamplerFlags
foreign import ccall "gst_video_resampler_flags_get_type" c_gst_video_resampler_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoResamplerFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_resampler_flags_get_type
instance B.Types.BoxedFlags VideoResamplerFlags
instance IsGFlag VideoResamplerFlags
data VideoPackFlags =
VideoPackFlagsNone
| VideoPackFlagsTruncateRange
| VideoPackFlagsInterlaced
| AnotherVideoPackFlags Int
deriving (Int -> VideoPackFlags -> ShowS
[VideoPackFlags] -> ShowS
VideoPackFlags -> String
(Int -> VideoPackFlags -> ShowS)
-> (VideoPackFlags -> String)
-> ([VideoPackFlags] -> ShowS)
-> Show VideoPackFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoPackFlags -> ShowS
showsPrec :: Int -> VideoPackFlags -> ShowS
$cshow :: VideoPackFlags -> String
show :: VideoPackFlags -> String
$cshowList :: [VideoPackFlags] -> ShowS
showList :: [VideoPackFlags] -> ShowS
Show, VideoPackFlags -> VideoPackFlags -> Bool
(VideoPackFlags -> VideoPackFlags -> Bool)
-> (VideoPackFlags -> VideoPackFlags -> Bool) -> Eq VideoPackFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoPackFlags -> VideoPackFlags -> Bool
== :: VideoPackFlags -> VideoPackFlags -> Bool
$c/= :: VideoPackFlags -> VideoPackFlags -> Bool
/= :: VideoPackFlags -> VideoPackFlags -> Bool
Eq)
instance P.Enum VideoPackFlags where
fromEnum :: VideoPackFlags -> Int
fromEnum VideoPackFlags
VideoPackFlagsNone = Int
0
fromEnum VideoPackFlags
VideoPackFlagsTruncateRange = Int
1
fromEnum VideoPackFlags
VideoPackFlagsInterlaced = Int
2
fromEnum (AnotherVideoPackFlags Int
k) = Int
k
toEnum :: Int -> VideoPackFlags
toEnum Int
0 = VideoPackFlags
VideoPackFlagsNone
toEnum Int
1 = VideoPackFlags
VideoPackFlagsTruncateRange
toEnum Int
2 = VideoPackFlags
VideoPackFlagsInterlaced
toEnum Int
k = Int -> VideoPackFlags
AnotherVideoPackFlags Int
k
instance P.Ord VideoPackFlags where
compare :: VideoPackFlags -> VideoPackFlags -> Ordering
compare VideoPackFlags
a VideoPackFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoPackFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoPackFlags
a) (VideoPackFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoPackFlags
b)
type instance O.ParentTypes VideoPackFlags = '[]
instance O.HasParentTypes VideoPackFlags
foreign import ccall "gst_video_pack_flags_get_type" c_gst_video_pack_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoPackFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_pack_flags_get_type
instance B.Types.BoxedFlags VideoPackFlags
instance IsGFlag VideoPackFlags
data VideoOverlayFormatFlags =
VideoOverlayFormatFlagsNone
| VideoOverlayFormatFlagsPremultipliedAlpha
| VideoOverlayFormatFlagsGlobalAlpha
| AnotherVideoOverlayFormatFlags Int
deriving (Int -> VideoOverlayFormatFlags -> ShowS
[VideoOverlayFormatFlags] -> ShowS
VideoOverlayFormatFlags -> String
(Int -> VideoOverlayFormatFlags -> ShowS)
-> (VideoOverlayFormatFlags -> String)
-> ([VideoOverlayFormatFlags] -> ShowS)
-> Show VideoOverlayFormatFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoOverlayFormatFlags -> ShowS
showsPrec :: Int -> VideoOverlayFormatFlags -> ShowS
$cshow :: VideoOverlayFormatFlags -> String
show :: VideoOverlayFormatFlags -> String
$cshowList :: [VideoOverlayFormatFlags] -> ShowS
showList :: [VideoOverlayFormatFlags] -> ShowS
Show, VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool
(VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool)
-> (VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool)
-> Eq VideoOverlayFormatFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool
== :: VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool
$c/= :: VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool
/= :: VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Bool
Eq)
instance P.Enum VideoOverlayFormatFlags where
fromEnum :: VideoOverlayFormatFlags -> Int
fromEnum VideoOverlayFormatFlags
VideoOverlayFormatFlagsNone = Int
0
fromEnum VideoOverlayFormatFlags
VideoOverlayFormatFlagsPremultipliedAlpha = Int
1
fromEnum VideoOverlayFormatFlags
VideoOverlayFormatFlagsGlobalAlpha = Int
2
fromEnum (AnotherVideoOverlayFormatFlags Int
k) = Int
k
toEnum :: Int -> VideoOverlayFormatFlags
toEnum Int
0 = VideoOverlayFormatFlags
VideoOverlayFormatFlagsNone
toEnum Int
1 = VideoOverlayFormatFlags
VideoOverlayFormatFlagsPremultipliedAlpha
toEnum Int
2 = VideoOverlayFormatFlags
VideoOverlayFormatFlagsGlobalAlpha
toEnum Int
k = Int -> VideoOverlayFormatFlags
AnotherVideoOverlayFormatFlags Int
k
instance P.Ord VideoOverlayFormatFlags where
compare :: VideoOverlayFormatFlags -> VideoOverlayFormatFlags -> Ordering
compare VideoOverlayFormatFlags
a VideoOverlayFormatFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoOverlayFormatFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoOverlayFormatFlags
a) (VideoOverlayFormatFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoOverlayFormatFlags
b)
type instance O.ParentTypes VideoOverlayFormatFlags = '[]
instance O.HasParentTypes VideoOverlayFormatFlags
foreign import ccall "gst_video_overlay_format_flags_get_type" c_gst_video_overlay_format_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoOverlayFormatFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_overlay_format_flags_get_type
instance B.Types.BoxedFlags VideoOverlayFormatFlags
instance IsGFlag VideoOverlayFormatFlags
data VideoMultiviewFlags =
VideoMultiviewFlagsNone
| VideoMultiviewFlagsRightViewFirst
| VideoMultiviewFlagsLeftFlipped
| VideoMultiviewFlagsLeftFlopped
| VideoMultiviewFlagsRightFlipped
| VideoMultiviewFlagsRightFlopped
| VideoMultiviewFlagsHalfAspect
| VideoMultiviewFlagsMixedMono
| AnotherVideoMultiviewFlags Int
deriving (Int -> VideoMultiviewFlags -> ShowS
[VideoMultiviewFlags] -> ShowS
VideoMultiviewFlags -> String
(Int -> VideoMultiviewFlags -> ShowS)
-> (VideoMultiviewFlags -> String)
-> ([VideoMultiviewFlags] -> ShowS)
-> Show VideoMultiviewFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoMultiviewFlags -> ShowS
showsPrec :: Int -> VideoMultiviewFlags -> ShowS
$cshow :: VideoMultiviewFlags -> String
show :: VideoMultiviewFlags -> String
$cshowList :: [VideoMultiviewFlags] -> ShowS
showList :: [VideoMultiviewFlags] -> ShowS
Show, VideoMultiviewFlags -> VideoMultiviewFlags -> Bool
(VideoMultiviewFlags -> VideoMultiviewFlags -> Bool)
-> (VideoMultiviewFlags -> VideoMultiviewFlags -> Bool)
-> Eq VideoMultiviewFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoMultiviewFlags -> VideoMultiviewFlags -> Bool
== :: VideoMultiviewFlags -> VideoMultiviewFlags -> Bool
$c/= :: VideoMultiviewFlags -> VideoMultiviewFlags -> Bool
/= :: VideoMultiviewFlags -> VideoMultiviewFlags -> Bool
Eq)
instance P.Enum VideoMultiviewFlags where
fromEnum :: VideoMultiviewFlags -> Int
fromEnum VideoMultiviewFlags
VideoMultiviewFlagsNone = Int
0
fromEnum VideoMultiviewFlags
VideoMultiviewFlagsRightViewFirst = Int
1
fromEnum VideoMultiviewFlags
VideoMultiviewFlagsLeftFlipped = Int
2
fromEnum VideoMultiviewFlags
VideoMultiviewFlagsLeftFlopped = Int
4
fromEnum VideoMultiviewFlags
VideoMultiviewFlagsRightFlipped = Int
8
fromEnum VideoMultiviewFlags
VideoMultiviewFlagsRightFlopped = Int
16
fromEnum VideoMultiviewFlags
VideoMultiviewFlagsHalfAspect = Int
16384
fromEnum VideoMultiviewFlags
VideoMultiviewFlagsMixedMono = Int
32768
fromEnum (AnotherVideoMultiviewFlags Int
k) = Int
k
toEnum :: Int -> VideoMultiviewFlags
toEnum Int
0 = VideoMultiviewFlags
VideoMultiviewFlagsNone
toEnum Int
1 = VideoMultiviewFlags
VideoMultiviewFlagsRightViewFirst
toEnum Int
2 = VideoMultiviewFlags
VideoMultiviewFlagsLeftFlipped
toEnum Int
4 = VideoMultiviewFlags
VideoMultiviewFlagsLeftFlopped
toEnum Int
8 = VideoMultiviewFlags
VideoMultiviewFlagsRightFlipped
toEnum Int
16 = VideoMultiviewFlags
VideoMultiviewFlagsRightFlopped
toEnum Int
16384 = VideoMultiviewFlags
VideoMultiviewFlagsHalfAspect
toEnum Int
32768 = VideoMultiviewFlags
VideoMultiviewFlagsMixedMono
toEnum Int
k = Int -> VideoMultiviewFlags
AnotherVideoMultiviewFlags Int
k
instance P.Ord VideoMultiviewFlags where
compare :: VideoMultiviewFlags -> VideoMultiviewFlags -> Ordering
compare VideoMultiviewFlags
a VideoMultiviewFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoMultiviewFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoMultiviewFlags
a) (VideoMultiviewFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoMultiviewFlags
b)
type instance O.ParentTypes VideoMultiviewFlags = '[]
instance O.HasParentTypes VideoMultiviewFlags
foreign import ccall "gst_video_multiview_flags_get_type" c_gst_video_multiview_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoMultiviewFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_multiview_flags_get_type
instance B.Types.BoxedFlags VideoMultiviewFlags
instance IsGFlag VideoMultiviewFlags
data VideoFrameMapFlags =
VideoFrameMapFlagsNoRef
| VideoFrameMapFlagsLast
| AnotherVideoFrameMapFlags Int
deriving (Int -> VideoFrameMapFlags -> ShowS
[VideoFrameMapFlags] -> ShowS
VideoFrameMapFlags -> String
(Int -> VideoFrameMapFlags -> ShowS)
-> (VideoFrameMapFlags -> String)
-> ([VideoFrameMapFlags] -> ShowS)
-> Show VideoFrameMapFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoFrameMapFlags -> ShowS
showsPrec :: Int -> VideoFrameMapFlags -> ShowS
$cshow :: VideoFrameMapFlags -> String
show :: VideoFrameMapFlags -> String
$cshowList :: [VideoFrameMapFlags] -> ShowS
showList :: [VideoFrameMapFlags] -> ShowS
Show, VideoFrameMapFlags -> VideoFrameMapFlags -> Bool
(VideoFrameMapFlags -> VideoFrameMapFlags -> Bool)
-> (VideoFrameMapFlags -> VideoFrameMapFlags -> Bool)
-> Eq VideoFrameMapFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoFrameMapFlags -> VideoFrameMapFlags -> Bool
== :: VideoFrameMapFlags -> VideoFrameMapFlags -> Bool
$c/= :: VideoFrameMapFlags -> VideoFrameMapFlags -> Bool
/= :: VideoFrameMapFlags -> VideoFrameMapFlags -> Bool
Eq)
instance P.Enum VideoFrameMapFlags where
fromEnum :: VideoFrameMapFlags -> Int
fromEnum VideoFrameMapFlags
VideoFrameMapFlagsNoRef = Int
65536
fromEnum VideoFrameMapFlags
VideoFrameMapFlagsLast = Int
16777216
fromEnum (AnotherVideoFrameMapFlags Int
k) = Int
k
toEnum :: Int -> VideoFrameMapFlags
toEnum Int
65536 = VideoFrameMapFlags
VideoFrameMapFlagsNoRef
toEnum Int
16777216 = VideoFrameMapFlags
VideoFrameMapFlagsLast
toEnum Int
k = Int -> VideoFrameMapFlags
AnotherVideoFrameMapFlags Int
k
instance P.Ord VideoFrameMapFlags where
compare :: VideoFrameMapFlags -> VideoFrameMapFlags -> Ordering
compare VideoFrameMapFlags
a VideoFrameMapFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoFrameMapFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoFrameMapFlags
a) (VideoFrameMapFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoFrameMapFlags
b)
type instance O.ParentTypes VideoFrameMapFlags = '[]
instance O.HasParentTypes VideoFrameMapFlags
foreign import ccall "gst_video_frame_map_flags_get_type" c_gst_video_frame_map_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoFrameMapFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_frame_map_flags_get_type
instance B.Types.BoxedFlags VideoFrameMapFlags
instance IsGFlag VideoFrameMapFlags
data VideoFrameFlags =
VideoFrameFlagsNone
| VideoFrameFlagsInterlaced
| VideoFrameFlagsTff
| VideoFrameFlagsRff
| VideoFrameFlagsOnefield
| VideoFrameFlagsMultipleView
| VideoFrameFlagsFirstInBundle
| VideoFrameFlagsTopField
| VideoFrameFlagsBottomField
| AnotherVideoFrameFlags Int
deriving (Int -> VideoFrameFlags -> ShowS
[VideoFrameFlags] -> ShowS
VideoFrameFlags -> String
(Int -> VideoFrameFlags -> ShowS)
-> (VideoFrameFlags -> String)
-> ([VideoFrameFlags] -> ShowS)
-> Show VideoFrameFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoFrameFlags -> ShowS
showsPrec :: Int -> VideoFrameFlags -> ShowS
$cshow :: VideoFrameFlags -> String
show :: VideoFrameFlags -> String
$cshowList :: [VideoFrameFlags] -> ShowS
showList :: [VideoFrameFlags] -> ShowS
Show, VideoFrameFlags -> VideoFrameFlags -> Bool
(VideoFrameFlags -> VideoFrameFlags -> Bool)
-> (VideoFrameFlags -> VideoFrameFlags -> Bool)
-> Eq VideoFrameFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoFrameFlags -> VideoFrameFlags -> Bool
== :: VideoFrameFlags -> VideoFrameFlags -> Bool
$c/= :: VideoFrameFlags -> VideoFrameFlags -> Bool
/= :: VideoFrameFlags -> VideoFrameFlags -> Bool
Eq)
instance P.Enum VideoFrameFlags where
fromEnum :: VideoFrameFlags -> Int
fromEnum VideoFrameFlags
VideoFrameFlagsNone = Int
0
fromEnum VideoFrameFlags
VideoFrameFlagsInterlaced = Int
1
fromEnum VideoFrameFlags
VideoFrameFlagsTff = Int
2
fromEnum VideoFrameFlags
VideoFrameFlagsRff = Int
4
fromEnum VideoFrameFlags
VideoFrameFlagsOnefield = Int
8
fromEnum VideoFrameFlags
VideoFrameFlagsMultipleView = Int
16
fromEnum VideoFrameFlags
VideoFrameFlagsFirstInBundle = Int
32
fromEnum VideoFrameFlags
VideoFrameFlagsTopField = Int
10
fromEnum VideoFrameFlags
VideoFrameFlagsBottomField = Int
8
fromEnum (AnotherVideoFrameFlags Int
k) = Int
k
toEnum :: Int -> VideoFrameFlags
toEnum Int
0 = VideoFrameFlags
VideoFrameFlagsNone
toEnum Int
1 = VideoFrameFlags
VideoFrameFlagsInterlaced
toEnum Int
2 = VideoFrameFlags
VideoFrameFlagsTff
toEnum Int
4 = VideoFrameFlags
VideoFrameFlagsRff
toEnum Int
8 = VideoFrameFlags
VideoFrameFlagsOnefield
toEnum Int
16 = VideoFrameFlags
VideoFrameFlagsMultipleView
toEnum Int
32 = VideoFrameFlags
VideoFrameFlagsFirstInBundle
toEnum Int
10 = VideoFrameFlags
VideoFrameFlagsTopField
toEnum Int
k = Int -> VideoFrameFlags
AnotherVideoFrameFlags Int
k
instance P.Ord VideoFrameFlags where
compare :: VideoFrameFlags -> VideoFrameFlags -> Ordering
compare VideoFrameFlags
a VideoFrameFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoFrameFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoFrameFlags
a) (VideoFrameFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoFrameFlags
b)
type instance O.ParentTypes VideoFrameFlags = '[]
instance O.HasParentTypes VideoFrameFlags
foreign import ccall "gst_video_frame_flags_get_type" c_gst_video_frame_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoFrameFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_frame_flags_get_type
instance B.Types.BoxedFlags VideoFrameFlags
instance IsGFlag VideoFrameFlags
data VideoFormatFlags =
VideoFormatFlagsYuv
| VideoFormatFlagsRgb
| VideoFormatFlagsGray
| VideoFormatFlagsAlpha
| VideoFormatFlagsLe
| VideoFormatFlagsPalette
| VideoFormatFlagsComplex
| VideoFormatFlagsUnpack
| VideoFormatFlagsTiled
| VideoFormatFlagsSubtiles
| AnotherVideoFormatFlags Int
deriving (Int -> VideoFormatFlags -> ShowS
[VideoFormatFlags] -> ShowS
VideoFormatFlags -> String
(Int -> VideoFormatFlags -> ShowS)
-> (VideoFormatFlags -> String)
-> ([VideoFormatFlags] -> ShowS)
-> Show VideoFormatFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoFormatFlags -> ShowS
showsPrec :: Int -> VideoFormatFlags -> ShowS
$cshow :: VideoFormatFlags -> String
show :: VideoFormatFlags -> String
$cshowList :: [VideoFormatFlags] -> ShowS
showList :: [VideoFormatFlags] -> ShowS
Show, VideoFormatFlags -> VideoFormatFlags -> Bool
(VideoFormatFlags -> VideoFormatFlags -> Bool)
-> (VideoFormatFlags -> VideoFormatFlags -> Bool)
-> Eq VideoFormatFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoFormatFlags -> VideoFormatFlags -> Bool
== :: VideoFormatFlags -> VideoFormatFlags -> Bool
$c/= :: VideoFormatFlags -> VideoFormatFlags -> Bool
/= :: VideoFormatFlags -> VideoFormatFlags -> Bool
Eq)
instance P.Enum VideoFormatFlags where
fromEnum :: VideoFormatFlags -> Int
fromEnum VideoFormatFlags
VideoFormatFlagsYuv = Int
1
fromEnum VideoFormatFlags
VideoFormatFlagsRgb = Int
2
fromEnum VideoFormatFlags
VideoFormatFlagsGray = Int
4
fromEnum VideoFormatFlags
VideoFormatFlagsAlpha = Int
8
fromEnum VideoFormatFlags
VideoFormatFlagsLe = Int
16
fromEnum VideoFormatFlags
VideoFormatFlagsPalette = Int
32
fromEnum VideoFormatFlags
VideoFormatFlagsComplex = Int
64
fromEnum VideoFormatFlags
VideoFormatFlagsUnpack = Int
128
fromEnum VideoFormatFlags
VideoFormatFlagsTiled = Int
256
fromEnum VideoFormatFlags
VideoFormatFlagsSubtiles = Int
512
fromEnum (AnotherVideoFormatFlags Int
k) = Int
k
toEnum :: Int -> VideoFormatFlags
toEnum Int
1 = VideoFormatFlags
VideoFormatFlagsYuv
toEnum Int
2 = VideoFormatFlags
VideoFormatFlagsRgb
toEnum Int
4 = VideoFormatFlags
VideoFormatFlagsGray
toEnum Int
8 = VideoFormatFlags
VideoFormatFlagsAlpha
toEnum Int
16 = VideoFormatFlags
VideoFormatFlagsLe
toEnum Int
32 = VideoFormatFlags
VideoFormatFlagsPalette
toEnum Int
64 = VideoFormatFlags
VideoFormatFlagsComplex
toEnum Int
128 = VideoFormatFlags
VideoFormatFlagsUnpack
toEnum Int
256 = VideoFormatFlags
VideoFormatFlagsTiled
toEnum Int
512 = VideoFormatFlags
VideoFormatFlagsSubtiles
toEnum Int
k = Int -> VideoFormatFlags
AnotherVideoFormatFlags Int
k
instance P.Ord VideoFormatFlags where
compare :: VideoFormatFlags -> VideoFormatFlags -> Ordering
compare VideoFormatFlags
a VideoFormatFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoFormatFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoFormatFlags
a) (VideoFormatFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoFormatFlags
b)
type instance O.ParentTypes VideoFormatFlags = '[]
instance O.HasParentTypes VideoFormatFlags
foreign import ccall "gst_video_format_flags_get_type" c_gst_video_format_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoFormatFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_format_flags_get_type
instance B.Types.BoxedFlags VideoFormatFlags
instance IsGFlag VideoFormatFlags
data VideoFlags =
VideoFlagsNone
| VideoFlagsVariableFps
| VideoFlagsPremultipliedAlpha
| AnotherVideoFlags Int
deriving (Int -> VideoFlags -> ShowS
[VideoFlags] -> ShowS
VideoFlags -> String
(Int -> VideoFlags -> ShowS)
-> (VideoFlags -> String)
-> ([VideoFlags] -> ShowS)
-> Show VideoFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoFlags -> ShowS
showsPrec :: Int -> VideoFlags -> ShowS
$cshow :: VideoFlags -> String
show :: VideoFlags -> String
$cshowList :: [VideoFlags] -> ShowS
showList :: [VideoFlags] -> ShowS
Show, VideoFlags -> VideoFlags -> Bool
(VideoFlags -> VideoFlags -> Bool)
-> (VideoFlags -> VideoFlags -> Bool) -> Eq VideoFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoFlags -> VideoFlags -> Bool
== :: VideoFlags -> VideoFlags -> Bool
$c/= :: VideoFlags -> VideoFlags -> Bool
/= :: VideoFlags -> VideoFlags -> Bool
Eq)
instance P.Enum VideoFlags where
fromEnum :: VideoFlags -> Int
fromEnum VideoFlags
VideoFlagsNone = Int
0
fromEnum VideoFlags
VideoFlagsVariableFps = Int
1
fromEnum VideoFlags
VideoFlagsPremultipliedAlpha = Int
2
fromEnum (AnotherVideoFlags Int
k) = Int
k
toEnum :: Int -> VideoFlags
toEnum Int
0 = VideoFlags
VideoFlagsNone
toEnum Int
1 = VideoFlags
VideoFlagsVariableFps
toEnum Int
2 = VideoFlags
VideoFlagsPremultipliedAlpha
toEnum Int
k = Int -> VideoFlags
AnotherVideoFlags Int
k
instance P.Ord VideoFlags where
compare :: VideoFlags -> VideoFlags -> Ordering
compare VideoFlags
a VideoFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoFlags
a) (VideoFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoFlags
b)
type instance O.ParentTypes VideoFlags = '[]
instance O.HasParentTypes VideoFlags
foreign import ccall "gst_video_flags_get_type" c_gst_video_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_flags_get_type
instance B.Types.BoxedFlags VideoFlags
instance IsGFlag VideoFlags
data VideoDitherFlags =
VideoDitherFlagsNone
| VideoDitherFlagsInterlaced
| VideoDitherFlagsQuantize
| AnotherVideoDitherFlags Int
deriving (Int -> VideoDitherFlags -> ShowS
[VideoDitherFlags] -> ShowS
VideoDitherFlags -> String
(Int -> VideoDitherFlags -> ShowS)
-> (VideoDitherFlags -> String)
-> ([VideoDitherFlags] -> ShowS)
-> Show VideoDitherFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoDitherFlags -> ShowS
showsPrec :: Int -> VideoDitherFlags -> ShowS
$cshow :: VideoDitherFlags -> String
show :: VideoDitherFlags -> String
$cshowList :: [VideoDitherFlags] -> ShowS
showList :: [VideoDitherFlags] -> ShowS
Show, VideoDitherFlags -> VideoDitherFlags -> Bool
(VideoDitherFlags -> VideoDitherFlags -> Bool)
-> (VideoDitherFlags -> VideoDitherFlags -> Bool)
-> Eq VideoDitherFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoDitherFlags -> VideoDitherFlags -> Bool
== :: VideoDitherFlags -> VideoDitherFlags -> Bool
$c/= :: VideoDitherFlags -> VideoDitherFlags -> Bool
/= :: VideoDitherFlags -> VideoDitherFlags -> Bool
Eq)
instance P.Enum VideoDitherFlags where
fromEnum :: VideoDitherFlags -> Int
fromEnum VideoDitherFlags
VideoDitherFlagsNone = Int
0
fromEnum VideoDitherFlags
VideoDitherFlagsInterlaced = Int
1
fromEnum VideoDitherFlags
VideoDitherFlagsQuantize = Int
2
fromEnum (AnotherVideoDitherFlags Int
k) = Int
k
toEnum :: Int -> VideoDitherFlags
toEnum Int
0 = VideoDitherFlags
VideoDitherFlagsNone
toEnum Int
1 = VideoDitherFlags
VideoDitherFlagsInterlaced
toEnum Int
2 = VideoDitherFlags
VideoDitherFlagsQuantize
toEnum Int
k = Int -> VideoDitherFlags
AnotherVideoDitherFlags Int
k
instance P.Ord VideoDitherFlags where
compare :: VideoDitherFlags -> VideoDitherFlags -> Ordering
compare VideoDitherFlags
a VideoDitherFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoDitherFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoDitherFlags
a) (VideoDitherFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoDitherFlags
b)
type instance O.ParentTypes VideoDitherFlags = '[]
instance O.HasParentTypes VideoDitherFlags
foreign import ccall "gst_video_dither_flags_get_type" c_gst_video_dither_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoDitherFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_dither_flags_get_type
instance B.Types.BoxedFlags VideoDitherFlags
instance IsGFlag VideoDitherFlags
data VideoDecoderRequestSyncPointFlags =
VideoDecoderRequestSyncPointFlagsDiscardInput
| VideoDecoderRequestSyncPointFlagsCorruptOutput
| AnotherVideoDecoderRequestSyncPointFlags Int
deriving (Int -> VideoDecoderRequestSyncPointFlags -> ShowS
[VideoDecoderRequestSyncPointFlags] -> ShowS
VideoDecoderRequestSyncPointFlags -> String
(Int -> VideoDecoderRequestSyncPointFlags -> ShowS)
-> (VideoDecoderRequestSyncPointFlags -> String)
-> ([VideoDecoderRequestSyncPointFlags] -> ShowS)
-> Show VideoDecoderRequestSyncPointFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoDecoderRequestSyncPointFlags -> ShowS
showsPrec :: Int -> VideoDecoderRequestSyncPointFlags -> ShowS
$cshow :: VideoDecoderRequestSyncPointFlags -> String
show :: VideoDecoderRequestSyncPointFlags -> String
$cshowList :: [VideoDecoderRequestSyncPointFlags] -> ShowS
showList :: [VideoDecoderRequestSyncPointFlags] -> ShowS
Show, VideoDecoderRequestSyncPointFlags
-> VideoDecoderRequestSyncPointFlags -> Bool
(VideoDecoderRequestSyncPointFlags
-> VideoDecoderRequestSyncPointFlags -> Bool)
-> (VideoDecoderRequestSyncPointFlags
-> VideoDecoderRequestSyncPointFlags -> Bool)
-> Eq VideoDecoderRequestSyncPointFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoDecoderRequestSyncPointFlags
-> VideoDecoderRequestSyncPointFlags -> Bool
== :: VideoDecoderRequestSyncPointFlags
-> VideoDecoderRequestSyncPointFlags -> Bool
$c/= :: VideoDecoderRequestSyncPointFlags
-> VideoDecoderRequestSyncPointFlags -> Bool
/= :: VideoDecoderRequestSyncPointFlags
-> VideoDecoderRequestSyncPointFlags -> Bool
Eq)
instance P.Enum VideoDecoderRequestSyncPointFlags where
fromEnum :: VideoDecoderRequestSyncPointFlags -> Int
fromEnum VideoDecoderRequestSyncPointFlags
VideoDecoderRequestSyncPointFlagsDiscardInput = Int
1
fromEnum VideoDecoderRequestSyncPointFlags
VideoDecoderRequestSyncPointFlagsCorruptOutput = Int
2
fromEnum (AnotherVideoDecoderRequestSyncPointFlags Int
k) = Int
k
toEnum :: Int -> VideoDecoderRequestSyncPointFlags
toEnum Int
1 = VideoDecoderRequestSyncPointFlags
VideoDecoderRequestSyncPointFlagsDiscardInput
toEnum Int
2 = VideoDecoderRequestSyncPointFlags
VideoDecoderRequestSyncPointFlagsCorruptOutput
toEnum Int
k = Int -> VideoDecoderRequestSyncPointFlags
AnotherVideoDecoderRequestSyncPointFlags Int
k
instance P.Ord VideoDecoderRequestSyncPointFlags where
compare :: VideoDecoderRequestSyncPointFlags
-> VideoDecoderRequestSyncPointFlags -> Ordering
compare VideoDecoderRequestSyncPointFlags
a VideoDecoderRequestSyncPointFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoDecoderRequestSyncPointFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoDecoderRequestSyncPointFlags
a) (VideoDecoderRequestSyncPointFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoDecoderRequestSyncPointFlags
b)
type instance O.ParentTypes VideoDecoderRequestSyncPointFlags = '[]
instance O.HasParentTypes VideoDecoderRequestSyncPointFlags
foreign import ccall "gst_video_decoder_request_sync_point_flags_get_type" c_gst_video_decoder_request_sync_point_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoDecoderRequestSyncPointFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_decoder_request_sync_point_flags_get_type
instance B.Types.BoxedFlags VideoDecoderRequestSyncPointFlags
instance IsGFlag VideoDecoderRequestSyncPointFlags
data VideoCodecFrameFlags =
VideoCodecFrameFlagsDecodeOnly
| VideoCodecFrameFlagsSyncPoint
| VideoCodecFrameFlagsForceKeyframe
|
| VideoCodecFrameFlagsCorrupted
| AnotherVideoCodecFrameFlags Int
deriving (Int -> VideoCodecFrameFlags -> ShowS
[VideoCodecFrameFlags] -> ShowS
VideoCodecFrameFlags -> String
(Int -> VideoCodecFrameFlags -> ShowS)
-> (VideoCodecFrameFlags -> String)
-> ([VideoCodecFrameFlags] -> ShowS)
-> Show VideoCodecFrameFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoCodecFrameFlags -> ShowS
showsPrec :: Int -> VideoCodecFrameFlags -> ShowS
$cshow :: VideoCodecFrameFlags -> String
show :: VideoCodecFrameFlags -> String
$cshowList :: [VideoCodecFrameFlags] -> ShowS
showList :: [VideoCodecFrameFlags] -> ShowS
Show, VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool
(VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool)
-> (VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool)
-> Eq VideoCodecFrameFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool
== :: VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool
$c/= :: VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool
/= :: VideoCodecFrameFlags -> VideoCodecFrameFlags -> Bool
Eq)
instance P.Enum VideoCodecFrameFlags where
fromEnum :: VideoCodecFrameFlags -> Int
fromEnum VideoCodecFrameFlags
VideoCodecFrameFlagsDecodeOnly = Int
1
fromEnum VideoCodecFrameFlags
VideoCodecFrameFlagsSyncPoint = Int
2
fromEnum VideoCodecFrameFlags
VideoCodecFrameFlagsForceKeyframe = Int
4
fromEnum VideoCodecFrameFlags
VideoCodecFrameFlagsForceKeyframeHeaders = Int
8
fromEnum VideoCodecFrameFlags
VideoCodecFrameFlagsCorrupted = Int
16
fromEnum (AnotherVideoCodecFrameFlags Int
k) = Int
k
toEnum :: Int -> VideoCodecFrameFlags
toEnum Int
1 = VideoCodecFrameFlags
VideoCodecFrameFlagsDecodeOnly
toEnum Int
2 = VideoCodecFrameFlags
VideoCodecFrameFlagsSyncPoint
toEnum Int
4 = VideoCodecFrameFlags
VideoCodecFrameFlagsForceKeyframe
toEnum Int
8 = VideoCodecFrameFlags
VideoCodecFrameFlagsForceKeyframeHeaders
toEnum Int
16 = VideoCodecFrameFlags
VideoCodecFrameFlagsCorrupted
toEnum Int
k = Int -> VideoCodecFrameFlags
AnotherVideoCodecFrameFlags Int
k
instance P.Ord VideoCodecFrameFlags where
compare :: VideoCodecFrameFlags -> VideoCodecFrameFlags -> Ordering
compare VideoCodecFrameFlags
a VideoCodecFrameFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoCodecFrameFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoCodecFrameFlags
a) (VideoCodecFrameFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoCodecFrameFlags
b)
type instance O.ParentTypes VideoCodecFrameFlags = '[]
instance O.HasParentTypes VideoCodecFrameFlags
foreign import ccall "gst_video_codec_frame_flags_get_type" c_gst_video_codec_frame_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoCodecFrameFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_codec_frame_flags_get_type
instance B.Types.BoxedFlags VideoCodecFrameFlags
instance IsGFlag VideoCodecFrameFlags
data VideoChromaSite =
VideoChromaSiteUnknown
| VideoChromaSiteNone
| VideoChromaSiteHCosited
| VideoChromaSiteVCosited
| VideoChromaSiteAltLine
| VideoChromaSiteCosited
| VideoChromaSiteJpeg
| VideoChromaSiteMpeg2
| VideoChromaSiteDv
| AnotherVideoChromaSite Int
deriving (Int -> VideoChromaSite -> ShowS
[VideoChromaSite] -> ShowS
VideoChromaSite -> String
(Int -> VideoChromaSite -> ShowS)
-> (VideoChromaSite -> String)
-> ([VideoChromaSite] -> ShowS)
-> Show VideoChromaSite
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoChromaSite -> ShowS
showsPrec :: Int -> VideoChromaSite -> ShowS
$cshow :: VideoChromaSite -> String
show :: VideoChromaSite -> String
$cshowList :: [VideoChromaSite] -> ShowS
showList :: [VideoChromaSite] -> ShowS
Show, VideoChromaSite -> VideoChromaSite -> Bool
(VideoChromaSite -> VideoChromaSite -> Bool)
-> (VideoChromaSite -> VideoChromaSite -> Bool)
-> Eq VideoChromaSite
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoChromaSite -> VideoChromaSite -> Bool
== :: VideoChromaSite -> VideoChromaSite -> Bool
$c/= :: VideoChromaSite -> VideoChromaSite -> Bool
/= :: VideoChromaSite -> VideoChromaSite -> Bool
Eq)
instance P.Enum VideoChromaSite where
fromEnum :: VideoChromaSite -> Int
fromEnum VideoChromaSite
VideoChromaSiteUnknown = Int
0
fromEnum VideoChromaSite
VideoChromaSiteNone = Int
1
fromEnum VideoChromaSite
VideoChromaSiteHCosited = Int
2
fromEnum VideoChromaSite
VideoChromaSiteVCosited = Int
4
fromEnum VideoChromaSite
VideoChromaSiteAltLine = Int
8
fromEnum VideoChromaSite
VideoChromaSiteCosited = Int
6
fromEnum VideoChromaSite
VideoChromaSiteJpeg = Int
1
fromEnum VideoChromaSite
VideoChromaSiteMpeg2 = Int
2
fromEnum VideoChromaSite
VideoChromaSiteDv = Int
14
fromEnum (AnotherVideoChromaSite Int
k) = Int
k
toEnum :: Int -> VideoChromaSite
toEnum Int
0 = VideoChromaSite
VideoChromaSiteUnknown
toEnum Int
1 = VideoChromaSite
VideoChromaSiteNone
toEnum Int
2 = VideoChromaSite
VideoChromaSiteHCosited
toEnum Int
4 = VideoChromaSite
VideoChromaSiteVCosited
toEnum Int
8 = VideoChromaSite
VideoChromaSiteAltLine
toEnum Int
6 = VideoChromaSite
VideoChromaSiteCosited
toEnum Int
14 = VideoChromaSite
VideoChromaSiteDv
toEnum Int
k = Int -> VideoChromaSite
AnotherVideoChromaSite Int
k
instance P.Ord VideoChromaSite where
compare :: VideoChromaSite -> VideoChromaSite -> Ordering
compare VideoChromaSite
a VideoChromaSite
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoChromaSite -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoChromaSite
a) (VideoChromaSite -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoChromaSite
b)
type instance O.ParentTypes VideoChromaSite = '[]
instance O.HasParentTypes VideoChromaSite
foreign import ccall "gst_video_chroma_site_get_type" c_gst_video_chroma_site_get_type ::
IO GType
instance B.Types.TypedObject VideoChromaSite where
glibType :: IO GType
glibType = IO GType
c_gst_video_chroma_site_get_type
instance B.Types.BoxedFlags VideoChromaSite
instance IsGFlag VideoChromaSite
data VideoChromaFlags =
VideoChromaFlagsNone
| VideoChromaFlagsInterlaced
| AnotherVideoChromaFlags Int
deriving (Int -> VideoChromaFlags -> ShowS
[VideoChromaFlags] -> ShowS
VideoChromaFlags -> String
(Int -> VideoChromaFlags -> ShowS)
-> (VideoChromaFlags -> String)
-> ([VideoChromaFlags] -> ShowS)
-> Show VideoChromaFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoChromaFlags -> ShowS
showsPrec :: Int -> VideoChromaFlags -> ShowS
$cshow :: VideoChromaFlags -> String
show :: VideoChromaFlags -> String
$cshowList :: [VideoChromaFlags] -> ShowS
showList :: [VideoChromaFlags] -> ShowS
Show, VideoChromaFlags -> VideoChromaFlags -> Bool
(VideoChromaFlags -> VideoChromaFlags -> Bool)
-> (VideoChromaFlags -> VideoChromaFlags -> Bool)
-> Eq VideoChromaFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoChromaFlags -> VideoChromaFlags -> Bool
== :: VideoChromaFlags -> VideoChromaFlags -> Bool
$c/= :: VideoChromaFlags -> VideoChromaFlags -> Bool
/= :: VideoChromaFlags -> VideoChromaFlags -> Bool
Eq)
instance P.Enum VideoChromaFlags where
fromEnum :: VideoChromaFlags -> Int
fromEnum VideoChromaFlags
VideoChromaFlagsNone = Int
0
fromEnum VideoChromaFlags
VideoChromaFlagsInterlaced = Int
1
fromEnum (AnotherVideoChromaFlags Int
k) = Int
k
toEnum :: Int -> VideoChromaFlags
toEnum Int
0 = VideoChromaFlags
VideoChromaFlagsNone
toEnum Int
1 = VideoChromaFlags
VideoChromaFlagsInterlaced
toEnum Int
k = Int -> VideoChromaFlags
AnotherVideoChromaFlags Int
k
instance P.Ord VideoChromaFlags where
compare :: VideoChromaFlags -> VideoChromaFlags -> Ordering
compare VideoChromaFlags
a VideoChromaFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoChromaFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoChromaFlags
a) (VideoChromaFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoChromaFlags
b)
type instance O.ParentTypes VideoChromaFlags = '[]
instance O.HasParentTypes VideoChromaFlags
foreign import ccall "gst_video_chroma_flags_get_type" c_gst_video_chroma_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoChromaFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_chroma_flags_get_type
instance B.Types.BoxedFlags VideoChromaFlags
instance IsGFlag VideoChromaFlags
data VideoBufferFlags =
VideoBufferFlagsInterlaced
| VideoBufferFlagsTff
| VideoBufferFlagsRff
| VideoBufferFlagsOnefield
| VideoBufferFlagsMultipleView
| VideoBufferFlagsFirstInBundle
| VideoBufferFlagsTopField
| VideoBufferFlagsBottomField
| VideoBufferFlagsMarker
| VideoBufferFlagsLast
| AnotherVideoBufferFlags Int
deriving (Int -> VideoBufferFlags -> ShowS
[VideoBufferFlags] -> ShowS
VideoBufferFlags -> String
(Int -> VideoBufferFlags -> ShowS)
-> (VideoBufferFlags -> String)
-> ([VideoBufferFlags] -> ShowS)
-> Show VideoBufferFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoBufferFlags -> ShowS
showsPrec :: Int -> VideoBufferFlags -> ShowS
$cshow :: VideoBufferFlags -> String
show :: VideoBufferFlags -> String
$cshowList :: [VideoBufferFlags] -> ShowS
showList :: [VideoBufferFlags] -> ShowS
Show, VideoBufferFlags -> VideoBufferFlags -> Bool
(VideoBufferFlags -> VideoBufferFlags -> Bool)
-> (VideoBufferFlags -> VideoBufferFlags -> Bool)
-> Eq VideoBufferFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoBufferFlags -> VideoBufferFlags -> Bool
== :: VideoBufferFlags -> VideoBufferFlags -> Bool
$c/= :: VideoBufferFlags -> VideoBufferFlags -> Bool
/= :: VideoBufferFlags -> VideoBufferFlags -> Bool
Eq)
instance P.Enum VideoBufferFlags where
fromEnum :: VideoBufferFlags -> Int
fromEnum VideoBufferFlags
VideoBufferFlagsInterlaced = Int
1048576
fromEnum VideoBufferFlags
VideoBufferFlagsTff = Int
2097152
fromEnum VideoBufferFlags
VideoBufferFlagsRff = Int
4194304
fromEnum VideoBufferFlags
VideoBufferFlagsOnefield = Int
8388608
fromEnum VideoBufferFlags
VideoBufferFlagsMultipleView = Int
16777216
fromEnum VideoBufferFlags
VideoBufferFlagsFirstInBundle = Int
33554432
fromEnum VideoBufferFlags
VideoBufferFlagsTopField = Int
10485760
fromEnum VideoBufferFlags
VideoBufferFlagsBottomField = Int
8388608
fromEnum VideoBufferFlags
VideoBufferFlagsMarker = Int
512
fromEnum VideoBufferFlags
VideoBufferFlagsLast = Int
268435456
fromEnum (AnotherVideoBufferFlags Int
k) = Int
k
toEnum :: Int -> VideoBufferFlags
toEnum Int
1048576 = VideoBufferFlags
VideoBufferFlagsInterlaced
toEnum Int
2097152 = VideoBufferFlags
VideoBufferFlagsTff
toEnum Int
4194304 = VideoBufferFlags
VideoBufferFlagsRff
toEnum Int
8388608 = VideoBufferFlags
VideoBufferFlagsOnefield
toEnum Int
16777216 = VideoBufferFlags
VideoBufferFlagsMultipleView
toEnum Int
33554432 = VideoBufferFlags
VideoBufferFlagsFirstInBundle
toEnum Int
10485760 = VideoBufferFlags
VideoBufferFlagsTopField
toEnum Int
512 = VideoBufferFlags
VideoBufferFlagsMarker
toEnum Int
268435456 = VideoBufferFlags
VideoBufferFlagsLast
toEnum Int
k = Int -> VideoBufferFlags
AnotherVideoBufferFlags Int
k
instance P.Ord VideoBufferFlags where
compare :: VideoBufferFlags -> VideoBufferFlags -> Ordering
compare VideoBufferFlags
a VideoBufferFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VideoBufferFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoBufferFlags
a) (VideoBufferFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum VideoBufferFlags
b)
type instance O.ParentTypes VideoBufferFlags = '[]
instance O.HasParentTypes VideoBufferFlags
foreign import ccall "gst_video_buffer_flags_get_type" c_gst_video_buffer_flags_get_type ::
IO GType
instance B.Types.TypedObject VideoBufferFlags where
glibType :: IO GType
glibType = IO GType
c_gst_video_buffer_flags_get_type
instance B.Types.BoxedFlags VideoBufferFlags
instance IsGFlag VideoBufferFlags
data NavigationModifierType =
NavigationModifierTypeNone
| NavigationModifierTypeShiftMask
| NavigationModifierTypeLockMask
| NavigationModifierTypeControlMask
| NavigationModifierTypeMod1Mask
| NavigationModifierTypeMod2Mask
| NavigationModifierTypeMod3Mask
| NavigationModifierTypeMod4Mask
| NavigationModifierTypeMod5Mask
| NavigationModifierTypeButton1Mask
| NavigationModifierTypeButton2Mask
| NavigationModifierTypeButton3Mask
| NavigationModifierTypeButton4Mask
| NavigationModifierTypeButton5Mask
| NavigationModifierTypeSuperMask
| NavigationModifierTypeHyperMask
| NavigationModifierTypeMetaMask
| NavigationModifierTypeMask
| AnotherNavigationModifierType Int
deriving (Int -> NavigationModifierType -> ShowS
[NavigationModifierType] -> ShowS
NavigationModifierType -> String
(Int -> NavigationModifierType -> ShowS)
-> (NavigationModifierType -> String)
-> ([NavigationModifierType] -> ShowS)
-> Show NavigationModifierType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NavigationModifierType -> ShowS
showsPrec :: Int -> NavigationModifierType -> ShowS
$cshow :: NavigationModifierType -> String
show :: NavigationModifierType -> String
$cshowList :: [NavigationModifierType] -> ShowS
showList :: [NavigationModifierType] -> ShowS
Show, NavigationModifierType -> NavigationModifierType -> Bool
(NavigationModifierType -> NavigationModifierType -> Bool)
-> (NavigationModifierType -> NavigationModifierType -> Bool)
-> Eq NavigationModifierType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NavigationModifierType -> NavigationModifierType -> Bool
== :: NavigationModifierType -> NavigationModifierType -> Bool
$c/= :: NavigationModifierType -> NavigationModifierType -> Bool
/= :: NavigationModifierType -> NavigationModifierType -> Bool
Eq)
instance P.Enum NavigationModifierType where
fromEnum :: NavigationModifierType -> Int
fromEnum NavigationModifierType
NavigationModifierTypeNone = Int
0
fromEnum NavigationModifierType
NavigationModifierTypeShiftMask = Int
1
fromEnum NavigationModifierType
NavigationModifierTypeLockMask = Int
2
fromEnum NavigationModifierType
NavigationModifierTypeControlMask = Int
4
fromEnum NavigationModifierType
NavigationModifierTypeMod1Mask = Int
8
fromEnum NavigationModifierType
NavigationModifierTypeMod2Mask = Int
16
fromEnum NavigationModifierType
NavigationModifierTypeMod3Mask = Int
32
fromEnum NavigationModifierType
NavigationModifierTypeMod4Mask = Int
64
fromEnum NavigationModifierType
NavigationModifierTypeMod5Mask = Int
128
fromEnum NavigationModifierType
NavigationModifierTypeButton1Mask = Int
256
fromEnum NavigationModifierType
NavigationModifierTypeButton2Mask = Int
512
fromEnum NavigationModifierType
NavigationModifierTypeButton3Mask = Int
1024
fromEnum NavigationModifierType
NavigationModifierTypeButton4Mask = Int
2048
fromEnum NavigationModifierType
NavigationModifierTypeButton5Mask = Int
4096
fromEnum NavigationModifierType
NavigationModifierTypeSuperMask = Int
67108864
fromEnum NavigationModifierType
NavigationModifierTypeHyperMask = Int
134217728
fromEnum NavigationModifierType
NavigationModifierTypeMetaMask = Int
268435456
fromEnum NavigationModifierType
NavigationModifierTypeMask = Int
469770239
fromEnum (AnotherNavigationModifierType Int
k) = Int
k
toEnum :: Int -> NavigationModifierType
toEnum Int
0 = NavigationModifierType
NavigationModifierTypeNone
toEnum Int
1 = NavigationModifierType
NavigationModifierTypeShiftMask
toEnum Int
2 = NavigationModifierType
NavigationModifierTypeLockMask
toEnum Int
4 = NavigationModifierType
NavigationModifierTypeControlMask
toEnum Int
8 = NavigationModifierType
NavigationModifierTypeMod1Mask
toEnum Int
16 = NavigationModifierType
NavigationModifierTypeMod2Mask
toEnum Int
32 = NavigationModifierType
NavigationModifierTypeMod3Mask
toEnum Int
64 = NavigationModifierType
NavigationModifierTypeMod4Mask
toEnum Int
128 = NavigationModifierType
NavigationModifierTypeMod5Mask
toEnum Int
256 = NavigationModifierType
NavigationModifierTypeButton1Mask
toEnum Int
512 = NavigationModifierType
NavigationModifierTypeButton2Mask
toEnum Int
1024 = NavigationModifierType
NavigationModifierTypeButton3Mask
toEnum Int
2048 = NavigationModifierType
NavigationModifierTypeButton4Mask
toEnum Int
4096 = NavigationModifierType
NavigationModifierTypeButton5Mask
toEnum Int
67108864 = NavigationModifierType
NavigationModifierTypeSuperMask
toEnum Int
134217728 = NavigationModifierType
NavigationModifierTypeHyperMask
toEnum Int
268435456 = NavigationModifierType
NavigationModifierTypeMetaMask
toEnum Int
469770239 = NavigationModifierType
NavigationModifierTypeMask
toEnum Int
k = Int -> NavigationModifierType
AnotherNavigationModifierType Int
k
instance P.Ord NavigationModifierType where
compare :: NavigationModifierType -> NavigationModifierType -> Ordering
compare NavigationModifierType
a NavigationModifierType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (NavigationModifierType -> Int
forall a. Enum a => a -> Int
P.fromEnum NavigationModifierType
a) (NavigationModifierType -> Int
forall a. Enum a => a -> Int
P.fromEnum NavigationModifierType
b)
type instance O.ParentTypes NavigationModifierType = '[]
instance O.HasParentTypes NavigationModifierType
foreign import ccall "gst_navigation_modifier_type_get_type" c_gst_navigation_modifier_type_get_type ::
IO GType
instance B.Types.TypedObject NavigationModifierType where
glibType :: IO GType
glibType = IO GType
c_gst_navigation_modifier_type_get_type
instance B.Types.BoxedFlags NavigationModifierType
instance IsGFlag NavigationModifierType