gi-gstvideo 1.0.16 → 1.0.18

raw patch · 107 files changed

+33971/−9 lines, 107 filesdep ~haskell-gidep ~haskell-gi-basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: haskell-gi, haskell-gi-base

API changes (from Hackage documentation)

Files

• ChangeLog.md +8/−0
• GI/GstVideo.hs +60/−0
• GI/GstVideo/Callbacks.hs +736/−0
• GI/GstVideo/Constants.hs +538/−0
• GI/GstVideo/Enums.hs +2633/−0
• GI/GstVideo/Enums.hs-boot +115/−0
• GI/GstVideo/Flags.hs +983/−0
• GI/GstVideo/Flags.hs-boot +82/−0
• GI/GstVideo/Functions.hs +2198/−0
• GI/GstVideo/Interfaces.hs +49/−0
• GI/GstVideo/Interfaces/ColorBalance.hs +482/−0
• GI/GstVideo/Interfaces/ColorBalance.hs-boot +47/−0
• GI/GstVideo/Interfaces/Navigation.hs +1201/−0
• GI/GstVideo/Interfaces/Navigation.hs-boot +39/−0
• GI/GstVideo/Interfaces/VideoDirection.hs +194/−0
• GI/GstVideo/Interfaces/VideoDirection.hs-boot +32/−0
• GI/GstVideo/Interfaces/VideoOrientation.hs +470/−0
• GI/GstVideo/Interfaces/VideoOrientation.hs-boot +51/−0
• GI/GstVideo/Interfaces/VideoOverlay.hs +695/−0
• GI/GstVideo/Interfaces/VideoOverlay.hs-boot +45/−0
• GI/GstVideo/Objects.hs +59/−0
• GI/GstVideo/Objects/ColorBalanceChannel.hs +217/−0
• GI/GstVideo/Objects/ColorBalanceChannel.hs-boot +32/−0
• GI/GstVideo/Objects/VideoAggregator.hs +224/−0
• GI/GstVideo/Objects/VideoAggregator.hs-boot +29/−0
• GI/GstVideo/Objects/VideoAggregatorConvertPad.hs +364/−0
• GI/GstVideo/Objects/VideoAggregatorConvertPad.hs-boot +35/−0
• GI/GstVideo/Objects/VideoAggregatorPad.hs +566/−0
• GI/GstVideo/Objects/VideoAggregatorPad.hs-boot +47/−0
• GI/GstVideo/Objects/VideoBufferPool.hs +190/−0
• GI/GstVideo/Objects/VideoBufferPool.hs-boot +29/−0
• GI/GstVideo/Objects/VideoDecoder.hs +2011/−0
• GI/GstVideo/Objects/VideoDecoder.hs-boot +128/−0
• GI/GstVideo/Objects/VideoEncoder.hs +1352/−0
• GI/GstVideo/Objects/VideoEncoder.hs-boot +89/−0
• GI/GstVideo/Objects/VideoFilter.hs +226/−0
• GI/GstVideo/Objects/VideoFilter.hs-boot +29/−0
• GI/GstVideo/Objects/VideoMultiviewFlagsSet.hs +36/−0
• GI/GstVideo/Objects/VideoSink.hs +367/−0
• GI/GstVideo/Objects/VideoSink.hs-boot +32/−0
• GI/GstVideo/Structs.hs +101/−0
• GI/GstVideo/Structs/VideoAffineTransformationMeta.hs +231/−0
• GI/GstVideo/Structs/VideoAffineTransformationMeta.hs-boot +29/−0
• GI/GstVideo/Structs/VideoAlignment.hs +359/−0
• GI/GstVideo/Structs/VideoAlignment.hs-boot +29/−0
• GI/GstVideo/Structs/VideoAncillary.hs +263/−0
• GI/GstVideo/Structs/VideoAncillary.hs-boot +26/−0
• GI/GstVideo/Structs/VideoCaptionMeta.hs +286/−0
• GI/GstVideo/Structs/VideoCaptionMeta.hs-boot +26/−0
• GI/GstVideo/Structs/VideoChromaResample.hs +171/−0
• GI/GstVideo/Structs/VideoChromaResample.hs-boot +32/−0
• GI/GstVideo/Structs/VideoCodecFrame.hs +766/−0
• GI/GstVideo/Structs/VideoCodecFrame.hs-boot +38/−0
• GI/GstVideo/Structs/VideoCodecState.hs +452/−0
• GI/GstVideo/Structs/VideoCodecState.hs-boot +32/−0
• GI/GstVideo/Structs/VideoColorPrimariesInfo.hs +609/−0
• GI/GstVideo/Structs/VideoColorPrimariesInfo.hs-boot +26/−0
• GI/GstVideo/Structs/VideoColorimetry.hs +523/−0
• GI/GstVideo/Structs/VideoColorimetry.hs-boot +38/−0
• GI/GstVideo/Structs/VideoConverter.hs +284/−0
• GI/GstVideo/Structs/VideoConverter.hs-boot +38/−0
• GI/GstVideo/Structs/VideoCropMeta.hs +390/−0
• GI/GstVideo/Structs/VideoCropMeta.hs-boot +26/−0
• GI/GstVideo/Structs/VideoDither.hs +179/−0
• GI/GstVideo/Structs/VideoDither.hs-boot +32/−0
• GI/GstVideo/Structs/VideoFormatInfo.hs +949/−0
• GI/GstVideo/Structs/VideoFormatInfo.hs-boot +26/−0
• GI/GstVideo/Structs/VideoFrame.hs +708/−0
• GI/GstVideo/Structs/VideoFrame.hs-boot +41/−0
• GI/GstVideo/Structs/VideoGLTextureUploadMeta.hs +334/−0
• GI/GstVideo/Structs/VideoGLTextureUploadMeta.hs-boot +29/−0
• GI/GstVideo/Structs/VideoInfo.hs +1383/−0
• GI/GstVideo/Structs/VideoInfo.hs-boot +56/−0
• GI/GstVideo/Structs/VideoMeta.hs +842/−0
• GI/GstVideo/Structs/VideoMeta.hs-boot +32/−0
• GI/GstVideo/Structs/VideoMetaTransform.hs +268/−0
• GI/GstVideo/Structs/VideoMetaTransform.hs-boot +26/−0
• GI/GstVideo/Structs/VideoOverlayComposition.hs +486/−0
• GI/GstVideo/Structs/VideoOverlayComposition.hs-boot +47/−0
• GI/GstVideo/Structs/VideoOverlayCompositionMeta.hs +242/−0
• GI/GstVideo/Structs/VideoOverlayCompositionMeta.hs-boot +26/−0
• GI/GstVideo/Structs/VideoOverlayRectangle.hs +868/−0
• GI/GstVideo/Structs/VideoOverlayRectangle.hs-boot +65/−0
• GI/GstVideo/Structs/VideoRectangle.hs +311/−0
• GI/GstVideo/Structs/VideoRectangle.hs-boot +26/−0
• GI/GstVideo/Structs/VideoRegionOfInterestMeta.hs +736/−0
• GI/GstVideo/Structs/VideoRegionOfInterestMeta.hs-boot +32/−0
• GI/GstVideo/Structs/VideoResampler.hs +649/−0
• GI/GstVideo/Structs/VideoResampler.hs-boot +32/−0
• GI/GstVideo/Structs/VideoScaler.hs +426/−0
• GI/GstVideo/Structs/VideoScaler.hs-boot +44/−0
• GI/GstVideo/Structs/VideoTimeCode.hs +1476/−0
• GI/GstVideo/Structs/VideoTimeCode.hs-boot +71/−0
• GI/GstVideo/Structs/VideoTimeCodeConfig.hs +336/−0
• GI/GstVideo/Structs/VideoTimeCodeConfig.hs-boot +26/−0
• GI/GstVideo/Structs/VideoTimeCodeInterval.hs +596/−0
• GI/GstVideo/Structs/VideoTimeCodeInterval.hs-boot +38/−0
• GI/GstVideo/Structs/VideoTimeCodeMeta.hs +219/−0
• GI/GstVideo/Structs/VideoTimeCodeMeta.hs-boot +26/−0
• GI/GstVideo/Structs/VideoVBIEncoder.hs +325/−0
• GI/GstVideo/Structs/VideoVBIEncoder.hs-boot +38/−0
• GI/GstVideo/Structs/VideoVBIParser.hs +313/−0
• GI/GstVideo/Structs/VideoVBIParser.hs-boot +38/−0
• LICENSE +14/−0
• README.md +1/−1
• gi-gstvideo.cabal +63/−7
• stack.yaml +1/−1

@@ -1,3 +1,11 @@+### 1.0.18+++ Update to haskell-gi(-base) 0.22++### 1.0.17+++ Update stack version to 12.10+ ### 1.0.16  + Do not generate bindings for `VideoOverlay.installProperties`, since we don't support class structures yet.

@@ -0,0 +1,60 @@+++{- |+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+    (     module GI.GstVideo.Callbacks            ,+    module GI.GstVideo.Constants            ,+    module GI.GstVideo.Enums                ,+    module GI.GstVideo.Flags                ,+    module GI.GstVideo.Functions            ,+    module GI.GstVideo.Interfaces           ,+    module GI.GstVideo.Objects              ,+    module GI.GstVideo.Structs              ,++++    module Data.GI.Base                     ,+++    ) where++import GI.GstVideo.Callbacks+import GI.GstVideo.Constants+import GI.GstVideo.Enums+import GI.GstVideo.Flags+import GI.GstVideo.Functions+import GI.GstVideo.Interfaces+import GI.GstVideo.Objects+import GI.GstVideo.Structs++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+++import Data.GI.Base+

@@ -0,0 +1,736 @@+++{- |+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.Callbacks+    ( ++ -- * Signals+-- ** VideoAffineTransformationGetMatrix #signal:VideoAffineTransformationGetMatrix#++    C_VideoAffineTransformationGetMatrix    ,+    VideoAffineTransformationGetMatrix      ,+    dynamic_VideoAffineTransformationGetMatrix,+    genClosure_VideoAffineTransformationGetMatrix,+    mk_VideoAffineTransformationGetMatrix   ,+    noVideoAffineTransformationGetMatrix    ,+    wrap_VideoAffineTransformationGetMatrix ,+++-- ** VideoConvertSampleCallback #signal:VideoConvertSampleCallback#++    C_VideoConvertSampleCallback            ,+    VideoConvertSampleCallback              ,+    VideoConvertSampleCallback_WithClosures ,+    drop_closures_VideoConvertSampleCallback,+    dynamic_VideoConvertSampleCallback      ,+    genClosure_VideoConvertSampleCallback   ,+    mk_VideoConvertSampleCallback           ,+    noVideoConvertSampleCallback            ,+    noVideoConvertSampleCallback_WithClosures,+    wrap_VideoConvertSampleCallback         ,+++-- ** VideoFormatPack #signal:VideoFormatPack#++    C_VideoFormatPack                       ,+    VideoFormatPack                         ,+    dynamic_VideoFormatPack                 ,+    genClosure_VideoFormatPack              ,+    mk_VideoFormatPack                      ,+    noVideoFormatPack                       ,+    wrap_VideoFormatPack                    ,+++-- ** VideoFormatUnpack #signal:VideoFormatUnpack#++    C_VideoFormatUnpack                     ,+    VideoFormatUnpack                       ,+    dynamic_VideoFormatUnpack               ,+    genClosure_VideoFormatUnpack            ,+    mk_VideoFormatUnpack                    ,+    noVideoFormatUnpack                     ,+    wrap_VideoFormatUnpack                  ,+++-- ** VideoGLTextureUpload #signal:VideoGLTextureUpload#++    C_VideoGLTextureUpload                  ,+    VideoGLTextureUpload                    ,+    dynamic_VideoGLTextureUpload            ,+    genClosure_VideoGLTextureUpload         ,+    mk_VideoGLTextureUpload                 ,+    noVideoGLTextureUpload                  ,+    wrap_VideoGLTextureUpload               ,+++-- ** VideoMetaMapFieldCallback #signal:VideoMetaMapFieldCallback#++    C_VideoMetaMapFieldCallback             ,+    VideoMetaMapFieldCallback               ,+    dynamic_VideoMetaMapFieldCallback       ,+    genClosure_VideoMetaMapFieldCallback    ,+    mk_VideoMetaMapFieldCallback            ,+    noVideoMetaMapFieldCallback             ,+    wrap_VideoMetaMapFieldCallback          ,+++-- ** VideoMetaUnmapFieldCallback #signal:VideoMetaUnmapFieldCallback#++    C_VideoMetaUnmapFieldCallback           ,+    VideoMetaUnmapFieldCallback             ,+    dynamic_VideoMetaUnmapFieldCallback     ,+    genClosure_VideoMetaUnmapFieldCallback  ,+    mk_VideoMetaUnmapFieldCallback          ,+    noVideoMetaUnmapFieldCallback           ,+    wrap_VideoMetaUnmapFieldCallback        ,+++++    ) 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++import qualified GI.Gst.Flags as Gst.Flags+import qualified GI.Gst.Structs.MapInfo as Gst.MapInfo+import qualified GI.Gst.Structs.Sample as Gst.Sample+import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoAffineTransformationMeta as GstVideo.VideoAffineTransformationMeta+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoFormatInfo as GstVideo.VideoFormatInfo+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoGLTextureUploadMeta as GstVideo.VideoGLTextureUploadMeta+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoMeta as GstVideo.VideoMeta++-- callback VideoMetaUnmapFieldCallback+--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gst", name = "MapInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_VideoMetaUnmapFieldCallback =+    Ptr GstVideo.VideoMeta.VideoMeta ->+    Word32 ->+    Ptr Gst.MapInfo.MapInfo ->+    IO CInt++-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gst", name = "MapInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_VideoMetaUnmapFieldCallback :: FunPtr C_VideoMetaUnmapFieldCallback -> C_VideoMetaUnmapFieldCallback++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_VideoMetaUnmapFieldCallback ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    FunPtr C_VideoMetaUnmapFieldCallback+    -> GstVideo.VideoMeta.VideoMeta+    -> Word32+    -> Gst.MapInfo.MapInfo+    -> m Bool+dynamic_VideoMetaUnmapFieldCallback __funPtr meta plane info = liftIO $ do+    meta' <- unsafeManagedPtrGetPtr meta+    info' <- unsafeManagedPtrGetPtr info+    result <- (__dynamic_C_VideoMetaUnmapFieldCallback __funPtr) meta' plane info'+    let result' = (/= 0) result+    touchManagedPtr meta+    touchManagedPtr info+    return result'++-- | Generate a function pointer callable from C code, from a `C_VideoMetaUnmapFieldCallback`.+foreign import ccall "wrapper"+    mk_VideoMetaUnmapFieldCallback :: C_VideoMetaUnmapFieldCallback -> IO (FunPtr C_VideoMetaUnmapFieldCallback)++{- |+/No description available in the introspection data./+-}+type VideoMetaUnmapFieldCallback =+    GstVideo.VideoMeta.VideoMeta+    -> Word32+    -> Gst.MapInfo.MapInfo+    -> IO Bool++-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoMetaUnmapFieldCallback`@.+noVideoMetaUnmapFieldCallback :: Maybe VideoMetaUnmapFieldCallback+noVideoMetaUnmapFieldCallback = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_VideoMetaUnmapFieldCallback :: MonadIO m => VideoMetaUnmapFieldCallback -> m (GClosure C_VideoMetaUnmapFieldCallback)+genClosure_VideoMetaUnmapFieldCallback cb = liftIO $ do+    let cb' = wrap_VideoMetaUnmapFieldCallback Nothing cb+    mk_VideoMetaUnmapFieldCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `VideoMetaUnmapFieldCallback` into a `C_VideoMetaUnmapFieldCallback`.+wrap_VideoMetaUnmapFieldCallback ::+    Maybe (Ptr (FunPtr C_VideoMetaUnmapFieldCallback)) ->+    VideoMetaUnmapFieldCallback ->+    C_VideoMetaUnmapFieldCallback+wrap_VideoMetaUnmapFieldCallback funptrptr _cb meta plane info = do+    meta' <- (newPtr GstVideo.VideoMeta.VideoMeta) meta+    info' <- (newPtr Gst.MapInfo.MapInfo) info+    result <- _cb  meta' plane info'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'+++-- callback VideoMetaMapFieldCallback+--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gst", name = "MapInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "MapFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_VideoMetaMapFieldCallback =+    Ptr GstVideo.VideoMeta.VideoMeta ->+    Word32 ->+    Ptr Gst.MapInfo.MapInfo ->+    Ptr () ->+    Int32 ->+    CUInt ->+    IO CInt++-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gst", name = "MapInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "MapFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_VideoMetaMapFieldCallback :: FunPtr C_VideoMetaMapFieldCallback -> C_VideoMetaMapFieldCallback++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_VideoMetaMapFieldCallback ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    FunPtr C_VideoMetaMapFieldCallback+    -> GstVideo.VideoMeta.VideoMeta+    -> Word32+    -> Gst.MapInfo.MapInfo+    -> Ptr ()+    -> Int32+    -> [Gst.Flags.MapFlags]+    -> m Bool+dynamic_VideoMetaMapFieldCallback __funPtr meta plane info data_ stride flags = liftIO $ do+    meta' <- unsafeManagedPtrGetPtr meta+    info' <- unsafeManagedPtrGetPtr info+    let flags' = gflagsToWord flags+    result <- (__dynamic_C_VideoMetaMapFieldCallback __funPtr) meta' plane info' data_ stride flags'+    let result' = (/= 0) result+    touchManagedPtr meta+    touchManagedPtr info+    return result'++-- | Generate a function pointer callable from C code, from a `C_VideoMetaMapFieldCallback`.+foreign import ccall "wrapper"+    mk_VideoMetaMapFieldCallback :: C_VideoMetaMapFieldCallback -> IO (FunPtr C_VideoMetaMapFieldCallback)++{- |+/No description available in the introspection data./+-}+type VideoMetaMapFieldCallback =+    GstVideo.VideoMeta.VideoMeta+    -> Word32+    -> Gst.MapInfo.MapInfo+    -> Ptr ()+    -> Int32+    -> [Gst.Flags.MapFlags]+    -> IO Bool++-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoMetaMapFieldCallback`@.+noVideoMetaMapFieldCallback :: Maybe VideoMetaMapFieldCallback+noVideoMetaMapFieldCallback = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_VideoMetaMapFieldCallback :: MonadIO m => VideoMetaMapFieldCallback -> m (GClosure C_VideoMetaMapFieldCallback)+genClosure_VideoMetaMapFieldCallback cb = liftIO $ do+    let cb' = wrap_VideoMetaMapFieldCallback Nothing cb+    mk_VideoMetaMapFieldCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `VideoMetaMapFieldCallback` into a `C_VideoMetaMapFieldCallback`.+wrap_VideoMetaMapFieldCallback ::+    Maybe (Ptr (FunPtr C_VideoMetaMapFieldCallback)) ->+    VideoMetaMapFieldCallback ->+    C_VideoMetaMapFieldCallback+wrap_VideoMetaMapFieldCallback funptrptr _cb meta plane info data_ stride flags = do+    meta' <- (newPtr GstVideo.VideoMeta.VideoMeta) meta+    info' <- (newPtr Gst.MapInfo.MapInfo) info+    let flags' = wordToGFlags flags+    result <- _cb  meta' plane info' data_ stride flags'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'+++-- callback VideoGLTextureUpload+--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureUploadMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "texture_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_VideoGLTextureUpload =+    Ptr GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta ->+    Word32 ->+    IO CInt++-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureUploadMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "texture_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_VideoGLTextureUpload :: FunPtr C_VideoGLTextureUpload -> C_VideoGLTextureUpload++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_VideoGLTextureUpload ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    FunPtr C_VideoGLTextureUpload+    -> GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta+    -> Word32+    -> m Bool+dynamic_VideoGLTextureUpload __funPtr meta textureId = liftIO $ do+    meta' <- unsafeManagedPtrGetPtr meta+    result <- (__dynamic_C_VideoGLTextureUpload __funPtr) meta' textureId+    let result' = (/= 0) result+    touchManagedPtr meta+    return result'++-- | Generate a function pointer callable from C code, from a `C_VideoGLTextureUpload`.+foreign import ccall "wrapper"+    mk_VideoGLTextureUpload :: C_VideoGLTextureUpload -> IO (FunPtr C_VideoGLTextureUpload)++{- |+/No description available in the introspection data./+-}+type VideoGLTextureUpload =+    GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta+    -> Word32+    -> IO Bool++-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoGLTextureUpload`@.+noVideoGLTextureUpload :: Maybe VideoGLTextureUpload+noVideoGLTextureUpload = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_VideoGLTextureUpload :: MonadIO m => VideoGLTextureUpload -> m (GClosure C_VideoGLTextureUpload)+genClosure_VideoGLTextureUpload cb = liftIO $ do+    let cb' = wrap_VideoGLTextureUpload Nothing cb+    mk_VideoGLTextureUpload cb' >>= B.GClosure.newGClosure+++-- | Wrap a `VideoGLTextureUpload` into a `C_VideoGLTextureUpload`.+wrap_VideoGLTextureUpload ::+    Maybe (Ptr (FunPtr C_VideoGLTextureUpload)) ->+    VideoGLTextureUpload ->+    C_VideoGLTextureUpload+wrap_VideoGLTextureUpload funptrptr _cb meta textureId = do+    meta' <- (newPtr GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta) meta+    result <- _cb  meta' textureId+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'+++-- callback VideoFormatUnpack+--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormatInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormatInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoPackFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags to control the unpacking", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a destination array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "pointers to the data planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "strides of the planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x position in the image to start from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y position in the image to start from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the amount of pixels to unpack.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Unpacks @width pixels from the given planes and strides containing data of\nformat @info. The pixels will be unpacked into @dest with each component\ninterleaved as per @info's unpack_format, which will usually be one of\n#GST_VIDEO_FORMAT_ARGB, #GST_VIDEO_FORMAT_AYUV, #GST_VIDEO_FORMAT_ARGB64 or\n#GST_VIDEO_FORMAT_AYUV64 depending on the format to unpack.\n@dest should at least be big enough to hold @width * bytes_per_pixel bytes\nwhere bytes_per_pixel relates to the unpack format and will usually be\neither 4 or 8 depending on the unpack format. bytes_per_pixel will be\nthe same as the pixel stride for plane 0 for the above formats.\n\nFor subsampled formats, the components will be duplicated in the destination\narray. Reconstruction of the missing components can be performed in a\nseparate step after unpacking.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_VideoFormatUnpack =+    Ptr GstVideo.VideoFormatInfo.VideoFormatInfo ->+    CUInt ->+    Ptr () ->+    Ptr () ->+    Int32 ->+    Int32 ->+    Int32 ->+    Int32 ->+    IO ()++-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormatInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormatInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoPackFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags to control the unpacking", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a destination array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "pointers to the data planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "strides of the planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x position in the image to start from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y position in the image to start from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the amount of pixels to unpack.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_VideoFormatUnpack :: FunPtr C_VideoFormatUnpack -> C_VideoFormatUnpack++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_VideoFormatUnpack ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    FunPtr C_VideoFormatUnpack+    -> GstVideo.VideoFormatInfo.VideoFormatInfo+    {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoFormatInfo.VideoFormatInfo' -}+    -> [GstVideo.Flags.VideoPackFlags]+    {- ^ /@flags@/: flags to control the unpacking -}+    -> Ptr ()+    {- ^ /@dest@/: a destination array -}+    -> Ptr ()+    {- ^ /@data@/: pointers to the data planes -}+    -> Int32+    {- ^ /@stride@/: strides of the planes -}+    -> Int32+    {- ^ /@x@/: the x position in the image to start from -}+    -> Int32+    {- ^ /@y@/: the y position in the image to start from -}+    -> Int32+    {- ^ /@width@/: the amount of pixels to unpack. -}+    -> m ()+dynamic_VideoFormatUnpack __funPtr info flags dest data_ stride x y width = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    let flags' = gflagsToWord flags+    (__dynamic_C_VideoFormatUnpack __funPtr) info' flags' dest data_ stride x y width+    touchManagedPtr info+    return ()++-- | Generate a function pointer callable from C code, from a `C_VideoFormatUnpack`.+foreign import ccall "wrapper"+    mk_VideoFormatUnpack :: C_VideoFormatUnpack -> IO (FunPtr C_VideoFormatUnpack)++{- |+Unpacks /@width@/ pixels from the given planes and strides containing data of+format /@info@/. The pixels will be unpacked into /@dest@/ with each component+interleaved as per /@info@/\'s unpack_format, which will usually be one of+@/GST_VIDEO_FORMAT_ARGB/@, @/GST_VIDEO_FORMAT_AYUV/@, @/GST_VIDEO_FORMAT_ARGB64/@ or+@/GST_VIDEO_FORMAT_AYUV64/@ depending on the format to unpack.+/@dest@/ should at least be big enough to hold /@width@/ * bytes_per_pixel bytes+where bytes_per_pixel relates to the unpack format and will usually be+either 4 or 8 depending on the unpack format. bytes_per_pixel will be+the same as the pixel stride for plane 0 for the above formats.++For subsampled formats, the components will be duplicated in the destination+array. Reconstruction of the missing components can be performed in a+separate step after unpacking.+-}+type VideoFormatUnpack =+    GstVideo.VideoFormatInfo.VideoFormatInfo+    {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoFormatInfo.VideoFormatInfo' -}+    -> [GstVideo.Flags.VideoPackFlags]+    {- ^ /@flags@/: flags to control the unpacking -}+    -> Ptr ()+    {- ^ /@dest@/: a destination array -}+    -> Ptr ()+    {- ^ /@data@/: pointers to the data planes -}+    -> Int32+    {- ^ /@stride@/: strides of the planes -}+    -> Int32+    {- ^ /@x@/: the x position in the image to start from -}+    -> Int32+    {- ^ /@y@/: the y position in the image to start from -}+    -> Int32+    {- ^ /@width@/: the amount of pixels to unpack. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoFormatUnpack`@.+noVideoFormatUnpack :: Maybe VideoFormatUnpack+noVideoFormatUnpack = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_VideoFormatUnpack :: MonadIO m => VideoFormatUnpack -> m (GClosure C_VideoFormatUnpack)+genClosure_VideoFormatUnpack cb = liftIO $ do+    let cb' = wrap_VideoFormatUnpack Nothing cb+    mk_VideoFormatUnpack cb' >>= B.GClosure.newGClosure+++-- | Wrap a `VideoFormatUnpack` into a `C_VideoFormatUnpack`.+wrap_VideoFormatUnpack ::+    Maybe (Ptr (FunPtr C_VideoFormatUnpack)) ->+    VideoFormatUnpack ->+    C_VideoFormatUnpack+wrap_VideoFormatUnpack funptrptr _cb info flags dest data_ stride x y width = do+    info' <- (newPtr GstVideo.VideoFormatInfo.VideoFormatInfo) info+    let flags' = wordToGFlags flags+    _cb  info' flags' dest data_ stride x y width+    maybeReleaseFunPtr funptrptr+++-- callback VideoFormatPack+--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormatInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormatInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoPackFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags to control the packing", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a source array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sstride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source array stride", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "pointers to the destination data planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "strides of the destination planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chroma_site", argType = TInterface (Name {namespace = "GstVideo", name = "VideoChromaSite"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the chroma siting of the target when subsampled (not used)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y position in the image to pack to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the amount of pixels to pack.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Packs @width pixels from @src to the given planes and strides in the\nformat @info. The pixels from source have each component interleaved\nand will be packed into the planes in @data.\n\nThis function operates on pack_lines lines, meaning that @src should\ncontain at least pack_lines lines with a stride of @sstride and @y\nshould be a multiple of pack_lines.\n\nSubsampled formats will use the horizontally and vertically cosited\ncomponent from the source. Subsampling should be performed before\npacking.\n\nBecause this function does not have a x coordinate, it is not possible to\npack pixels starting from an unaligned position. For tiled images this\nmeans that packing should start from a tile coordinate. For subsampled\nformats this means that a complete pixel needs to be packed.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_VideoFormatPack =+    Ptr GstVideo.VideoFormatInfo.VideoFormatInfo ->+    CUInt ->+    Ptr () ->+    Int32 ->+    Ptr () ->+    Int32 ->+    CUInt ->+    Int32 ->+    Int32 ->+    IO ()++-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormatInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormatInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoPackFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags to control the packing", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a source array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sstride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source array stride", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "pointers to the destination data planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "strides of the destination planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chroma_site", argType = TInterface (Name {namespace = "GstVideo", name = "VideoChromaSite"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the chroma siting of the target when subsampled (not used)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y position in the image to pack to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the amount of pixels to pack.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_VideoFormatPack :: FunPtr C_VideoFormatPack -> C_VideoFormatPack++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_VideoFormatPack ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    FunPtr C_VideoFormatPack+    -> GstVideo.VideoFormatInfo.VideoFormatInfo+    {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoFormatInfo.VideoFormatInfo' -}+    -> [GstVideo.Flags.VideoPackFlags]+    {- ^ /@flags@/: flags to control the packing -}+    -> Ptr ()+    {- ^ /@src@/: a source array -}+    -> Int32+    {- ^ /@sstride@/: the source array stride -}+    -> Ptr ()+    {- ^ /@data@/: pointers to the destination data planes -}+    -> Int32+    {- ^ /@stride@/: strides of the destination planes -}+    -> [GstVideo.Flags.VideoChromaSite]+    {- ^ /@chromaSite@/: the chroma siting of the target when subsampled (not used) -}+    -> Int32+    {- ^ /@y@/: the y position in the image to pack to -}+    -> Int32+    {- ^ /@width@/: the amount of pixels to pack. -}+    -> m ()+dynamic_VideoFormatPack __funPtr info flags src sstride data_ stride chromaSite y width = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    let flags' = gflagsToWord flags+    let chromaSite' = gflagsToWord chromaSite+    (__dynamic_C_VideoFormatPack __funPtr) info' flags' src sstride data_ stride chromaSite' y width+    touchManagedPtr info+    return ()++-- | Generate a function pointer callable from C code, from a `C_VideoFormatPack`.+foreign import ccall "wrapper"+    mk_VideoFormatPack :: C_VideoFormatPack -> IO (FunPtr C_VideoFormatPack)++{- |+Packs /@width@/ pixels from /@src@/ to the given planes and strides in the+format /@info@/. The pixels from source have each component interleaved+and will be packed into the planes in /@data@/.++This function operates on pack_lines lines, meaning that /@src@/ should+contain at least pack_lines lines with a stride of /@sstride@/ and /@y@/+should be a multiple of pack_lines.++Subsampled formats will use the horizontally and vertically cosited+component from the source. Subsampling should be performed before+packing.++Because this function does not have a x coordinate, it is not possible to+pack pixels starting from an unaligned position. For tiled images this+means that packing should start from a tile coordinate. For subsampled+formats this means that a complete pixel needs to be packed.+-}+type VideoFormatPack =+    GstVideo.VideoFormatInfo.VideoFormatInfo+    {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoFormatInfo.VideoFormatInfo' -}+    -> [GstVideo.Flags.VideoPackFlags]+    {- ^ /@flags@/: flags to control the packing -}+    -> Ptr ()+    {- ^ /@src@/: a source array -}+    -> Int32+    {- ^ /@sstride@/: the source array stride -}+    -> Ptr ()+    {- ^ /@data@/: pointers to the destination data planes -}+    -> Int32+    {- ^ /@stride@/: strides of the destination planes -}+    -> [GstVideo.Flags.VideoChromaSite]+    {- ^ /@chromaSite@/: the chroma siting of the target when subsampled (not used) -}+    -> Int32+    {- ^ /@y@/: the y position in the image to pack to -}+    -> Int32+    {- ^ /@width@/: the amount of pixels to pack. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoFormatPack`@.+noVideoFormatPack :: Maybe VideoFormatPack+noVideoFormatPack = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_VideoFormatPack :: MonadIO m => VideoFormatPack -> m (GClosure C_VideoFormatPack)+genClosure_VideoFormatPack cb = liftIO $ do+    let cb' = wrap_VideoFormatPack Nothing cb+    mk_VideoFormatPack cb' >>= B.GClosure.newGClosure+++-- | Wrap a `VideoFormatPack` into a `C_VideoFormatPack`.+wrap_VideoFormatPack ::+    Maybe (Ptr (FunPtr C_VideoFormatPack)) ->+    VideoFormatPack ->+    C_VideoFormatPack+wrap_VideoFormatPack funptrptr _cb info flags src sstride data_ stride chromaSite y width = do+    info' <- (newPtr GstVideo.VideoFormatInfo.VideoFormatInfo) info+    let flags' = wordToGFlags flags+    let chromaSite' = wordToGFlags chromaSite+    _cb  info' flags' src sstride data_ stride chromaSite' y width+    maybeReleaseFunPtr funptrptr+++-- callback VideoConvertSampleCallback+--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "sample", argType = TInterface (Name {namespace = "Gst", name = "Sample"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_VideoConvertSampleCallback =+    Ptr Gst.Sample.Sample ->+    Ptr GError ->+    Ptr () ->+    IO ()++-- Args : [Arg {argCName = "sample", argType = TInterface (Name {namespace = "Gst", name = "Sample"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_VideoConvertSampleCallback :: FunPtr C_VideoConvertSampleCallback -> C_VideoConvertSampleCallback++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_VideoConvertSampleCallback ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    FunPtr C_VideoConvertSampleCallback+    -> Gst.Sample.Sample+    -> GError+    -> Ptr ()+    -> m ()+dynamic_VideoConvertSampleCallback __funPtr sample error_ userData = liftIO $ do+    sample' <- unsafeManagedPtrGetPtr sample+    error_' <- unsafeManagedPtrGetPtr error_+    (__dynamic_C_VideoConvertSampleCallback __funPtr) sample' error_' userData+    touchManagedPtr sample+    touchManagedPtr error_+    return ()++-- | Generate a function pointer callable from C code, from a `C_VideoConvertSampleCallback`.+foreign import ccall "wrapper"+    mk_VideoConvertSampleCallback :: C_VideoConvertSampleCallback -> IO (FunPtr C_VideoConvertSampleCallback)++{- |+/No description available in the introspection data./+-}+type VideoConvertSampleCallback =+    Gst.Sample.Sample+    -> GError+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoConvertSampleCallback`@.+noVideoConvertSampleCallback :: Maybe VideoConvertSampleCallback+noVideoConvertSampleCallback = Nothing++{- |+/No description available in the introspection data./+-}+type VideoConvertSampleCallback_WithClosures =+    Gst.Sample.Sample+    -> GError+    -> Ptr ()+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoConvertSampleCallback_WithClosures`@.+noVideoConvertSampleCallback_WithClosures :: Maybe VideoConvertSampleCallback_WithClosures+noVideoConvertSampleCallback_WithClosures = Nothing++-- | A simple wrapper that ignores the closure arguments.+drop_closures_VideoConvertSampleCallback :: VideoConvertSampleCallback -> VideoConvertSampleCallback_WithClosures+drop_closures_VideoConvertSampleCallback _f sample error_ _ = _f sample error_++-- | Wrap the callback into a `GClosure`.+genClosure_VideoConvertSampleCallback :: MonadIO m => VideoConvertSampleCallback -> m (GClosure C_VideoConvertSampleCallback)+genClosure_VideoConvertSampleCallback cb = liftIO $ do+    let cb' = drop_closures_VideoConvertSampleCallback cb+    let cb'' = wrap_VideoConvertSampleCallback Nothing cb'+    mk_VideoConvertSampleCallback cb'' >>= B.GClosure.newGClosure+++-- | Wrap a `VideoConvertSampleCallback` into a `C_VideoConvertSampleCallback`.+wrap_VideoConvertSampleCallback ::+    Maybe (Ptr (FunPtr C_VideoConvertSampleCallback)) ->+    VideoConvertSampleCallback_WithClosures ->+    C_VideoConvertSampleCallback+wrap_VideoConvertSampleCallback funptrptr _cb sample error_ userData = do+    B.ManagedPtr.withTransient Gst.Sample.Sample sample $ \sample' -> do+        error_' <- (newBoxed GError) error_+        _cb  sample' error_' userData+        maybeReleaseFunPtr funptrptr+++-- callback VideoAffineTransformationGetMatrix+--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAffineTransformationMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "matrix", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_VideoAffineTransformationGetMatrix =+    Ptr GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta ->+    CFloat ->+    IO CInt++-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAffineTransformationMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "matrix", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_VideoAffineTransformationGetMatrix :: FunPtr C_VideoAffineTransformationGetMatrix -> C_VideoAffineTransformationGetMatrix++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_VideoAffineTransformationGetMatrix ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    FunPtr C_VideoAffineTransformationGetMatrix+    -> GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta+    -> Float+    -> m Bool+dynamic_VideoAffineTransformationGetMatrix __funPtr meta matrix = liftIO $ do+    meta' <- unsafeManagedPtrGetPtr meta+    let matrix' = realToFrac matrix+    result <- (__dynamic_C_VideoAffineTransformationGetMatrix __funPtr) meta' matrix'+    let result' = (/= 0) result+    touchManagedPtr meta+    return result'++-- | Generate a function pointer callable from C code, from a `C_VideoAffineTransformationGetMatrix`.+foreign import ccall "wrapper"+    mk_VideoAffineTransformationGetMatrix :: C_VideoAffineTransformationGetMatrix -> IO (FunPtr C_VideoAffineTransformationGetMatrix)++{- |+/No description available in the introspection data./+-}+type VideoAffineTransformationGetMatrix =+    GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta+    -> Float+    -> IO Bool++-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoAffineTransformationGetMatrix`@.+noVideoAffineTransformationGetMatrix :: Maybe VideoAffineTransformationGetMatrix+noVideoAffineTransformationGetMatrix = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_VideoAffineTransformationGetMatrix :: MonadIO m => VideoAffineTransformationGetMatrix -> m (GClosure C_VideoAffineTransformationGetMatrix)+genClosure_VideoAffineTransformationGetMatrix cb = liftIO $ do+    let cb' = wrap_VideoAffineTransformationGetMatrix Nothing cb+    mk_VideoAffineTransformationGetMatrix cb' >>= B.GClosure.newGClosure+++-- | Wrap a `VideoAffineTransformationGetMatrix` into a `C_VideoAffineTransformationGetMatrix`.+wrap_VideoAffineTransformationGetMatrix ::+    Maybe (Ptr (FunPtr C_VideoAffineTransformationGetMatrix)) ->+    VideoAffineTransformationGetMatrix ->+    C_VideoAffineTransformationGetMatrix+wrap_VideoAffineTransformationGetMatrix funptrptr _cb meta matrix = do+    meta' <- (newPtr GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta) meta+    let matrix' = realToFrac matrix+    result <- _cb  meta' matrix'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'+++

@@ -0,0 +1,538 @@+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}+++{- |+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.Constants+    ( +    pattern VIDEO_TILE_Y_TILES_SHIFT        ,+    pattern VIDEO_TILE_X_TILES_MASK         ,+    pattern VIDEO_TILE_TYPE_SHIFT           ,+    pattern VIDEO_TILE_TYPE_MASK            ,+    pattern VIDEO_SIZE_RANGE                ,+    pattern VIDEO_SCALER_OPT_DITHER_METHOD  ,+    pattern VIDEO_RESAMPLER_OPT_SHARPNESS   ,+    pattern VIDEO_RESAMPLER_OPT_SHARPEN     ,+    pattern VIDEO_RESAMPLER_OPT_MAX_TAPS    ,+    pattern VIDEO_RESAMPLER_OPT_ENVELOPE    ,+    pattern VIDEO_RESAMPLER_OPT_CUBIC_C     ,+    pattern VIDEO_RESAMPLER_OPT_CUBIC_B     ,+    pattern VIDEO_OVERLAY_COMPOSITION_BLEND_FORMATS,+    pattern VIDEO_MAX_PLANES                ,+    pattern VIDEO_MAX_COMPONENTS            ,+    pattern VIDEO_FPS_RANGE                 ,+    pattern VIDEO_FORMATS_ALL               ,+    pattern VIDEO_ENCODER_SRC_NAME          ,+    pattern VIDEO_ENCODER_SINK_NAME         ,+    pattern VIDEO_DECODER_SRC_NAME          ,+    pattern VIDEO_DECODER_SINK_NAME         ,+    pattern VIDEO_DECODER_MAX_ERRORS        ,+    pattern VIDEO_CONVERTER_OPT_THREADS     ,+    pattern VIDEO_CONVERTER_OPT_SRC_Y       ,+    pattern VIDEO_CONVERTER_OPT_SRC_X       ,+    pattern VIDEO_CONVERTER_OPT_SRC_WIDTH   ,+    pattern VIDEO_CONVERTER_OPT_SRC_HEIGHT  ,+    pattern VIDEO_CONVERTER_OPT_RESAMPLER_TAPS,+    pattern VIDEO_CONVERTER_OPT_RESAMPLER_METHOD,+    pattern VIDEO_CONVERTER_OPT_PRIMARIES_MODE,+    pattern VIDEO_CONVERTER_OPT_MATRIX_MODE ,+    pattern VIDEO_CONVERTER_OPT_GAMMA_MODE  ,+    pattern VIDEO_CONVERTER_OPT_FILL_BORDER ,+    pattern VIDEO_CONVERTER_OPT_DITHER_QUANTIZATION,+    pattern VIDEO_CONVERTER_OPT_DITHER_METHOD,+    pattern VIDEO_CONVERTER_OPT_DEST_Y      ,+    pattern VIDEO_CONVERTER_OPT_DEST_X      ,+    pattern VIDEO_CONVERTER_OPT_DEST_WIDTH  ,+    pattern VIDEO_CONVERTER_OPT_DEST_HEIGHT ,+    pattern VIDEO_CONVERTER_OPT_CHROMA_RESAMPLER_METHOD,+    pattern VIDEO_CONVERTER_OPT_CHROMA_MODE ,+    pattern VIDEO_CONVERTER_OPT_BORDER_ARGB ,+    pattern VIDEO_CONVERTER_OPT_ALPHA_VALUE ,+    pattern VIDEO_CONVERTER_OPT_ALPHA_MODE  ,+    pattern VIDEO_COMP_Y                    ,+    pattern VIDEO_COMP_V                    ,+    pattern VIDEO_COMP_U                    ,+    pattern VIDEO_COMP_R                    ,+    pattern VIDEO_COMP_PALETTE              ,+    pattern VIDEO_COMP_INDEX                ,+    pattern VIDEO_COMP_G                    ,+    pattern VIDEO_COMP_B                    ,+    pattern VIDEO_COMP_A                    ,+    pattern VIDEO_COLORIMETRY_SRGB          ,+    pattern VIDEO_COLORIMETRY_SMPTE240M     ,+    pattern VIDEO_COLORIMETRY_BT709         ,+    pattern VIDEO_COLORIMETRY_BT601         ,+    pattern VIDEO_COLORIMETRY_BT2020        ,+    pattern META_TAG_VIDEO_STR              ,+    pattern META_TAG_VIDEO_SIZE_STR         ,+    pattern META_TAG_VIDEO_ORIENTATION_STR  ,+    pattern META_TAG_VIDEO_COLORSPACE_STR   ,+    pattern CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION,+    pattern CAPS_FEATURE_META_GST_VIDEO_META,+    pattern CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META,+    pattern CAPS_FEATURE_META_GST_VIDEO_AFFINE_TRANSFORMATION_META,+    pattern CAPS_FEATURE_FORMAT_INTERLACED  ,+    pattern BUFFER_POOL_OPTION_VIDEO_META   ,+    pattern BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META,+    pattern BUFFER_POOL_OPTION_VIDEO_ALIGNMENT,+    pattern BUFFER_POOL_OPTION_VIDEO_AFFINE_TRANSFORMATION_META,++    ) 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+++{- |+/No description available in the introspection data./+-}+pattern VIDEO_TILE_Y_TILES_SHIFT = 16 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_TILE_X_TILES_MASK = 65535 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_TILE_TYPE_SHIFT = 16 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_TILE_TYPE_MASK = 65535 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_SIZE_RANGE = "(int) [ 1, max ]" :: T.Text++{- |+@/GST_TYPE_VIDEO_DITHER_METHOD/@, The dither method to use for propagating+quatization errors.+-}+pattern VIDEO_SCALER_OPT_DITHER_METHOD = "GstVideoScaler.dither-method" :: T.Text++{- |+G_TYPE_DOUBLE, specifies sharpness of the filter for+/@gSTVIDEORESAMPLERMETHODLANCZOS@/. values are clamped between+0.5 and 1.5. 1.0 is the default.+-}+pattern VIDEO_RESAMPLER_OPT_SHARPNESS = "GstVideoResampler.sharpness" :: T.Text++{- |+G_TYPE_DOUBLE, specifies sharpening of the filter for+/@gSTVIDEORESAMPLERMETHODLANCZOS@/. values are clamped between+0.0 and 1.0. 0.0 is the default.+-}+pattern VIDEO_RESAMPLER_OPT_SHARPEN = "GstVideoResampler.sharpen" :: T.Text++{- |+G_TYPE_INT, limits the maximum number of taps to use.+16 is the default.+-}+pattern VIDEO_RESAMPLER_OPT_MAX_TAPS = "GstVideoResampler.max-taps" :: T.Text++{- |+G_TYPE_DOUBLE, specifies the size of filter envelope for+/@gSTVIDEORESAMPLERMETHODLANCZOS@/. values are clamped between+1.0 and 5.0. 2.0 is the default.+-}+pattern VIDEO_RESAMPLER_OPT_ENVELOPE = "GstVideoResampler.envelope" :: T.Text++{- |+G_TYPE_DOUBLE, C parameter of the cubic filter. The C+parameter controls the Keys alpha value. Values between 0.0 and+2.0 are accepted. 1\/3 is the default.++See 'GI.GstVideo.Constants.VIDEO_RESAMPLER_OPT_CUBIC_B' for some more common values+-}+pattern VIDEO_RESAMPLER_OPT_CUBIC_C = "GstVideoResampler.cubic-c" :: T.Text++{- |+G_TYPE_DOUBLE, B parameter of the cubic filter. The B+parameter controls the bluriness. Values between 0.0 and+2.0 are accepted. 1\/3 is the default.++Below are some values of popular filters:+                   B       C+Hermite           0.0     0.0+Spline            1.0     0.0+Catmull-Rom       0.0     1\/2+Mitchell          1\/3     1\/3+Robidoux          0.3782  0.3109+Robidoux+ Sharp            0.2620  0.3690+Robidoux+ Soft             0.6796  0.1602+-}+pattern VIDEO_RESAMPLER_OPT_CUBIC_B = "GstVideoResampler.cubic-b" :: T.Text++{- |+Video formats supported by 'GI.GstVideo.Structs.VideoOverlayComposition.videoOverlayCompositionBlend', for+use in overlay elements\' pad template caps.++/Since: 1.2/+-}+pattern VIDEO_OVERLAY_COMPOSITION_BLEND_FORMATS = "{ BGRx, RGBx, xRGB, xBGR, RGBA, BGRA, ARGB, ABGR, RGB, BGR, I420, YV12, AYUV, YUY2, UYVY, v308, Y41B, Y42B, Y444, NV12, NV21, A420, YUV9, YVU9, IYU1, GRAY8 }" :: T.Text++{- |+/No description available in the introspection data./+-}+pattern VIDEO_MAX_PLANES = 4 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_MAX_COMPONENTS = 4 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_FPS_RANGE = "(fraction) [ 0, max ]" :: T.Text++{- |+/No description available in the introspection data./+-}+pattern VIDEO_FORMATS_ALL = "{ I420, YV12, YUY2, UYVY, AYUV, VUYA, RGBx, BGRx, xRGB, xBGR, RGBA, BGRA, ARGB, ABGR, RGB, BGR, Y41B, Y42B, YVYU, Y444, v210, v216, Y210, Y410, NV12, NV21, GRAY8, GRAY16_BE, GRAY16_LE, v308, RGB16, BGR16, RGB15, BGR15, UYVP, A420, RGB8P, YUV9, YVU9, IYU1, ARGB64, AYUV64, r210, I420_10BE, I420_10LE, I422_10BE, I422_10LE, Y444_10BE, Y444_10LE, GBR, GBR_10BE, GBR_10LE, NV16, NV24, NV12_64Z32, A420_10BE, A420_10LE, A422_10BE, A422_10LE, A444_10BE, A444_10LE, NV61, P010_10BE, P010_10LE, IYU2, VYUY, GBRA, GBRA_10BE, GBRA_10LE, BGR10A2_LE, GBR_12BE, GBR_12LE, GBRA_12BE, GBRA_12LE, I420_12BE, I420_12LE, I422_12BE, I422_12LE, Y444_12BE, Y444_12LE, GRAY10_LE32, NV12_10LE32, NV16_10LE32, NV12_10LE40 }" :: T.Text++{- |+The name of the templates for the source pad.+-}+pattern VIDEO_ENCODER_SRC_NAME = "src" :: T.Text++{- |+The name of the templates for the sink pad.+-}+pattern VIDEO_ENCODER_SINK_NAME = "sink" :: T.Text++{- |+The name of the templates for the source pad.+-}+pattern VIDEO_DECODER_SRC_NAME = "src" :: T.Text++{- |+The name of the templates for the sink pad.+-}+pattern VIDEO_DECODER_SINK_NAME = "sink" :: T.Text++{- |+Default maximum number of errors tolerated before signaling error.+-}+pattern VIDEO_DECODER_MAX_ERRORS = 10 :: Int32++{- |+@/G_TYPE_UINT/@, maximum number of threads to use. Default 1, 0 for the number+of cores.+-}+pattern VIDEO_CONVERTER_OPT_THREADS = "GstVideoConverter.threads" :: T.Text++{- |+@/G_TYPE_INT/@, source y position to start conversion, default 0+-}+pattern VIDEO_CONVERTER_OPT_SRC_Y = "GstVideoConverter.src-y" :: T.Text++{- |+@/G_TYPE_INT/@, source x position to start conversion, default 0+-}+pattern VIDEO_CONVERTER_OPT_SRC_X = "GstVideoConverter.src-x" :: T.Text++{- |+@/G_TYPE_INT/@, source width to convert, default source width+-}+pattern VIDEO_CONVERTER_OPT_SRC_WIDTH = "GstVideoConverter.src-width" :: T.Text++{- |+@/G_TYPE_INT/@, source height to convert, default source height+-}+pattern VIDEO_CONVERTER_OPT_SRC_HEIGHT = "GstVideoConverter.src-height" :: T.Text++{- |+@/G_TYPE_UINT/@, The number of taps for the resampler.+Default is 0: let the resampler choose a good value.+-}+pattern VIDEO_CONVERTER_OPT_RESAMPLER_TAPS = "GstVideoConverter.resampler-taps" :: T.Text++{- |+@/GST_TYPE_VIDEO_RESAMPLER_METHOD/@, The resampler method to use for+resampling. Other options for the resampler can be used, see+the 'GI.GstVideo.Structs.VideoResampler.VideoResampler'. Default is @/GST_VIDEO_RESAMPLER_METHOD_CUBIC/@+-}+pattern VIDEO_CONVERTER_OPT_RESAMPLER_METHOD = "GstVideoConverter.resampler-method" :: T.Text++{- |+@/GST_TYPE_VIDEO_PRIMARIES_MODE/@, set the primaries conversion mode.+Default is @/GST_VIDEO_PRIMARIES_MODE_NONE/@.+-}+pattern VIDEO_CONVERTER_OPT_PRIMARIES_MODE = "GstVideoConverter.primaries-mode" :: T.Text++{- |+@/GST_TYPE_VIDEO_MATRIX_MODE/@, set the color matrix conversion mode for+converting between Y\'PbPr and non-linear RGB (R\'G\'B\').+Default is @/GST_VIDEO_MATRIX_MODE_FULL/@.+-}+pattern VIDEO_CONVERTER_OPT_MATRIX_MODE = "GstVideoConverter.matrix-mode" :: T.Text++{- |+@/GST_TYPE_VIDEO_GAMMA_MODE/@, set the gamma mode.+Default is @/GST_VIDEO_GAMMA_MODE_NONE/@.+-}+pattern VIDEO_CONVERTER_OPT_GAMMA_MODE = "GstVideoConverter.gamma-mode" :: T.Text++{- |+@/G_TYPE_BOOLEAN/@, if the destination rectangle does not fill the complete+destination image, render a border with+'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_BORDER_ARGB'. Otherwise the unusded pixels in the+destination are untouched. Default 'True'.+-}+pattern VIDEO_CONVERTER_OPT_FILL_BORDER = "GstVideoConverter.fill-border" :: T.Text++{- |+@/G_TYPE_UINT/@, The quantization amount to dither to. Components will be+quantized to multiples of this value.+Default is 1+-}+pattern VIDEO_CONVERTER_OPT_DITHER_QUANTIZATION = "GstVideoConverter.dither-quantization" :: T.Text++{- |+@/GST_TYPE_VIDEO_DITHER_METHOD/@, The dither method to use when+changing bit depth.+Default is @/GST_VIDEO_DITHER_BAYER/@.+-}+pattern VIDEO_CONVERTER_OPT_DITHER_METHOD = "GstVideoConverter.dither-method" :: T.Text++{- |+@/G_TYPE_INT/@, y position in the destination frame, default 0+-}+pattern VIDEO_CONVERTER_OPT_DEST_Y = "GstVideoConverter.dest-y" :: T.Text++{- |+@/G_TYPE_INT/@, x position in the destination frame, default 0+-}+pattern VIDEO_CONVERTER_OPT_DEST_X = "GstVideoConverter.dest-x" :: T.Text++{- |+@/G_TYPE_INT/@, width in the destination frame, default destination width+-}+pattern VIDEO_CONVERTER_OPT_DEST_WIDTH = "GstVideoConverter.dest-width" :: T.Text++{- |+@/G_TYPE_INT/@, height in the destination frame, default destination height+-}+pattern VIDEO_CONVERTER_OPT_DEST_HEIGHT = "GstVideoConverter.dest-height" :: T.Text++{- |+@/GST_TYPE_VIDEO_RESAMPLER_METHOD/@, The resampler method to use for+chroma resampling. Other options for the resampler can be used, see+the 'GI.GstVideo.Structs.VideoResampler.VideoResampler'. Default is @/GST_VIDEO_RESAMPLER_METHOD_LINEAR/@+-}+pattern VIDEO_CONVERTER_OPT_CHROMA_RESAMPLER_METHOD = "GstVideoConverter.chroma-resampler-method" :: T.Text++{- |+@/GST_TYPE_VIDEO_CHROMA_MODE/@, set the chroma resample mode subsampled+formats. Default is @/GST_VIDEO_CHROMA_MODE_FULL/@.+-}+pattern VIDEO_CONVERTER_OPT_CHROMA_MODE = "GstVideoConverter.chroma-mode" :: T.Text++{- |+@/G_TYPE_UINT/@, the border color to use if 'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_FILL_BORDER'+is set to 'True'. The color is in ARGB format.+Default 0xff000000+-}+pattern VIDEO_CONVERTER_OPT_BORDER_ARGB = "GstVideoConverter.border-argb" :: T.Text++{- |+@/G_TYPE_DOUBLE/@, the alpha color value to use.+Default to 1.0+-}+pattern VIDEO_CONVERTER_OPT_ALPHA_VALUE = "GstVideoConverter.alpha-value" :: T.Text++{- |+@/GST_TYPE_VIDEO_ALPHA_MODE/@, the alpha mode to use.+Default is @/GST_VIDEO_ALPHA_MODE_COPY/@.+-}+pattern VIDEO_CONVERTER_OPT_ALPHA_MODE = "GstVideoConverter.alpha-mode" :: T.Text++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COMP_Y = 0 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COMP_V = 2 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COMP_U = 1 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COMP_R = 0 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COMP_PALETTE = 1 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COMP_INDEX = 0 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COMP_G = 1 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COMP_B = 2 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COMP_A = 3 :: Int32++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COLORIMETRY_SRGB = "sRGB" :: T.Text++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COLORIMETRY_SMPTE240M = "smpte240m" :: T.Text++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COLORIMETRY_BT709 = "bt709" :: T.Text++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COLORIMETRY_BT601 = "bt601" :: T.Text++{- |+/No description available in the introspection data./+-}+pattern VIDEO_COLORIMETRY_BT2020 = "bt2020" :: T.Text++{- |+This metadata is relevant for video streams.++/Since: 1.2/+-}+pattern META_TAG_VIDEO_STR = "video" :: T.Text++{- |+This metadata stays relevant as long as video size is unchanged.++/Since: 1.2/+-}+pattern META_TAG_VIDEO_SIZE_STR = "size" :: T.Text++{- |+This metadata stays relevant as long as video orientation is unchanged.++/Since: 1.2/+-}+pattern META_TAG_VIDEO_ORIENTATION_STR = "orientation" :: T.Text++{- |+This metadata stays relevant as long as video colorspace is unchanged.++/Since: 1.2/+-}+pattern META_TAG_VIDEO_COLORSPACE_STR = "colorspace" :: T.Text++{- |+/No description available in the introspection data./+-}+pattern CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION = "meta:GstVideoOverlayComposition" :: T.Text++{- |+/No description available in the introspection data./+-}+pattern CAPS_FEATURE_META_GST_VIDEO_META = "meta:GstVideoMeta" :: T.Text++{- |+/No description available in the introspection data./+-}+pattern CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META = "meta:GstVideoGLTextureUploadMeta" :: T.Text++{- |+/No description available in the introspection data./+-}+pattern CAPS_FEATURE_META_GST_VIDEO_AFFINE_TRANSFORMATION_META = "meta:GstVideoAffineTransformation" :: T.Text++{- |+Name of the caps feature indicating that the stream is interlaced. Currently+it is only used for video.++/Since: 1.16./+-}+pattern CAPS_FEATURE_FORMAT_INTERLACED = "format:Interlaced" :: T.Text++{- |+An option that can be activated on bufferpool to request video metadata+on buffers from the pool.+-}+pattern BUFFER_POOL_OPTION_VIDEO_META = "GstBufferPoolOptionVideoMeta" :: T.Text++{- |+An option that can be activated on a bufferpool to request gl texture upload+meta on buffers from the pool.++When this option is enabled on the bufferpool,+/@gSTBUFFERPOOLOPTIONVIDEOMETA@/ should also be enabled.++/Since: 1.2.2/+-}+pattern BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META = "GstBufferPoolOptionVideoGLTextureUploadMeta" :: T.Text++{- |+A bufferpool option to enable extra padding. When a bufferpool supports this+option, 'GI.GstVideo.Functions.bufferPoolConfigSetVideoAlignment' can be called.++When this option is enabled on the bufferpool,+'GI.GstVideo.Constants.BUFFER_POOL_OPTION_VIDEO_META' should also be enabled.+-}+pattern BUFFER_POOL_OPTION_VIDEO_ALIGNMENT = "GstBufferPoolOptionVideoAlignment" :: T.Text++{- |+/No description available in the introspection data./+-}+pattern BUFFER_POOL_OPTION_VIDEO_AFFINE_TRANSFORMATION_META = "GstBufferPoolOptionVideoAffineTransformation" :: T.Text++

@@ -0,0 +1,2633 @@+++{- |+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++

@@ -0,0 +1,115 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GstVideo.Enums 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++data VideoVBIParserResult+instance P.Enum VideoVBIParserResult where+instance BoxedEnum VideoVBIParserResult where+data VideoTransferFunction+instance P.Enum VideoTransferFunction where+instance BoxedEnum VideoTransferFunction where+data VideoTileType+instance P.Enum VideoTileType where+instance BoxedEnum VideoTileType where+data VideoTileMode+instance P.Enum VideoTileMode where+instance BoxedEnum VideoTileMode where+data VideoResamplerMethod+instance P.Enum VideoResamplerMethod where+instance BoxedEnum VideoResamplerMethod where+data VideoPrimariesMode+instance P.Enum VideoPrimariesMode where+instance BoxedEnum VideoPrimariesMode where+data VideoOrientationMethod+instance P.Enum VideoOrientationMethod where+instance BoxedEnum VideoOrientationMethod where+data VideoMultiviewMode+instance P.Enum VideoMultiviewMode where+instance BoxedEnum VideoMultiviewMode where+data VideoMultiviewFramePacking+instance P.Enum VideoMultiviewFramePacking where+instance BoxedEnum VideoMultiviewFramePacking where+data VideoMatrixMode+instance P.Enum VideoMatrixMode where+instance BoxedEnum VideoMatrixMode where+data VideoInterlaceMode+instance P.Enum VideoInterlaceMode where+instance BoxedEnum VideoInterlaceMode where+data VideoGammaMode+instance P.Enum VideoGammaMode where+instance BoxedEnum VideoGammaMode where+data VideoGLTextureType+instance P.Enum VideoGLTextureType where+data VideoGLTextureOrientation+instance P.Enum VideoGLTextureOrientation where+data VideoFormat+instance P.Enum VideoFormat where+instance BoxedEnum VideoFormat where+data VideoFieldOrder+instance P.Enum VideoFieldOrder where+instance BoxedEnum VideoFieldOrder where+data VideoDitherMethod+instance P.Enum VideoDitherMethod where+instance BoxedEnum VideoDitherMethod where+data VideoColorRange+instance P.Enum VideoColorRange where+instance BoxedEnum VideoColorRange where+data VideoColorPrimaries+instance P.Enum VideoColorPrimaries where+instance BoxedEnum VideoColorPrimaries where+data VideoColorMatrix+instance P.Enum VideoColorMatrix where+instance BoxedEnum VideoColorMatrix where+data VideoChromaMode+instance P.Enum VideoChromaMode where+instance BoxedEnum VideoChromaMode where+data VideoChromaMethod+instance P.Enum VideoChromaMethod where+instance BoxedEnum VideoChromaMethod where+data VideoCaptionType+instance P.Enum VideoCaptionType where+instance BoxedEnum VideoCaptionType where+data VideoAncillaryDID16+instance P.Enum VideoAncillaryDID16 where+instance BoxedEnum VideoAncillaryDID16 where+data VideoAncillaryDID+instance P.Enum VideoAncillaryDID where+instance BoxedEnum VideoAncillaryDID where+data VideoAlphaMode+instance P.Enum VideoAlphaMode where+instance BoxedEnum VideoAlphaMode where+data NavigationQueryType+instance P.Enum NavigationQueryType where+instance BoxedEnum NavigationQueryType where+data NavigationMessageType+instance P.Enum NavigationMessageType where+instance BoxedEnum NavigationMessageType where+data NavigationEventType+instance P.Enum NavigationEventType where+instance BoxedEnum NavigationEventType where+data NavigationCommand+instance P.Enum NavigationCommand where+instance BoxedEnum NavigationCommand where+data ColorBalanceType+instance P.Enum ColorBalanceType where+instance BoxedEnum ColorBalanceType where

@@ -0,0 +1,983 @@+++{- |+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.Flags+    ( ++ -- * Flags+-- ** VideoBufferFlags #flag:VideoBufferFlags#++    VideoBufferFlags(..)                    ,+++-- ** VideoChromaFlags #flag:VideoChromaFlags#++    VideoChromaFlags(..)                    ,+++-- ** VideoChromaSite #flag:VideoChromaSite#++    VideoChromaSite(..)                     ,+++-- ** VideoCodecFrameFlags #flag:VideoCodecFrameFlags#++    VideoCodecFrameFlags(..)                ,+++-- ** VideoDitherFlags #flag:VideoDitherFlags#++    VideoDitherFlags(..)                    ,+++-- ** VideoFlags #flag:VideoFlags#++    VideoFlags(..)                          ,+++-- ** VideoFormatFlags #flag:VideoFormatFlags#++    VideoFormatFlags(..)                    ,+++-- ** VideoFrameFlags #flag:VideoFrameFlags#++    VideoFrameFlags(..)                     ,+++-- ** VideoFrameMapFlags #flag:VideoFrameMapFlags#++    VideoFrameMapFlags(..)                  ,+++-- ** VideoMultiviewFlags #flag:VideoMultiviewFlags#++    VideoMultiviewFlags(..)                 ,+++-- ** VideoOverlayFormatFlags #flag:VideoOverlayFormatFlags#++    VideoOverlayFormatFlags(..)             ,+++-- ** VideoPackFlags #flag:VideoPackFlags#++    VideoPackFlags(..)                      ,+++-- ** VideoResamplerFlags #flag:VideoResamplerFlags#++    VideoResamplerFlags(..)                 ,+++-- ** VideoScalerFlags #flag:VideoScalerFlags#++    VideoScalerFlags(..)                    ,+++-- ** VideoTimeCodeFlags #flag:VideoTimeCodeFlags#++    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.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+++-- Flags VideoTimeCodeFlags+{- |+Flags related to the time code information.+For drop frame, only 30000\/1001 and 60000\/1001 frame rates are supported.++/Since: 1.10/+-}+data VideoTimeCodeFlags = +      VideoTimeCodeFlagsNone+    {- ^+    No flags+    -}+    | VideoTimeCodeFlagsDropFrame+    {- ^+    Whether we have drop frame rate+    -}+    | VideoTimeCodeFlagsInterlaced+    {- ^+    Whether we have interlaced video+    -}+    | AnotherVideoTimeCodeFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoTimeCodeFlags where+    fromEnum VideoTimeCodeFlagsNone = 0+    fromEnum VideoTimeCodeFlagsDropFrame = 1+    fromEnum VideoTimeCodeFlagsInterlaced = 2+    fromEnum (AnotherVideoTimeCodeFlags k) = k++    toEnum 0 = VideoTimeCodeFlagsNone+    toEnum 1 = VideoTimeCodeFlagsDropFrame+    toEnum 2 = VideoTimeCodeFlagsInterlaced+    toEnum k = AnotherVideoTimeCodeFlags k++instance P.Ord VideoTimeCodeFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++instance IsGFlag VideoTimeCodeFlags++-- Flags VideoScalerFlags+{- |+Different scale flags.+-}+data VideoScalerFlags = +      VideoScalerFlagsNone+    {- ^+    no flags+    -}+    | VideoScalerFlagsInterlaced+    {- ^+    Set up a scaler for interlaced content+    -}+    | AnotherVideoScalerFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoScalerFlags where+    fromEnum VideoScalerFlagsNone = 0+    fromEnum VideoScalerFlagsInterlaced = 1+    fromEnum (AnotherVideoScalerFlags k) = k++    toEnum 0 = VideoScalerFlagsNone+    toEnum 1 = VideoScalerFlagsInterlaced+    toEnum k = AnotherVideoScalerFlags k++instance P.Ord VideoScalerFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_video_scaler_flags_get_type" c_gst_video_scaler_flags_get_type :: +    IO GType++instance BoxedFlags VideoScalerFlags where+    boxedFlagsType _ = c_gst_video_scaler_flags_get_type++instance IsGFlag VideoScalerFlags++-- Flags VideoResamplerFlags+{- |+Different resampler flags.++/Since: 1.6/+-}+data VideoResamplerFlags = +      VideoResamplerFlagsNone+    {- ^+    no flags+    -}+    | VideoResamplerFlagsHalfTaps+    {- ^+    when no taps are given, half the+                 number of calculated taps. This can be used when making scalers+                 for the different fields of an interlaced picture. Since 1.10+    -}+    | AnotherVideoResamplerFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoResamplerFlags where+    fromEnum VideoResamplerFlagsNone = 0+    fromEnum VideoResamplerFlagsHalfTaps = 1+    fromEnum (AnotherVideoResamplerFlags k) = k++    toEnum 0 = VideoResamplerFlagsNone+    toEnum 1 = VideoResamplerFlagsHalfTaps+    toEnum k = AnotherVideoResamplerFlags k++instance P.Ord VideoResamplerFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_video_resampler_flags_get_type" c_gst_video_resampler_flags_get_type :: +    IO GType++instance BoxedFlags VideoResamplerFlags where+    boxedFlagsType _ = c_gst_video_resampler_flags_get_type++instance IsGFlag VideoResamplerFlags++-- Flags VideoPackFlags+{- |+The different flags that can be used when packing and unpacking.+-}+data VideoPackFlags = +      VideoPackFlagsNone+    {- ^+    No flag+    -}+    | VideoPackFlagsTruncateRange+    {- ^+    When the source has a smaller depth+      than the target format, set the least significant bits of the target+      to 0. This is likely sightly faster but less accurate. When this flag+      is not specified, the most significant bits of the source are duplicated+      in the least significant bits of the destination.+    -}+    | VideoPackFlagsInterlaced+    {- ^+    The source is interlaced. The unpacked+      format will be interlaced as well with each line containing+      information from alternating fields. (Since 1.2)+    -}+    | AnotherVideoPackFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoPackFlags where+    fromEnum VideoPackFlagsNone = 0+    fromEnum VideoPackFlagsTruncateRange = 1+    fromEnum VideoPackFlagsInterlaced = 2+    fromEnum (AnotherVideoPackFlags k) = k++    toEnum 0 = VideoPackFlagsNone+    toEnum 1 = VideoPackFlagsTruncateRange+    toEnum 2 = VideoPackFlagsInterlaced+    toEnum k = AnotherVideoPackFlags k++instance P.Ord VideoPackFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_video_pack_flags_get_type" c_gst_video_pack_flags_get_type :: +    IO GType++instance BoxedFlags VideoPackFlags where+    boxedFlagsType _ = c_gst_video_pack_flags_get_type++instance IsGFlag VideoPackFlags++-- Flags VideoOverlayFormatFlags+{- |+Overlay format flags.+-}+data VideoOverlayFormatFlags = +      VideoOverlayFormatFlagsNone+    {- ^+    no flags+    -}+    | VideoOverlayFormatFlagsPremultipliedAlpha+    {- ^+    RGB are premultiplied by A\/255.+    -}+    | VideoOverlayFormatFlagsGlobalAlpha+    {- ^+    a global-alpha value != 1 is set.+    -}+    | AnotherVideoOverlayFormatFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoOverlayFormatFlags where+    fromEnum VideoOverlayFormatFlagsNone = 0+    fromEnum VideoOverlayFormatFlagsPremultipliedAlpha = 1+    fromEnum VideoOverlayFormatFlagsGlobalAlpha = 2+    fromEnum (AnotherVideoOverlayFormatFlags k) = k++    toEnum 0 = VideoOverlayFormatFlagsNone+    toEnum 1 = VideoOverlayFormatFlagsPremultipliedAlpha+    toEnum 2 = VideoOverlayFormatFlagsGlobalAlpha+    toEnum k = AnotherVideoOverlayFormatFlags k++instance P.Ord VideoOverlayFormatFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_video_overlay_format_flags_get_type" c_gst_video_overlay_format_flags_get_type :: +    IO GType++instance BoxedFlags VideoOverlayFormatFlags where+    boxedFlagsType _ = c_gst_video_overlay_format_flags_get_type++instance IsGFlag VideoOverlayFormatFlags++-- Flags VideoMultiviewFlags+{- |+GstVideoMultiviewFlags are used to indicate extra properties of a+stereo\/multiview stream beyond the frame layout and buffer mapping+that is conveyed in the 'GI.GstVideo.Enums.VideoMultiviewMode'.+-}+data VideoMultiviewFlags = +      VideoMultiviewFlagsNone+    {- ^+    No flags+    -}+    | VideoMultiviewFlagsRightViewFirst+    {- ^+    For stereo streams, the+        normal arrangement of left and right views is reversed.+    -}+    | VideoMultiviewFlagsLeftFlipped+    {- ^+    The left view is vertically+        mirrored.+    -}+    | VideoMultiviewFlagsLeftFlopped+    {- ^+    The left view is horizontally+        mirrored.+    -}+    | VideoMultiviewFlagsRightFlipped+    {- ^+    The right view is+        vertically mirrored.+    -}+    | VideoMultiviewFlagsRightFlopped+    {- ^+    The right view is+        horizontally mirrored.+    -}+    | VideoMultiviewFlagsHalfAspect+    {- ^+    For frame-packed+        multiview modes, indicates that the individual+        views have been encoded with half the true width or height+        and should be scaled back up for display. This flag+        is used for overriding input layout interpretation+        by adjusting pixel-aspect-ratio.+        For side-by-side, column interleaved or checkerboard packings, the+        pixel width will be doubled. For row interleaved and top-bottom+        encodings, pixel height will be doubled.+    -}+    | VideoMultiviewFlagsMixedMono+    {- ^+    The video stream contains both+        mono and multiview portions, signalled on each buffer by the+        absence or presence of the /@gSTVIDEOBUFFERFLAGMULTIPLEVIEW@/+        buffer flag.+    -}+    | AnotherVideoMultiviewFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoMultiviewFlags where+    fromEnum VideoMultiviewFlagsNone = 0+    fromEnum VideoMultiviewFlagsRightViewFirst = 1+    fromEnum VideoMultiviewFlagsLeftFlipped = 2+    fromEnum VideoMultiviewFlagsLeftFlopped = 4+    fromEnum VideoMultiviewFlagsRightFlipped = 8+    fromEnum VideoMultiviewFlagsRightFlopped = 16+    fromEnum VideoMultiviewFlagsHalfAspect = 16384+    fromEnum VideoMultiviewFlagsMixedMono = 32768+    fromEnum (AnotherVideoMultiviewFlags k) = k++    toEnum 0 = VideoMultiviewFlagsNone+    toEnum 1 = VideoMultiviewFlagsRightViewFirst+    toEnum 2 = VideoMultiviewFlagsLeftFlipped+    toEnum 4 = VideoMultiviewFlagsLeftFlopped+    toEnum 8 = VideoMultiviewFlagsRightFlipped+    toEnum 16 = VideoMultiviewFlagsRightFlopped+    toEnum 16384 = VideoMultiviewFlagsHalfAspect+    toEnum 32768 = VideoMultiviewFlagsMixedMono+    toEnum k = AnotherVideoMultiviewFlags k++instance P.Ord VideoMultiviewFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_video_multiview_flags_get_type" c_gst_video_multiview_flags_get_type :: +    IO GType++instance BoxedFlags VideoMultiviewFlags where+    boxedFlagsType _ = c_gst_video_multiview_flags_get_type++instance IsGFlag VideoMultiviewFlags++-- Flags VideoFrameMapFlags+{- |+Additional mapping flags for 'GI.GstVideo.Structs.VideoFrame.videoFrameMap'.++/Since: 1.6/+-}+data VideoFrameMapFlags = +      VideoFrameMapFlagsNoRef+    {- ^+    Don\'t take another reference of the buffer and store it in+                                       the GstVideoFrame. This makes sure that the buffer stays+                                       writable while the frame is mapped, but requires that the+                                       buffer reference stays valid until the frame is unmapped again.+    -}+    | VideoFrameMapFlagsLast+    {- ^+    Offset to define more flags+    -}+    | AnotherVideoFrameMapFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoFrameMapFlags where+    fromEnum VideoFrameMapFlagsNoRef = 65536+    fromEnum VideoFrameMapFlagsLast = 16777216+    fromEnum (AnotherVideoFrameMapFlags k) = k++    toEnum 65536 = VideoFrameMapFlagsNoRef+    toEnum 16777216 = VideoFrameMapFlagsLast+    toEnum k = AnotherVideoFrameMapFlags k++instance P.Ord VideoFrameMapFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_video_frame_map_flags_get_type" c_gst_video_frame_map_flags_get_type :: +    IO GType++instance BoxedFlags VideoFrameMapFlags where+    boxedFlagsType _ = c_gst_video_frame_map_flags_get_type++instance IsGFlag VideoFrameMapFlags++-- Flags VideoFrameFlags+{- |+Extra video frame flags+-}+data VideoFrameFlags = +      VideoFrameFlagsNone+    {- ^+    no flags+    -}+    | VideoFrameFlagsInterlaced+    {- ^+    The video frame is interlaced. In mixed+              interlace-mode, this flag specifies if the frame is interlaced or+              progressive.+    -}+    | VideoFrameFlagsTff+    {- ^+    The video frame has the top field first+    -}+    | VideoFrameFlagsRff+    {- ^+    The video frame has the repeat flag+    -}+    | VideoFrameFlagsOnefield+    {- ^+    The video frame has one field+    -}+    | VideoFrameFlagsMultipleView+    {- ^+    The video contains one or+        more non-mono views+    -}+    | VideoFrameFlagsFirstInBundle+    {- ^+    The video frame is the first+        in a set of corresponding views provided as sequential frames.+    -}+    | VideoFrameFlagsTopField+    {- ^+    The video frame has the top field only. This+        is the same as GST_VIDEO_FRAME_FLAG_TFF | GST_VIDEO_FRAME_FLAG_ONEFIELD+        (Since: 1.16).+    -}+    | VideoFrameFlagsBottomField+    {- ^+    The video frame has the bottom field+        only. This is the same as GST_VIDEO_FRAME_FLAG_ONEFIELD+        (GST_VIDEO_FRAME_FLAG_TFF flag unset) (Since: 1.16).+    -}+    | AnotherVideoFrameFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoFrameFlags where+    fromEnum VideoFrameFlagsNone = 0+    fromEnum VideoFrameFlagsInterlaced = 1+    fromEnum VideoFrameFlagsTff = 2+    fromEnum VideoFrameFlagsRff = 4+    fromEnum VideoFrameFlagsOnefield = 8+    fromEnum VideoFrameFlagsMultipleView = 16+    fromEnum VideoFrameFlagsFirstInBundle = 32+    fromEnum VideoFrameFlagsTopField = 10+    fromEnum VideoFrameFlagsBottomField = 8+    fromEnum (AnotherVideoFrameFlags k) = k++    toEnum 0 = VideoFrameFlagsNone+    toEnum 1 = VideoFrameFlagsInterlaced+    toEnum 2 = VideoFrameFlagsTff+    toEnum 4 = VideoFrameFlagsRff+    toEnum 8 = VideoFrameFlagsOnefield+    toEnum 16 = VideoFrameFlagsMultipleView+    toEnum 32 = VideoFrameFlagsFirstInBundle+    toEnum 10 = VideoFrameFlagsTopField+    toEnum 8 = VideoFrameFlagsBottomField+    toEnum k = AnotherVideoFrameFlags k++instance P.Ord VideoFrameFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_video_frame_flags_get_type" c_gst_video_frame_flags_get_type :: +    IO GType++instance BoxedFlags VideoFrameFlags where+    boxedFlagsType _ = c_gst_video_frame_flags_get_type++instance IsGFlag VideoFrameFlags++-- Flags VideoFormatFlags+{- |+The different video flags that a format info can have.+-}+data VideoFormatFlags = +      VideoFormatFlagsYuv+    {- ^+    The video format is YUV, components are numbered+      0=Y, 1=U, 2=V.+    -}+    | VideoFormatFlagsRgb+    {- ^+    The video format is RGB, components are numbered+      0=R, 1=G, 2=B.+    -}+    | VideoFormatFlagsGray+    {- ^+    The video is gray, there is one gray component+      with index 0.+    -}+    | VideoFormatFlagsAlpha+    {- ^+    The video format has an alpha components with+      the number 3.+    -}+    | VideoFormatFlagsLe+    {- ^+    The video format has data stored in little+      endianness.+    -}+    | VideoFormatFlagsPalette+    {- ^+    The video format has a palette. The palette+      is stored in the second plane and indexes are stored in the first plane.+    -}+    | VideoFormatFlagsComplex+    {- ^+    The video format has a complex layout that+      can\'t be described with the usual information in the 'GI.GstVideo.Structs.VideoFormatInfo.VideoFormatInfo'.+    -}+    | VideoFormatFlagsUnpack+    {- ^+    This format can be used in a+      'GI.GstVideo.Callbacks.VideoFormatUnpack' and 'GI.GstVideo.Callbacks.VideoFormatPack' function.+    -}+    | VideoFormatFlagsTiled+    {- ^+    The format is tiled, there is tiling information+      in the last plane.+    -}+    | AnotherVideoFormatFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoFormatFlags where+    fromEnum VideoFormatFlagsYuv = 1+    fromEnum VideoFormatFlagsRgb = 2+    fromEnum VideoFormatFlagsGray = 4+    fromEnum VideoFormatFlagsAlpha = 8+    fromEnum VideoFormatFlagsLe = 16+    fromEnum VideoFormatFlagsPalette = 32+    fromEnum VideoFormatFlagsComplex = 64+    fromEnum VideoFormatFlagsUnpack = 128+    fromEnum VideoFormatFlagsTiled = 256+    fromEnum (AnotherVideoFormatFlags k) = k++    toEnum 1 = VideoFormatFlagsYuv+    toEnum 2 = VideoFormatFlagsRgb+    toEnum 4 = VideoFormatFlagsGray+    toEnum 8 = VideoFormatFlagsAlpha+    toEnum 16 = VideoFormatFlagsLe+    toEnum 32 = VideoFormatFlagsPalette+    toEnum 64 = VideoFormatFlagsComplex+    toEnum 128 = VideoFormatFlagsUnpack+    toEnum 256 = VideoFormatFlagsTiled+    toEnum k = AnotherVideoFormatFlags k++instance P.Ord VideoFormatFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_video_format_flags_get_type" c_gst_video_format_flags_get_type :: +    IO GType++instance BoxedFlags VideoFormatFlags where+    boxedFlagsType _ = c_gst_video_format_flags_get_type++instance IsGFlag VideoFormatFlags++-- Flags VideoFlags+{- |+Extra video flags+-}+data VideoFlags = +      VideoFlagsNone+    {- ^+    no flags+    -}+    | VideoFlagsVariableFps+    {- ^+    a variable fps is selected, fps_n and fps_d+        denote the maximum fps of the video+    -}+    | VideoFlagsPremultipliedAlpha+    {- ^+    Each color has been scaled by the alpha+        value.+    -}+    | AnotherVideoFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoFlags where+    fromEnum VideoFlagsNone = 0+    fromEnum VideoFlagsVariableFps = 1+    fromEnum VideoFlagsPremultipliedAlpha = 2+    fromEnum (AnotherVideoFlags k) = k++    toEnum 0 = VideoFlagsNone+    toEnum 1 = VideoFlagsVariableFps+    toEnum 2 = VideoFlagsPremultipliedAlpha+    toEnum k = AnotherVideoFlags k++instance P.Ord VideoFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_video_flags_get_type" c_gst_video_flags_get_type :: +    IO GType++instance BoxedFlags VideoFlags where+    boxedFlagsType _ = c_gst_video_flags_get_type++instance IsGFlag VideoFlags++-- Flags VideoDitherFlags+{- |+Extra flags that influence the result from @/gst_video_chroma_resample_new()/@.+-}+data VideoDitherFlags = +      VideoDitherFlagsNone+    {- ^+    no flags+    -}+    | VideoDitherFlagsInterlaced+    {- ^+    the input is interlaced+    -}+    | VideoDitherFlagsQuantize+    {- ^+    quantize values in addition to adding dither.+    -}+    | AnotherVideoDitherFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoDitherFlags where+    fromEnum VideoDitherFlagsNone = 0+    fromEnum VideoDitherFlagsInterlaced = 1+    fromEnum VideoDitherFlagsQuantize = 2+    fromEnum (AnotherVideoDitherFlags k) = k++    toEnum 0 = VideoDitherFlagsNone+    toEnum 1 = VideoDitherFlagsInterlaced+    toEnum 2 = VideoDitherFlagsQuantize+    toEnum k = AnotherVideoDitherFlags k++instance P.Ord VideoDitherFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_video_dither_flags_get_type" c_gst_video_dither_flags_get_type :: +    IO GType++instance BoxedFlags VideoDitherFlags where+    boxedFlagsType _ = c_gst_video_dither_flags_get_type++instance IsGFlag VideoDitherFlags++-- Flags VideoCodecFrameFlags+{- |+Flags for 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame'+-}+data VideoCodecFrameFlags = +      VideoCodecFrameFlagsDecodeOnly+    {- ^+    is the frame only meant to be decoded+    -}+    | VideoCodecFrameFlagsSyncPoint+    {- ^+    is the frame a synchronization point (keyframe)+    -}+    | VideoCodecFrameFlagsForceKeyframe+    {- ^+    should the output frame be made a keyframe+    -}+    | VideoCodecFrameFlagsForceKeyframeHeaders+    {- ^+    should the encoder output stream headers+    -}+    | AnotherVideoCodecFrameFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoCodecFrameFlags where+    fromEnum VideoCodecFrameFlagsDecodeOnly = 1+    fromEnum VideoCodecFrameFlagsSyncPoint = 2+    fromEnum VideoCodecFrameFlagsForceKeyframe = 4+    fromEnum VideoCodecFrameFlagsForceKeyframeHeaders = 8+    fromEnum (AnotherVideoCodecFrameFlags k) = k++    toEnum 1 = VideoCodecFrameFlagsDecodeOnly+    toEnum 2 = VideoCodecFrameFlagsSyncPoint+    toEnum 4 = VideoCodecFrameFlagsForceKeyframe+    toEnum 8 = VideoCodecFrameFlagsForceKeyframeHeaders+    toEnum k = AnotherVideoCodecFrameFlags k++instance P.Ord VideoCodecFrameFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++instance IsGFlag VideoCodecFrameFlags++-- Flags VideoChromaSite+{- |+Various Chroma sitings.+-}+data VideoChromaSite = +      VideoChromaSiteUnknown+    {- ^+    unknown cositing+    -}+    | VideoChromaSiteNone+    {- ^+    no cositing+    -}+    | VideoChromaSiteHCosited+    {- ^+    chroma is horizontally cosited+    -}+    | VideoChromaSiteVCosited+    {- ^+    chroma is vertically cosited+    -}+    | VideoChromaSiteAltLine+    {- ^+    choma samples are sited on alternate lines+    -}+    | VideoChromaSiteCosited+    {- ^+    chroma samples cosited with luma samples+    -}+    | VideoChromaSiteJpeg+    {- ^+    jpeg style cositing, also for mpeg1 and mjpeg+    -}+    | VideoChromaSiteMpeg2+    {- ^+    mpeg2 style cositing+    -}+    | VideoChromaSiteDv+    {- ^+    DV style cositing+    -}+    | AnotherVideoChromaSite Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoChromaSite where+    fromEnum VideoChromaSiteUnknown = 0+    fromEnum VideoChromaSiteNone = 1+    fromEnum VideoChromaSiteHCosited = 2+    fromEnum VideoChromaSiteVCosited = 4+    fromEnum VideoChromaSiteAltLine = 8+    fromEnum VideoChromaSiteCosited = 6+    fromEnum VideoChromaSiteJpeg = 1+    fromEnum VideoChromaSiteMpeg2 = 2+    fromEnum VideoChromaSiteDv = 14+    fromEnum (AnotherVideoChromaSite k) = k++    toEnum 0 = VideoChromaSiteUnknown+    toEnum 1 = VideoChromaSiteNone+    toEnum 2 = VideoChromaSiteHCosited+    toEnum 4 = VideoChromaSiteVCosited+    toEnum 8 = VideoChromaSiteAltLine+    toEnum 6 = VideoChromaSiteCosited+    toEnum 1 = VideoChromaSiteJpeg+    toEnum 2 = VideoChromaSiteMpeg2+    toEnum 14 = VideoChromaSiteDv+    toEnum k = AnotherVideoChromaSite k++instance P.Ord VideoChromaSite where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_video_chroma_site_get_type" c_gst_video_chroma_site_get_type :: +    IO GType++instance BoxedFlags VideoChromaSite where+    boxedFlagsType _ = c_gst_video_chroma_site_get_type++instance IsGFlag VideoChromaSite++-- Flags VideoChromaFlags+{- |+Extra flags that influence the result from @/gst_video_chroma_resample_new()/@.+-}+data VideoChromaFlags = +      VideoChromaFlagsNone+    {- ^+    no flags+    -}+    | VideoChromaFlagsInterlaced+    {- ^+    the input is interlaced+    -}+    | AnotherVideoChromaFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoChromaFlags where+    fromEnum VideoChromaFlagsNone = 0+    fromEnum VideoChromaFlagsInterlaced = 1+    fromEnum (AnotherVideoChromaFlags k) = k++    toEnum 0 = VideoChromaFlagsNone+    toEnum 1 = VideoChromaFlagsInterlaced+    toEnum k = AnotherVideoChromaFlags k++instance P.Ord VideoChromaFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_video_chroma_flags_get_type" c_gst_video_chroma_flags_get_type :: +    IO GType++instance BoxedFlags VideoChromaFlags where+    boxedFlagsType _ = c_gst_video_chroma_flags_get_type++instance IsGFlag VideoChromaFlags++-- Flags VideoBufferFlags+{- |+Additional video buffer flags. These flags can potentially be used on any+buffers carrying video data - even encoded data.++Note that these are only valid for 'GI.Gst.Structs.Caps.Caps' of type: video\/...+They can conflict with other extended buffer flags.+-}+data VideoBufferFlags = +      VideoBufferFlagsInterlaced+    {- ^+    If the 'GI.Gst.Structs.Buffer.Buffer' is interlaced. In mixed+                                        interlace-mode, this flags specifies if the frame is+                                        interlaced or progressive.+    -}+    | VideoBufferFlagsTff+    {- ^+    If the 'GI.Gst.Structs.Buffer.Buffer' is interlaced, then the first field+                                        in the video frame is the top field.  If unset, the+                                        bottom field is first.+    -}+    | VideoBufferFlagsRff+    {- ^+    If the 'GI.Gst.Structs.Buffer.Buffer' is interlaced, then the first field+                                        (as defined by the 'GI.GstVideo.Flags.VideoBufferFlagsTff' flag setting)+                                        is repeated.+    -}+    | VideoBufferFlagsOnefield+    {- ^+    If the 'GI.Gst.Structs.Buffer.Buffer' is interlaced, then only the+                                        first field (as defined by the 'GI.GstVideo.Flags.VideoBufferFlagsTff'+                                        flag setting) is to be displayed (Since: 1.16).+    -}+    | VideoBufferFlagsMultipleView+    {- ^+    The 'GI.Gst.Structs.Buffer.Buffer' contains one or more specific views,+                                        such as left or right eye view. This flags is set on+                                        any buffer that contains non-mono content - even for+                                        streams that contain only a single viewpoint. In mixed+                                        mono \/ non-mono streams, the absense of the flag marks+                                        mono buffers.+    -}+    | VideoBufferFlagsFirstInBundle+    {- ^+    When conveying stereo\/multiview content with+                                        frame-by-frame methods, this flag marks the first buffer+                                         in a bundle of frames that belong together.+    -}+    | VideoBufferFlagsTopField+    {- ^+    The video frame has the top field only. This is the+                                        same as GST_VIDEO_BUFFER_FLAG_TFF |+                                        GST_VIDEO_BUFFER_FLAG_ONEFIELD (Since: 1.16).+    -}+    | VideoBufferFlagsBottomField+    {- ^+    The video frame has the bottom field only. This is+                                        the same as GST_VIDEO_BUFFER_FLAG_ONEFIELD+                                        (GST_VIDEO_BUFFER_FLAG_TFF flag unset) (Since: 1.16).+    -}+    | VideoBufferFlagsLast+    {- ^+    Offset to define more flags+    -}+    | AnotherVideoBufferFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum VideoBufferFlags where+    fromEnum VideoBufferFlagsInterlaced = 1048576+    fromEnum VideoBufferFlagsTff = 2097152+    fromEnum VideoBufferFlagsRff = 4194304+    fromEnum VideoBufferFlagsOnefield = 8388608+    fromEnum VideoBufferFlagsMultipleView = 16777216+    fromEnum VideoBufferFlagsFirstInBundle = 33554432+    fromEnum VideoBufferFlagsTopField = 10485760+    fromEnum VideoBufferFlagsBottomField = 8388608+    fromEnum VideoBufferFlagsLast = 268435456+    fromEnum (AnotherVideoBufferFlags k) = k++    toEnum 1048576 = VideoBufferFlagsInterlaced+    toEnum 2097152 = VideoBufferFlagsTff+    toEnum 4194304 = VideoBufferFlagsRff+    toEnum 8388608 = VideoBufferFlagsOnefield+    toEnum 16777216 = VideoBufferFlagsMultipleView+    toEnum 33554432 = VideoBufferFlagsFirstInBundle+    toEnum 10485760 = VideoBufferFlagsTopField+    toEnum 8388608 = VideoBufferFlagsBottomField+    toEnum 268435456 = VideoBufferFlagsLast+    toEnum k = AnotherVideoBufferFlags k++instance P.Ord VideoBufferFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gst_video_buffer_flags_get_type" c_gst_video_buffer_flags_get_type :: +    IO GType++instance BoxedFlags VideoBufferFlags where+    boxedFlagsType _ = c_gst_video_buffer_flags_get_type++instance IsGFlag VideoBufferFlags++

@@ -0,0 +1,82 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GstVideo.Flags 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++data VideoTimeCodeFlags+instance P.Enum VideoTimeCodeFlags where+instance IsGFlag VideoTimeCodeFlags+data VideoScalerFlags+instance P.Enum VideoScalerFlags where+instance BoxedFlags VideoScalerFlags where+instance IsGFlag VideoScalerFlags+data VideoResamplerFlags+instance P.Enum VideoResamplerFlags where+instance BoxedFlags VideoResamplerFlags where+instance IsGFlag VideoResamplerFlags+data VideoPackFlags+instance P.Enum VideoPackFlags where+instance BoxedFlags VideoPackFlags where+instance IsGFlag VideoPackFlags+data VideoOverlayFormatFlags+instance P.Enum VideoOverlayFormatFlags where+instance BoxedFlags VideoOverlayFormatFlags where+instance IsGFlag VideoOverlayFormatFlags+data VideoMultiviewFlags+instance P.Enum VideoMultiviewFlags where+instance BoxedFlags VideoMultiviewFlags where+instance IsGFlag VideoMultiviewFlags+data VideoFrameMapFlags+instance P.Enum VideoFrameMapFlags where+instance BoxedFlags VideoFrameMapFlags where+instance IsGFlag VideoFrameMapFlags+data VideoFrameFlags+instance P.Enum VideoFrameFlags where+instance BoxedFlags VideoFrameFlags where+instance IsGFlag VideoFrameFlags+data VideoFormatFlags+instance P.Enum VideoFormatFlags where+instance BoxedFlags VideoFormatFlags where+instance IsGFlag VideoFormatFlags+data VideoFlags+instance P.Enum VideoFlags where+instance BoxedFlags VideoFlags where+instance IsGFlag VideoFlags+data VideoDitherFlags+instance P.Enum VideoDitherFlags where+instance BoxedFlags VideoDitherFlags where+instance IsGFlag VideoDitherFlags+data VideoCodecFrameFlags+instance P.Enum VideoCodecFrameFlags where+instance IsGFlag VideoCodecFrameFlags+data VideoChromaSite+instance P.Enum VideoChromaSite where+instance BoxedFlags VideoChromaSite where+instance IsGFlag VideoChromaSite+data VideoChromaFlags+instance P.Enum VideoChromaFlags where+instance BoxedFlags VideoChromaFlags where+instance IsGFlag VideoChromaFlags+data VideoBufferFlags+instance P.Enum VideoBufferFlags where+instance BoxedFlags VideoBufferFlags where+instance IsGFlag VideoBufferFlags

@@ -0,0 +1,2198 @@+++{- |+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.Functions+    ( ++ -- * Methods+-- ** bufferAddVideoAffineTransformationMeta #method:bufferAddVideoAffineTransformationMeta#++    bufferAddVideoAffineTransformationMeta  ,+++-- ** bufferAddVideoCaptionMeta #method:bufferAddVideoCaptionMeta#++    bufferAddVideoCaptionMeta               ,+++-- ** bufferAddVideoGlTextureUploadMeta #method:bufferAddVideoGlTextureUploadMeta#++    bufferAddVideoGlTextureUploadMeta       ,+++-- ** bufferAddVideoMeta #method:bufferAddVideoMeta#++    bufferAddVideoMeta                      ,+++-- ** bufferAddVideoMetaFull #method:bufferAddVideoMetaFull#++    bufferAddVideoMetaFull                  ,+++-- ** bufferAddVideoOverlayCompositionMeta #method:bufferAddVideoOverlayCompositionMeta#++    bufferAddVideoOverlayCompositionMeta    ,+++-- ** bufferAddVideoRegionOfInterestMeta #method:bufferAddVideoRegionOfInterestMeta#++    bufferAddVideoRegionOfInterestMeta      ,+++-- ** bufferAddVideoRegionOfInterestMetaId #method:bufferAddVideoRegionOfInterestMetaId#++    bufferAddVideoRegionOfInterestMetaId    ,+++-- ** bufferAddVideoTimeCodeMeta #method:bufferAddVideoTimeCodeMeta#++    bufferAddVideoTimeCodeMeta              ,+++-- ** bufferAddVideoTimeCodeMetaFull #method:bufferAddVideoTimeCodeMetaFull#++    bufferAddVideoTimeCodeMetaFull          ,+++-- ** bufferGetVideoMeta #method:bufferGetVideoMeta#++    bufferGetVideoMeta                      ,+++-- ** bufferGetVideoMetaId #method:bufferGetVideoMetaId#++    bufferGetVideoMetaId                    ,+++-- ** bufferGetVideoRegionOfInterestMetaId #method:bufferGetVideoRegionOfInterestMetaId#++    bufferGetVideoRegionOfInterestMetaId    ,+++-- ** bufferPoolConfigGetVideoAlignment #method:bufferPoolConfigGetVideoAlignment#++    bufferPoolConfigGetVideoAlignment       ,+++-- ** bufferPoolConfigSetVideoAlignment #method:bufferPoolConfigSetVideoAlignment#++    bufferPoolConfigSetVideoAlignment       ,+++-- ** isVideoOverlayPrepareWindowHandleMessage #method:isVideoOverlayPrepareWindowHandleMessage#++    isVideoOverlayPrepareWindowHandleMessage,+++-- ** videoAffineTransformationMetaApiGetType #method:videoAffineTransformationMetaApiGetType#++    videoAffineTransformationMetaApiGetType ,+++-- ** videoBlend #method:videoBlend#++    videoBlend                              ,+++-- ** videoBlendScaleLinearRGBA #method:videoBlendScaleLinearRGBA#++    videoBlendScaleLinearRGBA               ,+++-- ** videoCalculateDisplayRatio #method:videoCalculateDisplayRatio#++    videoCalculateDisplayRatio              ,+++-- ** videoCaptionMetaApiGetType #method:videoCaptionMetaApiGetType#++    videoCaptionMetaApiGetType              ,+++-- ** videoChromaFromString #method:videoChromaFromString#++    videoChromaFromString                   ,+++-- ** videoChromaResample #method:videoChromaResample#++    videoChromaResample                     ,+++-- ** videoChromaToString #method:videoChromaToString#++    videoChromaToString                     ,+++-- ** videoColorTransferDecode #method:videoColorTransferDecode#++    videoColorTransferDecode                ,+++-- ** videoColorTransferEncode #method:videoColorTransferEncode#++    videoColorTransferEncode                ,+++-- ** videoConvertSample #method:videoConvertSample#++    videoConvertSample                      ,+++-- ** videoConvertSampleAsync #method:videoConvertSampleAsync#++    videoConvertSampleAsync                 ,+++-- ** videoCropMetaApiGetType #method:videoCropMetaApiGetType#++    videoCropMetaApiGetType                 ,+++-- ** videoEventIsForceKeyUnit #method:videoEventIsForceKeyUnit#++    videoEventIsForceKeyUnit                ,+++-- ** videoEventNewDownstreamForceKeyUnit #method:videoEventNewDownstreamForceKeyUnit#++    videoEventNewDownstreamForceKeyUnit     ,+++-- ** videoEventNewStillFrame #method:videoEventNewStillFrame#++    videoEventNewStillFrame                 ,+++-- ** videoEventNewUpstreamForceKeyUnit #method:videoEventNewUpstreamForceKeyUnit#++    videoEventNewUpstreamForceKeyUnit       ,+++-- ** videoEventParseDownstreamForceKeyUnit #method:videoEventParseDownstreamForceKeyUnit#++    videoEventParseDownstreamForceKeyUnit   ,+++-- ** videoEventParseStillFrame #method:videoEventParseStillFrame#++    videoEventParseStillFrame               ,+++-- ** videoEventParseUpstreamForceKeyUnit #method:videoEventParseUpstreamForceKeyUnit#++    videoEventParseUpstreamForceKeyUnit     ,+++-- ** videoGlTextureUploadMetaApiGetType #method:videoGlTextureUploadMetaApiGetType#++    videoGlTextureUploadMetaApiGetType      ,+++-- ** videoGuessFramerate #method:videoGuessFramerate#++    videoGuessFramerate                     ,+++-- ** videoMetaApiGetType #method:videoMetaApiGetType#++    videoMetaApiGetType                     ,+++-- ** videoMultiviewGetDoubledHeightModes #method:videoMultiviewGetDoubledHeightModes#++    videoMultiviewGetDoubledHeightModes     ,+++-- ** videoMultiviewGetDoubledSizeModes #method:videoMultiviewGetDoubledSizeModes#++    videoMultiviewGetDoubledSizeModes       ,+++-- ** videoMultiviewGetDoubledWidthModes #method:videoMultiviewGetDoubledWidthModes#++    videoMultiviewGetDoubledWidthModes      ,+++-- ** videoMultiviewGetMonoModes #method:videoMultiviewGetMonoModes#++    videoMultiviewGetMonoModes              ,+++-- ** videoMultiviewGetUnpackedModes #method:videoMultiviewGetUnpackedModes#++    videoMultiviewGetUnpackedModes          ,+++-- ** videoMultiviewGuessHalfAspect #method:videoMultiviewGuessHalfAspect#++    videoMultiviewGuessHalfAspect           ,+++-- ** videoMultiviewVideoInfoChangeMode #method:videoMultiviewVideoInfoChangeMode#++    videoMultiviewVideoInfoChangeMode       ,+++-- ** videoOverlayCompositionMetaApiGetType #method:videoOverlayCompositionMetaApiGetType#++    videoOverlayCompositionMetaApiGetType   ,+++-- ** videoRegionOfInterestMetaApiGetType #method:videoRegionOfInterestMetaApiGetType#++    videoRegionOfInterestMetaApiGetType     ,+++-- ** videoTileGetIndex #method:videoTileGetIndex#++    videoTileGetIndex                       ,+++-- ** videoTimeCodeMetaApiGetType #method:videoTimeCodeMetaApiGetType#++    videoTimeCodeMetaApiGetType             ,+++++    ) 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++import qualified GI.GLib.Callbacks as GLib.Callbacks+import qualified GI.GLib.Structs.DateTime as GLib.DateTime+import qualified GI.GObject.Callbacks as GObject.Callbacks+import qualified GI.Gst.Structs.Buffer as Gst.Buffer+import qualified GI.Gst.Structs.Caps as Gst.Caps+import qualified GI.Gst.Structs.Event as Gst.Event+import qualified GI.Gst.Structs.Message as Gst.Message+import qualified GI.Gst.Structs.Sample as Gst.Sample+import qualified GI.Gst.Structs.Structure as Gst.Structure+import qualified GI.GstVideo.Callbacks as GstVideo.Callbacks+import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums+import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoAffineTransformationMeta as GstVideo.VideoAffineTransformationMeta+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoAlignment as GstVideo.VideoAlignment+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoCaptionMeta as GstVideo.VideoCaptionMeta+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoChromaResample as GstVideo.VideoChromaResample+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoFrame as GstVideo.VideoFrame+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoGLTextureUploadMeta as GstVideo.VideoGLTextureUploadMeta+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoInfo as GstVideo.VideoInfo+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoMeta as GstVideo.VideoMeta+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoOverlayComposition as GstVideo.VideoOverlayComposition+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoOverlayCompositionMeta as GstVideo.VideoOverlayCompositionMeta+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoRegionOfInterestMeta as GstVideo.VideoRegionOfInterestMeta+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoTimeCode as GstVideo.VideoTimeCode+import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoTimeCodeMeta as GstVideo.VideoTimeCodeMeta++-- function gst_video_time_code_meta_api_get_type+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TGType)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_time_code_meta_api_get_type" gst_video_time_code_meta_api_get_type :: +    IO CGType++{- |+/No description available in the introspection data./+-}+videoTimeCodeMetaApiGetType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GType+videoTimeCodeMetaApiGetType  = liftIO $ do+    result <- gst_video_time_code_meta_api_get_type+    let result' = GType result+    return result'+++-- function gst_video_tile_get_index+-- Args : [Arg {argCName = "mode", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTileMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTileMode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "x coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "y coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x_tiles", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of horizintal tiles", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y_tiles", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of vertical tiles", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_tile_get_index" gst_video_tile_get_index :: +    CUInt ->                                -- mode : TInterface (Name {namespace = "GstVideo", name = "VideoTileMode"})+    Int32 ->                                -- x : TBasicType TInt+    Int32 ->                                -- y : TBasicType TInt+    Int32 ->                                -- x_tiles : TBasicType TInt+    Int32 ->                                -- y_tiles : TBasicType TInt+    IO Word32++{- |+Get the tile index of the tile at coordinates /@x@/ and /@y@/ in the tiled+image of /@xTiles@/ by /@yTiles@/.++Use this method when /@mode@/ is of type 'GI.GstVideo.Enums.VideoTileTypeIndexed'.++/Since: 1.4/+-}+videoTileGetIndex ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GstVideo.Enums.VideoTileMode+    {- ^ /@mode@/: a 'GI.GstVideo.Enums.VideoTileMode' -}+    -> Int32+    {- ^ /@x@/: x coordinate -}+    -> Int32+    {- ^ /@y@/: y coordinate -}+    -> Int32+    {- ^ /@xTiles@/: number of horizintal tiles -}+    -> Int32+    {- ^ /@yTiles@/: number of vertical tiles -}+    -> m Word32+    {- ^ __Returns:__ the index of the tile at /@x@/ and /@y@/ in the tiled image of+  /@xTiles@/ by /@yTiles@/. -}+videoTileGetIndex mode x y xTiles yTiles = liftIO $ do+    let mode' = (fromIntegral . fromEnum) mode+    result <- gst_video_tile_get_index mode' x y xTiles yTiles+    return result+++-- function gst_video_region_of_interest_meta_api_get_type+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TGType)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_region_of_interest_meta_api_get_type" gst_video_region_of_interest_meta_api_get_type :: +    IO CGType++{- |+/No description available in the introspection data./+-}+videoRegionOfInterestMetaApiGetType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GType+videoRegionOfInterestMetaApiGetType  = liftIO $ do+    result <- gst_video_region_of_interest_meta_api_get_type+    let result' = GType result+    return result'+++-- function gst_video_overlay_composition_meta_api_get_type+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TGType)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_composition_meta_api_get_type" gst_video_overlay_composition_meta_api_get_type :: +    IO CGType++{- |+/No description available in the introspection data./+-}+videoOverlayCompositionMetaApiGetType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GType+videoOverlayCompositionMetaApiGetType  = liftIO $ do+    result <- gst_video_overlay_composition_meta_api_get_type+    let result' = GType result+    return result'+++-- function gst_video_multiview_video_info_change_mode+-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstVideoInfo structure to operate on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_mview_mode", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMultiviewMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstVideoMultiviewMode value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_mview_flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMultiviewFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A set of #GstVideoMultiviewFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_multiview_video_info_change_mode" gst_video_multiview_video_info_change_mode :: +    Ptr GstVideo.VideoInfo.VideoInfo ->     -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"})+    CInt ->                                 -- out_mview_mode : TInterface (Name {namespace = "GstVideo", name = "VideoMultiviewMode"})+    CUInt ->                                -- out_mview_flags : TInterface (Name {namespace = "GstVideo", name = "VideoMultiviewFlags"})+    IO ()++{- |+Utility function that transforms the width\/height\/PAR+and multiview mode and flags of a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' into+the requested mode.++/Since: 1.6/+-}+videoMultiviewVideoInfoChangeMode ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GstVideo.VideoInfo.VideoInfo+    {- ^ /@info@/: A 'GI.GstVideo.Structs.VideoInfo.VideoInfo' structure to operate on -}+    -> GstVideo.Enums.VideoMultiviewMode+    {- ^ /@outMviewMode@/: A 'GI.GstVideo.Enums.VideoMultiviewMode' value -}+    -> [GstVideo.Flags.VideoMultiviewFlags]+    {- ^ /@outMviewFlags@/: A set of 'GI.GstVideo.Flags.VideoMultiviewFlags' -}+    -> m ()+videoMultiviewVideoInfoChangeMode info outMviewMode outMviewFlags = liftIO $ do+    info' <- unsafeManagedPtrGetPtr info+    let outMviewMode' = (fromIntegral . fromEnum) outMviewMode+    let outMviewFlags' = gflagsToWord outMviewFlags+    gst_video_multiview_video_info_change_mode info' outMviewMode' outMviewFlags'+    touchManagedPtr info+    return ()+++-- function gst_video_multiview_guess_half_aspect+-- Args : [Arg {argCName = "mv_mode", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMultiviewMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstVideoMultiviewMode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Video frame width in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Video frame height in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "par_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the video pixel-aspect-ratio", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "par_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the video pixel-aspect-ratio", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_multiview_guess_half_aspect" gst_video_multiview_guess_half_aspect :: +    CInt ->                                 -- mv_mode : TInterface (Name {namespace = "GstVideo", name = "VideoMultiviewMode"})+    Word32 ->                               -- width : TBasicType TUInt+    Word32 ->                               -- height : TBasicType TUInt+    Word32 ->                               -- par_n : TBasicType TUInt+    Word32 ->                               -- par_d : TBasicType TUInt+    IO CInt++{- |+/No description available in the introspection data./++/Since: 1.6/+-}+videoMultiviewGuessHalfAspect ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GstVideo.Enums.VideoMultiviewMode+    {- ^ /@mvMode@/: A 'GI.GstVideo.Enums.VideoMultiviewMode' -}+    -> Word32+    {- ^ /@width@/: Video frame width in pixels -}+    -> Word32+    {- ^ /@height@/: Video frame height in pixels -}+    -> Word32+    {- ^ /@parN@/: Numerator of the video pixel-aspect-ratio -}+    -> Word32+    {- ^ /@parD@/: Denominator of the video pixel-aspect-ratio -}+    -> m Bool+    {- ^ __Returns:__ A boolean indicating whether the+  @/GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT/@ flag should be set.++Utility function that heuristically guess whether a+frame-packed stereoscopic video contains half width\/height+encoded views, or full-frame views by looking at the+overall display aspect ratio. -}+videoMultiviewGuessHalfAspect mvMode width height parN parD = liftIO $ do+    let mvMode' = (fromIntegral . fromEnum) mvMode+    result <- gst_video_multiview_guess_half_aspect mvMode' width height parN parD+    let result' = (/= 0) result+    return result'+++-- function gst_video_multiview_get_unpacked_modes+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_multiview_get_unpacked_modes" gst_video_multiview_get_unpacked_modes :: +    IO (Ptr GValue)++{- |+/No description available in the introspection data./++/Since: 1.6/+-}+videoMultiviewGetUnpackedModes ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GValue+    {- ^ __Returns:__ A const 'GI.GObject.Structs.Value.Value' containing a list of \'unpacked\' stereo video modes++Utility function that returns a 'GI.GObject.Structs.Value.Value' with a GstList of unpacked+stereo video modes (separated\/frame-by-frame\/frame-by-frame-multiview)+for use in caps negotiations. -}+videoMultiviewGetUnpackedModes  = liftIO $ do+    result <- gst_video_multiview_get_unpacked_modes+    checkUnexpectedReturnNULL "videoMultiviewGetUnpackedModes" result+    result' <- (newBoxed GValue) result+    return result'+++-- function gst_video_multiview_get_mono_modes+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_multiview_get_mono_modes" gst_video_multiview_get_mono_modes :: +    IO (Ptr GValue)++{- |+/No description available in the introspection data./++/Since: 1.6/+-}+videoMultiviewGetMonoModes ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GValue+    {- ^ __Returns:__ A const 'GI.GObject.Structs.Value.Value' containing a list of mono video modes++Utility function that returns a 'GI.GObject.Structs.Value.Value' with a GstList of mono video+modes (mono\/left\/right) for use in caps negotiations. -}+videoMultiviewGetMonoModes  = liftIO $ do+    result <- gst_video_multiview_get_mono_modes+    checkUnexpectedReturnNULL "videoMultiviewGetMonoModes" result+    result' <- (newBoxed GValue) result+    return result'+++-- function gst_video_multiview_get_doubled_width_modes+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_multiview_get_doubled_width_modes" gst_video_multiview_get_doubled_width_modes :: +    IO (Ptr GValue)++{- |+/No description available in the introspection data./++/Since: 1.6/+-}+videoMultiviewGetDoubledWidthModes ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GValue+    {- ^ __Returns:__ A const 'GI.GObject.Structs.Value.Value' containing a list of stereo video modes++Utility function that returns a 'GI.GObject.Structs.Value.Value' with a GstList of packed stereo+video modes with double the width of a single view for use in+caps negotiations. Currently this is side-by-side, side-by-side-quincunx+and column-interleaved. -}+videoMultiviewGetDoubledWidthModes  = liftIO $ do+    result <- gst_video_multiview_get_doubled_width_modes+    checkUnexpectedReturnNULL "videoMultiviewGetDoubledWidthModes" result+    result' <- (newBoxed GValue) result+    return result'+++-- function gst_video_multiview_get_doubled_size_modes+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_multiview_get_doubled_size_modes" gst_video_multiview_get_doubled_size_modes :: +    IO (Ptr GValue)++{- |+/No description available in the introspection data./++/Since: 1.6/+-}+videoMultiviewGetDoubledSizeModes ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GValue+    {- ^ __Returns:__ A const 'GI.GObject.Structs.Value.Value' containing a list of stereo video modes++Utility function that returns a 'GI.GObject.Structs.Value.Value' with a GstList of packed+stereo video modes that have double the width\/height of a single+view for use in caps negotiation. Currently this is just+\'checkerboard\' layout. -}+videoMultiviewGetDoubledSizeModes  = liftIO $ do+    result <- gst_video_multiview_get_doubled_size_modes+    checkUnexpectedReturnNULL "videoMultiviewGetDoubledSizeModes" result+    result' <- (newBoxed GValue) result+    return result'+++-- function gst_video_multiview_get_doubled_height_modes+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_multiview_get_doubled_height_modes" gst_video_multiview_get_doubled_height_modes :: +    IO (Ptr GValue)++{- |+/No description available in the introspection data./++/Since: 1.6/+-}+videoMultiviewGetDoubledHeightModes ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GValue+    {- ^ __Returns:__ A const 'GI.GObject.Structs.Value.Value' containing a list of stereo video modes++Utility function that returns a 'GI.GObject.Structs.Value.Value' with a GstList of packed stereo+video modes with double the height of a single view for use in+caps negotiations. Currently this is top-bottom and row-interleaved. -}+videoMultiviewGetDoubledHeightModes  = liftIO $ do+    result <- gst_video_multiview_get_doubled_height_modes+    checkUnexpectedReturnNULL "videoMultiviewGetDoubledHeightModes" result+    result' <- (newBoxed GValue) result+    return result'+++-- function gst_video_meta_api_get_type+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TGType)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_meta_api_get_type" gst_video_meta_api_get_type :: +    IO CGType++{- |+/No description available in the introspection data./+-}+videoMetaApiGetType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GType+videoMetaApiGetType  = liftIO $ do+    result <- gst_video_meta_api_get_type+    let result' = GType result+    return result'+++-- function gst_video_guess_framerate+-- Args : [Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Nominal duration of one frame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_n", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the calculated framerate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_d", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the calculated framerate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_guess_framerate" gst_video_guess_framerate :: +    Word64 ->                               -- duration : TBasicType TUInt64+    Ptr Int32 ->                            -- dest_n : TBasicType TInt+    Ptr Int32 ->                            -- dest_d : TBasicType TInt+    IO CInt++{- |+Given the nominal duration of one video frame,+this function will check some standard framerates for+a close match (within 0.1%) and return one if possible,++It will calculate an arbitrary framerate if no close+match was found, and return 'False'.++It returns 'False' if a duration of 0 is passed.++/Since: 1.6/+-}+videoGuessFramerate ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Word64+    {- ^ /@duration@/: Nominal duration of one frame -}+    -> m ((Bool, Int32, Int32))+    {- ^ __Returns:__ 'True' if a close \"standard\" framerate was+recognised, and 'False' otherwise. -}+videoGuessFramerate duration = liftIO $ do+    destN <- allocMem :: IO (Ptr Int32)+    destD <- allocMem :: IO (Ptr Int32)+    result <- gst_video_guess_framerate duration destN destD+    let result' = (/= 0) result+    destN' <- peek destN+    destD' <- peek destD+    freeMem destN+    freeMem destD+    return (result', destN', destD')+++-- function gst_video_gl_texture_upload_meta_api_get_type+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TGType)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_gl_texture_upload_meta_api_get_type" gst_video_gl_texture_upload_meta_api_get_type :: +    IO CGType++{- |+/No description available in the introspection data./+-}+videoGlTextureUploadMetaApiGetType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GType+videoGlTextureUploadMetaApiGetType  = liftIO $ do+    result <- gst_video_gl_texture_upload_meta_api_get_type+    let result' = GType result+    return result'+++-- function gst_video_event_parse_upstream_force_key_unit+-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstEvent to parse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the running_time in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "all_headers", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the all_headers flag in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "count", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the count field in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_event_parse_upstream_force_key_unit" gst_video_event_parse_upstream_force_key_unit :: +    Ptr Gst.Event.Event ->                  -- event : TInterface (Name {namespace = "Gst", name = "Event"})+    Ptr Word64 ->                           -- running_time : TBasicType TUInt64+    Ptr CInt ->                             -- all_headers : TBasicType TBoolean+    Ptr Word32 ->                           -- count : TBasicType TUInt+    IO CInt++{- |+Get running-time, all-headers and count in the force key unit event. See+'GI.GstVideo.Functions.videoEventNewUpstreamForceKeyUnit' for a full description of the+upstream force key unit event.++Create an upstream force key unit event using  'GI.GstVideo.Functions.videoEventNewUpstreamForceKeyUnit'++/@runningTime@/ will be adjusted for any pad offsets of pads it was passing through.+-}+videoEventParseUpstreamForceKeyUnit ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Event.Event+    {- ^ /@event@/: A 'GI.Gst.Structs.Event.Event' to parse -}+    -> m ((Bool, Word64, Bool, Word32))+    {- ^ __Returns:__ 'True' if the event is a valid upstream force-key-unit event. 'False' if not -}+videoEventParseUpstreamForceKeyUnit event = liftIO $ do+    event' <- unsafeManagedPtrGetPtr event+    runningTime <- allocMem :: IO (Ptr Word64)+    allHeaders <- allocMem :: IO (Ptr CInt)+    count <- allocMem :: IO (Ptr Word32)+    result <- gst_video_event_parse_upstream_force_key_unit event' runningTime allHeaders count+    let result' = (/= 0) result+    runningTime' <- peek runningTime+    allHeaders' <- peek allHeaders+    let allHeaders'' = (/= 0) allHeaders'+    count' <- peek count+    touchManagedPtr event+    freeMem runningTime+    freeMem allHeaders+    freeMem count+    return (result', runningTime', allHeaders'', count')+++-- function gst_video_event_parse_still_frame+-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstEvent to parse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "in_still", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n    A boolean to receive the still-frame status from the event, or NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_event_parse_still_frame" gst_video_event_parse_still_frame :: +    Ptr Gst.Event.Event ->                  -- event : TInterface (Name {namespace = "Gst", name = "Event"})+    Ptr CInt ->                             -- in_still : TBasicType TBoolean+    IO CInt++{- |+Parse a 'GI.Gst.Structs.Event.Event', identify if it is a Still Frame event, and+return the still-frame state from the event if it is.+If the event represents the start of a still frame, the in_still+variable will be set to TRUE, otherwise FALSE. It is OK to pass NULL for the+in_still variable order to just check whether the event is a valid still-frame+event.++Create a still frame event using 'GI.GstVideo.Functions.videoEventNewStillFrame'+-}+videoEventParseStillFrame ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Event.Event+    {- ^ /@event@/: A 'GI.Gst.Structs.Event.Event' to parse -}+    -> m ((Bool, Bool))+    {- ^ __Returns:__ 'True' if the event is a valid still-frame event. 'False' if not -}+videoEventParseStillFrame event = liftIO $ do+    event' <- unsafeManagedPtrGetPtr event+    inStill <- allocMem :: IO (Ptr CInt)+    result <- gst_video_event_parse_still_frame event' inStill+    let result' = (/= 0) result+    inStill' <- peek inStill+    let inStill'' = (/= 0) inStill'+    touchManagedPtr event+    freeMem inStill+    return (result', inStill'')+++-- function gst_video_event_parse_downstream_force_key_unit+-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstEvent to parse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the timestamp in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stream_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the stream-time in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the running-time in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "all_headers", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the all_headers flag in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "count", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the count field of the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_event_parse_downstream_force_key_unit" gst_video_event_parse_downstream_force_key_unit :: +    Ptr Gst.Event.Event ->                  -- event : TInterface (Name {namespace = "Gst", name = "Event"})+    Ptr Word64 ->                           -- timestamp : TBasicType TUInt64+    Ptr Word64 ->                           -- stream_time : TBasicType TUInt64+    Ptr Word64 ->                           -- running_time : TBasicType TUInt64+    Ptr CInt ->                             -- all_headers : TBasicType TBoolean+    Ptr Word32 ->                           -- count : TBasicType TUInt+    IO CInt++{- |+Get timestamp, stream-time, running-time, all-headers and count in the force+key unit event. See 'GI.GstVideo.Functions.videoEventNewDownstreamForceKeyUnit' for a+full description of the downstream force key unit event.++/@runningTime@/ will be adjusted for any pad offsets of pads it was passing through.+-}+videoEventParseDownstreamForceKeyUnit ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Event.Event+    {- ^ /@event@/: A 'GI.Gst.Structs.Event.Event' to parse -}+    -> m ((Bool, Word64, Word64, Word64, Bool, Word32))+    {- ^ __Returns:__ 'True' if the event is a valid downstream force key unit event. -}+videoEventParseDownstreamForceKeyUnit event = liftIO $ do+    event' <- unsafeManagedPtrGetPtr event+    timestamp <- allocMem :: IO (Ptr Word64)+    streamTime <- allocMem :: IO (Ptr Word64)+    runningTime <- allocMem :: IO (Ptr Word64)+    allHeaders <- allocMem :: IO (Ptr CInt)+    count <- allocMem :: IO (Ptr Word32)+    result <- gst_video_event_parse_downstream_force_key_unit event' timestamp streamTime runningTime allHeaders count+    let result' = (/= 0) result+    timestamp' <- peek timestamp+    streamTime' <- peek streamTime+    runningTime' <- peek runningTime+    allHeaders' <- peek allHeaders+    let allHeaders'' = (/= 0) allHeaders'+    count' <- peek count+    touchManagedPtr event+    freeMem timestamp+    freeMem streamTime+    freeMem runningTime+    freeMem allHeaders+    freeMem count+    return (result', timestamp', streamTime', runningTime', allHeaders'', count')+++-- function gst_video_event_new_upstream_force_key_unit+-- Args : [Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the running_time at which a new key unit should be produced", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "all_headers", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to produce headers when starting a new key unit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "integer that can be used to number key units", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Event"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_event_new_upstream_force_key_unit" gst_video_event_new_upstream_force_key_unit :: +    Word64 ->                               -- running_time : TBasicType TUInt64+    CInt ->                                 -- all_headers : TBasicType TBoolean+    Word32 ->                               -- count : TBasicType TUInt+    IO (Ptr Gst.Event.Event)++{- |+Creates a new upstream force key unit event. An upstream force key unit event+can be sent to request upstream elements to produce a key unit.++/@runningTime@/ can be set to request a new key unit at a specific+running_time. If set to GST_CLOCK_TIME_NONE, upstream elements will produce a+new key unit as soon as possible.++To parse an event created by 'GI.GstVideo.Functions.videoEventNewDownstreamForceKeyUnit' use+'GI.GstVideo.Functions.videoEventParseDownstreamForceKeyUnit'.+-}+videoEventNewUpstreamForceKeyUnit ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Word64+    {- ^ /@runningTime@/: the running_time at which a new key unit should be produced -}+    -> Bool+    {- ^ /@allHeaders@/: 'True' to produce headers when starting a new key unit -}+    -> Word32+    {- ^ /@count@/: integer that can be used to number key units -}+    -> m Gst.Event.Event+    {- ^ __Returns:__ The new GstEvent -}+videoEventNewUpstreamForceKeyUnit runningTime allHeaders count = liftIO $ do+    let allHeaders' = (fromIntegral . fromEnum) allHeaders+    result <- gst_video_event_new_upstream_force_key_unit runningTime allHeaders' count+    checkUnexpectedReturnNULL "videoEventNewUpstreamForceKeyUnit" result+    result' <- (wrapBoxed Gst.Event.Event) result+    return result'+++-- function gst_video_event_new_still_frame+-- Args : [Arg {argCName = "in_still", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "boolean value for the still-frame state of the event.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Event"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_event_new_still_frame" gst_video_event_new_still_frame :: +    CInt ->                                 -- in_still : TBasicType TBoolean+    IO (Ptr Gst.Event.Event)++{- |+Creates a new Still Frame event. If /@inStill@/ is 'True', then the event+represents the start of a still frame sequence. If it is 'False', then+the event ends a still frame sequence.++To parse an event created by 'GI.GstVideo.Functions.videoEventNewStillFrame' use+'GI.GstVideo.Functions.videoEventParseStillFrame'.+-}+videoEventNewStillFrame ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Bool+    {- ^ /@inStill@/: boolean value for the still-frame state of the event. -}+    -> m Gst.Event.Event+    {- ^ __Returns:__ The new GstEvent -}+videoEventNewStillFrame inStill = liftIO $ do+    let inStill' = (fromIntegral . fromEnum) inStill+    result <- gst_video_event_new_still_frame inStill'+    checkUnexpectedReturnNULL "videoEventNewStillFrame" result+    result' <- (wrapBoxed Gst.Event.Event) result+    return result'+++-- function gst_video_event_new_downstream_force_key_unit+-- Args : [Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the timestamp of the buffer that starts a new key unit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stream_time of the buffer that starts a new key unit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the running_time of the buffer that starts a new key unit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "all_headers", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to produce headers when starting a new key unit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "integer that can be used to number key units", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Event"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_event_new_downstream_force_key_unit" gst_video_event_new_downstream_force_key_unit :: +    Word64 ->                               -- timestamp : TBasicType TUInt64+    Word64 ->                               -- stream_time : TBasicType TUInt64+    Word64 ->                               -- running_time : TBasicType TUInt64+    CInt ->                                 -- all_headers : TBasicType TBoolean+    Word32 ->                               -- count : TBasicType TUInt+    IO (Ptr Gst.Event.Event)++{- |+Creates a new downstream force key unit event. A downstream force key unit+event can be sent down the pipeline to request downstream elements to produce+a key unit. A downstream force key unit event must also be sent when handling+an upstream force key unit event to notify downstream that the latter has been+handled.++To parse an event created by 'GI.GstVideo.Functions.videoEventNewDownstreamForceKeyUnit' use+'GI.GstVideo.Functions.videoEventParseDownstreamForceKeyUnit'.+-}+videoEventNewDownstreamForceKeyUnit ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Word64+    {- ^ /@timestamp@/: the timestamp of the buffer that starts a new key unit -}+    -> Word64+    {- ^ /@streamTime@/: the stream_time of the buffer that starts a new key unit -}+    -> Word64+    {- ^ /@runningTime@/: the running_time of the buffer that starts a new key unit -}+    -> Bool+    {- ^ /@allHeaders@/: 'True' to produce headers when starting a new key unit -}+    -> Word32+    {- ^ /@count@/: integer that can be used to number key units -}+    -> m Gst.Event.Event+    {- ^ __Returns:__ The new GstEvent -}+videoEventNewDownstreamForceKeyUnit timestamp streamTime runningTime allHeaders count = liftIO $ do+    let allHeaders' = (fromIntegral . fromEnum) allHeaders+    result <- gst_video_event_new_downstream_force_key_unit timestamp streamTime runningTime allHeaders' count+    checkUnexpectedReturnNULL "videoEventNewDownstreamForceKeyUnit" result+    result' <- (wrapBoxed Gst.Event.Event) result+    return result'+++-- function gst_video_event_is_force_key_unit+-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstEvent to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_event_is_force_key_unit" gst_video_event_is_force_key_unit :: +    Ptr Gst.Event.Event ->                  -- event : TInterface (Name {namespace = "Gst", name = "Event"})+    IO CInt++{- |+Checks if an event is a force key unit event. Returns true for both upstream+and downstream force key unit events.+-}+videoEventIsForceKeyUnit ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Event.Event+    {- ^ /@event@/: A 'GI.Gst.Structs.Event.Event' to check -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the event is a valid force key unit event -}+videoEventIsForceKeyUnit event = liftIO $ do+    event' <- unsafeManagedPtrGetPtr event+    result <- gst_video_event_is_force_key_unit event'+    let result' = (/= 0) result+    touchManagedPtr event+    return result'+++-- function gst_video_crop_meta_api_get_type+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TGType)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_crop_meta_api_get_type" gst_video_crop_meta_api_get_type :: +    IO CGType++{- |+/No description available in the introspection data./+-}+videoCropMetaApiGetType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GType+videoCropMetaApiGetType  = liftIO $ do+    result <- gst_video_crop_meta_api_get_type+    let result' = GType result+    return result'+++-- function gst_video_convert_sample_async+-- Args : [Arg {argCName = "sample", argType = TInterface (Name {namespace = "Gst", name = "Sample"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstSample", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "to_caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstCaps to convert to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum amount of time allowed for the processing.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GstVideo", name = "VideoConvertSampleCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%GstVideoConvertSampleCallback that will be called after conversion.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 4, argDestroy = 5, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "extra data that will be passed to the @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%GDestroyNotify to be called after @user_data is not needed anymore", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_convert_sample_async" gst_video_convert_sample_async :: +    Ptr Gst.Sample.Sample ->                -- sample : TInterface (Name {namespace = "Gst", name = "Sample"})+    Ptr Gst.Caps.Caps ->                    -- to_caps : TInterface (Name {namespace = "Gst", name = "Caps"})+    Word64 ->                               -- timeout : TBasicType TUInt64+    FunPtr GstVideo.Callbacks.C_VideoConvertSampleCallback -> -- callback : TInterface (Name {namespace = "GstVideo", name = "VideoConvertSampleCallback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    IO ()++{- |+Converts a raw video buffer into the specified output caps.++The output caps can be any raw video formats or any image formats (jpeg, png, ...).++The width, height and pixel-aspect-ratio can also be specified in the output caps.++/@callback@/ will be called after conversion, when an error occured or if conversion didn\'t+finish after /@timeout@/. /@callback@/ will always be called from the thread default+@/GMainContext/@, see 'GI.GLib.Functions.mainContextGetThreadDefault'. If GLib before 2.22 is used,+this will always be the global default main context.++/@destroyNotify@/ will be called after the callback was called and /@userData@/ is not needed+anymore.+-}+videoConvertSampleAsync ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Sample.Sample+    {- ^ /@sample@/: a 'GI.Gst.Structs.Sample.Sample' -}+    -> Gst.Caps.Caps+    {- ^ /@toCaps@/: the 'GI.Gst.Structs.Caps.Caps' to convert to -}+    -> Word64+    {- ^ /@timeout@/: the maximum amount of time allowed for the processing. -}+    -> GstVideo.Callbacks.VideoConvertSampleCallback+    {- ^ /@callback@/: @/GstVideoConvertSampleCallback/@ that will be called after conversion. -}+    -> m ()+videoConvertSampleAsync sample toCaps timeout callback = liftIO $ do+    sample' <- unsafeManagedPtrGetPtr sample+    toCaps' <- unsafeManagedPtrGetPtr toCaps+    callback' <- GstVideo.Callbacks.mk_VideoConvertSampleCallback (GstVideo.Callbacks.wrap_VideoConvertSampleCallback Nothing (GstVideo.Callbacks.drop_closures_VideoConvertSampleCallback callback))+    let userData = castFunPtrToPtr callback'+    let destroyNotify = safeFreeFunPtrPtr+    gst_video_convert_sample_async sample' toCaps' timeout callback' userData destroyNotify+    touchManagedPtr sample+    touchManagedPtr toCaps+    return ()+++-- function gst_video_convert_sample+-- Args : [Arg {argCName = "sample", argType = TInterface (Name {namespace = "Gst", name = "Sample"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstSample", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "to_caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstCaps to convert to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum amount of time allowed for the processing.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Sample"}))+-- throws : True+-- Skip return : False++foreign import ccall "gst_video_convert_sample" gst_video_convert_sample :: +    Ptr Gst.Sample.Sample ->                -- sample : TInterface (Name {namespace = "Gst", name = "Sample"})+    Ptr Gst.Caps.Caps ->                    -- to_caps : TInterface (Name {namespace = "Gst", name = "Caps"})+    Word64 ->                               -- timeout : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Gst.Sample.Sample)++{- |+Converts a raw video buffer into the specified output caps.++The output caps can be any raw video formats or any image formats (jpeg, png, ...).++The width, height and pixel-aspect-ratio can also be specified in the output caps.+-}+videoConvertSample ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Sample.Sample+    {- ^ /@sample@/: a 'GI.Gst.Structs.Sample.Sample' -}+    -> Gst.Caps.Caps+    {- ^ /@toCaps@/: the 'GI.Gst.Structs.Caps.Caps' to convert to -}+    -> Word64+    {- ^ /@timeout@/: the maximum amount of time allowed for the processing. -}+    -> m Gst.Sample.Sample+    {- ^ __Returns:__ The converted 'GI.Gst.Structs.Sample.Sample', or 'Nothing' if an error happened (in which case /@err@/+will point to the 'GError'). /(Can throw 'Data.GI.Base.GError.GError')/ -}+videoConvertSample sample toCaps timeout = liftIO $ do+    sample' <- unsafeManagedPtrGetPtr sample+    toCaps' <- unsafeManagedPtrGetPtr toCaps+    onException (do+        result <- propagateGError $ gst_video_convert_sample sample' toCaps' timeout+        checkUnexpectedReturnNULL "videoConvertSample" result+        result' <- (wrapBoxed Gst.Sample.Sample) result+        touchManagedPtr sample+        touchManagedPtr toCaps+        return result'+     ) (do+        return ()+     )+++-- function gst_video_color_transfer_encode+-- Args : [Arg {argCName = "func", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTransferFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTransferFunction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TDouble)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_color_transfer_encode" gst_video_color_transfer_encode :: +    CUInt ->                                -- func : TInterface (Name {namespace = "GstVideo", name = "VideoTransferFunction"})+    CDouble ->                              -- val : TBasicType TDouble+    IO CDouble++{- |+Convert /@val@/ to its gamma encoded value.++For a linear value L in the range [0..1], conversion to the non-linear+(gamma encoded) L\' is in general performed with a power function like:++>+>   L' = L ^ (1 / gamma)+++Depending on /@func@/, different formulas might be applied. Some formulas+encode a linear segment in the lower range.++/Since: 1.6/+-}+videoColorTransferEncode ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GstVideo.Enums.VideoTransferFunction+    {- ^ /@func@/: a 'GI.GstVideo.Enums.VideoTransferFunction' -}+    -> Double+    {- ^ /@val@/: a value -}+    -> m Double+    {- ^ __Returns:__ the gamme encoded value of /@val@/ -}+videoColorTransferEncode func val = liftIO $ do+    let func' = (fromIntegral . fromEnum) func+    let val' = realToFrac val+    result <- gst_video_color_transfer_encode func' val'+    let result' = realToFrac result+    return result'+++-- function gst_video_color_transfer_decode+-- Args : [Arg {argCName = "func", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTransferFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTransferFunction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TDouble)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_color_transfer_decode" gst_video_color_transfer_decode :: +    CUInt ->                                -- func : TInterface (Name {namespace = "GstVideo", name = "VideoTransferFunction"})+    CDouble ->                              -- val : TBasicType TDouble+    IO CDouble++{- |+Convert /@val@/ to its gamma decoded value. This is the inverse operation of+/@gstVideoColorTransferEncode@/().++For a non-linear value L\' in the range [0..1], conversion to the linear+L is in general performed with a power function like:++>+>   L = L' ^ gamma+++Depending on /@func@/, different formulas might be applied. Some formulas+encode a linear segment in the lower range.++/Since: 1.6/+-}+videoColorTransferDecode ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GstVideo.Enums.VideoTransferFunction+    {- ^ /@func@/: a 'GI.GstVideo.Enums.VideoTransferFunction' -}+    -> Double+    {- ^ /@val@/: a value -}+    -> m Double+    {- ^ __Returns:__ the gamme decoded value of /@val@/ -}+videoColorTransferDecode func val = liftIO $ do+    let func' = (fromIntegral . fromEnum) func+    let val' = realToFrac val+    result <- gst_video_color_transfer_decode func' val'+    let result' = realToFrac result+    return result'+++-- function gst_video_chroma_to_string+-- Args : [Arg {argCName = "site", argType = TInterface (Name {namespace = "GstVideo", name = "VideoChromaSite"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoChromaSite", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_chroma_to_string" gst_video_chroma_to_string :: +    CUInt ->                                -- site : TInterface (Name {namespace = "GstVideo", name = "VideoChromaSite"})+    IO CString++{- |+Converts /@site@/ to its string representation.+-}+videoChromaToString ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    [GstVideo.Flags.VideoChromaSite]+    {- ^ /@site@/: a 'GI.GstVideo.Flags.VideoChromaSite' -}+    -> m T.Text+    {- ^ __Returns:__ a string describing /@site@/. -}+videoChromaToString site = liftIO $ do+    let site' = gflagsToWord site+    result <- gst_video_chroma_to_string site'+    checkUnexpectedReturnNULL "videoChromaToString" result+    result' <- cstringToText result+    return result'+++-- function gst_video_chroma_resample+-- Args : [Arg {argCName = "resample", argType = TInterface (Name {namespace = "GstVideo", name = "VideoChromaResample"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoChromaResample", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "lines", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "pixel lines", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of pixels on one line", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_chroma_resample" gst_video_chroma_resample :: +    Ptr GstVideo.VideoChromaResample.VideoChromaResample -> -- resample : TInterface (Name {namespace = "GstVideo", name = "VideoChromaResample"})+    Ptr () ->                               -- lines : TBasicType TPtr+    Int32 ->                                -- width : TBasicType TInt+    IO ()++{- |+Perform resampling of /@width@/ chroma pixels in /@lines@/.+-}+videoChromaResample ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GstVideo.VideoChromaResample.VideoChromaResample+    {- ^ /@resample@/: a 'GI.GstVideo.Structs.VideoChromaResample.VideoChromaResample' -}+    -> Ptr ()+    {- ^ /@lines@/: pixel lines -}+    -> Int32+    {- ^ /@width@/: the number of pixels on one line -}+    -> m ()+videoChromaResample resample lines width = liftIO $ do+    resample' <- unsafeManagedPtrGetPtr resample+    gst_video_chroma_resample resample' lines width+    touchManagedPtr resample+    return ()+++-- function gst_video_chroma_from_string+-- Args : [Arg {argCName = "s", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a chromasite string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoChromaSite"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_chroma_from_string" gst_video_chroma_from_string :: +    CString ->                              -- s : TBasicType TUTF8+    IO CUInt++{- |+Convert /@s@/ to a 'GI.GstVideo.Flags.VideoChromaSite'+-}+videoChromaFromString ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@s@/: a chromasite string -}+    -> m [GstVideo.Flags.VideoChromaSite]+    {- ^ __Returns:__ a 'GI.GstVideo.Flags.VideoChromaSite' or 'GI.GstVideo.Flags.VideoChromaSiteUnknown' when /@s@/ does+not contain a valid chroma description. -}+videoChromaFromString s = liftIO $ do+    s' <- textToCString s+    result <- gst_video_chroma_from_string s'+    let result' = wordToGFlags result+    freeMem s'+    return result'+++-- function gst_video_caption_meta_api_get_type+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TGType)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_caption_meta_api_get_type" gst_video_caption_meta_api_get_type :: +    IO CGType++{- |+/No description available in the introspection data./+-}+videoCaptionMetaApiGetType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GType+videoCaptionMetaApiGetType  = liftIO $ do+    result <- gst_video_caption_meta_api_get_type+    let result' = GType result+    return result'+++-- function gst_video_calculate_display_ratio+-- Args : [Arg {argCName = "dar_n", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the calculated display_ratio", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dar_d", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the calculated display_ratio", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "video_width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Width of the video frame in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "video_height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Height of the video frame in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "video_par_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the pixel aspect ratio of the input video.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "video_par_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the pixel aspect ratio of the input video.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "display_par_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the pixel aspect ratio of the display device", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "display_par_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the pixel aspect ratio of the display device", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_calculate_display_ratio" gst_video_calculate_display_ratio :: +    Ptr Word32 ->                           -- dar_n : TBasicType TUInt+    Ptr Word32 ->                           -- dar_d : TBasicType TUInt+    Word32 ->                               -- video_width : TBasicType TUInt+    Word32 ->                               -- video_height : TBasicType TUInt+    Word32 ->                               -- video_par_n : TBasicType TUInt+    Word32 ->                               -- video_par_d : TBasicType TUInt+    Word32 ->                               -- display_par_n : TBasicType TUInt+    Word32 ->                               -- display_par_d : TBasicType TUInt+    IO CInt++{- |+Given the Pixel Aspect Ratio and size of an input video frame, and the+pixel aspect ratio of the intended display device, calculates the actual+display ratio the video will be rendered with.+-}+videoCalculateDisplayRatio ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Word32+    {- ^ /@videoWidth@/: Width of the video frame in pixels -}+    -> Word32+    {- ^ /@videoHeight@/: Height of the video frame in pixels -}+    -> Word32+    {- ^ /@videoParN@/: Numerator of the pixel aspect ratio of the input video. -}+    -> Word32+    {- ^ /@videoParD@/: Denominator of the pixel aspect ratio of the input video. -}+    -> Word32+    {- ^ /@displayParN@/: Numerator of the pixel aspect ratio of the display device -}+    -> Word32+    {- ^ /@displayParD@/: Denominator of the pixel aspect ratio of the display device -}+    -> m ((Bool, Word32, Word32))+    {- ^ __Returns:__ A boolean indicating success and a calculated Display Ratio in the+dar_n and dar_d parameters.+The return value is FALSE in the case of integer overflow or other error. -}+videoCalculateDisplayRatio videoWidth videoHeight videoParN videoParD displayParN displayParD = liftIO $ do+    darN <- allocMem :: IO (Ptr Word32)+    darD <- allocMem :: IO (Ptr Word32)+    result <- gst_video_calculate_display_ratio darN darD videoWidth videoHeight videoParN videoParD displayParN displayParD+    let result' = (/= 0) result+    darN' <- peek darN+    darD' <- peek darD+    freeMem darN+    freeMem darD+    return (result', darN', darD')+++-- function gst_video_blend_scale_linear_RGBA+-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstVideoInfo describing the video data in @src_buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source buffer containing video pixels to scale", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height in pixels to scale the video data in @src_buffer to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width in pixels to scale the video data in @src_buffer to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer to a #GstVideoInfo structure that will be filled in\n    with the details for @dest_buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "dest_buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GstBuffer variable, which will be\n    set to a newly-allocated buffer containing the scaled pixels.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_blend_scale_linear_RGBA" gst_video_blend_scale_linear_RGBA :: +    Ptr GstVideo.VideoInfo.VideoInfo ->     -- src : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"})+    Ptr Gst.Buffer.Buffer ->                -- src_buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    Int32 ->                                -- dest_height : TBasicType TInt+    Int32 ->                                -- dest_width : TBasicType TInt+    Ptr GstVideo.VideoInfo.VideoInfo ->     -- dest : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"})+    Ptr (Ptr Gst.Buffer.Buffer) ->          -- dest_buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    IO ()++{- |+Scales a buffer containing RGBA (or AYUV) video. This is an internal+helper function which is used to scale subtitle overlays, and may be+deprecated in the near future. Use 'GI.GstVideo.Structs.VideoScaler.VideoScaler' to scale video buffers+instead.+-}+videoBlendScaleLinearRGBA ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GstVideo.VideoInfo.VideoInfo+    {- ^ /@src@/: the 'GI.GstVideo.Structs.VideoInfo.VideoInfo' describing the video data in /@srcBuffer@/ -}+    -> Gst.Buffer.Buffer+    {- ^ /@srcBuffer@/: the source buffer containing video pixels to scale -}+    -> Int32+    {- ^ /@destHeight@/: the height in pixels to scale the video data in /@srcBuffer@/ to -}+    -> Int32+    {- ^ /@destWidth@/: the width in pixels to scale the video data in /@srcBuffer@/ to -}+    -> m ((GstVideo.VideoInfo.VideoInfo, Gst.Buffer.Buffer))+videoBlendScaleLinearRGBA src srcBuffer destHeight destWidth = liftIO $ do+    src' <- unsafeManagedPtrGetPtr src+    srcBuffer' <- unsafeManagedPtrGetPtr srcBuffer+    dest <- callocBoxedBytes 120 :: IO (Ptr GstVideo.VideoInfo.VideoInfo)+    destBuffer <- allocMem :: IO (Ptr (Ptr Gst.Buffer.Buffer))+    gst_video_blend_scale_linear_RGBA src' srcBuffer' destHeight destWidth dest destBuffer+    dest' <- (wrapBoxed GstVideo.VideoInfo.VideoInfo) dest+    destBuffer' <- peek destBuffer+    destBuffer'' <- (wrapBoxed Gst.Buffer.Buffer) destBuffer'+    touchManagedPtr src+    touchManagedPtr srcBuffer+    freeMem destBuffer+    return (dest', destBuffer'')+++-- function gst_video_blend+-- Args : [Arg {argCName = "dest", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GstVideoFrame where to blend @src in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstVideoFrame that we want to blend into", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The x offset in pixel where the @src image should be blended", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y offset in pixel where the @src image should be blended", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "global_alpha", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the global_alpha each per-pixel alpha value is multiplied\n               with", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_blend" gst_video_blend :: +    Ptr GstVideo.VideoFrame.VideoFrame ->   -- dest : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"})+    Ptr GstVideo.VideoFrame.VideoFrame ->   -- src : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"})+    Int32 ->                                -- x : TBasicType TInt+    Int32 ->                                -- y : TBasicType TInt+    CFloat ->                               -- global_alpha : TBasicType TFloat+    IO CInt++{- |+Lets you blend the /@src@/ image into the /@dest@/ image+-}+videoBlend ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GstVideo.VideoFrame.VideoFrame+    {- ^ /@dest@/: The 'GI.GstVideo.Structs.VideoFrame.VideoFrame' where to blend /@src@/ in -}+    -> GstVideo.VideoFrame.VideoFrame+    {- ^ /@src@/: the 'GI.GstVideo.Structs.VideoFrame.VideoFrame' that we want to blend into -}+    -> Int32+    {- ^ /@x@/: The x offset in pixel where the /@src@/ image should be blended -}+    -> Int32+    {- ^ /@y@/: the y offset in pixel where the /@src@/ image should be blended -}+    -> Float+    {- ^ /@globalAlpha@/: the global_alpha each per-pixel alpha value is multiplied+               with -}+    -> m Bool+videoBlend dest src x y globalAlpha = liftIO $ do+    dest' <- unsafeManagedPtrGetPtr dest+    src' <- unsafeManagedPtrGetPtr src+    let globalAlpha' = realToFrac globalAlpha+    result <- gst_video_blend dest' src' x y globalAlpha'+    let result' = (/= 0) result+    touchManagedPtr dest+    touchManagedPtr src+    return result'+++-- function gst_video_affine_transformation_meta_api_get_type+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TGType)+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_affine_transformation_meta_api_get_type" gst_video_affine_transformation_meta_api_get_type :: +    IO CGType++{- |+/No description available in the introspection data./+-}+videoAffineTransformationMetaApiGetType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GType+videoAffineTransformationMetaApiGetType  = liftIO $ do+    result <- gst_video_affine_transformation_meta_api_get_type+    let result' = GType result+    return result'+++-- function gst_is_video_overlay_prepare_window_handle_message+-- Args : [Arg {argCName = "msg", argType = TInterface (Name {namespace = "Gst", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMessage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_is_video_overlay_prepare_window_handle_message" gst_is_video_overlay_prepare_window_handle_message :: +    Ptr Gst.Message.Message ->              -- msg : TInterface (Name {namespace = "Gst", name = "Message"})+    IO CInt++{- |+Convenience function to check if the given message is a+\"prepare-window-handle\" message from a 'GI.GstVideo.Interfaces.VideoOverlay.VideoOverlay'.+-}+isVideoOverlayPrepareWindowHandleMessage ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Message.Message+    {- ^ /@msg@/: a 'GI.Gst.Structs.Message.Message' -}+    -> m Bool+    {- ^ __Returns:__ whether /@msg@/ is a \"prepare-window-handle\" message -}+isVideoOverlayPrepareWindowHandleMessage msg = liftIO $ do+    msg' <- unsafeManagedPtrGetPtr msg+    result <- gst_is_video_overlay_prepare_window_handle_message msg'+    let result' = (/= 0) result+    touchManagedPtr msg+    return result'+++-- function gst_buffer_pool_config_set_video_alignment+-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoAlignment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_config_set_video_alignment" gst_buffer_pool_config_set_video_alignment :: +    Ptr Gst.Structure.Structure ->          -- config : TInterface (Name {namespace = "Gst", name = "Structure"})+    Ptr GstVideo.VideoAlignment.VideoAlignment -> -- align : TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"})+    IO ()++{- |+Set the video alignment in /@align@/ to the bufferpool configuration+/@config@/+-}+bufferPoolConfigSetVideoAlignment ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Structure.Structure+    {- ^ /@config@/: a 'GI.Gst.Structs.Structure.Structure' -}+    -> GstVideo.VideoAlignment.VideoAlignment+    {- ^ /@align@/: a 'GI.GstVideo.Structs.VideoAlignment.VideoAlignment' -}+    -> m ()+bufferPoolConfigSetVideoAlignment config align = liftIO $ do+    config' <- unsafeManagedPtrGetPtr config+    align' <- unsafeManagedPtrGetPtr align+    gst_buffer_pool_config_set_video_alignment config' align'+    touchManagedPtr config+    touchManagedPtr align+    return ()+++-- function gst_buffer_pool_config_get_video_alignment+-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoAlignment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_config_get_video_alignment" gst_buffer_pool_config_get_video_alignment :: +    Ptr Gst.Structure.Structure ->          -- config : TInterface (Name {namespace = "Gst", name = "Structure"})+    Ptr GstVideo.VideoAlignment.VideoAlignment -> -- align : TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"})+    IO CInt++{- |+Get the video alignment from the bufferpool configuration /@config@/ in+in /@align@/+-}+bufferPoolConfigGetVideoAlignment ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Structure.Structure+    {- ^ /@config@/: a 'GI.Gst.Structs.Structure.Structure' -}+    -> GstVideo.VideoAlignment.VideoAlignment+    {- ^ /@align@/: a 'GI.GstVideo.Structs.VideoAlignment.VideoAlignment' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if /@config@/ could be parsed correctly. -}+bufferPoolConfigGetVideoAlignment config align = liftIO $ do+    config' <- unsafeManagedPtrGetPtr config+    align' <- unsafeManagedPtrGetPtr align+    result <- gst_buffer_pool_config_get_video_alignment config' align'+    let result' = (/= 0) result+    touchManagedPtr config+    touchManagedPtr align+    return result'+++-- function gst_buffer_get_video_region_of_interest_meta_id+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a metadata id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoRegionOfInterestMeta"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_get_video_region_of_interest_meta_id" gst_buffer_get_video_region_of_interest_meta_id :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    Int32 ->                                -- id : TBasicType TInt+    IO (Ptr GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta)++{- |+Find the 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' on /@buffer@/ with the given /@id@/.++Buffers can contain multiple 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' metadata items if+multiple regions of interests are marked on a frame.+-}+bufferGetVideoRegionOfInterestMetaId ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -}+    -> Int32+    {- ^ /@id@/: a metadata id -}+    -> m GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta+    {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' with /@id@/ or 'Nothing' when there is+no such metadata on /@buffer@/. -}+bufferGetVideoRegionOfInterestMetaId buffer id = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    result <- gst_buffer_get_video_region_of_interest_meta_id buffer' id+    checkUnexpectedReturnNULL "bufferGetVideoRegionOfInterestMetaId" result+    result' <- (newPtr GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta) result+    touchManagedPtr buffer+    return result'+++-- function gst_buffer_get_video_meta_id+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a metadata id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_get_video_meta_id" gst_buffer_get_video_meta_id :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    Int32 ->                                -- id : TBasicType TInt+    IO (Ptr GstVideo.VideoMeta.VideoMeta)++{- |+Find the 'GI.GstVideo.Structs.VideoMeta.VideoMeta' on /@buffer@/ with the given /@id@/.++Buffers can contain multiple 'GI.GstVideo.Structs.VideoMeta.VideoMeta' metadata items when dealing with+multiview buffers.+-}+bufferGetVideoMetaId ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -}+    -> Int32+    {- ^ /@id@/: a metadata id -}+    -> m GstVideo.VideoMeta.VideoMeta+    {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoMeta.VideoMeta' with /@id@/ or 'Nothing' when there is no such metadata+on /@buffer@/. -}+bufferGetVideoMetaId buffer id = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    result <- gst_buffer_get_video_meta_id buffer' id+    checkUnexpectedReturnNULL "bufferGetVideoMetaId" result+    result' <- (newPtr GstVideo.VideoMeta.VideoMeta) result+    touchManagedPtr buffer+    return result'+++-- function gst_buffer_get_video_meta+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_get_video_meta" gst_buffer_get_video_meta :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    IO (Ptr GstVideo.VideoMeta.VideoMeta)++{- |+Find the 'GI.GstVideo.Structs.VideoMeta.VideoMeta' on /@buffer@/ with the lowest /@id@/.++Buffers can contain multiple 'GI.GstVideo.Structs.VideoMeta.VideoMeta' metadata items when dealing with+multiview buffers.+-}+bufferGetVideoMeta ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -}+    -> m GstVideo.VideoMeta.VideoMeta+    {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoMeta.VideoMeta' with lowest id (usually 0) or 'Nothing' when there+is no such metadata on /@buffer@/. -}+bufferGetVideoMeta buffer = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    result <- gst_buffer_get_video_meta buffer'+    checkUnexpectedReturnNULL "bufferGetVideoMeta" result+    result' <- (newPtr GstVideo.VideoMeta.VideoMeta) result+    touchManagedPtr buffer+    return result'+++-- function gst_buffer_add_video_time_code_meta_full+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "framerate numerator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "framerate denominator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "latest_daily_jam", argType = TInterface (Name {namespace = "GLib", name = "DateTime"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDateTime for the latest daily jam", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCodeFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hours", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "hours since the daily jam", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minutes", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "minutes since the daily jam", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seconds", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "seconds since the daily jam", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frames", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "frames since the daily jam", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "fields since the daily jam", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeMeta"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_video_time_code_meta_full" gst_buffer_add_video_time_code_meta_full :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    Word32 ->                               -- fps_n : TBasicType TUInt+    Word32 ->                               -- fps_d : TBasicType TUInt+    Ptr GLib.DateTime.DateTime ->           -- latest_daily_jam : TInterface (Name {namespace = "GLib", name = "DateTime"})+    CUInt ->                                -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"})+    Word32 ->                               -- hours : TBasicType TUInt+    Word32 ->                               -- minutes : TBasicType TUInt+    Word32 ->                               -- seconds : TBasicType TUInt+    Word32 ->                               -- frames : TBasicType TUInt+    Word32 ->                               -- field_count : TBasicType TUInt+    IO (Ptr GstVideo.VideoTimeCodeMeta.VideoTimeCodeMeta)++{- |+Attaches 'GI.GstVideo.Structs.VideoTimeCodeMeta.VideoTimeCodeMeta' metadata to /@buffer@/ with the given+parameters.++/Since: 1.10/+-}+bufferAddVideoTimeCodeMetaFull ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -}+    -> Word32+    {- ^ /@fpsN@/: framerate numerator -}+    -> Word32+    {- ^ /@fpsD@/: framerate denominator -}+    -> GLib.DateTime.DateTime+    {- ^ /@latestDailyJam@/: a 'GI.GLib.Structs.DateTime.DateTime' for the latest daily jam -}+    -> [GstVideo.Flags.VideoTimeCodeFlags]+    {- ^ /@flags@/: a 'GI.GstVideo.Flags.VideoTimeCodeFlags' -}+    -> Word32+    {- ^ /@hours@/: hours since the daily jam -}+    -> Word32+    {- ^ /@minutes@/: minutes since the daily jam -}+    -> Word32+    {- ^ /@seconds@/: seconds since the daily jam -}+    -> Word32+    {- ^ /@frames@/: frames since the daily jam -}+    -> Word32+    {- ^ /@fieldCount@/: fields since the daily jam -}+    -> m GstVideo.VideoTimeCodeMeta.VideoTimeCodeMeta+    {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoTimeCodeMeta.VideoTimeCodeMeta' on /@buffer@/, or+(since 1.16) 'Nothing' if the timecode was invalid. -}+bufferAddVideoTimeCodeMetaFull buffer fpsN fpsD latestDailyJam flags hours minutes seconds frames fieldCount = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    latestDailyJam' <- unsafeManagedPtrGetPtr latestDailyJam+    let flags' = gflagsToWord flags+    result <- gst_buffer_add_video_time_code_meta_full buffer' fpsN fpsD latestDailyJam' flags' hours minutes seconds frames fieldCount+    checkUnexpectedReturnNULL "bufferAddVideoTimeCodeMetaFull" result+    result' <- (newPtr GstVideo.VideoTimeCodeMeta.VideoTimeCodeMeta) result+    touchManagedPtr buffer+    touchManagedPtr latestDailyJam+    return result'+++-- function gst_buffer_add_video_time_code_meta+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeMeta"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_video_time_code_meta" gst_buffer_add_video_time_code_meta :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    Ptr GstVideo.VideoTimeCode.VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"})+    IO (Ptr GstVideo.VideoTimeCodeMeta.VideoTimeCodeMeta)++{- |+Attaches 'GI.GstVideo.Structs.VideoTimeCodeMeta.VideoTimeCodeMeta' metadata to /@buffer@/ with the given+parameters.++/Since: 1.10/+-}+bufferAddVideoTimeCodeMeta ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -}+    -> GstVideo.VideoTimeCode.VideoTimeCode+    {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -}+    -> m (Maybe GstVideo.VideoTimeCodeMeta.VideoTimeCodeMeta)+    {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoTimeCodeMeta.VideoTimeCodeMeta' on /@buffer@/, or+(since 1.16) 'Nothing' if the timecode was invalid. -}+bufferAddVideoTimeCodeMeta buffer tc = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    tc' <- unsafeManagedPtrGetPtr tc+    result <- gst_buffer_add_video_time_code_meta buffer' tc'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newPtr GstVideo.VideoTimeCodeMeta.VideoTimeCodeMeta) result'+        return result''+    touchManagedPtr buffer+    touchManagedPtr tc+    return maybeResult+++-- function gst_buffer_add_video_region_of_interest_meta_id+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "roi_type", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Type of the region of interest (e.g. \"face\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "w", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "h", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoRegionOfInterestMeta"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_video_region_of_interest_meta_id" gst_buffer_add_video_region_of_interest_meta_id :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    Word32 ->                               -- roi_type : TBasicType TUInt32+    Word32 ->                               -- x : TBasicType TUInt+    Word32 ->                               -- y : TBasicType TUInt+    Word32 ->                               -- w : TBasicType TUInt+    Word32 ->                               -- h : TBasicType TUInt+    IO (Ptr GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta)++{- |+Attaches 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' metadata to /@buffer@/ with the given+parameters.+-}+bufferAddVideoRegionOfInterestMetaId ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -}+    -> Word32+    {- ^ /@roiType@/: Type of the region of interest (e.g. \"face\") -}+    -> Word32+    {- ^ /@x@/: X position -}+    -> Word32+    {- ^ /@y@/: Y position -}+    -> Word32+    {- ^ /@w@/: width -}+    -> Word32+    {- ^ /@h@/: height -}+    -> m GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta+    {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' on /@buffer@/. -}+bufferAddVideoRegionOfInterestMetaId buffer roiType x y w h = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    result <- gst_buffer_add_video_region_of_interest_meta_id buffer' roiType x y w h+    checkUnexpectedReturnNULL "bufferAddVideoRegionOfInterestMetaId" result+    result' <- (newPtr GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta) result+    touchManagedPtr buffer+    return result'+++-- function gst_buffer_add_video_region_of_interest_meta+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "roi_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Type of the region of interest (e.g. \"face\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "w", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "h", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoRegionOfInterestMeta"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_video_region_of_interest_meta" gst_buffer_add_video_region_of_interest_meta :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    CString ->                              -- roi_type : TBasicType TUTF8+    Word32 ->                               -- x : TBasicType TUInt+    Word32 ->                               -- y : TBasicType TUInt+    Word32 ->                               -- w : TBasicType TUInt+    Word32 ->                               -- h : TBasicType TUInt+    IO (Ptr GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta)++{- |+Attaches 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' metadata to /@buffer@/ with the given+parameters.+-}+bufferAddVideoRegionOfInterestMeta ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -}+    -> T.Text+    {- ^ /@roiType@/: Type of the region of interest (e.g. \"face\") -}+    -> Word32+    {- ^ /@x@/: X position -}+    -> Word32+    {- ^ /@y@/: Y position -}+    -> Word32+    {- ^ /@w@/: width -}+    -> Word32+    {- ^ /@h@/: height -}+    -> m GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta+    {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' on /@buffer@/. -}+bufferAddVideoRegionOfInterestMeta buffer roiType x y w h = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    roiType' <- textToCString roiType+    result <- gst_buffer_add_video_region_of_interest_meta buffer' roiType' x y w h+    checkUnexpectedReturnNULL "bufferAddVideoRegionOfInterestMeta" result+    result' <- (newPtr GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta) result+    touchManagedPtr buffer+    freeMem roiType'+    return result'+++-- function gst_buffer_add_video_overlay_composition_meta+-- Args : [Arg {argCName = "buf", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "comp", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayComposition", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoOverlayCompositionMeta"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_video_overlay_composition_meta" gst_buffer_add_video_overlay_composition_meta :: +    Ptr Gst.Buffer.Buffer ->                -- buf : TInterface (Name {namespace = "Gst", name = "Buffer"})+    Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition -> -- comp : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"})+    IO (Ptr GstVideo.VideoOverlayCompositionMeta.VideoOverlayCompositionMeta)++{- |+Sets an overlay composition on a buffer. The buffer will obtain its own+reference to the composition, meaning this function does not take ownership+of /@comp@/.+-}+bufferAddVideoOverlayCompositionMeta ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buf@/: a 'GI.Gst.Structs.Buffer.Buffer' -}+    -> Maybe (GstVideo.VideoOverlayComposition.VideoOverlayComposition)+    {- ^ /@comp@/: a 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' -}+    -> m GstVideo.VideoOverlayCompositionMeta.VideoOverlayCompositionMeta+    {- ^ __Returns:__ a 'GI.GstVideo.Structs.VideoOverlayCompositionMeta.VideoOverlayCompositionMeta' -}+bufferAddVideoOverlayCompositionMeta buf comp = liftIO $ do+    buf' <- unsafeManagedPtrGetPtr buf+    maybeComp <- case comp of+        Nothing -> return nullPtr+        Just jComp -> do+            jComp' <- unsafeManagedPtrGetPtr jComp+            return jComp'+    result <- gst_buffer_add_video_overlay_composition_meta buf' maybeComp+    checkUnexpectedReturnNULL "bufferAddVideoOverlayCompositionMeta" result+    result' <- (newPtr GstVideo.VideoOverlayCompositionMeta.VideoOverlayCompositionMeta) result+    touchManagedPtr buf+    whenJust comp touchManagedPtr+    return result'+++-- function gst_buffer_add_video_meta_full+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrameFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoFrameFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_planes", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TCArray False 4 (-1) (TBasicType TUInt64), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "offset of each plane", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TCArray False 4 (-1) (TBasicType TInt), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "stride of each plane", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_video_meta_full" gst_buffer_add_video_meta_full :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    CUInt ->                                -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoFrameFlags"})+    CUInt ->                                -- format : TInterface (Name {namespace = "GstVideo", name = "VideoFormat"})+    Word32 ->                               -- width : TBasicType TUInt+    Word32 ->                               -- height : TBasicType TUInt+    Word32 ->                               -- n_planes : TBasicType TUInt+    Ptr Word64 ->                           -- offset : TCArray False 4 (-1) (TBasicType TUInt64)+    Ptr Int32 ->                            -- stride : TCArray False 4 (-1) (TBasicType TInt)+    IO (Ptr GstVideo.VideoMeta.VideoMeta)++{- |+Attaches GstVideoMeta metadata to /@buffer@/ with the given parameters.+-}+bufferAddVideoMetaFull ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -}+    -> [GstVideo.Flags.VideoFrameFlags]+    {- ^ /@flags@/: 'GI.GstVideo.Flags.VideoFrameFlags' -}+    -> GstVideo.Enums.VideoFormat+    {- ^ /@format@/: a 'GI.GstVideo.Enums.VideoFormat' -}+    -> Word32+    {- ^ /@width@/: the width -}+    -> Word32+    {- ^ /@height@/: the height -}+    -> Word32+    {- ^ /@nPlanes@/: number of planes -}+    -> [Word64]+    {- ^ /@offset@/: offset of each plane -}+    -> [Int32]+    {- ^ /@stride@/: stride of each plane -}+    -> m GstVideo.VideoMeta.VideoMeta+    {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoMeta.VideoMeta' on /@buffer@/. -}+bufferAddVideoMetaFull buffer flags format width height nPlanes offset stride = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    let flags' = gflagsToWord flags+    let format' = (fromIntegral . fromEnum) format+    offset' <- packStorableArray offset+    stride' <- packStorableArray stride+    result <- gst_buffer_add_video_meta_full buffer' flags' format' width height nPlanes offset' stride'+    checkUnexpectedReturnNULL "bufferAddVideoMetaFull" result+    result' <- (newPtr GstVideo.VideoMeta.VideoMeta) result+    touchManagedPtr buffer+    freeMem offset'+    freeMem stride'+    return result'+++-- function gst_buffer_add_video_meta+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrameFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoFrameFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_video_meta" gst_buffer_add_video_meta :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    CUInt ->                                -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoFrameFlags"})+    CUInt ->                                -- format : TInterface (Name {namespace = "GstVideo", name = "VideoFormat"})+    Word32 ->                               -- width : TBasicType TUInt+    Word32 ->                               -- height : TBasicType TUInt+    IO (Ptr GstVideo.VideoMeta.VideoMeta)++{- |+Attaches GstVideoMeta metadata to /@buffer@/ with the given parameters and the+default offsets and strides for /@format@/ and /@width@/ x /@height@/.++This function calculates the default offsets and strides and then calls+'GI.GstVideo.Functions.bufferAddVideoMetaFull' with them.+-}+bufferAddVideoMeta ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -}+    -> [GstVideo.Flags.VideoFrameFlags]+    {- ^ /@flags@/: 'GI.GstVideo.Flags.VideoFrameFlags' -}+    -> GstVideo.Enums.VideoFormat+    {- ^ /@format@/: a 'GI.GstVideo.Enums.VideoFormat' -}+    -> Word32+    {- ^ /@width@/: the width -}+    -> Word32+    {- ^ /@height@/: the height -}+    -> m GstVideo.VideoMeta.VideoMeta+    {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoMeta.VideoMeta' on /@buffer@/. -}+bufferAddVideoMeta buffer flags format width height = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    let flags' = gflagsToWord flags+    let format' = (fromIntegral . fromEnum) format+    result <- gst_buffer_add_video_meta buffer' flags' format' width height+    checkUnexpectedReturnNULL "bufferAddVideoMeta" result+    result' <- (newPtr GstVideo.VideoMeta.VideoMeta) result+    touchManagedPtr buffer+    return result'+++-- function gst_buffer_add_video_gl_texture_upload_meta+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "texture_orientation", argType = TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureOrientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstVideoGLTextureOrientation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_textures", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of textures", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "texture_type", argType = TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "array of #GstVideoGLTextureType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "upload", argType = TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureUpload"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the function to upload the buffer to a specific texture ID", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data for the implementor of @upload", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data_copy", argType = TInterface (Name {namespace = "GObject", name = "BoxedCopyFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "function to copy @user_data", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data_free", argType = TInterface (Name {namespace = "GObject", name = "BoxedFreeFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "function to free @user_data", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureUploadMeta"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_video_gl_texture_upload_meta" gst_buffer_add_video_gl_texture_upload_meta :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    CUInt ->                                -- texture_orientation : TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureOrientation"})+    Word32 ->                               -- n_textures : TBasicType TUInt+    CUInt ->                                -- texture_type : TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureType"})+    FunPtr GstVideo.Callbacks.C_VideoGLTextureUpload -> -- upload : TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureUpload"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GObject.Callbacks.C_BoxedCopyFunc -> -- user_data_copy : TInterface (Name {namespace = "GObject", name = "BoxedCopyFunc"})+    FunPtr GObject.Callbacks.C_BoxedFreeFunc -> -- user_data_free : TInterface (Name {namespace = "GObject", name = "BoxedFreeFunc"})+    IO (Ptr GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta)++{- |+Attaches GstVideoGLTextureUploadMeta metadata to /@buffer@/ with the given+parameters.+-}+bufferAddVideoGlTextureUploadMeta ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -}+    -> GstVideo.Enums.VideoGLTextureOrientation+    {- ^ /@textureOrientation@/: the 'GI.GstVideo.Enums.VideoGLTextureOrientation' -}+    -> Word32+    {- ^ /@nTextures@/: the number of textures -}+    -> GstVideo.Enums.VideoGLTextureType+    {- ^ /@textureType@/: array of 'GI.GstVideo.Enums.VideoGLTextureType' -}+    -> GstVideo.Callbacks.VideoGLTextureUpload+    {- ^ /@upload@/: the function to upload the buffer to a specific texture ID -}+    -> GObject.Callbacks.BoxedCopyFunc+    {- ^ /@userDataCopy@/: function to copy /@userData@/ -}+    -> GObject.Callbacks.BoxedFreeFunc+    {- ^ /@userDataFree@/: function to free /@userData@/ -}+    -> m GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta+    {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta' on /@buffer@/. -}+bufferAddVideoGlTextureUploadMeta buffer textureOrientation nTextures textureType upload userDataCopy userDataFree = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    let textureOrientation' = (fromIntegral . fromEnum) textureOrientation+    let textureType' = (fromIntegral . fromEnum) textureType+    upload' <- GstVideo.Callbacks.mk_VideoGLTextureUpload (GstVideo.Callbacks.wrap_VideoGLTextureUpload Nothing upload)+    userDataCopy' <- GObject.Callbacks.mk_BoxedCopyFunc (GObject.Callbacks.wrap_BoxedCopyFunc Nothing userDataCopy)+    userDataFree' <- GObject.Callbacks.mk_BoxedFreeFunc (GObject.Callbacks.wrap_BoxedFreeFunc Nothing userDataFree)+    let userData = nullPtr+    result <- gst_buffer_add_video_gl_texture_upload_meta buffer' textureOrientation' nTextures textureType' upload' userData userDataCopy' userDataFree'+    checkUnexpectedReturnNULL "bufferAddVideoGlTextureUploadMeta" result+    result' <- (newPtr GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta) result+    safeFreeFunPtr $ castFunPtrToPtr upload'+    safeFreeFunPtr $ castFunPtrToPtr userDataCopy'+    safeFreeFunPtr $ castFunPtrToPtr userDataFree'+    touchManagedPtr buffer+    return result'+++-- function gst_buffer_add_video_caption_meta+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caption_type", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCaptionType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The type of Closed Caption to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The Closed Caption data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The size of @data in bytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The size of @data in bytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCaptionMeta"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_video_caption_meta" gst_buffer_add_video_caption_meta :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    CUInt ->                                -- caption_type : TInterface (Name {namespace = "GstVideo", name = "VideoCaptionType"})+    Ptr Word8 ->                            -- data : TCArray False (-1) 3 (TBasicType TUInt8)+    Word64 ->                               -- size : TBasicType TUInt64+    IO (Ptr GstVideo.VideoCaptionMeta.VideoCaptionMeta)++{- |+Attaches 'GI.GstVideo.Structs.VideoCaptionMeta.VideoCaptionMeta' metadata to /@buffer@/ with the given+parameters.++/Since: 1.16/+-}+bufferAddVideoCaptionMeta ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -}+    -> GstVideo.Enums.VideoCaptionType+    {- ^ /@captionType@/: The type of Closed Caption to add -}+    -> ByteString+    {- ^ /@data@/: The Closed Caption data -}+    -> m GstVideo.VideoCaptionMeta.VideoCaptionMeta+    {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoCaptionMeta.VideoCaptionMeta' on /@buffer@/. -}+bufferAddVideoCaptionMeta buffer captionType data_ = liftIO $ do+    let size = fromIntegral $ B.length data_+    buffer' <- unsafeManagedPtrGetPtr buffer+    let captionType' = (fromIntegral . fromEnum) captionType+    data_' <- packByteString data_+    result <- gst_buffer_add_video_caption_meta buffer' captionType' data_' size+    checkUnexpectedReturnNULL "bufferAddVideoCaptionMeta" result+    result' <- (newPtr GstVideo.VideoCaptionMeta.VideoCaptionMeta) result+    touchManagedPtr buffer+    freeMem data_'+    return result'+++-- function gst_buffer_add_video_affine_transformation_meta+-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoAffineTransformationMeta"}))+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_video_affine_transformation_meta" gst_buffer_add_video_affine_transformation_meta :: +    Ptr Gst.Buffer.Buffer ->                -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"})+    IO (Ptr GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta)++{- |+Attaches GstVideoAffineTransformationMeta metadata to /@buffer@/ with+the given parameters.++/Since: 1.8/+-}+bufferAddVideoAffineTransformationMeta ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Gst.Buffer.Buffer+    {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -}+    -> m GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta+    {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoAffineTransformationMeta.VideoAffineTransformationMeta' on /@buffer@/. -}+bufferAddVideoAffineTransformationMeta buffer = liftIO $ do+    buffer' <- unsafeManagedPtrGetPtr buffer+    result <- gst_buffer_add_video_affine_transformation_meta buffer'+    checkUnexpectedReturnNULL "bufferAddVideoAffineTransformationMeta" result+    result' <- (newPtr GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta) result+    touchManagedPtr buffer+    return result'+++