packages feed

gi-gstvideo (empty) → 0.1.6.13

raw patch · 77 files changed

+14438/−0 lines, 77 filesdep +basedep +bytestringdep +containerssetup-changed

Dependencies added: base, bytestring, containers, gi-glib, gi-gobject, gi-gst, gi-gstbase, haskell-gi-base, text, transformers

Files

+ GI/GstVideo.hs view
@@ -0,0 +1,47 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++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 Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++import Data.GI.Base+-- APIObject "VideoMultiviewFlagsSet" does not descend from GObject, it will be ignored.+
+ GI/GstVideo/Callbacks.hs view
@@ -0,0 +1,343 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Callbacks+    ( ++ -- * Signals+-- ** VideoConvertSampleCallback+    VideoConvertSampleCallback              ,+    VideoConvertSampleCallbackC             ,+    mkVideoConvertSampleCallback            ,+    noVideoConvertSampleCallback            ,+    videoConvertSampleCallbackClosure       ,+    videoConvertSampleCallbackWrapper       ,+++-- ** VideoFormatPack+    VideoFormatPack                         ,+    VideoFormatPackC                        ,+    mkVideoFormatPack                       ,+    noVideoFormatPack                       ,+    videoFormatPackClosure                  ,+    videoFormatPackWrapper                  ,+++-- ** VideoFormatUnpack+    VideoFormatUnpack                       ,+    VideoFormatUnpackC                      ,+    mkVideoFormatUnpack                     ,+    noVideoFormatUnpack                     ,+    videoFormatUnpackClosure                ,+    videoFormatUnpackWrapper                ,+++-- ** VideoGLTextureUpload+    VideoGLTextureUpload                    ,+    VideoGLTextureUploadC                   ,+    mkVideoGLTextureUpload                  ,+    noVideoGLTextureUpload                  ,+    videoGLTextureUploadClosure             ,+    videoGLTextureUploadWrapper             ,+++-- ** VideoMetaMapFieldCallback+    VideoMetaMapFieldCallback               ,+    VideoMetaMapFieldCallbackC              ,+    mkVideoMetaMapFieldCallback             ,+    noVideoMetaMapFieldCallback             ,+    videoMetaMapFieldCallbackClosure        ,+    videoMetaMapFieldCallbackWrapper        ,+++-- ** VideoMetaUnmapFieldCallback+    VideoMetaUnmapFieldCallback             ,+    VideoMetaUnmapFieldCallbackC            ,+    mkVideoMetaUnmapFieldCallback           ,+    noVideoMetaUnmapFieldCallback           ,+    videoMetaUnmapFieldCallbackClosure      ,+    videoMetaUnmapFieldCallbackWrapper      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types++import qualified GI.Gst as Gst++-- callback VideoMetaUnmapFieldCallback+videoMetaUnmapFieldCallbackClosure :: VideoMetaUnmapFieldCallback -> IO Closure+videoMetaUnmapFieldCallbackClosure cb = newCClosure =<< mkVideoMetaUnmapFieldCallback wrapped+    where wrapped = videoMetaUnmapFieldCallbackWrapper Nothing cb++type VideoMetaUnmapFieldCallbackC =+    Ptr VideoMeta ->+    Word32 ->+    Ptr Gst.MapInfo ->+    IO CInt++foreign import ccall "wrapper"+    mkVideoMetaUnmapFieldCallback :: VideoMetaUnmapFieldCallbackC -> IO (FunPtr VideoMetaUnmapFieldCallbackC)++type VideoMetaUnmapFieldCallback =+    VideoMeta ->+    Word32 ->+    Gst.MapInfo ->+    IO Bool++noVideoMetaUnmapFieldCallback :: Maybe VideoMetaUnmapFieldCallback+noVideoMetaUnmapFieldCallback = Nothing++videoMetaUnmapFieldCallbackWrapper ::+    Maybe (Ptr (FunPtr (VideoMetaUnmapFieldCallbackC))) ->+    VideoMetaUnmapFieldCallback ->+    Ptr VideoMeta ->+    Word32 ->+    Ptr Gst.MapInfo ->+    IO CInt+videoMetaUnmapFieldCallbackWrapper funptrptr _cb meta plane info = do+    meta' <- (newPtr 112 VideoMeta) meta+    info' <- (newPtr 104 Gst.MapInfo) info+    result <- _cb  meta' plane info'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback VideoMetaMapFieldCallback+videoMetaMapFieldCallbackClosure :: VideoMetaMapFieldCallback -> IO Closure+videoMetaMapFieldCallbackClosure cb = newCClosure =<< mkVideoMetaMapFieldCallback wrapped+    where wrapped = videoMetaMapFieldCallbackWrapper Nothing cb++type VideoMetaMapFieldCallbackC =+    Ptr VideoMeta ->+    Word32 ->+    Ptr Gst.MapInfo ->+    Ptr () ->+    Int32 ->+    CUInt ->+    IO CInt++foreign import ccall "wrapper"+    mkVideoMetaMapFieldCallback :: VideoMetaMapFieldCallbackC -> IO (FunPtr VideoMetaMapFieldCallbackC)++type VideoMetaMapFieldCallback =+    VideoMeta ->+    Word32 ->+    Gst.MapInfo ->+    Ptr () ->+    Int32 ->+    [Gst.MapFlags] ->+    IO Bool++noVideoMetaMapFieldCallback :: Maybe VideoMetaMapFieldCallback+noVideoMetaMapFieldCallback = Nothing++videoMetaMapFieldCallbackWrapper ::+    Maybe (Ptr (FunPtr (VideoMetaMapFieldCallbackC))) ->+    VideoMetaMapFieldCallback ->+    Ptr VideoMeta ->+    Word32 ->+    Ptr Gst.MapInfo ->+    Ptr () ->+    Int32 ->+    CUInt ->+    IO CInt+videoMetaMapFieldCallbackWrapper funptrptr _cb meta plane info data_ stride flags = do+    meta' <- (newPtr 112 VideoMeta) meta+    info' <- (newPtr 104 Gst.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+videoGLTextureUploadClosure :: VideoGLTextureUpload -> IO Closure+videoGLTextureUploadClosure cb = newCClosure =<< mkVideoGLTextureUpload wrapped+    where wrapped = videoGLTextureUploadWrapper Nothing cb++type VideoGLTextureUploadC =+    Ptr VideoGLTextureUploadMeta ->+    Word32 ->+    IO CInt++foreign import ccall "wrapper"+    mkVideoGLTextureUpload :: VideoGLTextureUploadC -> IO (FunPtr VideoGLTextureUploadC)++type VideoGLTextureUpload =+    VideoGLTextureUploadMeta ->+    Word32 ->+    IO Bool++noVideoGLTextureUpload :: Maybe VideoGLTextureUpload+noVideoGLTextureUpload = Nothing++videoGLTextureUploadWrapper ::+    Maybe (Ptr (FunPtr (VideoGLTextureUploadC))) ->+    VideoGLTextureUpload ->+    Ptr VideoGLTextureUploadMeta ->+    Word32 ->+    IO CInt+videoGLTextureUploadWrapper funptrptr _cb meta textureId = do+    meta' <- (newPtr 80 VideoGLTextureUploadMeta) meta+    result <- _cb  meta' textureId+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback VideoFormatUnpack+videoFormatUnpackClosure :: VideoFormatUnpack -> IO Closure+videoFormatUnpackClosure cb = newCClosure =<< mkVideoFormatUnpack wrapped+    where wrapped = videoFormatUnpackWrapper Nothing cb++type VideoFormatUnpackC =+    Ptr VideoFormatInfo ->+    CUInt ->+    Ptr () ->+    Ptr () ->+    Int32 ->+    Int32 ->+    Int32 ->+    Int32 ->+    IO ()++foreign import ccall "wrapper"+    mkVideoFormatUnpack :: VideoFormatUnpackC -> IO (FunPtr VideoFormatUnpackC)++type VideoFormatUnpack =+    VideoFormatInfo ->+    [VideoPackFlags] ->+    Ptr () ->+    Ptr () ->+    Int32 ->+    Int32 ->+    Int32 ->+    Int32 ->+    IO ()++noVideoFormatUnpack :: Maybe VideoFormatUnpack+noVideoFormatUnpack = Nothing++videoFormatUnpackWrapper ::+    Maybe (Ptr (FunPtr (VideoFormatUnpackC))) ->+    VideoFormatUnpack ->+    Ptr VideoFormatInfo ->+    CUInt ->+    Ptr () ->+    Ptr () ->+    Int32 ->+    Int32 ->+    Int32 ->+    Int32 ->+    IO ()+videoFormatUnpackWrapper funptrptr _cb info flags dest data_ stride x y width = do+    info' <- (newPtr 232 VideoFormatInfo) info+    let flags' = wordToGFlags flags+    _cb  info' flags' dest data_ stride x y width+    maybeReleaseFunPtr funptrptr++-- callback VideoFormatPack+videoFormatPackClosure :: VideoFormatPack -> IO Closure+videoFormatPackClosure cb = newCClosure =<< mkVideoFormatPack wrapped+    where wrapped = videoFormatPackWrapper Nothing cb++type VideoFormatPackC =+    Ptr VideoFormatInfo ->+    CUInt ->+    Ptr () ->+    Int32 ->+    Ptr () ->+    Int32 ->+    CUInt ->+    Int32 ->+    Int32 ->+    IO ()++foreign import ccall "wrapper"+    mkVideoFormatPack :: VideoFormatPackC -> IO (FunPtr VideoFormatPackC)++type VideoFormatPack =+    VideoFormatInfo ->+    [VideoPackFlags] ->+    Ptr () ->+    Int32 ->+    Ptr () ->+    Int32 ->+    [VideoChromaSite] ->+    Int32 ->+    Int32 ->+    IO ()++noVideoFormatPack :: Maybe VideoFormatPack+noVideoFormatPack = Nothing++videoFormatPackWrapper ::+    Maybe (Ptr (FunPtr (VideoFormatPackC))) ->+    VideoFormatPack ->+    Ptr VideoFormatInfo ->+    CUInt ->+    Ptr () ->+    Int32 ->+    Ptr () ->+    Int32 ->+    CUInt ->+    Int32 ->+    Int32 ->+    IO ()+videoFormatPackWrapper funptrptr _cb info flags src sstride data_ stride chromaSite y width = do+    info' <- (newPtr 232 VideoFormatInfo) info+    let flags' = wordToGFlags flags+    let chromaSite' = wordToGFlags chromaSite+    _cb  info' flags' src sstride data_ stride chromaSite' y width+    maybeReleaseFunPtr funptrptr++-- callback VideoConvertSampleCallback+videoConvertSampleCallbackClosure :: VideoConvertSampleCallback -> IO Closure+videoConvertSampleCallbackClosure cb = newCClosure =<< mkVideoConvertSampleCallback wrapped+    where wrapped = videoConvertSampleCallbackWrapper Nothing cb++type VideoConvertSampleCallbackC =+    Ptr Gst.Sample ->+    Ptr GError ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkVideoConvertSampleCallback :: VideoConvertSampleCallbackC -> IO (FunPtr VideoConvertSampleCallbackC)++type VideoConvertSampleCallback =+    Gst.Sample ->+    GError ->+    IO ()++noVideoConvertSampleCallback :: Maybe VideoConvertSampleCallback+noVideoConvertSampleCallback = Nothing++videoConvertSampleCallbackWrapper ::+    Maybe (Ptr (FunPtr (VideoConvertSampleCallbackC))) ->+    VideoConvertSampleCallback ->+    Ptr Gst.Sample ->+    Ptr GError ->+    Ptr () ->+    IO ()+videoConvertSampleCallbackWrapper funptrptr _cb sample error_ _ = do+    sample' <- (newBoxed Gst.Sample) sample+    error_' <- (newBoxed GError) error_+    _cb  sample' error_'+    maybeReleaseFunPtr funptrptr++
+ GI/GstVideo/Constants.hs view
@@ -0,0 +1,293 @@+{-# 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 (garetxe@gmail.com)+-}++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_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 BUFFER_POOL_OPTION_VIDEO_META   ,+    pattern BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META,+    pattern BUFFER_POOL_OPTION_VIDEO_ALIGNMENT,++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+++pattern VIDEO_TILE_Y_TILES_SHIFT = 16 :: Int32+++pattern VIDEO_TILE_X_TILES_MASK = 0 :: Int32+++pattern VIDEO_TILE_TYPE_SHIFT = 16 :: Int32+++pattern VIDEO_TILE_TYPE_MASK = 0 :: Int32+++pattern VIDEO_SIZE_RANGE = "(int) [ 1, max ]" :: T.Text+++pattern VIDEO_SCALER_OPT_DITHER_METHOD = "GstVideoScaler.dither-method" :: T.Text+++pattern VIDEO_RESAMPLER_OPT_SHARPNESS = "GstVideoResampler.sharpness" :: T.Text+++pattern VIDEO_RESAMPLER_OPT_SHARPEN = "GstVideoResampler.sharpen" :: T.Text+++pattern VIDEO_RESAMPLER_OPT_MAX_TAPS = "GstVideoResampler.max-taps" :: T.Text+++pattern VIDEO_RESAMPLER_OPT_ENVELOPE = "GstVideoResampler.envelope" :: T.Text+++pattern VIDEO_RESAMPLER_OPT_CUBIC_C = "GstVideoResampler.cubic-c" :: T.Text+++pattern VIDEO_RESAMPLER_OPT_CUBIC_B = "GstVideoResampler.cubic-b" :: T.Text+++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+++pattern VIDEO_MAX_PLANES = 4 :: Int32+++pattern VIDEO_MAX_COMPONENTS = 4 :: Int32+++pattern VIDEO_FPS_RANGE = "(fraction) [ 0, max ]" :: T.Text+++pattern VIDEO_FORMATS_ALL = "{ I420, YV12, YUY2, UYVY, AYUV, RGBx, BGRx, xRGB, xBGR, RGBA, BGRA, ARGB, ABGR, RGB, BGR, Y41B, Y42B, YVYU, Y444, v210, v216, NV12, NV21, NV16, NV61, NV24, GRAY8, GRAY16_BE, GRAY16_LE, v308, RGB16, BGR16, RGB15, BGR15, UYVP, A420, RGB8P, YUV9, YVU9, IYU1, ARGB64, AYUV64, r210, I420_10LE, I420_10BE, I422_10LE, I422_10BE,  Y444_10LE, Y444_10BE, GBR, GBR_10LE, GBR_10BE, NV12_64Z32, A420_10LE,  A420_10BE, A422_10LE, A422_10BE, A444_10LE, A444_10BE }" :: T.Text+++pattern VIDEO_ENCODER_SRC_NAME = "src" :: T.Text+++pattern VIDEO_ENCODER_SINK_NAME = "sink" :: T.Text+++pattern VIDEO_DECODER_SRC_NAME = "src" :: T.Text+++pattern VIDEO_DECODER_SINK_NAME = "sink" :: T.Text+++pattern VIDEO_DECODER_MAX_ERRORS = 10 :: Int32+++pattern VIDEO_CONVERTER_OPT_SRC_Y = "GstVideoConverter.src-y" :: T.Text+++pattern VIDEO_CONVERTER_OPT_SRC_X = "GstVideoConverter.src-x" :: T.Text+++pattern VIDEO_CONVERTER_OPT_SRC_WIDTH = "GstVideoConverter.src-width" :: T.Text+++pattern VIDEO_CONVERTER_OPT_SRC_HEIGHT = "GstVideoConverter.src-height" :: T.Text+++pattern VIDEO_CONVERTER_OPT_RESAMPLER_TAPS = "GstVideoConverter.resampler-taps" :: T.Text+++pattern VIDEO_CONVERTER_OPT_RESAMPLER_METHOD = "GstVideoConverter.resampler-method" :: T.Text+++pattern VIDEO_CONVERTER_OPT_PRIMARIES_MODE = "GstVideoConverter.primaries-mode" :: T.Text+++pattern VIDEO_CONVERTER_OPT_MATRIX_MODE = "GstVideoConverter.matrix-mode" :: T.Text+++pattern VIDEO_CONVERTER_OPT_GAMMA_MODE = "GstVideoConverter.gamma-mode" :: T.Text+++pattern VIDEO_CONVERTER_OPT_FILL_BORDER = "GstVideoConverter.fill-border" :: T.Text+++pattern VIDEO_CONVERTER_OPT_DITHER_QUANTIZATION = "GstVideoConverter.dither-quantization" :: T.Text+++pattern VIDEO_CONVERTER_OPT_DITHER_METHOD = "GstVideoConverter.dither-method" :: T.Text+++pattern VIDEO_CONVERTER_OPT_DEST_Y = "GstVideoConverter.dest-y" :: T.Text+++pattern VIDEO_CONVERTER_OPT_DEST_X = "GstVideoConverter.dest-x" :: T.Text+++pattern VIDEO_CONVERTER_OPT_DEST_WIDTH = "GstVideoConverter.dest-width" :: T.Text+++pattern VIDEO_CONVERTER_OPT_DEST_HEIGHT = "GstVideoConverter.dest-height" :: T.Text+++pattern VIDEO_CONVERTER_OPT_CHROMA_RESAMPLER_METHOD = "GstVideoConverter.chroma-resampler-method" :: T.Text+++pattern VIDEO_CONVERTER_OPT_CHROMA_MODE = "GstVideoConverter.chroma-mode" :: T.Text+++pattern VIDEO_CONVERTER_OPT_BORDER_ARGB = "GstVideoConverter.border-argb" :: T.Text+++pattern VIDEO_CONVERTER_OPT_ALPHA_VALUE = "GstVideoConverter.alpha-value" :: T.Text+++pattern VIDEO_CONVERTER_OPT_ALPHA_MODE = "GstVideoConverter.alpha-mode" :: T.Text+++pattern VIDEO_COMP_Y = 0 :: Int32+++pattern VIDEO_COMP_V = 2 :: Int32+++pattern VIDEO_COMP_U = 1 :: Int32+++pattern VIDEO_COMP_R = 0 :: Int32+++pattern VIDEO_COMP_PALETTE = 1 :: Int32+++pattern VIDEO_COMP_INDEX = 0 :: Int32+++pattern VIDEO_COMP_G = 1 :: Int32+++pattern VIDEO_COMP_B = 2 :: Int32+++pattern VIDEO_COMP_A = 3 :: Int32+++pattern VIDEO_COLORIMETRY_SRGB = "sRGB" :: T.Text+++pattern VIDEO_COLORIMETRY_SMPTE240M = "smpte240m" :: T.Text+++pattern VIDEO_COLORIMETRY_BT709 = "bt709" :: T.Text+++pattern VIDEO_COLORIMETRY_BT601 = "bt601" :: T.Text+++pattern VIDEO_COLORIMETRY_BT2020 = "bt2020" :: T.Text+++pattern META_TAG_VIDEO_STR = "video" :: T.Text+++pattern META_TAG_VIDEO_SIZE_STR = "size" :: T.Text+++pattern META_TAG_VIDEO_ORIENTATION_STR = "orientation" :: T.Text+++pattern META_TAG_VIDEO_COLORSPACE_STR = "colorspace" :: T.Text+++pattern CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION = "meta:GstVideoOverlayComposition" :: T.Text+++pattern CAPS_FEATURE_META_GST_VIDEO_META = "meta:GstVideoMeta" :: T.Text+++pattern CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META = "meta:GstVideoGLTextureUploadMeta" :: T.Text+++pattern BUFFER_POOL_OPTION_VIDEO_META = "GstBufferPoolOptionVideoMeta" :: T.Text+++pattern BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META = "GstBufferPoolOptionVideoGLTextureUploadMeta" :: T.Text+++pattern BUFFER_POOL_OPTION_VIDEO_ALIGNMENT = "GstBufferPoolOptionVideoAlignment" :: T.Text++
+ GI/GstVideo/Enums.hs view
@@ -0,0 +1,1083 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Enums+    ( ++-- * Exported types+    VideoTransferFunction(..)               ,+    VideoTileType(..)                       ,+    VideoTileMode(..)                       ,+    VideoResamplerMethod(..)                ,+    VideoResamplerFlags(..)                 ,+    VideoPrimariesMode(..)                  ,+    VideoOverlayFormatFlags(..)             ,+    VideoMultiviewMode(..)                  ,+    VideoMultiviewFramePacking(..)          ,+    VideoMatrixMode(..)                     ,+    VideoInterlaceMode(..)                  ,+    VideoGammaMode(..)                      ,+    VideoGLTextureType(..)                  ,+    VideoGLTextureOrientation(..)           ,+    VideoFormat(..)                         ,+    VideoDitherMethod(..)                   ,+    VideoColorRange(..)                     ,+    VideoColorPrimaries(..)                 ,+    VideoColorMatrix(..)                    ,+    VideoChromaMode(..)                     ,+    VideoChromaMethod(..)                   ,+    VideoAlphaMode(..)                      ,+    NavigationQueryType(..)                 ,+    NavigationMessageType(..)               ,+    NavigationEventType(..)                 ,+    NavigationCommand(..)                   ,+    ColorBalanceType(..)                    ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+++++-- Enum VideoTransferFunction++data VideoTransferFunction = +      VideoTransferFunctionUnknown+    | VideoTransferFunctionGamma10+    | VideoTransferFunctionGamma18+    | VideoTransferFunctionGamma20+    | VideoTransferFunctionGamma22+    | VideoTransferFunctionBt709+    | VideoTransferFunctionSmpte240m+    | VideoTransferFunctionSrgb+    | VideoTransferFunctionGamma28+    | VideoTransferFunctionLog100+    | VideoTransferFunctionLog316+    | VideoTransferFunctionBt202012+    | AnotherVideoTransferFunction Int+    deriving (Show, Eq)++instance 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 (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 k = AnotherVideoTransferFunction k++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++data VideoTileType = +      VideoTileTypeIndexed+    | AnotherVideoTileType Int+    deriving (Show, Eq)++instance Enum VideoTileType where+    fromEnum VideoTileTypeIndexed = 0+    fromEnum (AnotherVideoTileType k) = k++    toEnum 0 = VideoTileTypeIndexed+    toEnum k = AnotherVideoTileType k++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++data VideoTileMode = +      VideoTileModeUnknown+    | VideoTileModeZflipz2x2+    | AnotherVideoTileMode Int+    deriving (Show, Eq)++instance Enum VideoTileMode where+    fromEnum VideoTileModeUnknown = 0+    fromEnum VideoTileModeZflipz2x2 = 65536+    fromEnum (AnotherVideoTileMode k) = k++    toEnum 0 = VideoTileModeUnknown+    toEnum 65536 = VideoTileModeZflipz2x2+    toEnum k = AnotherVideoTileMode k++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++data VideoResamplerMethod = +      VideoResamplerMethodNearest+    | VideoResamplerMethodLinear+    | VideoResamplerMethodCubic+    | VideoResamplerMethodSinc+    | VideoResamplerMethodLanczos+    | AnotherVideoResamplerMethod Int+    deriving (Show, Eq)++instance 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++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 VideoResamplerFlags++data VideoResamplerFlags = +      VideoResamplerFlagsNone+    | AnotherVideoResamplerFlags Int+    deriving (Show, Eq)++instance Enum VideoResamplerFlags where+    fromEnum VideoResamplerFlagsNone = 0+    fromEnum (AnotherVideoResamplerFlags k) = k++    toEnum 0 = VideoResamplerFlagsNone+    toEnum k = AnotherVideoResamplerFlags k++foreign import ccall "gst_video_resampler_flags_get_type" c_gst_video_resampler_flags_get_type :: +    IO GType++instance BoxedEnum VideoResamplerFlags where+    boxedEnumType _ = c_gst_video_resampler_flags_get_type++-- Enum VideoPrimariesMode++data VideoPrimariesMode = +      VideoPrimariesModeNone+    | VideoPrimariesModeMergeOnly+    | VideoPrimariesModeFast+    | AnotherVideoPrimariesMode Int+    deriving (Show, Eq)++instance 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++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 VideoOverlayFormatFlags++data VideoOverlayFormatFlags = +      VideoOverlayFormatFlagsNone+    | VideoOverlayFormatFlagsPremultipliedAlpha+    | VideoOverlayFormatFlagsGlobalAlpha+    | AnotherVideoOverlayFormatFlags Int+    deriving (Show, Eq)++instance 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++-- Enum VideoMultiviewMode++data VideoMultiviewMode = +      VideoMultiviewModeNone+    | VideoMultiviewModeMono+    | VideoMultiviewModeLeft+    | VideoMultiviewModeRight+    | VideoMultiviewModeSideBySide+    | VideoMultiviewModeSideBySideQuincunx+    | VideoMultiviewModeColumnInterleaved+    | VideoMultiviewModeRowInterleaved+    | VideoMultiviewModeTopBottom+    | VideoMultiviewModeCheckerboard+    | VideoMultiviewModeFrameByFrame+    | VideoMultiviewModeMultiviewFrameByFrame+    | VideoMultiviewModeSeparated+    | AnotherVideoMultiviewMode Int+    deriving (Show, Eq)++instance 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++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++data VideoMultiviewFramePacking = +      VideoMultiviewFramePackingNone+    | VideoMultiviewFramePackingMono+    | VideoMultiviewFramePackingLeft+    | VideoMultiviewFramePackingRight+    | VideoMultiviewFramePackingSideBySide+    | VideoMultiviewFramePackingSideBySideQuincunx+    | VideoMultiviewFramePackingColumnInterleaved+    | VideoMultiviewFramePackingRowInterleaved+    | VideoMultiviewFramePackingTopBottom+    | VideoMultiviewFramePackingCheckerboard+    | AnotherVideoMultiviewFramePacking Int+    deriving (Show, Eq)++instance 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++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++data VideoMatrixMode = +      VideoMatrixModeFull+    | VideoMatrixModeInputOnly+    | VideoMatrixModeOutputOnly+    | VideoMatrixModeNone+    | AnotherVideoMatrixMode Int+    deriving (Show, Eq)++instance 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++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++data VideoInterlaceMode = +      VideoInterlaceModeProgressive+    | VideoInterlaceModeInterleaved+    | VideoInterlaceModeMixed+    | VideoInterlaceModeFields+    | AnotherVideoInterlaceMode Int+    deriving (Show, Eq)++instance Enum VideoInterlaceMode where+    fromEnum VideoInterlaceModeProgressive = 0+    fromEnum VideoInterlaceModeInterleaved = 1+    fromEnum VideoInterlaceModeMixed = 2+    fromEnum VideoInterlaceModeFields = 3+    fromEnum (AnotherVideoInterlaceMode k) = k++    toEnum 0 = VideoInterlaceModeProgressive+    toEnum 1 = VideoInterlaceModeInterleaved+    toEnum 2 = VideoInterlaceModeMixed+    toEnum 3 = VideoInterlaceModeFields+    toEnum k = AnotherVideoInterlaceMode k++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++data VideoGammaMode = +      VideoGammaModeNone+    | VideoGammaModeRemap+    | AnotherVideoGammaMode Int+    deriving (Show, Eq)++instance Enum VideoGammaMode where+    fromEnum VideoGammaModeNone = 0+    fromEnum VideoGammaModeRemap = 1+    fromEnum (AnotherVideoGammaMode k) = k++    toEnum 0 = VideoGammaModeNone+    toEnum 1 = VideoGammaModeRemap+    toEnum k = AnotherVideoGammaMode k++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++data VideoGLTextureType = +      VideoGLTextureTypeLuminance+    | VideoGLTextureTypeLuminanceAlpha+    | VideoGLTextureTypeRgb16+    | VideoGLTextureTypeRgb+    | VideoGLTextureTypeRgba+    | VideoGLTextureTypeR+    | VideoGLTextureTypeRg+    | AnotherVideoGLTextureType Int+    deriving (Show, Eq)++instance 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++-- Enum VideoGLTextureOrientation++data VideoGLTextureOrientation = +      VideoGLTextureOrientationNormalYNormal+    | VideoGLTextureOrientationNormalYFlip+    | VideoGLTextureOrientationFlipYNormal+    | VideoGLTextureOrientationFlipYFlip+    | AnotherVideoGLTextureOrientation Int+    deriving (Show, Eq)++instance 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++-- Enum VideoFormat++data VideoFormat = +      VideoFormatUnknown+    | VideoFormatEncoded+    | VideoFormatI420+    | VideoFormatYv12+    | VideoFormatYuy2+    | VideoFormatUyvy+    | VideoFormatAyuv+    | VideoFormatRgbx+    | VideoFormatBgrx+    | VideoFormatXrgb+    | VideoFormatXbgr+    | VideoFormatRgba+    | VideoFormatBgra+    | VideoFormatArgb+    | VideoFormatAbgr+    | VideoFormatRgb+    | VideoFormatBgr+    | VideoFormatY41b+    | VideoFormatY42b+    | VideoFormatYvyu+    | VideoFormatY444+    | VideoFormatV210+    | VideoFormatV216+    | VideoFormatNv12+    | VideoFormatNv21+    | VideoFormatGray8+    | VideoFormatGray16Be+    | VideoFormatGray16Le+    | VideoFormatV308+    | VideoFormatRgb16+    | VideoFormatBgr16+    | VideoFormatRgb15+    | VideoFormatBgr15+    | VideoFormatUyvp+    | VideoFormatA420+    | VideoFormatRgb8p+    | VideoFormatYuv9+    | VideoFormatYvu9+    | VideoFormatIyu1+    | VideoFormatArgb64+    | VideoFormatAyuv64+    | VideoFormatR210+    | VideoFormatI42010be+    | VideoFormatI42010le+    | VideoFormatI42210be+    | VideoFormatI42210le+    | VideoFormatY44410be+    | VideoFormatY44410le+    | VideoFormatGbr+    | VideoFormatGbr10be+    | VideoFormatGbr10le+    | VideoFormatNv16+    | VideoFormatNv24+    | VideoFormatNv1264z32+    | VideoFormatA42010be+    | VideoFormatA42010le+    | VideoFormatA42210be+    | VideoFormatA42210le+    | VideoFormatA44410be+    | VideoFormatA44410le+    | VideoFormatNv61+    | AnotherVideoFormat Int+    deriving (Show, Eq)++instance 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 (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 k = AnotherVideoFormat k++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 VideoDitherMethod++data VideoDitherMethod = +      VideoDitherMethodNone+    | VideoDitherMethodVerterr+    | VideoDitherMethodFloydSteinberg+    | VideoDitherMethodSierraLite+    | VideoDitherMethodBayer+    | AnotherVideoDitherMethod Int+    deriving (Show, Eq)++instance 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++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++data VideoColorRange = +      VideoColorRangeUnknown+    | VideoColorRange0255+    | VideoColorRange16235+    | AnotherVideoColorRange Int+    deriving (Show, Eq)++instance 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++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++data VideoColorPrimaries = +      VideoColorPrimariesUnknown+    | VideoColorPrimariesBt709+    | VideoColorPrimariesBt470m+    | VideoColorPrimariesBt470bg+    | VideoColorPrimariesSmpte170m+    | VideoColorPrimariesSmpte240m+    | VideoColorPrimariesFilm+    | VideoColorPrimariesBt2020+    | AnotherVideoColorPrimaries Int+    deriving (Show, Eq)++instance 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 (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 k = AnotherVideoColorPrimaries k++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++data VideoColorMatrix = +      VideoColorMatrixUnknown+    | VideoColorMatrixRgb+    | VideoColorMatrixFcc+    | VideoColorMatrixBt709+    | VideoColorMatrixBt601+    | VideoColorMatrixSmpte240m+    | VideoColorMatrixBt2020+    | AnotherVideoColorMatrix Int+    deriving (Show, Eq)++instance 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++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++data VideoChromaMode = +      VideoChromaModeFull+    | VideoChromaModeUpsampleOnly+    | VideoChromaModeDownsampleOnly+    | VideoChromaModeNone+    | AnotherVideoChromaMode Int+    deriving (Show, Eq)++instance 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++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++data VideoChromaMethod = +      VideoChromaMethodNearest+    | VideoChromaMethodLinear+    | AnotherVideoChromaMethod Int+    deriving (Show, Eq)++instance Enum VideoChromaMethod where+    fromEnum VideoChromaMethodNearest = 0+    fromEnum VideoChromaMethodLinear = 1+    fromEnum (AnotherVideoChromaMethod k) = k++    toEnum 0 = VideoChromaMethodNearest+    toEnum 1 = VideoChromaMethodLinear+    toEnum k = AnotherVideoChromaMethod k++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 VideoAlphaMode++data VideoAlphaMode = +      VideoAlphaModeCopy+    | VideoAlphaModeSet+    | VideoAlphaModeMult+    | AnotherVideoAlphaMode Int+    deriving (Show, Eq)++instance 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++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++data NavigationQueryType = +      NavigationQueryTypeInvalid+    | NavigationQueryTypeCommands+    | NavigationQueryTypeAngles+    | AnotherNavigationQueryType Int+    deriving (Show, Eq)++instance 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++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++data NavigationMessageType = +      NavigationMessageTypeInvalid+    | NavigationMessageTypeMouseOver+    | NavigationMessageTypeCommandsChanged+    | NavigationMessageTypeAnglesChanged+    | NavigationMessageTypeEvent+    | AnotherNavigationMessageType Int+    deriving (Show, Eq)++instance 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++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++data NavigationEventType = +      NavigationEventTypeInvalid+    | NavigationEventTypeKeyPress+    | NavigationEventTypeKeyRelease+    | NavigationEventTypeMouseButtonPress+    | NavigationEventTypeMouseButtonRelease+    | NavigationEventTypeMouseMove+    | NavigationEventTypeCommand+    | AnotherNavigationEventType Int+    deriving (Show, Eq)++instance 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++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++data NavigationCommand = +      NavigationCommandInvalid+    | NavigationCommandMenu1+    | NavigationCommandMenu2+    | NavigationCommandMenu3+    | NavigationCommandMenu4+    | NavigationCommandMenu5+    | NavigationCommandMenu6+    | NavigationCommandMenu7+    | NavigationCommandLeft+    | NavigationCommandRight+    | NavigationCommandUp+    | NavigationCommandDown+    | NavigationCommandActivate+    | NavigationCommandPrevAngle+    | NavigationCommandNextAngle+    | AnotherNavigationCommand Int+    deriving (Show, Eq)++instance 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++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++data ColorBalanceType = +      ColorBalanceTypeHardware+    | ColorBalanceTypeSoftware+    | AnotherColorBalanceType Int+    deriving (Show, Eq)++instance Enum ColorBalanceType where+    fromEnum ColorBalanceTypeHardware = 0+    fromEnum ColorBalanceTypeSoftware = 1+    fromEnum (AnotherColorBalanceType k) = k++    toEnum 0 = ColorBalanceTypeHardware+    toEnum 1 = ColorBalanceTypeSoftware+    toEnum k = AnotherColorBalanceType k++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++
+ GI/GstVideo/Flags.hs view
@@ -0,0 +1,436 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Flags+    ( ++-- * Exported types+    VideoScalerFlags(..)                    ,+    VideoPackFlags(..)                      ,+    VideoMultiviewFlags(..)                 ,+    VideoFrameMapFlags(..)                  ,+    VideoFrameFlags(..)                     ,+    VideoFormatFlags(..)                    ,+    VideoFlags(..)                          ,+    VideoDitherFlags(..)                    ,+    VideoCodecFrameFlags(..)                ,+    VideoChromaSite(..)                     ,+    VideoChromaFlags(..)                    ,+    VideoBufferFlags(..)                    ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+++++-- Flags VideoScalerFlags++data VideoScalerFlags = +      VideoScalerFlagsNone+    | VideoScalerFlagsInterlaced+    | AnotherVideoScalerFlags Int+    deriving (Show, Eq)++instance Enum VideoScalerFlags where+    fromEnum VideoScalerFlagsNone = 0+    fromEnum VideoScalerFlagsInterlaced = 1+    fromEnum (AnotherVideoScalerFlags k) = k++    toEnum 0 = VideoScalerFlagsNone+    toEnum 1 = VideoScalerFlagsInterlaced+    toEnum k = AnotherVideoScalerFlags k++foreign import ccall "gst_video_scaler_flags_get_type" c_gst_video_scaler_flags_get_type :: +    IO GType++instance BoxedEnum VideoScalerFlags where+    boxedEnumType _ = c_gst_video_scaler_flags_get_type++instance IsGFlag VideoScalerFlags++-- Flags VideoPackFlags++data VideoPackFlags = +      VideoPackFlagsNone+    | VideoPackFlagsTruncateRange+    | VideoPackFlagsInterlaced+    | AnotherVideoPackFlags Int+    deriving (Show, Eq)++instance 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++foreign import ccall "gst_video_pack_flags_get_type" c_gst_video_pack_flags_get_type :: +    IO GType++instance BoxedEnum VideoPackFlags where+    boxedEnumType _ = c_gst_video_pack_flags_get_type++instance IsGFlag VideoPackFlags++-- Flags VideoMultiviewFlags++data VideoMultiviewFlags = +      VideoMultiviewFlagsNone+    | VideoMultiviewFlagsRightViewFirst+    | VideoMultiviewFlagsLeftFlipped+    | VideoMultiviewFlagsLeftFlopped+    | VideoMultiviewFlagsRightFlipped+    | VideoMultiviewFlagsRightFlopped+    | VideoMultiviewFlagsHalfAspect+    | VideoMultiviewFlagsMixedMono+    | AnotherVideoMultiviewFlags Int+    deriving (Show, Eq)++instance 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++foreign import ccall "gst_video_multiview_flags_get_type" c_gst_video_multiview_flags_get_type :: +    IO GType++instance BoxedEnum VideoMultiviewFlags where+    boxedEnumType _ = c_gst_video_multiview_flags_get_type++instance IsGFlag VideoMultiviewFlags++-- Flags VideoFrameMapFlags++data VideoFrameMapFlags = +      VideoFrameMapFlagsNoRef+    | VideoFrameMapFlagsLast+    | AnotherVideoFrameMapFlags Int+    deriving (Show, Eq)++instance Enum VideoFrameMapFlags where+    fromEnum VideoFrameMapFlagsNoRef = 65536+    fromEnum VideoFrameMapFlagsLast = 16777216+    fromEnum (AnotherVideoFrameMapFlags k) = k++    toEnum 65536 = VideoFrameMapFlagsNoRef+    toEnum 16777216 = VideoFrameMapFlagsLast+    toEnum k = AnotherVideoFrameMapFlags k++foreign import ccall "gst_video_frame_map_flags_get_type" c_gst_video_frame_map_flags_get_type :: +    IO GType++instance BoxedEnum VideoFrameMapFlags where+    boxedEnumType _ = c_gst_video_frame_map_flags_get_type++instance IsGFlag VideoFrameMapFlags++-- Flags VideoFrameFlags++data VideoFrameFlags = +      VideoFrameFlagsNone+    | VideoFrameFlagsInterlaced+    | VideoFrameFlagsTff+    | VideoFrameFlagsRff+    | VideoFrameFlagsOnefield+    | VideoFrameFlagsMultipleView+    | VideoFrameFlagsFirstInBundle+    | AnotherVideoFrameFlags Int+    deriving (Show, Eq)++instance 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 (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 k = AnotherVideoFrameFlags k++foreign import ccall "gst_video_frame_flags_get_type" c_gst_video_frame_flags_get_type :: +    IO GType++instance BoxedEnum VideoFrameFlags where+    boxedEnumType _ = c_gst_video_frame_flags_get_type++instance IsGFlag VideoFrameFlags++-- Flags VideoFormatFlags++data VideoFormatFlags = +      VideoFormatFlagsYuv+    | VideoFormatFlagsRgb+    | VideoFormatFlagsGray+    | VideoFormatFlagsAlpha+    | VideoFormatFlagsLe+    | VideoFormatFlagsPalette+    | VideoFormatFlagsComplex+    | VideoFormatFlagsUnpack+    | VideoFormatFlagsTiled+    | AnotherVideoFormatFlags Int+    deriving (Show, Eq)++instance 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++foreign import ccall "gst_video_format_flags_get_type" c_gst_video_format_flags_get_type :: +    IO GType++instance BoxedEnum VideoFormatFlags where+    boxedEnumType _ = c_gst_video_format_flags_get_type++instance IsGFlag VideoFormatFlags++-- Flags VideoFlags++data VideoFlags = +      VideoFlagsNone+    | VideoFlagsVariableFps+    | VideoFlagsPremultipliedAlpha+    | AnotherVideoFlags Int+    deriving (Show, Eq)++instance 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++foreign import ccall "gst_video_flags_get_type" c_gst_video_flags_get_type :: +    IO GType++instance BoxedEnum VideoFlags where+    boxedEnumType _ = c_gst_video_flags_get_type++instance IsGFlag VideoFlags++-- Flags VideoDitherFlags++data VideoDitherFlags = +      VideoDitherFlagsNone+    | VideoDitherFlagsInterlaced+    | VideoDitherFlagsQuantize+    | AnotherVideoDitherFlags Int+    deriving (Show, Eq)++instance 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++foreign import ccall "gst_video_dither_flags_get_type" c_gst_video_dither_flags_get_type :: +    IO GType++instance BoxedEnum VideoDitherFlags where+    boxedEnumType _ = c_gst_video_dither_flags_get_type++instance IsGFlag VideoDitherFlags++-- Flags VideoCodecFrameFlags++data VideoCodecFrameFlags = +      VideoCodecFrameFlagsDecodeOnly+    | VideoCodecFrameFlagsSyncPoint+    | VideoCodecFrameFlagsForceKeyframe+    | VideoCodecFrameFlagsForceKeyframeHeaders+    | AnotherVideoCodecFrameFlags Int+    deriving (Show, Eq)++instance 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 IsGFlag VideoCodecFrameFlags++-- Flags VideoChromaSite++data VideoChromaSite = +      VideoChromaSiteUnknown+    | VideoChromaSiteNone+    | VideoChromaSiteHCosited+    | VideoChromaSiteVCosited+    | VideoChromaSiteAltLine+    | VideoChromaSiteCosited+    | VideoChromaSiteJpeg+    | VideoChromaSiteMpeg2+    | VideoChromaSiteDv+    | AnotherVideoChromaSite Int+    deriving (Show, Eq)++instance 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 6 = VideoChromaSiteCosited+    toEnum 8 = VideoChromaSiteAltLine+    toEnum 14 = VideoChromaSiteDv+    toEnum k = AnotherVideoChromaSite k++foreign import ccall "gst_video_chroma_site_get_type" c_gst_video_chroma_site_get_type :: +    IO GType++instance BoxedEnum VideoChromaSite where+    boxedEnumType _ = c_gst_video_chroma_site_get_type++instance IsGFlag VideoChromaSite++-- Flags VideoChromaFlags++data VideoChromaFlags = +      VideoChromaFlagsNone+    | VideoChromaFlagsInterlaced+    | AnotherVideoChromaFlags Int+    deriving (Show, Eq)++instance Enum VideoChromaFlags where+    fromEnum VideoChromaFlagsNone = 0+    fromEnum VideoChromaFlagsInterlaced = 1+    fromEnum (AnotherVideoChromaFlags k) = k++    toEnum 0 = VideoChromaFlagsNone+    toEnum 1 = VideoChromaFlagsInterlaced+    toEnum k = AnotherVideoChromaFlags k++foreign import ccall "gst_video_chroma_flags_get_type" c_gst_video_chroma_flags_get_type :: +    IO GType++instance BoxedEnum VideoChromaFlags where+    boxedEnumType _ = c_gst_video_chroma_flags_get_type++instance IsGFlag VideoChromaFlags++-- Flags VideoBufferFlags++data VideoBufferFlags = +      VideoBufferFlagsInterlaced+    | VideoBufferFlagsTff+    | VideoBufferFlagsRff+    | VideoBufferFlagsOnefield+    | VideoBufferFlagsMultipleView+    | VideoBufferFlagsFirstInBundle+    | VideoBufferFlagsLast+    | AnotherVideoBufferFlags Int+    deriving (Show, Eq)++instance Enum VideoBufferFlags where+    fromEnum VideoBufferFlagsInterlaced = 1048576+    fromEnum VideoBufferFlagsTff = 2097152+    fromEnum VideoBufferFlagsRff = 4194304+    fromEnum VideoBufferFlagsOnefield = 8388608+    fromEnum VideoBufferFlagsMultipleView = 16777216+    fromEnum VideoBufferFlagsFirstInBundle = 33554432+    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 268435456 = VideoBufferFlagsLast+    toEnum k = AnotherVideoBufferFlags k++foreign import ccall "gst_video_buffer_flags_get_type" c_gst_video_buffer_flags_get_type :: +    IO GType++instance BoxedEnum VideoBufferFlags where+    boxedEnumType _ = c_gst_video_buffer_flags_get_type++instance IsGFlag VideoBufferFlags++
+ GI/GstVideo/Functions.hs view
@@ -0,0 +1,1389 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Functions+    ( ++ -- * Methods+-- ** bufferAddVideoMeta+    bufferAddVideoMeta                      ,+++-- ** bufferAddVideoMetaFull+    bufferAddVideoMetaFull                  ,+++-- ** bufferAddVideoOverlayCompositionMeta+    bufferAddVideoOverlayCompositionMeta    ,+++-- ** bufferAddVideoRegionOfInterestMeta+    bufferAddVideoRegionOfInterestMeta      ,+++-- ** bufferAddVideoRegionOfInterestMetaId+    bufferAddVideoRegionOfInterestMetaId    ,+++-- ** bufferGetVideoMeta+    bufferGetVideoMeta                      ,+++-- ** bufferGetVideoMetaId+    bufferGetVideoMetaId                    ,+++-- ** bufferGetVideoRegionOfInterestMetaId+    bufferGetVideoRegionOfInterestMetaId    ,+++-- ** bufferPoolConfigGetVideoAlignment+    bufferPoolConfigGetVideoAlignment       ,+++-- ** bufferPoolConfigSetVideoAlignment+    bufferPoolConfigSetVideoAlignment       ,+++-- ** isVideoOverlayPrepareWindowHandleMessage+    isVideoOverlayPrepareWindowHandleMessage,+++-- ** videoBlend+    videoBlend                              ,+++-- ** videoBlendScaleLinearRGBA+    videoBlendScaleLinearRGBA               ,+++-- ** videoCalculateDisplayRatio+    videoCalculateDisplayRatio              ,+++-- ** videoChromaFromString+    videoChromaFromString                   ,+++-- ** videoChromaResample+    videoChromaResample                     ,+++-- ** videoChromaToString+    videoChromaToString                     ,+++-- ** videoColorTransferDecode+    videoColorTransferDecode                ,+++-- ** videoColorTransferEncode+    videoColorTransferEncode                ,+++-- ** videoConvertSample+    videoConvertSample                      ,+++-- ** videoConvertSampleAsync+    videoConvertSampleAsync                 ,+++-- ** videoCropMetaApiGetType+    videoCropMetaApiGetType                 ,+++-- ** videoEventIsForceKeyUnit+    videoEventIsForceKeyUnit                ,+++-- ** videoEventNewDownstreamForceKeyUnit+    videoEventNewDownstreamForceKeyUnit     ,+++-- ** videoEventNewStillFrame+    videoEventNewStillFrame                 ,+++-- ** videoEventNewUpstreamForceKeyUnit+    videoEventNewUpstreamForceKeyUnit       ,+++-- ** videoEventParseDownstreamForceKeyUnit+    videoEventParseDownstreamForceKeyUnit   ,+++-- ** videoEventParseStillFrame+    videoEventParseStillFrame               ,+++-- ** videoEventParseUpstreamForceKeyUnit+    videoEventParseUpstreamForceKeyUnit     ,+++-- ** videoGlTextureUploadMetaApiGetType+    videoGlTextureUploadMetaApiGetType      ,+++-- ** videoGuessFramerate+    videoGuessFramerate                     ,+++-- ** videoMetaApiGetType+    videoMetaApiGetType                     ,+++-- ** videoMultiviewGetDoubledHeightModes+    videoMultiviewGetDoubledHeightModes     ,+++-- ** videoMultiviewGetDoubledSizeModes+    videoMultiviewGetDoubledSizeModes       ,+++-- ** videoMultiviewGetDoubledWidthModes+    videoMultiviewGetDoubledWidthModes      ,+++-- ** videoMultiviewGetMonoModes+    videoMultiviewGetMonoModes              ,+++-- ** videoMultiviewGetUnpackedModes+    videoMultiviewGetUnpackedModes          ,+++-- ** videoMultiviewGuessHalfAspect+    videoMultiviewGuessHalfAspect           ,+++-- ** videoMultiviewVideoInfoChangeMode+    videoMultiviewVideoInfoChangeMode       ,+++-- ** videoOverlayCompositionMetaApiGetType+    videoOverlayCompositionMetaApiGetType   ,+++-- ** videoRegionOfInterestMetaApiGetType+    videoRegionOfInterestMetaApiGetType     ,+++-- ** videoTileGetIndex+    videoTileGetIndex                       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.GLib as GLib+import qualified GI.Gst as Gst++-- function gst_video_tile_get_index+-- Args : [Arg {argCName = "mode", argType = TInterface "GstVideo" "VideoTileMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x_tiles", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y_tiles", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_tile_get_index" gst_video_tile_get_index :: +    CUInt ->                                -- mode : TInterface "GstVideo" "VideoTileMode"+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- x_tiles : TBasicType TInt32+    Int32 ->                                -- y_tiles : TBasicType TInt32+    IO Word32+++videoTileGetIndex ::+    (MonadIO m) =>+    VideoTileMode                           -- mode+    -> Int32                                -- x+    -> Int32                                -- y+    -> Int32                                -- xTiles+    -> Int32                                -- yTiles+    -> m Word32                             -- result+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 : 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+++videoRegionOfInterestMetaApiGetType ::+    (MonadIO m) =>+    m GType                                 -- result+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 : 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+++videoOverlayCompositionMetaApiGetType ::+    (MonadIO m) =>+    m GType                                 -- result+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 "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_mview_mode", argType = TInterface "GstVideo" "VideoMultiviewMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_mview_flags", argType = TInterface "GstVideo" "VideoMultiviewFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_multiview_video_info_change_mode" gst_video_multiview_video_info_change_mode :: +    Ptr VideoInfo ->                        -- info : TInterface "GstVideo" "VideoInfo"+    CUInt ->                                -- out_mview_mode : TInterface "GstVideo" "VideoMultiviewMode"+    CUInt ->                                -- out_mview_flags : TInterface "GstVideo" "VideoMultiviewFlags"+    IO ()+++videoMultiviewVideoInfoChangeMode ::+    (MonadIO m) =>+    VideoInfo                               -- info+    -> VideoMultiviewMode                   -- outMviewMode+    -> [VideoMultiviewFlags]                -- outMviewFlags+    -> m ()                                 -- result+videoMultiviewVideoInfoChangeMode info outMviewMode outMviewFlags = liftIO $ do+    let 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 "GstVideo" "VideoMultiviewMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "par_n", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "par_d", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_multiview_guess_half_aspect" gst_video_multiview_guess_half_aspect :: +    CUInt ->                                -- mv_mode : TInterface "GstVideo" "VideoMultiviewMode"+    Word32 ->                               -- width : TBasicType TUInt32+    Word32 ->                               -- height : TBasicType TUInt32+    Word32 ->                               -- par_n : TBasicType TUInt32+    Word32 ->                               -- par_d : TBasicType TUInt32+    IO CInt+++videoMultiviewGuessHalfAspect ::+    (MonadIO m) =>+    VideoMultiviewMode                      -- mvMode+    -> Word32                               -- width+    -> Word32                               -- height+    -> Word32                               -- parN+    -> Word32                               -- parD+    -> m Bool                               -- result+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 : TInterface "GObject" "Value"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_multiview_get_unpacked_modes" gst_video_multiview_get_unpacked_modes :: +    IO (Ptr GValue)+++videoMultiviewGetUnpackedModes ::+    (MonadIO m) =>+    m GValue                                -- result+videoMultiviewGetUnpackedModes  = liftIO $ do+    result <- gst_video_multiview_get_unpacked_modes+    checkUnexpectedReturnNULL "gst_video_multiview_get_unpacked_modes" result+    result' <- (newBoxed GValue) result+    return result'+++-- function gst_video_multiview_get_mono_modes+-- Args : []+-- Lengths : []+-- returnType : TInterface "GObject" "Value"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_multiview_get_mono_modes" gst_video_multiview_get_mono_modes :: +    IO (Ptr GValue)+++videoMultiviewGetMonoModes ::+    (MonadIO m) =>+    m GValue                                -- result+videoMultiviewGetMonoModes  = liftIO $ do+    result <- gst_video_multiview_get_mono_modes+    checkUnexpectedReturnNULL "gst_video_multiview_get_mono_modes" result+    result' <- (newBoxed GValue) result+    return result'+++-- function gst_video_multiview_get_doubled_width_modes+-- Args : []+-- Lengths : []+-- returnType : TInterface "GObject" "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)+++videoMultiviewGetDoubledWidthModes ::+    (MonadIO m) =>+    m GValue                                -- result+videoMultiviewGetDoubledWidthModes  = liftIO $ do+    result <- gst_video_multiview_get_doubled_width_modes+    checkUnexpectedReturnNULL "gst_video_multiview_get_doubled_width_modes" result+    result' <- (newBoxed GValue) result+    return result'+++-- function gst_video_multiview_get_doubled_size_modes+-- Args : []+-- Lengths : []+-- returnType : TInterface "GObject" "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)+++videoMultiviewGetDoubledSizeModes ::+    (MonadIO m) =>+    m GValue                                -- result+videoMultiviewGetDoubledSizeModes  = liftIO $ do+    result <- gst_video_multiview_get_doubled_size_modes+    checkUnexpectedReturnNULL "gst_video_multiview_get_doubled_size_modes" result+    result' <- (newBoxed GValue) result+    return result'+++-- function gst_video_multiview_get_doubled_height_modes+-- Args : []+-- Lengths : []+-- returnType : TInterface "GObject" "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)+++videoMultiviewGetDoubledHeightModes ::+    (MonadIO m) =>+    m GValue                                -- result+videoMultiviewGetDoubledHeightModes  = liftIO $ do+    result <- gst_video_multiview_get_doubled_height_modes+    checkUnexpectedReturnNULL "gst_video_multiview_get_doubled_height_modes" result+    result' <- (newBoxed GValue) result+    return result'+++-- function gst_video_meta_api_get_type+-- Args : []+-- Lengths : []+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_meta_api_get_type" gst_video_meta_api_get_type :: +    IO CGType+++videoMetaApiGetType ::+    (MonadIO m) =>+    m GType                                 -- result+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, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_n", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_d", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : 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 TInt32+    Ptr Int32 ->                            -- dest_d : TBasicType TInt32+    IO CInt+++videoGuessFramerate ::+    (MonadIO m) =>+    Word64                                  -- duration+    -> m (Bool,Int32,Int32)                 -- result+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 : 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+++videoGlTextureUploadMetaApiGetType ::+    (MonadIO m) =>+    m GType                                 -- result+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 "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "all_headers", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "count", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : 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 : TInterface "Gst" "Event"+    Ptr Word64 ->                           -- running_time : TBasicType TUInt64+    Ptr CInt ->                             -- all_headers : TBasicType TBoolean+    Ptr Word32 ->                           -- count : TBasicType TUInt32+    IO CInt+++videoEventParseUpstreamForceKeyUnit ::+    (MonadIO m) =>+    Gst.Event                               -- event+    -> m (Bool,Word64,Bool,Word32)          -- result+videoEventParseUpstreamForceKeyUnit event = liftIO $ do+    let 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 "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "in_still", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : 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 : TInterface "Gst" "Event"+    CInt ->                                 -- in_still : TBasicType TBoolean+    IO CInt+++videoEventParseStillFrame ::+    (MonadIO m) =>+    Gst.Event                               -- event+    -> Bool                                 -- inStill+    -> m Bool                               -- result+videoEventParseStillFrame event inStill = liftIO $ do+    let event' = unsafeManagedPtrGetPtr event+    let inStill' = (fromIntegral . fromEnum) inStill+    result <- gst_video_event_parse_still_frame event' inStill'+    let result' = (/= 0) result+    touchManagedPtr event+    return result'+++-- function gst_video_event_parse_downstream_force_key_unit+-- Args : [Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stream_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "all_headers", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "count", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : 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 : TInterface "Gst" "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 TUInt32+    IO CInt+++videoEventParseDownstreamForceKeyUnit ::+    (MonadIO m) =>+    Gst.Event                               -- event+    -> m (Bool,Word64,Word64,Word64,Bool,Word32)-- result+videoEventParseDownstreamForceKeyUnit event = liftIO $ do+    let 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, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "all_headers", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "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 TUInt32+    IO (Ptr Gst.Event)+++videoEventNewUpstreamForceKeyUnit ::+    (MonadIO m) =>+    Word64                                  -- runningTime+    -> Bool                                 -- allHeaders+    -> Word32                               -- count+    -> m Gst.Event                          -- result+videoEventNewUpstreamForceKeyUnit runningTime allHeaders count = liftIO $ do+    let allHeaders' = (fromIntegral . fromEnum) allHeaders+    result <- gst_video_event_new_upstream_force_key_unit runningTime allHeaders' count+    checkUnexpectedReturnNULL "gst_video_event_new_upstream_force_key_unit" result+    result' <- (wrapBoxed Gst.Event) result+    return result'+++-- function gst_video_event_new_still_frame+-- Args : [Arg {argCName = "in_still", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "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)+++videoEventNewStillFrame ::+    (MonadIO m) =>+    Bool                                    -- inStill+    -> m Gst.Event                          -- result+videoEventNewStillFrame inStill = liftIO $ do+    let inStill' = (fromIntegral . fromEnum) inStill+    result <- gst_video_event_new_still_frame inStill'+    checkUnexpectedReturnNULL "gst_video_event_new_still_frame" result+    result' <- (wrapBoxed Gst.Event) result+    return result'+++-- function gst_video_event_new_downstream_force_key_unit+-- Args : [Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "all_headers", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "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 TUInt32+    IO (Ptr Gst.Event)+++videoEventNewDownstreamForceKeyUnit ::+    (MonadIO m) =>+    Word64                                  -- timestamp+    -> Word64                               -- streamTime+    -> Word64                               -- runningTime+    -> Bool                                 -- allHeaders+    -> Word32                               -- count+    -> m Gst.Event                          -- result+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 "gst_video_event_new_downstream_force_key_unit" result+    result' <- (wrapBoxed Gst.Event) result+    return result'+++-- function gst_video_event_is_force_key_unit+-- Args : [Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : 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 : TInterface "Gst" "Event"+    IO CInt+++videoEventIsForceKeyUnit ::+    (MonadIO m) =>+    Gst.Event                               -- event+    -> m Bool                               -- result+videoEventIsForceKeyUnit event = liftIO $ do+    let 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 : 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+++videoCropMetaApiGetType ::+    (MonadIO m) =>+    m GType                                 -- result+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 "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "to_caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface "GstVideo" "VideoConvertSampleCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 4, argDestroy = 5, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_convert_sample_async" gst_video_convert_sample_async :: +    Ptr Gst.Sample ->                       -- sample : TInterface "Gst" "Sample"+    Ptr Gst.Caps ->                         -- to_caps : TInterface "Gst" "Caps"+    Word64 ->                               -- timeout : TBasicType TUInt64+    FunPtr VideoConvertSampleCallbackC ->   -- callback : TInterface "GstVideo" "VideoConvertSampleCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy_notify : TInterface "GLib" "DestroyNotify"+    IO ()+++videoConvertSampleAsync ::+    (MonadIO m) =>+    Gst.Sample                              -- sample+    -> Gst.Caps                             -- toCaps+    -> Word64                               -- timeout+    -> VideoConvertSampleCallback           -- callback+    -> m ()                                 -- result+videoConvertSampleAsync sample toCaps timeout callback = liftIO $ do+    let sample' = unsafeManagedPtrGetPtr sample+    let toCaps' = unsafeManagedPtrGetPtr toCaps+    callback' <- mkVideoConvertSampleCallback (videoConvertSampleCallbackWrapper Nothing 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 "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "to_caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Sample"+-- throws : True+-- Skip return : False++foreign import ccall "gst_video_convert_sample" gst_video_convert_sample :: +    Ptr Gst.Sample ->                       -- sample : TInterface "Gst" "Sample"+    Ptr Gst.Caps ->                         -- to_caps : TInterface "Gst" "Caps"+    Word64 ->                               -- timeout : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Gst.Sample)+++videoConvertSample ::+    (MonadIO m) =>+    Gst.Sample                              -- sample+    -> Gst.Caps                             -- toCaps+    -> Word64                               -- timeout+    -> m Gst.Sample                         -- result+videoConvertSample sample toCaps timeout = liftIO $ do+    let sample' = unsafeManagedPtrGetPtr sample+    let toCaps' = unsafeManagedPtrGetPtr toCaps+    onException (do+        result <- propagateGError $ gst_video_convert_sample sample' toCaps' timeout+        checkUnexpectedReturnNULL "gst_video_convert_sample" result+        result' <- (wrapBoxed Gst.Sample) result+        touchManagedPtr sample+        touchManagedPtr toCaps+        return result'+     ) (do+        return ()+     )+++-- function gst_video_color_transfer_encode+-- Args : [Arg {argCName = "func", argType = TInterface "GstVideo" "VideoTransferFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_color_transfer_encode" gst_video_color_transfer_encode :: +    CUInt ->                                -- func : TInterface "GstVideo" "VideoTransferFunction"+    CDouble ->                              -- val : TBasicType TDouble+    IO CDouble+++videoColorTransferEncode ::+    (MonadIO m) =>+    VideoTransferFunction                   -- func+    -> Double                               -- val+    -> m Double                             -- result+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 "GstVideo" "VideoTransferFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_color_transfer_decode" gst_video_color_transfer_decode :: +    CUInt ->                                -- func : TInterface "GstVideo" "VideoTransferFunction"+    CDouble ->                              -- val : TBasicType TDouble+    IO CDouble+++videoColorTransferDecode ::+    (MonadIO m) =>+    VideoTransferFunction                   -- func+    -> Double                               -- val+    -> m Double                             -- result+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 "GstVideo" "VideoChromaSite", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_chroma_to_string" gst_video_chroma_to_string :: +    CUInt ->                                -- site : TInterface "GstVideo" "VideoChromaSite"+    IO CString+++videoChromaToString ::+    (MonadIO m) =>+    [VideoChromaSite]                       -- site+    -> m T.Text                             -- result+videoChromaToString site = liftIO $ do+    let site' = gflagsToWord site+    result <- gst_video_chroma_to_string site'+    checkUnexpectedReturnNULL "gst_video_chroma_to_string" result+    result' <- cstringToText result+    return result'+++-- function gst_video_chroma_resample+-- Args : [Arg {argCName = "resample", argType = TInterface "GstVideo" "VideoChromaResample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "lines", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_chroma_resample" gst_video_chroma_resample :: +    Ptr VideoChromaResample ->              -- resample : TInterface "GstVideo" "VideoChromaResample"+    Ptr () ->                               -- lines : TBasicType TVoid+    Int32 ->                                -- width : TBasicType TInt32+    IO ()+++videoChromaResample ::+    (MonadIO m) =>+    VideoChromaResample                     -- resample+    -> Ptr ()                               -- lines+    -> Int32                                -- width+    -> m ()                                 -- result+videoChromaResample resample lines width = liftIO $ do+    let 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, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "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+++videoChromaFromString ::+    (MonadIO m) =>+    T.Text                                  -- s+    -> m [VideoChromaSite]                  -- result+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_calculate_display_ratio+-- Args : [Arg {argCName = "dar_n", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dar_d", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "video_width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "video_height", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "video_par_n", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "video_par_d", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "display_par_n", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "display_par_d", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : 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 TUInt32+    Ptr Word32 ->                           -- dar_d : TBasicType TUInt32+    Word32 ->                               -- video_width : TBasicType TUInt32+    Word32 ->                               -- video_height : TBasicType TUInt32+    Word32 ->                               -- video_par_n : TBasicType TUInt32+    Word32 ->                               -- video_par_d : TBasicType TUInt32+    Word32 ->                               -- display_par_n : TBasicType TUInt32+    Word32 ->                               -- display_par_d : TBasicType TUInt32+    IO CInt+++videoCalculateDisplayRatio ::+    (MonadIO m) =>+    Word32                                  -- videoWidth+    -> Word32                               -- videoHeight+    -> Word32                               -- videoParN+    -> Word32                               -- videoParD+    -> Word32                               -- displayParN+    -> Word32                               -- displayParD+    -> m (Bool,Word32,Word32)               -- result+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 "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "GstVideo" "VideoInfo", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "dest_buffer", argType = TInterface "Gst" "Buffer", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_blend_scale_linear_RGBA" gst_video_blend_scale_linear_RGBA :: +    Ptr VideoInfo ->                        -- src : TInterface "GstVideo" "VideoInfo"+    Ptr Gst.Buffer ->                       -- src_buffer : TInterface "Gst" "Buffer"+    Int32 ->                                -- dest_height : TBasicType TInt32+    Int32 ->                                -- dest_width : TBasicType TInt32+    Ptr VideoInfo ->                        -- dest : TInterface "GstVideo" "VideoInfo"+    Ptr Gst.Buffer ->                       -- dest_buffer : TInterface "Gst" "Buffer"+    IO ()+++videoBlendScaleLinearRGBA ::+    (MonadIO m) =>+    VideoInfo                               -- src+    -> Gst.Buffer                           -- srcBuffer+    -> Int32                                -- destHeight+    -> Int32                                -- destWidth+    -> m (VideoInfo,Gst.Buffer)             -- result+videoBlendScaleLinearRGBA src srcBuffer destHeight destWidth = liftIO $ do+    let src' = unsafeManagedPtrGetPtr src+    let srcBuffer' = unsafeManagedPtrGetPtr srcBuffer+    dest <- callocBoxedBytes 120 :: IO (Ptr VideoInfo)+    destBuffer <- callocBoxedBytes 112 :: IO (Ptr Gst.Buffer)+    gst_video_blend_scale_linear_RGBA src' srcBuffer' destHeight destWidth dest destBuffer+    dest' <- (wrapBoxed VideoInfo) dest+    destBuffer' <- (wrapBoxed Gst.Buffer) destBuffer+    touchManagedPtr src+    touchManagedPtr srcBuffer+    return (dest', destBuffer')+++-- function gst_video_blend+-- Args : [Arg {argCName = "dest", argType = TInterface "GstVideo" "VideoFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "GstVideo" "VideoFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "global_alpha", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_blend" gst_video_blend :: +    Ptr VideoFrame ->                       -- dest : TInterface "GstVideo" "VideoFrame"+    Ptr VideoFrame ->                       -- src : TInterface "GstVideo" "VideoFrame"+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    CFloat ->                               -- global_alpha : TBasicType TFloat+    IO CInt+++videoBlend ::+    (MonadIO m) =>+    VideoFrame                              -- dest+    -> VideoFrame                           -- src+    -> Int32                                -- x+    -> Int32                                -- y+    -> Float                                -- globalAlpha+    -> m Bool                               -- result+videoBlend dest src x y globalAlpha = liftIO $ do+    let dest' = unsafeManagedPtrGetPtr dest+    let 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_is_video_overlay_prepare_window_handle_message+-- Args : [Arg {argCName = "msg", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : 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 ->                      -- msg : TInterface "Gst" "Message"+    IO CInt+++isVideoOverlayPrepareWindowHandleMessage ::+    (MonadIO m) =>+    Gst.Message                             -- msg+    -> m Bool                               -- result+isVideoOverlayPrepareWindowHandleMessage msg = liftIO $ do+    let 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 "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TInterface "GstVideo" "VideoAlignment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- 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 ->                    -- config : TInterface "Gst" "Structure"+    Ptr VideoAlignment ->                   -- align : TInterface "GstVideo" "VideoAlignment"+    IO ()+++bufferPoolConfigSetVideoAlignment ::+    (MonadIO m) =>+    Gst.Structure                           -- config+    -> VideoAlignment                       -- align+    -> m ()                                 -- result+bufferPoolConfigSetVideoAlignment config align = liftIO $ do+    let config' = unsafeManagedPtrGetPtr config+    let 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 "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TInterface "GstVideo" "VideoAlignment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : 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 ->                    -- config : TInterface "Gst" "Structure"+    Ptr VideoAlignment ->                   -- align : TInterface "GstVideo" "VideoAlignment"+    IO CInt+++bufferPoolConfigGetVideoAlignment ::+    (MonadIO m) =>+    Gst.Structure                           -- config+    -> VideoAlignment                       -- align+    -> m Bool                               -- result+bufferPoolConfigGetVideoAlignment config align = liftIO $ do+    let config' = unsafeManagedPtrGetPtr config+    let 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 "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "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 : TInterface "Gst" "Buffer"+    Int32 ->                                -- id : TBasicType TInt32+    IO (Ptr VideoRegionOfInterestMeta)+++bufferGetVideoRegionOfInterestMetaId ::+    (MonadIO m) =>+    Gst.Buffer                              -- buffer+    -> Int32                                -- id+    -> m VideoRegionOfInterestMeta          -- result+bufferGetVideoRegionOfInterestMetaId buffer id = liftIO $ do+    let buffer' = unsafeManagedPtrGetPtr buffer+    result <- gst_buffer_get_video_region_of_interest_meta_id buffer' id+    checkUnexpectedReturnNULL "gst_buffer_get_video_region_of_interest_meta_id" result+    result' <- (newPtr 48 VideoRegionOfInterestMeta) result+    touchManagedPtr buffer+    return result'+++-- function gst_buffer_get_video_meta_id+-- Args : [Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "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 : TInterface "Gst" "Buffer"+    Int32 ->                                -- id : TBasicType TInt32+    IO (Ptr VideoMeta)+++bufferGetVideoMetaId ::+    (MonadIO m) =>+    Gst.Buffer                              -- buffer+    -> Int32                                -- id+    -> m VideoMeta                          -- result+bufferGetVideoMetaId buffer id = liftIO $ do+    let buffer' = unsafeManagedPtrGetPtr buffer+    result <- gst_buffer_get_video_meta_id buffer' id+    checkUnexpectedReturnNULL "gst_buffer_get_video_meta_id" result+    result' <- (newPtr 112 VideoMeta) result+    touchManagedPtr buffer+    return result'+++-- function gst_buffer_get_video_meta+-- Args : [Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoMeta"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_get_video_meta" gst_buffer_get_video_meta :: +    Ptr Gst.Buffer ->                       -- buffer : TInterface "Gst" "Buffer"+    IO (Ptr VideoMeta)+++bufferGetVideoMeta ::+    (MonadIO m) =>+    Gst.Buffer                              -- buffer+    -> m VideoMeta                          -- result+bufferGetVideoMeta buffer = liftIO $ do+    let buffer' = unsafeManagedPtrGetPtr buffer+    result <- gst_buffer_get_video_meta buffer'+    checkUnexpectedReturnNULL "gst_buffer_get_video_meta" result+    result' <- (newPtr 112 VideoMeta) result+    touchManagedPtr buffer+    return result'+++-- function gst_buffer_add_video_region_of_interest_meta_id+-- Args : [Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "roi_type", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "w", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "h", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "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 : TInterface "Gst" "Buffer"+    Word32 ->                               -- roi_type : TBasicType TUInt32+    Word32 ->                               -- x : TBasicType TUInt32+    Word32 ->                               -- y : TBasicType TUInt32+    Word32 ->                               -- w : TBasicType TUInt32+    Word32 ->                               -- h : TBasicType TUInt32+    IO (Ptr VideoRegionOfInterestMeta)+++bufferAddVideoRegionOfInterestMetaId ::+    (MonadIO m) =>+    Gst.Buffer                              -- buffer+    -> Word32                               -- roiType+    -> Word32                               -- x+    -> Word32                               -- y+    -> Word32                               -- w+    -> Word32                               -- h+    -> m VideoRegionOfInterestMeta          -- result+bufferAddVideoRegionOfInterestMetaId buffer roiType x y w h = liftIO $ do+    let buffer' = unsafeManagedPtrGetPtr buffer+    result <- gst_buffer_add_video_region_of_interest_meta_id buffer' roiType x y w h+    checkUnexpectedReturnNULL "gst_buffer_add_video_region_of_interest_meta_id" result+    result' <- (newPtr 48 VideoRegionOfInterestMeta) result+    touchManagedPtr buffer+    return result'+++-- function gst_buffer_add_video_region_of_interest_meta+-- Args : [Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "roi_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "w", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "h", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "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 : TInterface "Gst" "Buffer"+    CString ->                              -- roi_type : TBasicType TUTF8+    Word32 ->                               -- x : TBasicType TUInt32+    Word32 ->                               -- y : TBasicType TUInt32+    Word32 ->                               -- w : TBasicType TUInt32+    Word32 ->                               -- h : TBasicType TUInt32+    IO (Ptr VideoRegionOfInterestMeta)+++bufferAddVideoRegionOfInterestMeta ::+    (MonadIO m) =>+    Gst.Buffer                              -- buffer+    -> T.Text                               -- roiType+    -> Word32                               -- x+    -> Word32                               -- y+    -> Word32                               -- w+    -> Word32                               -- h+    -> m VideoRegionOfInterestMeta          -- result+bufferAddVideoRegionOfInterestMeta buffer roiType x y w h = liftIO $ do+    let buffer' = unsafeManagedPtrGetPtr buffer+    roiType' <- textToCString roiType+    result <- gst_buffer_add_video_region_of_interest_meta buffer' roiType' x y w h+    checkUnexpectedReturnNULL "gst_buffer_add_video_region_of_interest_meta" result+    result' <- (newPtr 48 VideoRegionOfInterestMeta) result+    touchManagedPtr buffer+    freeMem roiType'+    return result'+++-- function gst_buffer_add_video_overlay_composition_meta+-- Args : [Arg {argCName = "buf", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "comp", argType = TInterface "GstVideo" "VideoOverlayComposition", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "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 ->                       -- buf : TInterface "Gst" "Buffer"+    Ptr VideoOverlayComposition ->          -- comp : TInterface "GstVideo" "VideoOverlayComposition"+    IO (Ptr VideoOverlayCompositionMeta)+++bufferAddVideoOverlayCompositionMeta ::+    (MonadIO m) =>+    Gst.Buffer                              -- buf+    -> Maybe (VideoOverlayComposition)      -- comp+    -> m VideoOverlayCompositionMeta        -- result+bufferAddVideoOverlayCompositionMeta buf comp = liftIO $ do+    let buf' = unsafeManagedPtrGetPtr buf+    maybeComp <- case comp of+        Nothing -> return nullPtr+        Just jComp -> do+            let jComp' = unsafeManagedPtrGetPtr jComp+            return jComp'+    result <- gst_buffer_add_video_overlay_composition_meta buf' maybeComp+    checkUnexpectedReturnNULL "gst_buffer_add_video_overlay_composition_meta" result+    result' <- (newPtr 24 VideoOverlayCompositionMeta) result+    touchManagedPtr buf+    whenJust comp touchManagedPtr+    return result'+++-- function gst_buffer_add_video_meta_full+-- Args : [Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "GstVideo" "VideoFrameFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "GstVideo" "VideoFormat", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_planes", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "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 : TInterface "Gst" "Buffer"+    CUInt ->                                -- flags : TInterface "GstVideo" "VideoFrameFlags"+    CUInt ->                                -- format : TInterface "GstVideo" "VideoFormat"+    Word32 ->                               -- width : TBasicType TUInt32+    Word32 ->                               -- height : TBasicType TUInt32+    Word32 ->                               -- n_planes : TBasicType TUInt32+    Word64 ->                               -- offset : TBasicType TUInt64+    Int32 ->                                -- stride : TBasicType TInt32+    IO (Ptr VideoMeta)+++bufferAddVideoMetaFull ::+    (MonadIO m) =>+    Gst.Buffer                              -- buffer+    -> [VideoFrameFlags]                    -- flags+    -> VideoFormat                          -- format+    -> Word32                               -- width+    -> Word32                               -- height+    -> Word32                               -- nPlanes+    -> Word64                               -- offset+    -> Int32                                -- stride+    -> m VideoMeta                          -- result+bufferAddVideoMetaFull buffer flags format width height nPlanes offset stride = liftIO $ do+    let buffer' = unsafeManagedPtrGetPtr buffer+    let flags' = gflagsToWord flags+    let format' = (fromIntegral . fromEnum) format+    result <- gst_buffer_add_video_meta_full buffer' flags' format' width height nPlanes offset stride+    checkUnexpectedReturnNULL "gst_buffer_add_video_meta_full" result+    result' <- (newPtr 112 VideoMeta) result+    touchManagedPtr buffer+    return result'+++-- function gst_buffer_add_video_meta+-- Args : [Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "GstVideo" "VideoFrameFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "GstVideo" "VideoFormat", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoMeta"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_video_meta" gst_buffer_add_video_meta :: +    Ptr Gst.Buffer ->                       -- buffer : TInterface "Gst" "Buffer"+    CUInt ->                                -- flags : TInterface "GstVideo" "VideoFrameFlags"+    CUInt ->                                -- format : TInterface "GstVideo" "VideoFormat"+    Word32 ->                               -- width : TBasicType TUInt32+    Word32 ->                               -- height : TBasicType TUInt32+    IO (Ptr VideoMeta)+++bufferAddVideoMeta ::+    (MonadIO m) =>+    Gst.Buffer                              -- buffer+    -> [VideoFrameFlags]                    -- flags+    -> VideoFormat                          -- format+    -> Word32                               -- width+    -> Word32                               -- height+    -> m VideoMeta                          -- result+bufferAddVideoMeta buffer flags format width height = liftIO $ do+    let buffer' = unsafeManagedPtrGetPtr buffer+    let flags' = gflagsToWord flags+    let format' = (fromIntegral . fromEnum) format+    result <- gst_buffer_add_video_meta buffer' flags' format' width height+    checkUnexpectedReturnNULL "gst_buffer_add_video_meta" result+    result' <- (newPtr 112 VideoMeta) result+    touchManagedPtr buffer+    return result'+++
+ GI/GstVideo/Interfaces.hs view
@@ -0,0 +1,33 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Interfaces+    (     module GI.GstVideo.Interfaces.ColorBalance,+    module GI.GstVideo.Interfaces.Navigation,+    module GI.GstVideo.Interfaces.VideoOrientation,+    module GI.GstVideo.Interfaces.VideoOverlay,+++    ) where++import GI.GstVideo.Interfaces.ColorBalance+import GI.GstVideo.Interfaces.Navigation+import GI.GstVideo.Interfaces.VideoOrientation+import GI.GstVideo.Interfaces.VideoOverlay++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++
+ GI/GstVideo/Interfaces/ColorBalance.hs view
@@ -0,0 +1,311 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Interfaces.ColorBalance+    ( ++-- * Exported types+    ColorBalance(..)                        ,+    noColorBalance                          ,+    ColorBalanceK                           ,+++ -- * Methods+-- ** colorBalanceGetBalanceType+    ColorBalanceGetBalanceTypeMethodInfo    ,+    colorBalanceGetBalanceType              ,+++-- ** colorBalanceGetValue+    ColorBalanceGetValueMethodInfo          ,+    colorBalanceGetValue                    ,+++-- ** colorBalanceListChannels+    ColorBalanceListChannelsMethodInfo      ,+    colorBalanceListChannels                ,+++-- ** colorBalanceSetValue+    ColorBalanceSetValueMethodInfo          ,+    colorBalanceSetValue                    ,+++-- ** colorBalanceValueChanged+    ColorBalanceValueChangedMethodInfo      ,+    colorBalanceValueChanged                ,+++++ -- * Signals+-- ** ValueChanged+    ColorBalanceValueChangedCallback        ,+    ColorBalanceValueChangedCallbackC       ,+    ColorBalanceValueChangedSignalInfo      ,+    afterColorBalanceValueChanged           ,+    colorBalanceValueChangedCallbackWrapper ,+    colorBalanceValueChangedClosure         ,+    mkColorBalanceValueChangedCallback      ,+    noColorBalanceValueChangedCallback      ,+    onColorBalanceValueChanged              ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++-- interface ColorBalance ++newtype ColorBalance = ColorBalance (ForeignPtr ColorBalance)+noColorBalance :: Maybe ColorBalance+noColorBalance = Nothing++type family ResolveColorBalanceMethod (t :: Symbol) (o :: *) :: * where+    ResolveColorBalanceMethod "listChannels" o = ColorBalanceListChannelsMethodInfo+    ResolveColorBalanceMethod "valueChanged" o = ColorBalanceValueChangedMethodInfo+    ResolveColorBalanceMethod "getBalanceType" o = ColorBalanceGetBalanceTypeMethodInfo+    ResolveColorBalanceMethod "getValue" o = ColorBalanceGetValueMethodInfo+    ResolveColorBalanceMethod "setValue" o = ColorBalanceSetValueMethodInfo+    ResolveColorBalanceMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveColorBalanceMethod t ColorBalance, MethodInfo info ColorBalance p) => IsLabelProxy t (ColorBalance -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveColorBalanceMethod t ColorBalance, MethodInfo info ColorBalance p) => IsLabel t (ColorBalance -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- signal ColorBalance::value-changed+type ColorBalanceValueChangedCallback =+    ColorBalanceChannel ->+    Int32 ->+    IO ()++noColorBalanceValueChangedCallback :: Maybe ColorBalanceValueChangedCallback+noColorBalanceValueChangedCallback = Nothing++type ColorBalanceValueChangedCallbackC =+    Ptr () ->                               -- object+    Ptr ColorBalanceChannel ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkColorBalanceValueChangedCallback :: ColorBalanceValueChangedCallbackC -> IO (FunPtr ColorBalanceValueChangedCallbackC)++colorBalanceValueChangedClosure :: ColorBalanceValueChangedCallback -> IO Closure+colorBalanceValueChangedClosure cb = newCClosure =<< mkColorBalanceValueChangedCallback wrapped+    where wrapped = colorBalanceValueChangedCallbackWrapper cb++colorBalanceValueChangedCallbackWrapper ::+    ColorBalanceValueChangedCallback ->+    Ptr () ->+    Ptr ColorBalanceChannel ->+    Int32 ->+    Ptr () ->+    IO ()+colorBalanceValueChangedCallbackWrapper _cb _ channel value _ = do+    channel' <- (newObject ColorBalanceChannel) channel+    _cb  channel' value++onColorBalanceValueChanged :: (GObject a, MonadIO m) => a -> ColorBalanceValueChangedCallback -> m SignalHandlerId+onColorBalanceValueChanged obj cb = liftIO $ connectColorBalanceValueChanged obj cb SignalConnectBefore+afterColorBalanceValueChanged :: (GObject a, MonadIO m) => a -> ColorBalanceValueChangedCallback -> m SignalHandlerId+afterColorBalanceValueChanged obj cb = connectColorBalanceValueChanged obj cb SignalConnectAfter++connectColorBalanceValueChanged :: (GObject a, MonadIO m) =>+                                   a -> ColorBalanceValueChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectColorBalanceValueChanged obj cb after = liftIO $ do+    cb' <- mkColorBalanceValueChangedCallback (colorBalanceValueChangedCallbackWrapper cb)+    connectSignalFunPtr obj "value-changed" cb' after++type instance AttributeList ColorBalance = ColorBalanceAttributeList+type ColorBalanceAttributeList = ('[ ] :: [(Symbol, *)])++data ColorBalanceValueChangedSignalInfo+instance SignalInfo ColorBalanceValueChangedSignalInfo where+    type HaskellCallbackType ColorBalanceValueChangedSignalInfo = ColorBalanceValueChangedCallback+    connectSignal _ = connectColorBalanceValueChanged++type instance SignalList ColorBalance = ColorBalanceSignalList+type ColorBalanceSignalList = ('[ '("valueChanged", ColorBalanceValueChangedSignalInfo)] :: [(Symbol, *)])++class ForeignPtrNewtype a => ColorBalanceK a+instance (ForeignPtrNewtype o, IsDescendantOf ColorBalance o) => ColorBalanceK o+type instance ParentTypes ColorBalance = ColorBalanceParentTypes+type ColorBalanceParentTypes = '[]++-- method ColorBalance::get_balance_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "ColorBalance", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "ColorBalanceType"+-- throws : False+-- Skip return : False++foreign import ccall "gst_color_balance_get_balance_type" gst_color_balance_get_balance_type :: +    Ptr ColorBalance ->                     -- _obj : TInterface "GstVideo" "ColorBalance"+    IO CUInt+++colorBalanceGetBalanceType ::+    (MonadIO m, ColorBalanceK a) =>+    a                                       -- _obj+    -> m ColorBalanceType                   -- result+colorBalanceGetBalanceType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_color_balance_get_balance_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data ColorBalanceGetBalanceTypeMethodInfo+instance (signature ~ (m ColorBalanceType), MonadIO m, ColorBalanceK a) => MethodInfo ColorBalanceGetBalanceTypeMethodInfo a signature where+    overloadedMethod _ = colorBalanceGetBalanceType++-- method ColorBalance::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "ColorBalance", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "channel", argType = TInterface "GstVideo" "ColorBalanceChannel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_color_balance_get_value" gst_color_balance_get_value :: +    Ptr ColorBalance ->                     -- _obj : TInterface "GstVideo" "ColorBalance"+    Ptr ColorBalanceChannel ->              -- channel : TInterface "GstVideo" "ColorBalanceChannel"+    IO Int32+++colorBalanceGetValue ::+    (MonadIO m, ColorBalanceK a, ColorBalanceChannelK b) =>+    a                                       -- _obj+    -> b                                    -- channel+    -> m Int32                              -- result+colorBalanceGetValue _obj channel = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let channel' = unsafeManagedPtrCastPtr channel+    result <- gst_color_balance_get_value _obj' channel'+    touchManagedPtr _obj+    touchManagedPtr channel+    return result++data ColorBalanceGetValueMethodInfo+instance (signature ~ (b -> m Int32), MonadIO m, ColorBalanceK a, ColorBalanceChannelK b) => MethodInfo ColorBalanceGetValueMethodInfo a signature where+    overloadedMethod _ = colorBalanceGetValue++-- method ColorBalance::list_channels+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "ColorBalance", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "GstVideo" "ColorBalanceChannel")+-- throws : False+-- Skip return : False++foreign import ccall "gst_color_balance_list_channels" gst_color_balance_list_channels :: +    Ptr ColorBalance ->                     -- _obj : TInterface "GstVideo" "ColorBalance"+    IO (Ptr (GList (Ptr ColorBalanceChannel)))+++colorBalanceListChannels ::+    (MonadIO m, ColorBalanceK a) =>+    a                                       -- _obj+    -> m [ColorBalanceChannel]              -- result+colorBalanceListChannels _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_color_balance_list_channels _obj'+    checkUnexpectedReturnNULL "gst_color_balance_list_channels" result+    result' <- unpackGList result+    result'' <- mapM (newObject ColorBalanceChannel) result'+    touchManagedPtr _obj+    return result''++data ColorBalanceListChannelsMethodInfo+instance (signature ~ (m [ColorBalanceChannel]), MonadIO m, ColorBalanceK a) => MethodInfo ColorBalanceListChannelsMethodInfo a signature where+    overloadedMethod _ = colorBalanceListChannels++-- method ColorBalance::set_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "ColorBalance", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "channel", argType = TInterface "GstVideo" "ColorBalanceChannel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_color_balance_set_value" gst_color_balance_set_value :: +    Ptr ColorBalance ->                     -- _obj : TInterface "GstVideo" "ColorBalance"+    Ptr ColorBalanceChannel ->              -- channel : TInterface "GstVideo" "ColorBalanceChannel"+    Int32 ->                                -- value : TBasicType TInt32+    IO ()+++colorBalanceSetValue ::+    (MonadIO m, ColorBalanceK a, ColorBalanceChannelK b) =>+    a                                       -- _obj+    -> b                                    -- channel+    -> Int32                                -- value+    -> m ()                                 -- result+colorBalanceSetValue _obj channel value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let channel' = unsafeManagedPtrCastPtr channel+    gst_color_balance_set_value _obj' channel' value+    touchManagedPtr _obj+    touchManagedPtr channel+    return ()++data ColorBalanceSetValueMethodInfo+instance (signature ~ (b -> Int32 -> m ()), MonadIO m, ColorBalanceK a, ColorBalanceChannelK b) => MethodInfo ColorBalanceSetValueMethodInfo a signature where+    overloadedMethod _ = colorBalanceSetValue++-- method ColorBalance::value_changed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "ColorBalance", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "channel", argType = TInterface "GstVideo" "ColorBalanceChannel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_color_balance_value_changed" gst_color_balance_value_changed :: +    Ptr ColorBalance ->                     -- _obj : TInterface "GstVideo" "ColorBalance"+    Ptr ColorBalanceChannel ->              -- channel : TInterface "GstVideo" "ColorBalanceChannel"+    Int32 ->                                -- value : TBasicType TInt32+    IO ()+++colorBalanceValueChanged ::+    (MonadIO m, ColorBalanceK a, ColorBalanceChannelK b) =>+    a                                       -- _obj+    -> b                                    -- channel+    -> Int32                                -- value+    -> m ()                                 -- result+colorBalanceValueChanged _obj channel value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let channel' = unsafeManagedPtrCastPtr channel+    gst_color_balance_value_changed _obj' channel' value+    touchManagedPtr _obj+    touchManagedPtr channel+    return ()++data ColorBalanceValueChangedMethodInfo+instance (signature ~ (b -> Int32 -> m ()), MonadIO m, ColorBalanceK a, ColorBalanceChannelK b) => MethodInfo ColorBalanceValueChangedMethodInfo a signature where+    overloadedMethod _ = colorBalanceValueChanged++
+ GI/GstVideo/Interfaces/ColorBalance.hs-boot view
@@ -0,0 +1,18 @@+module GI.GstVideo.Interfaces.ColorBalance where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ColorBalance = ColorBalance (ForeignPtr ColorBalance)+data ColorBalanceValueChangedSignalInfo+class ForeignPtrNewtype a => ColorBalanceK a+instance (ForeignPtrNewtype o, IsDescendantOf ColorBalance o) => ColorBalanceK o+data ColorBalanceGetBalanceTypeMethodInfo+data ColorBalanceGetValueMethodInfo+data ColorBalanceListChannelsMethodInfo+data ColorBalanceSetValueMethodInfo+data ColorBalanceValueChangedMethodInfo
+ GI/GstVideo/Interfaces/Navigation.hs view
@@ -0,0 +1,871 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Interfaces.Navigation+    ( ++-- * Exported types+    Navigation(..)                          ,+    noNavigation                            ,+    NavigationK                             ,+++ -- * Methods+-- ** navigationEventGetType+    navigationEventGetType                  ,+++-- ** navigationEventParseCommand+    navigationEventParseCommand             ,+++-- ** navigationEventParseKeyEvent+    navigationEventParseKeyEvent            ,+++-- ** navigationEventParseMouseButtonEvent+    navigationEventParseMouseButtonEvent    ,+++-- ** navigationEventParseMouseMoveEvent+    navigationEventParseMouseMoveEvent      ,+++-- ** navigationMessageGetType+    navigationMessageGetType                ,+++-- ** navigationMessageNewAnglesChanged+    navigationMessageNewAnglesChanged       ,+++-- ** navigationMessageNewCommandsChanged+    navigationMessageNewCommandsChanged     ,+++-- ** navigationMessageNewEvent+    navigationMessageNewEvent               ,+++-- ** navigationMessageNewMouseOver+    navigationMessageNewMouseOver           ,+++-- ** navigationMessageParseAnglesChanged+    navigationMessageParseAnglesChanged     ,+++-- ** navigationMessageParseEvent+    navigationMessageParseEvent             ,+++-- ** navigationMessageParseMouseOver+    navigationMessageParseMouseOver         ,+++-- ** navigationQueryGetType+    navigationQueryGetType                  ,+++-- ** navigationQueryNewAngles+    navigationQueryNewAngles                ,+++-- ** navigationQueryNewCommands+    navigationQueryNewCommands              ,+++-- ** navigationQueryParseAngles+    navigationQueryParseAngles              ,+++-- ** navigationQueryParseCommandsLength+    navigationQueryParseCommandsLength      ,+++-- ** navigationQueryParseCommandsNth+    navigationQueryParseCommandsNth         ,+++-- ** navigationQuerySetAngles+    navigationQuerySetAngles                ,+++-- ** navigationQuerySetCommandsv+    navigationQuerySetCommandsv             ,+++-- ** navigationSendCommand+    NavigationSendCommandMethodInfo         ,+    navigationSendCommand                   ,+++-- ** navigationSendEvent+    NavigationSendEventMethodInfo           ,+    navigationSendEvent                     ,+++-- ** navigationSendKeyEvent+    NavigationSendKeyEventMethodInfo        ,+    navigationSendKeyEvent                  ,+++-- ** navigationSendMouseEvent+    NavigationSendMouseEventMethodInfo      ,+    navigationSendMouseEvent                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.Gst as Gst++-- interface Navigation ++newtype Navigation = Navigation (ForeignPtr Navigation)+noNavigation :: Maybe Navigation+noNavigation = Nothing++type family ResolveNavigationMethod (t :: Symbol) (o :: *) :: * where+    ResolveNavigationMethod "sendCommand" o = NavigationSendCommandMethodInfo+    ResolveNavigationMethod "sendEvent" o = NavigationSendEventMethodInfo+    ResolveNavigationMethod "sendKeyEvent" o = NavigationSendKeyEventMethodInfo+    ResolveNavigationMethod "sendMouseEvent" o = NavigationSendMouseEventMethodInfo+    ResolveNavigationMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveNavigationMethod t Navigation, MethodInfo info Navigation p) => IsLabelProxy t (Navigation -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveNavigationMethod t Navigation, MethodInfo info Navigation p) => IsLabel t (Navigation -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList Navigation = NavigationAttributeList+type NavigationAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Navigation = NavigationSignalList+type NavigationSignalList = ('[ ] :: [(Symbol, *)])++class ForeignPtrNewtype a => NavigationK a+instance (ForeignPtrNewtype o, IsDescendantOf Navigation o) => NavigationK o+type instance ParentTypes Navigation = NavigationParentTypes+type NavigationParentTypes = '[]++-- method Navigation::send_command+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "Navigation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TInterface "GstVideo" "NavigationCommand", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_send_command" gst_navigation_send_command :: +    Ptr Navigation ->                       -- _obj : TInterface "GstVideo" "Navigation"+    CUInt ->                                -- command : TInterface "GstVideo" "NavigationCommand"+    IO ()+++navigationSendCommand ::+    (MonadIO m, NavigationK a) =>+    a                                       -- _obj+    -> NavigationCommand                    -- command+    -> m ()                                 -- result+navigationSendCommand _obj command = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let command' = (fromIntegral . fromEnum) command+    gst_navigation_send_command _obj' command'+    touchManagedPtr _obj+    return ()++data NavigationSendCommandMethodInfo+instance (signature ~ (NavigationCommand -> m ()), MonadIO m, NavigationK a) => MethodInfo NavigationSendCommandMethodInfo a signature where+    overloadedMethod _ = navigationSendCommand++-- method Navigation::send_event+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "Navigation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_send_event" gst_navigation_send_event :: +    Ptr Navigation ->                       -- _obj : TInterface "GstVideo" "Navigation"+    Ptr Gst.Structure ->                    -- structure : TInterface "Gst" "Structure"+    IO ()+++navigationSendEvent ::+    (MonadIO m, NavigationK a) =>+    a                                       -- _obj+    -> Gst.Structure                        -- structure+    -> m ()                                 -- result+navigationSendEvent _obj structure = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let structure' = unsafeManagedPtrGetPtr structure+    gst_navigation_send_event _obj' structure'+    touchManagedPtr _obj+    touchManagedPtr structure+    return ()++data NavigationSendEventMethodInfo+instance (signature ~ (Gst.Structure -> m ()), MonadIO m, NavigationK a) => MethodInfo NavigationSendEventMethodInfo a signature where+    overloadedMethod _ = navigationSendEvent++-- method Navigation::send_key_event+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "Navigation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_send_key_event" gst_navigation_send_key_event :: +    Ptr Navigation ->                       -- _obj : TInterface "GstVideo" "Navigation"+    CString ->                              -- event : TBasicType TUTF8+    CString ->                              -- key : TBasicType TUTF8+    IO ()+++navigationSendKeyEvent ::+    (MonadIO m, NavigationK a) =>+    a                                       -- _obj+    -> T.Text                               -- event+    -> T.Text                               -- key+    -> m ()                                 -- result+navigationSendKeyEvent _obj event key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    event' <- textToCString event+    key' <- textToCString key+    gst_navigation_send_key_event _obj' event' key'+    touchManagedPtr _obj+    freeMem event'+    freeMem key'+    return ()++data NavigationSendKeyEventMethodInfo+instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, NavigationK a) => MethodInfo NavigationSendKeyEventMethodInfo a signature where+    overloadedMethod _ = navigationSendKeyEvent++-- method Navigation::send_mouse_event+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "Navigation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "button", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_send_mouse_event" gst_navigation_send_mouse_event :: +    Ptr Navigation ->                       -- _obj : TInterface "GstVideo" "Navigation"+    CString ->                              -- event : TBasicType TUTF8+    Int32 ->                                -- button : TBasicType TInt32+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    IO ()+++navigationSendMouseEvent ::+    (MonadIO m, NavigationK a) =>+    a                                       -- _obj+    -> T.Text                               -- event+    -> Int32                                -- button+    -> Double                               -- x+    -> Double                               -- y+    -> m ()                                 -- result+navigationSendMouseEvent _obj event button x y = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    event' <- textToCString event+    let x' = realToFrac x+    let y' = realToFrac y+    gst_navigation_send_mouse_event _obj' event' button x' y'+    touchManagedPtr _obj+    freeMem event'+    return ()++data NavigationSendMouseEventMethodInfo+instance (signature ~ (T.Text -> Int32 -> Double -> Double -> m ()), MonadIO m, NavigationK a) => MethodInfo NavigationSendMouseEventMethodInfo a signature where+    overloadedMethod _ = navigationSendMouseEvent++-- method Navigation::event_get_type+-- method type : MemberFunction+-- Args : [Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "NavigationEventType"+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_event_get_type" gst_navigation_event_get_type :: +    Ptr Gst.Event ->                        -- event : TInterface "Gst" "Event"+    IO CUInt+++navigationEventGetType ::+    (MonadIO m) =>+    Gst.Event                               -- event+    -> m NavigationEventType                -- result+navigationEventGetType event = liftIO $ do+    let event' = unsafeManagedPtrGetPtr event+    result <- gst_navigation_event_get_type event'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr event+    return result'++-- method Navigation::event_parse_command+-- method type : MemberFunction+-- Args : [Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TInterface "GstVideo" "NavigationCommand", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_event_parse_command" gst_navigation_event_parse_command :: +    Ptr Gst.Event ->                        -- event : TInterface "Gst" "Event"+    CUInt ->                                -- command : TInterface "GstVideo" "NavigationCommand"+    IO CInt+++navigationEventParseCommand ::+    (MonadIO m) =>+    Gst.Event                               -- event+    -> NavigationCommand                    -- command+    -> m Bool                               -- result+navigationEventParseCommand event command = liftIO $ do+    let event' = unsafeManagedPtrGetPtr event+    let command' = (fromIntegral . fromEnum) command+    result <- gst_navigation_event_parse_command event' command'+    let result' = (/= 0) result+    touchManagedPtr event+    return result'++-- method Navigation::event_parse_key_event+-- method type : MemberFunction+-- Args : [Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_event_parse_key_event" gst_navigation_event_parse_key_event :: +    Ptr Gst.Event ->                        -- event : TInterface "Gst" "Event"+    CString ->                              -- key : TBasicType TUTF8+    IO CInt+++navigationEventParseKeyEvent ::+    (MonadIO m) =>+    Gst.Event                               -- event+    -> T.Text                               -- key+    -> m Bool                               -- result+navigationEventParseKeyEvent event key = liftIO $ do+    let event' = unsafeManagedPtrGetPtr event+    key' <- textToCString key+    result <- gst_navigation_event_parse_key_event event' key'+    let result' = (/= 0) result+    touchManagedPtr event+    freeMem key'+    return result'++-- method Navigation::event_parse_mouse_button_event+-- method type : MemberFunction+-- Args : [Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "button", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_event_parse_mouse_button_event" gst_navigation_event_parse_mouse_button_event :: +    Ptr Gst.Event ->                        -- event : TInterface "Gst" "Event"+    Int32 ->                                -- button : TBasicType TInt32+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    IO CInt+++navigationEventParseMouseButtonEvent ::+    (MonadIO m) =>+    Gst.Event                               -- event+    -> Int32                                -- button+    -> Double                               -- x+    -> Double                               -- y+    -> m Bool                               -- result+navigationEventParseMouseButtonEvent event button x y = liftIO $ do+    let event' = unsafeManagedPtrGetPtr event+    let x' = realToFrac x+    let y' = realToFrac y+    result <- gst_navigation_event_parse_mouse_button_event event' button x' y'+    let result' = (/= 0) result+    touchManagedPtr event+    return result'++-- method Navigation::event_parse_mouse_move_event+-- method type : MemberFunction+-- Args : [Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_event_parse_mouse_move_event" gst_navigation_event_parse_mouse_move_event :: +    Ptr Gst.Event ->                        -- event : TInterface "Gst" "Event"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    IO CInt+++navigationEventParseMouseMoveEvent ::+    (MonadIO m) =>+    Gst.Event                               -- event+    -> Double                               -- x+    -> Double                               -- y+    -> m Bool                               -- result+navigationEventParseMouseMoveEvent event x y = liftIO $ do+    let event' = unsafeManagedPtrGetPtr event+    let x' = realToFrac x+    let y' = realToFrac y+    result <- gst_navigation_event_parse_mouse_move_event event' x' y'+    let result' = (/= 0) result+    touchManagedPtr event+    return result'++-- method Navigation::message_get_type+-- method type : MemberFunction+-- Args : [Arg {argCName = "message", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "NavigationMessageType"+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_message_get_type" gst_navigation_message_get_type :: +    Ptr Gst.Message ->                      -- message : TInterface "Gst" "Message"+    IO CUInt+++navigationMessageGetType ::+    (MonadIO m) =>+    Gst.Message                             -- message+    -> m NavigationMessageType              -- result+navigationMessageGetType message = liftIO $ do+    let message' = unsafeManagedPtrGetPtr message+    result <- gst_navigation_message_get_type message'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr message+    return result'++-- method Navigation::message_new_angles_changed+-- method type : MemberFunction+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur_angle", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_angles", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_message_new_angles_changed" gst_navigation_message_new_angles_changed :: +    Ptr Gst.Object ->                       -- src : TInterface "Gst" "Object"+    Word32 ->                               -- cur_angle : TBasicType TUInt32+    Word32 ->                               -- n_angles : TBasicType TUInt32+    IO (Ptr Gst.Message)+++navigationMessageNewAnglesChanged ::+    (MonadIO m, Gst.ObjectK a) =>+    a                                       -- src+    -> Word32                               -- curAngle+    -> Word32                               -- nAngles+    -> m Gst.Message                        -- result+navigationMessageNewAnglesChanged src curAngle nAngles = liftIO $ do+    let src' = unsafeManagedPtrCastPtr src+    result <- gst_navigation_message_new_angles_changed src' curAngle nAngles+    checkUnexpectedReturnNULL "gst_navigation_message_new_angles_changed" result+    result' <- (wrapBoxed Gst.Message) result+    touchManagedPtr src+    return result'++-- method Navigation::message_new_commands_changed+-- method type : MemberFunction+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_message_new_commands_changed" gst_navigation_message_new_commands_changed :: +    Ptr Gst.Object ->                       -- src : TInterface "Gst" "Object"+    IO (Ptr Gst.Message)+++navigationMessageNewCommandsChanged ::+    (MonadIO m, Gst.ObjectK a) =>+    a                                       -- src+    -> m Gst.Message                        -- result+navigationMessageNewCommandsChanged src = liftIO $ do+    let src' = unsafeManagedPtrCastPtr src+    result <- gst_navigation_message_new_commands_changed src'+    checkUnexpectedReturnNULL "gst_navigation_message_new_commands_changed" result+    result' <- (wrapBoxed Gst.Message) result+    touchManagedPtr src+    return result'++-- method Navigation::message_new_event+-- method type : MemberFunction+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_message_new_event" gst_navigation_message_new_event :: +    Ptr Gst.Object ->                       -- src : TInterface "Gst" "Object"+    Ptr Gst.Event ->                        -- event : TInterface "Gst" "Event"+    IO (Ptr Gst.Message)+++navigationMessageNewEvent ::+    (MonadIO m, Gst.ObjectK a) =>+    a                                       -- src+    -> Gst.Event                            -- event+    -> m Gst.Message                        -- result+navigationMessageNewEvent src event = liftIO $ do+    let src' = unsafeManagedPtrCastPtr src+    let event' = unsafeManagedPtrGetPtr event+    result <- gst_navigation_message_new_event src' event'+    checkUnexpectedReturnNULL "gst_navigation_message_new_event" result+    result' <- (wrapBoxed Gst.Message) result+    touchManagedPtr src+    touchManagedPtr event+    return result'++-- method Navigation::message_new_mouse_over+-- method type : MemberFunction+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_message_new_mouse_over" gst_navigation_message_new_mouse_over :: +    Ptr Gst.Object ->                       -- src : TInterface "Gst" "Object"+    CInt ->                                 -- active : TBasicType TBoolean+    IO (Ptr Gst.Message)+++navigationMessageNewMouseOver ::+    (MonadIO m, Gst.ObjectK a) =>+    a                                       -- src+    -> Bool                                 -- active+    -> m Gst.Message                        -- result+navigationMessageNewMouseOver src active = liftIO $ do+    let src' = unsafeManagedPtrCastPtr src+    let active' = (fromIntegral . fromEnum) active+    result <- gst_navigation_message_new_mouse_over src' active'+    checkUnexpectedReturnNULL "gst_navigation_message_new_mouse_over" result+    result' <- (wrapBoxed Gst.Message) result+    touchManagedPtr src+    return result'++-- method Navigation::message_parse_angles_changed+-- method type : MemberFunction+-- Args : [Arg {argCName = "message", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur_angle", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_angles", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_message_parse_angles_changed" gst_navigation_message_parse_angles_changed :: +    Ptr Gst.Message ->                      -- message : TInterface "Gst" "Message"+    Word32 ->                               -- cur_angle : TBasicType TUInt32+    Word32 ->                               -- n_angles : TBasicType TUInt32+    IO CInt+++navigationMessageParseAnglesChanged ::+    (MonadIO m) =>+    Gst.Message                             -- message+    -> Word32                               -- curAngle+    -> Word32                               -- nAngles+    -> m Bool                               -- result+navigationMessageParseAnglesChanged message curAngle nAngles = liftIO $ do+    let message' = unsafeManagedPtrGetPtr message+    result <- gst_navigation_message_parse_angles_changed message' curAngle nAngles+    let result' = (/= 0) result+    touchManagedPtr message+    return result'++-- method Navigation::message_parse_event+-- method type : MemberFunction+-- Args : [Arg {argCName = "message", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_message_parse_event" gst_navigation_message_parse_event :: +    Ptr Gst.Message ->                      -- message : TInterface "Gst" "Message"+    Ptr Gst.Event ->                        -- event : TInterface "Gst" "Event"+    IO CInt+++navigationMessageParseEvent ::+    (MonadIO m) =>+    Gst.Message                             -- message+    -> m (Bool,Gst.Event)                   -- result+navigationMessageParseEvent message = liftIO $ do+    let message' = unsafeManagedPtrGetPtr message+    event <- callocBoxedBytes 88 :: IO (Ptr Gst.Event)+    result <- gst_navigation_message_parse_event message' event+    let result' = (/= 0) result+    event' <- (wrapBoxed Gst.Event) event+    touchManagedPtr message+    return (result', event')++-- method Navigation::message_parse_mouse_over+-- method type : MemberFunction+-- Args : [Arg {argCName = "message", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_message_parse_mouse_over" gst_navigation_message_parse_mouse_over :: +    Ptr Gst.Message ->                      -- message : TInterface "Gst" "Message"+    CInt ->                                 -- active : TBasicType TBoolean+    IO CInt+++navigationMessageParseMouseOver ::+    (MonadIO m) =>+    Gst.Message                             -- message+    -> Bool                                 -- active+    -> m Bool                               -- result+navigationMessageParseMouseOver message active = liftIO $ do+    let message' = unsafeManagedPtrGetPtr message+    let active' = (fromIntegral . fromEnum) active+    result <- gst_navigation_message_parse_mouse_over message' active'+    let result' = (/= 0) result+    touchManagedPtr message+    return result'++-- method Navigation::query_get_type+-- method type : MemberFunction+-- Args : [Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "NavigationQueryType"+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_query_get_type" gst_navigation_query_get_type :: +    Ptr Gst.Query ->                        -- query : TInterface "Gst" "Query"+    IO CUInt+++navigationQueryGetType ::+    (MonadIO m) =>+    Gst.Query                               -- query+    -> m NavigationQueryType                -- result+navigationQueryGetType query = liftIO $ do+    let query' = unsafeManagedPtrGetPtr query+    result <- gst_navigation_query_get_type query'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr query+    return result'++-- method Navigation::query_new_angles+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_query_new_angles" gst_navigation_query_new_angles :: +    IO (Ptr Gst.Query)+++navigationQueryNewAngles ::+    (MonadIO m) =>+    m Gst.Query                             -- result+navigationQueryNewAngles  = liftIO $ do+    result <- gst_navigation_query_new_angles+    checkUnexpectedReturnNULL "gst_navigation_query_new_angles" result+    result' <- (wrapBoxed Gst.Query) result+    return result'++-- method Navigation::query_new_commands+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_query_new_commands" gst_navigation_query_new_commands :: +    IO (Ptr Gst.Query)+++navigationQueryNewCommands ::+    (MonadIO m) =>+    m Gst.Query                             -- result+navigationQueryNewCommands  = liftIO $ do+    result <- gst_navigation_query_new_commands+    checkUnexpectedReturnNULL "gst_navigation_query_new_commands" result+    result' <- (wrapBoxed Gst.Query) result+    return result'++-- method Navigation::query_parse_angles+-- method type : MemberFunction+-- Args : [Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur_angle", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_angles", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_query_parse_angles" gst_navigation_query_parse_angles :: +    Ptr Gst.Query ->                        -- query : TInterface "Gst" "Query"+    Word32 ->                               -- cur_angle : TBasicType TUInt32+    Word32 ->                               -- n_angles : TBasicType TUInt32+    IO CInt+++navigationQueryParseAngles ::+    (MonadIO m) =>+    Gst.Query                               -- query+    -> Word32                               -- curAngle+    -> Word32                               -- nAngles+    -> m Bool                               -- result+navigationQueryParseAngles query curAngle nAngles = liftIO $ do+    let query' = unsafeManagedPtrGetPtr query+    result <- gst_navigation_query_parse_angles query' curAngle nAngles+    let result' = (/= 0) result+    touchManagedPtr query+    return result'++-- method Navigation::query_parse_commands_length+-- method type : MemberFunction+-- Args : [Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_cmds", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_query_parse_commands_length" gst_navigation_query_parse_commands_length :: +    Ptr Gst.Query ->                        -- query : TInterface "Gst" "Query"+    Ptr Word32 ->                           -- n_cmds : TBasicType TUInt32+    IO CInt+++navigationQueryParseCommandsLength ::+    (MonadIO m) =>+    Gst.Query                               -- query+    -> m (Bool,Word32)                      -- result+navigationQueryParseCommandsLength query = liftIO $ do+    let query' = unsafeManagedPtrGetPtr query+    nCmds <- allocMem :: IO (Ptr Word32)+    result <- gst_navigation_query_parse_commands_length query' nCmds+    let result' = (/= 0) result+    nCmds' <- peek nCmds+    touchManagedPtr query+    freeMem nCmds+    return (result', nCmds')++-- method Navigation::query_parse_commands_nth+-- method type : MemberFunction+-- Args : [Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nth", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cmd", argType = TInterface "GstVideo" "NavigationCommand", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_query_parse_commands_nth" gst_navigation_query_parse_commands_nth :: +    Ptr Gst.Query ->                        -- query : TInterface "Gst" "Query"+    Word32 ->                               -- nth : TBasicType TUInt32+    Ptr CUInt ->                            -- cmd : TInterface "GstVideo" "NavigationCommand"+    IO CInt+++navigationQueryParseCommandsNth ::+    (MonadIO m) =>+    Gst.Query                               -- query+    -> Word32                               -- nth+    -> m (Bool,NavigationCommand)           -- result+navigationQueryParseCommandsNth query nth = liftIO $ do+    let query' = unsafeManagedPtrGetPtr query+    cmd <- allocMem :: IO (Ptr CUInt)+    result <- gst_navigation_query_parse_commands_nth query' nth cmd+    let result' = (/= 0) result+    cmd' <- peek cmd+    let cmd'' = (toEnum . fromIntegral) cmd'+    touchManagedPtr query+    freeMem cmd+    return (result', cmd'')++-- method Navigation::query_set_angles+-- method type : MemberFunction+-- Args : [Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur_angle", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_angles", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_query_set_angles" gst_navigation_query_set_angles :: +    Ptr Gst.Query ->                        -- query : TInterface "Gst" "Query"+    Word32 ->                               -- cur_angle : TBasicType TUInt32+    Word32 ->                               -- n_angles : TBasicType TUInt32+    IO ()+++navigationQuerySetAngles ::+    (MonadIO m) =>+    Gst.Query                               -- query+    -> Word32                               -- curAngle+    -> Word32                               -- nAngles+    -> m ()                                 -- result+navigationQuerySetAngles query curAngle nAngles = liftIO $ do+    let query' = unsafeManagedPtrGetPtr query+    gst_navigation_query_set_angles query' curAngle nAngles+    touchManagedPtr query+    return ()++-- method Navigation::query_set_commandsv+-- method type : MemberFunction+-- Args : [Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_cmds", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cmds", argType = TInterface "GstVideo" "NavigationCommand", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_navigation_query_set_commandsv" gst_navigation_query_set_commandsv :: +    Ptr Gst.Query ->                        -- query : TInterface "Gst" "Query"+    Int32 ->                                -- n_cmds : TBasicType TInt32+    CUInt ->                                -- cmds : TInterface "GstVideo" "NavigationCommand"+    IO ()+++navigationQuerySetCommandsv ::+    (MonadIO m) =>+    Gst.Query                               -- query+    -> Int32                                -- nCmds+    -> NavigationCommand                    -- cmds+    -> m ()                                 -- result+navigationQuerySetCommandsv query nCmds cmds = liftIO $ do+    let query' = unsafeManagedPtrGetPtr query+    let cmds' = (fromIntegral . fromEnum) cmds+    gst_navigation_query_set_commandsv query' nCmds cmds'+    touchManagedPtr query+    return ()++
+ GI/GstVideo/Interfaces/Navigation.hs-boot view
@@ -0,0 +1,16 @@+module GI.GstVideo.Interfaces.Navigation where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Navigation = Navigation (ForeignPtr Navigation)+class ForeignPtrNewtype a => NavigationK a+instance (ForeignPtrNewtype o, IsDescendantOf Navigation o) => NavigationK o+data NavigationSendCommandMethodInfo+data NavigationSendEventMethodInfo+data NavigationSendKeyEventMethodInfo+data NavigationSendMouseEventMethodInfo
+ GI/GstVideo/Interfaces/VideoOrientation.hs view
@@ -0,0 +1,353 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Interfaces.VideoOrientation+    ( ++-- * Exported types+    VideoOrientation(..)                    ,+    noVideoOrientation                      ,+    VideoOrientationK                       ,+++ -- * Methods+-- ** videoOrientationGetHcenter+    VideoOrientationGetHcenterMethodInfo    ,+    videoOrientationGetHcenter              ,+++-- ** videoOrientationGetHflip+    VideoOrientationGetHflipMethodInfo      ,+    videoOrientationGetHflip                ,+++-- ** videoOrientationGetVcenter+    VideoOrientationGetVcenterMethodInfo    ,+    videoOrientationGetVcenter              ,+++-- ** videoOrientationGetVflip+    VideoOrientationGetVflipMethodInfo      ,+    videoOrientationGetVflip                ,+++-- ** videoOrientationSetHcenter+    VideoOrientationSetHcenterMethodInfo    ,+    videoOrientationSetHcenter              ,+++-- ** videoOrientationSetHflip+    VideoOrientationSetHflipMethodInfo      ,+    videoOrientationSetHflip                ,+++-- ** videoOrientationSetVcenter+    VideoOrientationSetVcenterMethodInfo    ,+    videoOrientationSetVcenter              ,+++-- ** videoOrientationSetVflip+    VideoOrientationSetVflipMethodInfo      ,+    videoOrientationSetVflip                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++-- interface VideoOrientation ++newtype VideoOrientation = VideoOrientation (ForeignPtr VideoOrientation)+noVideoOrientation :: Maybe VideoOrientation+noVideoOrientation = Nothing++type family ResolveVideoOrientationMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoOrientationMethod "getHcenter" o = VideoOrientationGetHcenterMethodInfo+    ResolveVideoOrientationMethod "getHflip" o = VideoOrientationGetHflipMethodInfo+    ResolveVideoOrientationMethod "getVcenter" o = VideoOrientationGetVcenterMethodInfo+    ResolveVideoOrientationMethod "getVflip" o = VideoOrientationGetVflipMethodInfo+    ResolveVideoOrientationMethod "setHcenter" o = VideoOrientationSetHcenterMethodInfo+    ResolveVideoOrientationMethod "setHflip" o = VideoOrientationSetHflipMethodInfo+    ResolveVideoOrientationMethod "setVcenter" o = VideoOrientationSetVcenterMethodInfo+    ResolveVideoOrientationMethod "setVflip" o = VideoOrientationSetVflipMethodInfo+    ResolveVideoOrientationMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoOrientationMethod t VideoOrientation, MethodInfo info VideoOrientation p) => IsLabelProxy t (VideoOrientation -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoOrientationMethod t VideoOrientation, MethodInfo info VideoOrientation p) => IsLabel t (VideoOrientation -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList VideoOrientation = VideoOrientationAttributeList+type VideoOrientationAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList VideoOrientation = VideoOrientationSignalList+type VideoOrientationSignalList = ('[ ] :: [(Symbol, *)])++class ForeignPtrNewtype a => VideoOrientationK a+instance (ForeignPtrNewtype o, IsDescendantOf VideoOrientation o) => VideoOrientationK o+type instance ParentTypes VideoOrientation = VideoOrientationParentTypes+type VideoOrientationParentTypes = '[]++-- method VideoOrientation::get_hcenter+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOrientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "center", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_orientation_get_hcenter" gst_video_orientation_get_hcenter :: +    Ptr VideoOrientation ->                 -- _obj : TInterface "GstVideo" "VideoOrientation"+    Int32 ->                                -- center : TBasicType TInt32+    IO CInt+++videoOrientationGetHcenter ::+    (MonadIO m, VideoOrientationK a) =>+    a                                       -- _obj+    -> Int32                                -- center+    -> m Bool                               -- result+videoOrientationGetHcenter _obj center = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_orientation_get_hcenter _obj' center+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoOrientationGetHcenterMethodInfo+instance (signature ~ (Int32 -> m Bool), MonadIO m, VideoOrientationK a) => MethodInfo VideoOrientationGetHcenterMethodInfo a signature where+    overloadedMethod _ = videoOrientationGetHcenter++-- method VideoOrientation::get_hflip+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOrientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flip", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_orientation_get_hflip" gst_video_orientation_get_hflip :: +    Ptr VideoOrientation ->                 -- _obj : TInterface "GstVideo" "VideoOrientation"+    CInt ->                                 -- flip : TBasicType TBoolean+    IO CInt+++videoOrientationGetHflip ::+    (MonadIO m, VideoOrientationK a) =>+    a                                       -- _obj+    -> Bool                                 -- flip+    -> m Bool                               -- result+videoOrientationGetHflip _obj flip = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flip' = (fromIntegral . fromEnum) flip+    result <- gst_video_orientation_get_hflip _obj' flip'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoOrientationGetHflipMethodInfo+instance (signature ~ (Bool -> m Bool), MonadIO m, VideoOrientationK a) => MethodInfo VideoOrientationGetHflipMethodInfo a signature where+    overloadedMethod _ = videoOrientationGetHflip++-- method VideoOrientation::get_vcenter+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOrientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "center", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_orientation_get_vcenter" gst_video_orientation_get_vcenter :: +    Ptr VideoOrientation ->                 -- _obj : TInterface "GstVideo" "VideoOrientation"+    Int32 ->                                -- center : TBasicType TInt32+    IO CInt+++videoOrientationGetVcenter ::+    (MonadIO m, VideoOrientationK a) =>+    a                                       -- _obj+    -> Int32                                -- center+    -> m Bool                               -- result+videoOrientationGetVcenter _obj center = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_orientation_get_vcenter _obj' center+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoOrientationGetVcenterMethodInfo+instance (signature ~ (Int32 -> m Bool), MonadIO m, VideoOrientationK a) => MethodInfo VideoOrientationGetVcenterMethodInfo a signature where+    overloadedMethod _ = videoOrientationGetVcenter++-- method VideoOrientation::get_vflip+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOrientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flip", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_orientation_get_vflip" gst_video_orientation_get_vflip :: +    Ptr VideoOrientation ->                 -- _obj : TInterface "GstVideo" "VideoOrientation"+    CInt ->                                 -- flip : TBasicType TBoolean+    IO CInt+++videoOrientationGetVflip ::+    (MonadIO m, VideoOrientationK a) =>+    a                                       -- _obj+    -> Bool                                 -- flip+    -> m Bool                               -- result+videoOrientationGetVflip _obj flip = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flip' = (fromIntegral . fromEnum) flip+    result <- gst_video_orientation_get_vflip _obj' flip'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoOrientationGetVflipMethodInfo+instance (signature ~ (Bool -> m Bool), MonadIO m, VideoOrientationK a) => MethodInfo VideoOrientationGetVflipMethodInfo a signature where+    overloadedMethod _ = videoOrientationGetVflip++-- method VideoOrientation::set_hcenter+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOrientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "center", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_orientation_set_hcenter" gst_video_orientation_set_hcenter :: +    Ptr VideoOrientation ->                 -- _obj : TInterface "GstVideo" "VideoOrientation"+    Int32 ->                                -- center : TBasicType TInt32+    IO CInt+++videoOrientationSetHcenter ::+    (MonadIO m, VideoOrientationK a) =>+    a                                       -- _obj+    -> Int32                                -- center+    -> m Bool                               -- result+videoOrientationSetHcenter _obj center = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_orientation_set_hcenter _obj' center+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoOrientationSetHcenterMethodInfo+instance (signature ~ (Int32 -> m Bool), MonadIO m, VideoOrientationK a) => MethodInfo VideoOrientationSetHcenterMethodInfo a signature where+    overloadedMethod _ = videoOrientationSetHcenter++-- method VideoOrientation::set_hflip+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOrientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flip", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_orientation_set_hflip" gst_video_orientation_set_hflip :: +    Ptr VideoOrientation ->                 -- _obj : TInterface "GstVideo" "VideoOrientation"+    CInt ->                                 -- flip : TBasicType TBoolean+    IO CInt+++videoOrientationSetHflip ::+    (MonadIO m, VideoOrientationK a) =>+    a                                       -- _obj+    -> Bool                                 -- flip+    -> m Bool                               -- result+videoOrientationSetHflip _obj flip = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flip' = (fromIntegral . fromEnum) flip+    result <- gst_video_orientation_set_hflip _obj' flip'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoOrientationSetHflipMethodInfo+instance (signature ~ (Bool -> m Bool), MonadIO m, VideoOrientationK a) => MethodInfo VideoOrientationSetHflipMethodInfo a signature where+    overloadedMethod _ = videoOrientationSetHflip++-- method VideoOrientation::set_vcenter+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOrientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "center", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_orientation_set_vcenter" gst_video_orientation_set_vcenter :: +    Ptr VideoOrientation ->                 -- _obj : TInterface "GstVideo" "VideoOrientation"+    Int32 ->                                -- center : TBasicType TInt32+    IO CInt+++videoOrientationSetVcenter ::+    (MonadIO m, VideoOrientationK a) =>+    a                                       -- _obj+    -> Int32                                -- center+    -> m Bool                               -- result+videoOrientationSetVcenter _obj center = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_orientation_set_vcenter _obj' center+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoOrientationSetVcenterMethodInfo+instance (signature ~ (Int32 -> m Bool), MonadIO m, VideoOrientationK a) => MethodInfo VideoOrientationSetVcenterMethodInfo a signature where+    overloadedMethod _ = videoOrientationSetVcenter++-- method VideoOrientation::set_vflip+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOrientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flip", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_orientation_set_vflip" gst_video_orientation_set_vflip :: +    Ptr VideoOrientation ->                 -- _obj : TInterface "GstVideo" "VideoOrientation"+    CInt ->                                 -- flip : TBasicType TBoolean+    IO CInt+++videoOrientationSetVflip ::+    (MonadIO m, VideoOrientationK a) =>+    a                                       -- _obj+    -> Bool                                 -- flip+    -> m Bool                               -- result+videoOrientationSetVflip _obj flip = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flip' = (fromIntegral . fromEnum) flip+    result <- gst_video_orientation_set_vflip _obj' flip'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoOrientationSetVflipMethodInfo+instance (signature ~ (Bool -> m Bool), MonadIO m, VideoOrientationK a) => MethodInfo VideoOrientationSetVflipMethodInfo a signature where+    overloadedMethod _ = videoOrientationSetVflip++
+ GI/GstVideo/Interfaces/VideoOrientation.hs-boot view
@@ -0,0 +1,20 @@+module GI.GstVideo.Interfaces.VideoOrientation where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoOrientation = VideoOrientation (ForeignPtr VideoOrientation)+class ForeignPtrNewtype a => VideoOrientationK a+instance (ForeignPtrNewtype o, IsDescendantOf VideoOrientation o) => VideoOrientationK o+data VideoOrientationGetHcenterMethodInfo+data VideoOrientationGetHflipMethodInfo+data VideoOrientationGetVcenterMethodInfo+data VideoOrientationGetVflipMethodInfo+data VideoOrientationSetHcenterMethodInfo+data VideoOrientationSetHflipMethodInfo+data VideoOrientationSetVcenterMethodInfo+data VideoOrientationSetVflipMethodInfo
+ GI/GstVideo/Interfaces/VideoOverlay.hs view
@@ -0,0 +1,275 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Interfaces.VideoOverlay+    ( ++-- * Exported types+    VideoOverlay(..)                        ,+    noVideoOverlay                          ,+    VideoOverlayK                           ,+++ -- * Methods+-- ** videoOverlayExpose+    VideoOverlayExposeMethodInfo            ,+    videoOverlayExpose                      ,+++-- ** videoOverlayGotWindowHandle+    VideoOverlayGotWindowHandleMethodInfo   ,+    videoOverlayGotWindowHandle             ,+++-- ** videoOverlayHandleEvents+    VideoOverlayHandleEventsMethodInfo      ,+    videoOverlayHandleEvents                ,+++-- ** videoOverlayPrepareWindowHandle+    VideoOverlayPrepareWindowHandleMethodInfo,+    videoOverlayPrepareWindowHandle         ,+++-- ** videoOverlaySetRenderRectangle+    VideoOverlaySetRenderRectangleMethodInfo,+    videoOverlaySetRenderRectangle          ,+++-- ** videoOverlaySetWindowHandle+    VideoOverlaySetWindowHandleMethodInfo   ,+    videoOverlaySetWindowHandle             ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++-- interface VideoOverlay ++newtype VideoOverlay = VideoOverlay (ForeignPtr VideoOverlay)+noVideoOverlay :: Maybe VideoOverlay+noVideoOverlay = Nothing++type family ResolveVideoOverlayMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoOverlayMethod "expose" o = VideoOverlayExposeMethodInfo+    ResolveVideoOverlayMethod "gotWindowHandle" o = VideoOverlayGotWindowHandleMethodInfo+    ResolveVideoOverlayMethod "handleEvents" o = VideoOverlayHandleEventsMethodInfo+    ResolveVideoOverlayMethod "prepareWindowHandle" o = VideoOverlayPrepareWindowHandleMethodInfo+    ResolveVideoOverlayMethod "setRenderRectangle" o = VideoOverlaySetRenderRectangleMethodInfo+    ResolveVideoOverlayMethod "setWindowHandle" o = VideoOverlaySetWindowHandleMethodInfo+    ResolveVideoOverlayMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoOverlayMethod t VideoOverlay, MethodInfo info VideoOverlay p) => IsLabelProxy t (VideoOverlay -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoOverlayMethod t VideoOverlay, MethodInfo info VideoOverlay p) => IsLabel t (VideoOverlay -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList VideoOverlay = VideoOverlayAttributeList+type VideoOverlayAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList VideoOverlay = VideoOverlaySignalList+type VideoOverlaySignalList = ('[ ] :: [(Symbol, *)])++class ForeignPtrNewtype a => VideoOverlayK a+instance (ForeignPtrNewtype o, IsDescendantOf VideoOverlay o) => VideoOverlayK o+type instance ParentTypes VideoOverlay = VideoOverlayParentTypes+type VideoOverlayParentTypes = '[]++-- method VideoOverlay::expose+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_expose" gst_video_overlay_expose :: +    Ptr VideoOverlay ->                     -- _obj : TInterface "GstVideo" "VideoOverlay"+    IO ()+++videoOverlayExpose ::+    (MonadIO m, VideoOverlayK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+videoOverlayExpose _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_video_overlay_expose _obj'+    touchManagedPtr _obj+    return ()++data VideoOverlayExposeMethodInfo+instance (signature ~ (m ()), MonadIO m, VideoOverlayK a) => MethodInfo VideoOverlayExposeMethodInfo a signature where+    overloadedMethod _ = videoOverlayExpose++-- method VideoOverlay::got_window_handle+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handle", argType = TBasicType TUIntPtr, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_got_window_handle" gst_video_overlay_got_window_handle :: +    Ptr VideoOverlay ->                     -- _obj : TInterface "GstVideo" "VideoOverlay"+    CUIntPtr ->                             -- handle : TBasicType TUIntPtr+    IO ()+++videoOverlayGotWindowHandle ::+    (MonadIO m, VideoOverlayK a) =>+    a                                       -- _obj+    -> CUIntPtr                             -- handle+    -> m ()                                 -- result+videoOverlayGotWindowHandle _obj handle = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_video_overlay_got_window_handle _obj' handle+    touchManagedPtr _obj+    return ()++data VideoOverlayGotWindowHandleMethodInfo+instance (signature ~ (CUIntPtr -> m ()), MonadIO m, VideoOverlayK a) => MethodInfo VideoOverlayGotWindowHandleMethodInfo a signature where+    overloadedMethod _ = videoOverlayGotWindowHandle++-- method VideoOverlay::handle_events+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handle_events", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_handle_events" gst_video_overlay_handle_events :: +    Ptr VideoOverlay ->                     -- _obj : TInterface "GstVideo" "VideoOverlay"+    CInt ->                                 -- handle_events : TBasicType TBoolean+    IO ()+++videoOverlayHandleEvents ::+    (MonadIO m, VideoOverlayK a) =>+    a                                       -- _obj+    -> Bool                                 -- handleEvents+    -> m ()                                 -- result+videoOverlayHandleEvents _obj handleEvents = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let handleEvents' = (fromIntegral . fromEnum) handleEvents+    gst_video_overlay_handle_events _obj' handleEvents'+    touchManagedPtr _obj+    return ()++data VideoOverlayHandleEventsMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, VideoOverlayK a) => MethodInfo VideoOverlayHandleEventsMethodInfo a signature where+    overloadedMethod _ = videoOverlayHandleEvents++-- method VideoOverlay::prepare_window_handle+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_prepare_window_handle" gst_video_overlay_prepare_window_handle :: +    Ptr VideoOverlay ->                     -- _obj : TInterface "GstVideo" "VideoOverlay"+    IO ()+++videoOverlayPrepareWindowHandle ::+    (MonadIO m, VideoOverlayK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+videoOverlayPrepareWindowHandle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_video_overlay_prepare_window_handle _obj'+    touchManagedPtr _obj+    return ()++data VideoOverlayPrepareWindowHandleMethodInfo+instance (signature ~ (m ()), MonadIO m, VideoOverlayK a) => MethodInfo VideoOverlayPrepareWindowHandleMethodInfo a signature where+    overloadedMethod _ = videoOverlayPrepareWindowHandle++-- method VideoOverlay::set_render_rectangle+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_set_render_rectangle" gst_video_overlay_set_render_rectangle :: +    Ptr VideoOverlay ->                     -- _obj : TInterface "GstVideo" "VideoOverlay"+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO CInt+++videoOverlaySetRenderRectangle ::+    (MonadIO m, VideoOverlayK a) =>+    a                                       -- _obj+    -> Int32                                -- x+    -> Int32                                -- y+    -> Int32                                -- width+    -> Int32                                -- height+    -> m Bool                               -- result+videoOverlaySetRenderRectangle _obj x y width height = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_overlay_set_render_rectangle _obj' x y width height+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoOverlaySetRenderRectangleMethodInfo+instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> m Bool), MonadIO m, VideoOverlayK a) => MethodInfo VideoOverlaySetRenderRectangleMethodInfo a signature where+    overloadedMethod _ = videoOverlaySetRenderRectangle++-- method VideoOverlay::set_window_handle+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handle", argType = TBasicType TUIntPtr, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_set_window_handle" gst_video_overlay_set_window_handle :: +    Ptr VideoOverlay ->                     -- _obj : TInterface "GstVideo" "VideoOverlay"+    CUIntPtr ->                             -- handle : TBasicType TUIntPtr+    IO ()+++videoOverlaySetWindowHandle ::+    (MonadIO m, VideoOverlayK a) =>+    a                                       -- _obj+    -> CUIntPtr                             -- handle+    -> m ()                                 -- result+videoOverlaySetWindowHandle _obj handle = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_video_overlay_set_window_handle _obj' handle+    touchManagedPtr _obj+    return ()++data VideoOverlaySetWindowHandleMethodInfo+instance (signature ~ (CUIntPtr -> m ()), MonadIO m, VideoOverlayK a) => MethodInfo VideoOverlaySetWindowHandleMethodInfo a signature where+    overloadedMethod _ = videoOverlaySetWindowHandle++
+ GI/GstVideo/Interfaces/VideoOverlay.hs-boot view
@@ -0,0 +1,18 @@+module GI.GstVideo.Interfaces.VideoOverlay where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoOverlay = VideoOverlay (ForeignPtr VideoOverlay)+class ForeignPtrNewtype a => VideoOverlayK a+instance (ForeignPtrNewtype o, IsDescendantOf VideoOverlay o) => VideoOverlayK o+data VideoOverlayExposeMethodInfo+data VideoOverlayGotWindowHandleMethodInfo+data VideoOverlayHandleEventsMethodInfo+data VideoOverlayPrepareWindowHandleMethodInfo+data VideoOverlaySetRenderRectangleMethodInfo+data VideoOverlaySetWindowHandleMethodInfo
+ GI/GstVideo/Objects.hs view
@@ -0,0 +1,37 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Objects+    (     module GI.GstVideo.Objects.ColorBalanceChannel,+    module GI.GstVideo.Objects.VideoBufferPool,+    module GI.GstVideo.Objects.VideoDecoder ,+    module GI.GstVideo.Objects.VideoEncoder ,+    module GI.GstVideo.Objects.VideoFilter  ,+    module GI.GstVideo.Objects.VideoSink    ,+++    ) where++import GI.GstVideo.Objects.ColorBalanceChannel+import GI.GstVideo.Objects.VideoBufferPool+import GI.GstVideo.Objects.VideoDecoder+import GI.GstVideo.Objects.VideoEncoder+import GI.GstVideo.Objects.VideoFilter+import GI.GstVideo.Objects.VideoSink++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++
+ GI/GstVideo/Objects/ColorBalanceChannel.hs view
@@ -0,0 +1,153 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Objects.ColorBalanceChannel+    ( ++-- * Exported types+    ColorBalanceChannel(..)                 ,+    ColorBalanceChannelK                    ,+    toColorBalanceChannel                   ,+    noColorBalanceChannel                   ,+++ -- * Signals+-- ** ValueChanged+    ColorBalanceChannelValueChangedCallback ,+    ColorBalanceChannelValueChangedCallbackC,+    ColorBalanceChannelValueChangedSignalInfo,+    afterColorBalanceChannelValueChanged    ,+    colorBalanceChannelValueChangedCallbackWrapper,+    colorBalanceChannelValueChangedClosure  ,+    mkColorBalanceChannelValueChangedCallback,+    noColorBalanceChannelValueChangedCallback,+    onColorBalanceChannelValueChanged       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.GObject as GObject++newtype ColorBalanceChannel = ColorBalanceChannel (ForeignPtr ColorBalanceChannel)+foreign import ccall "gst_color_balance_channel_get_type"+    c_gst_color_balance_channel_get_type :: IO GType++type instance ParentTypes ColorBalanceChannel = ColorBalanceChannelParentTypes+type ColorBalanceChannelParentTypes = '[GObject.Object]++instance GObject ColorBalanceChannel where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gst_color_balance_channel_get_type+    ++class GObject o => ColorBalanceChannelK o+instance (GObject o, IsDescendantOf ColorBalanceChannel o) => ColorBalanceChannelK o++toColorBalanceChannel :: ColorBalanceChannelK o => o -> IO ColorBalanceChannel+toColorBalanceChannel = unsafeCastTo ColorBalanceChannel++noColorBalanceChannel :: Maybe ColorBalanceChannel+noColorBalanceChannel = Nothing++type family ResolveColorBalanceChannelMethod (t :: Symbol) (o :: *) :: * where+    ResolveColorBalanceChannelMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveColorBalanceChannelMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveColorBalanceChannelMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveColorBalanceChannelMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveColorBalanceChannelMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveColorBalanceChannelMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveColorBalanceChannelMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveColorBalanceChannelMethod "ref" o = GObject.ObjectRefMethodInfo+    ResolveColorBalanceChannelMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveColorBalanceChannelMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveColorBalanceChannelMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveColorBalanceChannelMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveColorBalanceChannelMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveColorBalanceChannelMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveColorBalanceChannelMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveColorBalanceChannelMethod "unref" o = GObject.ObjectUnrefMethodInfo+    ResolveColorBalanceChannelMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveColorBalanceChannelMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveColorBalanceChannelMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveColorBalanceChannelMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveColorBalanceChannelMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveColorBalanceChannelMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveColorBalanceChannelMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveColorBalanceChannelMethod t ColorBalanceChannel, MethodInfo info ColorBalanceChannel p) => IsLabelProxy t (ColorBalanceChannel -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveColorBalanceChannelMethod t ColorBalanceChannel, MethodInfo info ColorBalanceChannel p) => IsLabel t (ColorBalanceChannel -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- signal ColorBalanceChannel::value-changed+type ColorBalanceChannelValueChangedCallback =+    Int32 ->+    IO ()++noColorBalanceChannelValueChangedCallback :: Maybe ColorBalanceChannelValueChangedCallback+noColorBalanceChannelValueChangedCallback = Nothing++type ColorBalanceChannelValueChangedCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkColorBalanceChannelValueChangedCallback :: ColorBalanceChannelValueChangedCallbackC -> IO (FunPtr ColorBalanceChannelValueChangedCallbackC)++colorBalanceChannelValueChangedClosure :: ColorBalanceChannelValueChangedCallback -> IO Closure+colorBalanceChannelValueChangedClosure cb = newCClosure =<< mkColorBalanceChannelValueChangedCallback wrapped+    where wrapped = colorBalanceChannelValueChangedCallbackWrapper cb++colorBalanceChannelValueChangedCallbackWrapper ::+    ColorBalanceChannelValueChangedCallback ->+    Ptr () ->+    Int32 ->+    Ptr () ->+    IO ()+colorBalanceChannelValueChangedCallbackWrapper _cb _ value _ = do+    _cb  value++onColorBalanceChannelValueChanged :: (GObject a, MonadIO m) => a -> ColorBalanceChannelValueChangedCallback -> m SignalHandlerId+onColorBalanceChannelValueChanged obj cb = liftIO $ connectColorBalanceChannelValueChanged obj cb SignalConnectBefore+afterColorBalanceChannelValueChanged :: (GObject a, MonadIO m) => a -> ColorBalanceChannelValueChangedCallback -> m SignalHandlerId+afterColorBalanceChannelValueChanged obj cb = connectColorBalanceChannelValueChanged obj cb SignalConnectAfter++connectColorBalanceChannelValueChanged :: (GObject a, MonadIO m) =>+                                          a -> ColorBalanceChannelValueChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectColorBalanceChannelValueChanged obj cb after = liftIO $ do+    cb' <- mkColorBalanceChannelValueChangedCallback (colorBalanceChannelValueChangedCallbackWrapper cb)+    connectSignalFunPtr obj "value-changed" cb' after++type instance AttributeList ColorBalanceChannel = ColorBalanceChannelAttributeList+type ColorBalanceChannelAttributeList = ('[ ] :: [(Symbol, *)])++data ColorBalanceChannelValueChangedSignalInfo+instance SignalInfo ColorBalanceChannelValueChangedSignalInfo where+    type HaskellCallbackType ColorBalanceChannelValueChangedSignalInfo = ColorBalanceChannelValueChangedCallback+    connectSignal _ = connectColorBalanceChannelValueChanged++type instance SignalList ColorBalanceChannel = ColorBalanceChannelSignalList+type ColorBalanceChannelSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("valueChanged", ColorBalanceChannelValueChangedSignalInfo)] :: [(Symbol, *)])++
+ GI/GstVideo/Objects/ColorBalanceChannel.hs-boot view
@@ -0,0 +1,14 @@+module GI.GstVideo.Objects.ColorBalanceChannel where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ColorBalanceChannel = ColorBalanceChannel (ForeignPtr ColorBalanceChannel)+instance GObject ColorBalanceChannel where+class GObject o => ColorBalanceChannelK o+instance (GObject o, IsDescendantOf ColorBalanceChannel o) => ColorBalanceChannelK o+data ColorBalanceChannelValueChangedSignalInfo
+ GI/GstVideo/Objects/VideoBufferPool.hs view
@@ -0,0 +1,151 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Objects.VideoBufferPool+    ( ++-- * Exported types+    VideoBufferPool(..)                     ,+    VideoBufferPoolK                        ,+    toVideoBufferPool                       ,+    noVideoBufferPool                       ,+++ -- * Methods+-- ** videoBufferPoolNew+    videoBufferPoolNew                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gst as Gst++newtype VideoBufferPool = VideoBufferPool (ForeignPtr VideoBufferPool)+foreign import ccall "gst_video_buffer_pool_get_type"+    c_gst_video_buffer_pool_get_type :: IO GType++type instance ParentTypes VideoBufferPool = VideoBufferPoolParentTypes+type VideoBufferPoolParentTypes = '[Gst.BufferPool, Gst.Object, GObject.Object]++instance GObject VideoBufferPool where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_video_buffer_pool_get_type+    ++class GObject o => VideoBufferPoolK o+instance (GObject o, IsDescendantOf VideoBufferPool o) => VideoBufferPoolK o++toVideoBufferPool :: VideoBufferPoolK o => o -> IO VideoBufferPool+toVideoBufferPool = unsafeCastTo VideoBufferPool++noVideoBufferPool :: Maybe VideoBufferPool+noVideoBufferPool = Nothing++type family ResolveVideoBufferPoolMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoBufferPoolMethod "acquireBuffer" o = Gst.BufferPoolAcquireBufferMethodInfo+    ResolveVideoBufferPoolMethod "addControlBinding" o = Gst.ObjectAddControlBindingMethodInfo+    ResolveVideoBufferPoolMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveVideoBufferPoolMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveVideoBufferPoolMethod "defaultError" o = Gst.ObjectDefaultErrorMethodInfo+    ResolveVideoBufferPoolMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveVideoBufferPoolMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveVideoBufferPoolMethod "hasActiveControlBindings" o = Gst.ObjectHasActiveControlBindingsMethodInfo+    ResolveVideoBufferPoolMethod "hasAncestor" o = Gst.ObjectHasAncestorMethodInfo+    ResolveVideoBufferPoolMethod "hasAsAncestor" o = Gst.ObjectHasAsAncestorMethodInfo+    ResolveVideoBufferPoolMethod "hasAsParent" o = Gst.ObjectHasAsParentMethodInfo+    ResolveVideoBufferPoolMethod "hasOption" o = Gst.BufferPoolHasOptionMethodInfo+    ResolveVideoBufferPoolMethod "isActive" o = Gst.BufferPoolIsActiveMethodInfo+    ResolveVideoBufferPoolMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveVideoBufferPoolMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveVideoBufferPoolMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveVideoBufferPoolMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveVideoBufferPoolMethod "releaseBuffer" o = Gst.BufferPoolReleaseBufferMethodInfo+    ResolveVideoBufferPoolMethod "removeControlBinding" o = Gst.ObjectRemoveControlBindingMethodInfo+    ResolveVideoBufferPoolMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveVideoBufferPoolMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveVideoBufferPoolMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveVideoBufferPoolMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveVideoBufferPoolMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveVideoBufferPoolMethod "suggestNextSync" o = Gst.ObjectSuggestNextSyncMethodInfo+    ResolveVideoBufferPoolMethod "syncValues" o = Gst.ObjectSyncValuesMethodInfo+    ResolveVideoBufferPoolMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveVideoBufferPoolMethod "unparent" o = Gst.ObjectUnparentMethodInfo+    ResolveVideoBufferPoolMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveVideoBufferPoolMethod "getConfig" o = Gst.BufferPoolGetConfigMethodInfo+    ResolveVideoBufferPoolMethod "getControlBinding" o = Gst.ObjectGetControlBindingMethodInfo+    ResolveVideoBufferPoolMethod "getControlRate" o = Gst.ObjectGetControlRateMethodInfo+    ResolveVideoBufferPoolMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveVideoBufferPoolMethod "getGValueArray" o = Gst.ObjectGetGValueArrayMethodInfo+    ResolveVideoBufferPoolMethod "getName" o = Gst.ObjectGetNameMethodInfo+    ResolveVideoBufferPoolMethod "getOptions" o = Gst.BufferPoolGetOptionsMethodInfo+    ResolveVideoBufferPoolMethod "getParent" o = Gst.ObjectGetParentMethodInfo+    ResolveVideoBufferPoolMethod "getPathString" o = Gst.ObjectGetPathStringMethodInfo+    ResolveVideoBufferPoolMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveVideoBufferPoolMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveVideoBufferPoolMethod "getValue" o = Gst.ObjectGetValueMethodInfo+    ResolveVideoBufferPoolMethod "getValueArray" o = Gst.ObjectGetValueArrayMethodInfo+    ResolveVideoBufferPoolMethod "setActive" o = Gst.BufferPoolSetActiveMethodInfo+    ResolveVideoBufferPoolMethod "setConfig" o = Gst.BufferPoolSetConfigMethodInfo+    ResolveVideoBufferPoolMethod "setControlBindingDisabled" o = Gst.ObjectSetControlBindingDisabledMethodInfo+    ResolveVideoBufferPoolMethod "setControlBindingsDisabled" o = Gst.ObjectSetControlBindingsDisabledMethodInfo+    ResolveVideoBufferPoolMethod "setControlRate" o = Gst.ObjectSetControlRateMethodInfo+    ResolveVideoBufferPoolMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveVideoBufferPoolMethod "setFlushing" o = Gst.BufferPoolSetFlushingMethodInfo+    ResolveVideoBufferPoolMethod "setName" o = Gst.ObjectSetNameMethodInfo+    ResolveVideoBufferPoolMethod "setParent" o = Gst.ObjectSetParentMethodInfo+    ResolveVideoBufferPoolMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveVideoBufferPoolMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoBufferPoolMethod t VideoBufferPool, MethodInfo info VideoBufferPool p) => IsLabelProxy t (VideoBufferPool -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoBufferPoolMethod t VideoBufferPool, MethodInfo info VideoBufferPool p) => IsLabel t (VideoBufferPool -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList VideoBufferPool = VideoBufferPoolAttributeList+type VideoBufferPoolAttributeList = ('[ '("name", Gst.ObjectNamePropertyInfo), '("parent", Gst.ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList VideoBufferPool = VideoBufferPoolSignalList+type VideoBufferPoolSignalList = ('[ '("deepNotify", Gst.ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method VideoBufferPool::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoBufferPool"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_buffer_pool_new" gst_video_buffer_pool_new :: +    IO (Ptr VideoBufferPool)+++videoBufferPoolNew ::+    (MonadIO m) =>+    m VideoBufferPool                       -- result+videoBufferPoolNew  = liftIO $ do+    result <- gst_video_buffer_pool_new+    checkUnexpectedReturnNULL "gst_video_buffer_pool_new" result+    result' <- (newObject VideoBufferPool) result+    return result'++
+ GI/GstVideo/Objects/VideoBufferPool.hs-boot view
@@ -0,0 +1,13 @@+module GI.GstVideo.Objects.VideoBufferPool where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoBufferPool = VideoBufferPool (ForeignPtr VideoBufferPool)+instance GObject VideoBufferPool where+class GObject o => VideoBufferPoolK o+instance (GObject o, IsDescendantOf VideoBufferPool o) => VideoBufferPoolK o
+ GI/GstVideo/Objects/VideoDecoder.hs view
@@ -0,0 +1,1315 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Objects.VideoDecoder+    ( ++-- * Exported types+    VideoDecoder(..)                        ,+    VideoDecoderK                           ,+    toVideoDecoder                          ,+    noVideoDecoder                          ,+++ -- * Methods+-- ** videoDecoderAddToFrame+    VideoDecoderAddToFrameMethodInfo        ,+    videoDecoderAddToFrame                  ,+++-- ** videoDecoderAllocateOutputBuffer+    VideoDecoderAllocateOutputBufferMethodInfo,+    videoDecoderAllocateOutputBuffer        ,+++-- ** videoDecoderAllocateOutputFrame+    VideoDecoderAllocateOutputFrameMethodInfo,+    videoDecoderAllocateOutputFrame         ,+++-- ** videoDecoderDropFrame+    VideoDecoderDropFrameMethodInfo         ,+    videoDecoderDropFrame                   ,+++-- ** videoDecoderFinishFrame+    VideoDecoderFinishFrameMethodInfo       ,+    videoDecoderFinishFrame                 ,+++-- ** videoDecoderGetAllocator+    VideoDecoderGetAllocatorMethodInfo      ,+    videoDecoderGetAllocator                ,+++-- ** videoDecoderGetBufferPool+    VideoDecoderGetBufferPoolMethodInfo     ,+    videoDecoderGetBufferPool               ,+++-- ** videoDecoderGetEstimateRate+    VideoDecoderGetEstimateRateMethodInfo   ,+    videoDecoderGetEstimateRate             ,+++-- ** videoDecoderGetFrame+    VideoDecoderGetFrameMethodInfo          ,+    videoDecoderGetFrame                    ,+++-- ** videoDecoderGetFrames+    VideoDecoderGetFramesMethodInfo         ,+    videoDecoderGetFrames                   ,+++-- ** videoDecoderGetLatency+    VideoDecoderGetLatencyMethodInfo        ,+    videoDecoderGetLatency                  ,+++-- ** videoDecoderGetMaxDecodeTime+    VideoDecoderGetMaxDecodeTimeMethodInfo  ,+    videoDecoderGetMaxDecodeTime            ,+++-- ** videoDecoderGetMaxErrors+    VideoDecoderGetMaxErrorsMethodInfo      ,+    videoDecoderGetMaxErrors                ,+++-- ** videoDecoderGetNeedsFormat+    VideoDecoderGetNeedsFormatMethodInfo    ,+    videoDecoderGetNeedsFormat              ,+++-- ** videoDecoderGetOldestFrame+    VideoDecoderGetOldestFrameMethodInfo    ,+    videoDecoderGetOldestFrame              ,+++-- ** videoDecoderGetOutputState+    VideoDecoderGetOutputStateMethodInfo    ,+    videoDecoderGetOutputState              ,+++-- ** videoDecoderGetPacketized+    VideoDecoderGetPacketizedMethodInfo     ,+    videoDecoderGetPacketized               ,+++-- ** videoDecoderGetPendingFrameSize+    VideoDecoderGetPendingFrameSizeMethodInfo,+    videoDecoderGetPendingFrameSize         ,+++-- ** videoDecoderGetQosProportion+    VideoDecoderGetQosProportionMethodInfo  ,+    videoDecoderGetQosProportion            ,+++-- ** videoDecoderHaveFrame+    VideoDecoderHaveFrameMethodInfo         ,+    videoDecoderHaveFrame                   ,+++-- ** videoDecoderMergeTags+    VideoDecoderMergeTagsMethodInfo         ,+    videoDecoderMergeTags                   ,+++-- ** videoDecoderNegotiate+    VideoDecoderNegotiateMethodInfo         ,+    videoDecoderNegotiate                   ,+++-- ** videoDecoderProxyGetcaps+    VideoDecoderProxyGetcapsMethodInfo      ,+    videoDecoderProxyGetcaps                ,+++-- ** videoDecoderReleaseFrame+    VideoDecoderReleaseFrameMethodInfo      ,+    videoDecoderReleaseFrame                ,+++-- ** videoDecoderSetEstimateRate+    VideoDecoderSetEstimateRateMethodInfo   ,+    videoDecoderSetEstimateRate             ,+++-- ** videoDecoderSetLatency+    VideoDecoderSetLatencyMethodInfo        ,+    videoDecoderSetLatency                  ,+++-- ** videoDecoderSetMaxErrors+    VideoDecoderSetMaxErrorsMethodInfo      ,+    videoDecoderSetMaxErrors                ,+++-- ** videoDecoderSetNeedsFormat+    VideoDecoderSetNeedsFormatMethodInfo    ,+    videoDecoderSetNeedsFormat              ,+++-- ** videoDecoderSetOutputState+    VideoDecoderSetOutputStateMethodInfo    ,+    videoDecoderSetOutputState              ,+++-- ** videoDecoderSetPacketized+    VideoDecoderSetPacketizedMethodInfo     ,+    videoDecoderSetPacketized               ,+++-- ** videoDecoderSetUseDefaultPadAcceptcaps+    VideoDecoderSetUseDefaultPadAcceptcapsMethodInfo,+    videoDecoderSetUseDefaultPadAcceptcaps  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gst as Gst++newtype VideoDecoder = VideoDecoder (ForeignPtr VideoDecoder)+foreign import ccall "gst_video_decoder_get_type"+    c_gst_video_decoder_get_type :: IO GType++type instance ParentTypes VideoDecoder = VideoDecoderParentTypes+type VideoDecoderParentTypes = '[Gst.Element, Gst.Object, GObject.Object]++instance GObject VideoDecoder where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_video_decoder_get_type+    ++class GObject o => VideoDecoderK o+instance (GObject o, IsDescendantOf VideoDecoder o) => VideoDecoderK o++toVideoDecoder :: VideoDecoderK o => o -> IO VideoDecoder+toVideoDecoder = unsafeCastTo VideoDecoder++noVideoDecoder :: Maybe VideoDecoder+noVideoDecoder = Nothing++type family ResolveVideoDecoderMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoDecoderMethod "abortState" o = Gst.ElementAbortStateMethodInfo+    ResolveVideoDecoderMethod "addControlBinding" o = Gst.ObjectAddControlBindingMethodInfo+    ResolveVideoDecoderMethod "addPad" o = Gst.ElementAddPadMethodInfo+    ResolveVideoDecoderMethod "addToFrame" o = VideoDecoderAddToFrameMethodInfo+    ResolveVideoDecoderMethod "allocateOutputBuffer" o = VideoDecoderAllocateOutputBufferMethodInfo+    ResolveVideoDecoderMethod "allocateOutputFrame" o = VideoDecoderAllocateOutputFrameMethodInfo+    ResolveVideoDecoderMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveVideoDecoderMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveVideoDecoderMethod "changeState" o = Gst.ElementChangeStateMethodInfo+    ResolveVideoDecoderMethod "continueState" o = Gst.ElementContinueStateMethodInfo+    ResolveVideoDecoderMethod "createAllPads" o = Gst.ElementCreateAllPadsMethodInfo+    ResolveVideoDecoderMethod "defaultError" o = Gst.ObjectDefaultErrorMethodInfo+    ResolveVideoDecoderMethod "dropFrame" o = VideoDecoderDropFrameMethodInfo+    ResolveVideoDecoderMethod "finishFrame" o = VideoDecoderFinishFrameMethodInfo+    ResolveVideoDecoderMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveVideoDecoderMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveVideoDecoderMethod "hasActiveControlBindings" o = Gst.ObjectHasActiveControlBindingsMethodInfo+    ResolveVideoDecoderMethod "hasAncestor" o = Gst.ObjectHasAncestorMethodInfo+    ResolveVideoDecoderMethod "hasAsAncestor" o = Gst.ObjectHasAsAncestorMethodInfo+    ResolveVideoDecoderMethod "hasAsParent" o = Gst.ObjectHasAsParentMethodInfo+    ResolveVideoDecoderMethod "haveFrame" o = VideoDecoderHaveFrameMethodInfo+    ResolveVideoDecoderMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveVideoDecoderMethod "isLockedState" o = Gst.ElementIsLockedStateMethodInfo+    ResolveVideoDecoderMethod "iteratePads" o = Gst.ElementIteratePadsMethodInfo+    ResolveVideoDecoderMethod "iterateSinkPads" o = Gst.ElementIterateSinkPadsMethodInfo+    ResolveVideoDecoderMethod "iterateSrcPads" o = Gst.ElementIterateSrcPadsMethodInfo+    ResolveVideoDecoderMethod "link" o = Gst.ElementLinkMethodInfo+    ResolveVideoDecoderMethod "linkFiltered" o = Gst.ElementLinkFilteredMethodInfo+    ResolveVideoDecoderMethod "linkPads" o = Gst.ElementLinkPadsMethodInfo+    ResolveVideoDecoderMethod "linkPadsFiltered" o = Gst.ElementLinkPadsFilteredMethodInfo+    ResolveVideoDecoderMethod "linkPadsFull" o = Gst.ElementLinkPadsFullMethodInfo+    ResolveVideoDecoderMethod "lostState" o = Gst.ElementLostStateMethodInfo+    ResolveVideoDecoderMethod "mergeTags" o = VideoDecoderMergeTagsMethodInfo+    ResolveVideoDecoderMethod "messageFull" o = Gst.ElementMessageFullMethodInfo+    ResolveVideoDecoderMethod "negotiate" o = VideoDecoderNegotiateMethodInfo+    ResolveVideoDecoderMethod "noMorePads" o = Gst.ElementNoMorePadsMethodInfo+    ResolveVideoDecoderMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveVideoDecoderMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveVideoDecoderMethod "postMessage" o = Gst.ElementPostMessageMethodInfo+    ResolveVideoDecoderMethod "provideClock" o = Gst.ElementProvideClockMethodInfo+    ResolveVideoDecoderMethod "proxyGetcaps" o = VideoDecoderProxyGetcapsMethodInfo+    ResolveVideoDecoderMethod "query" o = Gst.ElementQueryMethodInfo+    ResolveVideoDecoderMethod "queryConvert" o = Gst.ElementQueryConvertMethodInfo+    ResolveVideoDecoderMethod "queryDuration" o = Gst.ElementQueryDurationMethodInfo+    ResolveVideoDecoderMethod "queryPosition" o = Gst.ElementQueryPositionMethodInfo+    ResolveVideoDecoderMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveVideoDecoderMethod "releaseFrame" o = VideoDecoderReleaseFrameMethodInfo+    ResolveVideoDecoderMethod "releaseRequestPad" o = Gst.ElementReleaseRequestPadMethodInfo+    ResolveVideoDecoderMethod "removeControlBinding" o = Gst.ObjectRemoveControlBindingMethodInfo+    ResolveVideoDecoderMethod "removePad" o = Gst.ElementRemovePadMethodInfo+    ResolveVideoDecoderMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveVideoDecoderMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveVideoDecoderMethod "requestPad" o = Gst.ElementRequestPadMethodInfo+    ResolveVideoDecoderMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveVideoDecoderMethod "seek" o = Gst.ElementSeekMethodInfo+    ResolveVideoDecoderMethod "seekSimple" o = Gst.ElementSeekSimpleMethodInfo+    ResolveVideoDecoderMethod "sendEvent" o = Gst.ElementSendEventMethodInfo+    ResolveVideoDecoderMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveVideoDecoderMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveVideoDecoderMethod "suggestNextSync" o = Gst.ObjectSuggestNextSyncMethodInfo+    ResolveVideoDecoderMethod "syncStateWithParent" o = Gst.ElementSyncStateWithParentMethodInfo+    ResolveVideoDecoderMethod "syncValues" o = Gst.ObjectSyncValuesMethodInfo+    ResolveVideoDecoderMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveVideoDecoderMethod "unlink" o = Gst.ElementUnlinkMethodInfo+    ResolveVideoDecoderMethod "unlinkPads" o = Gst.ElementUnlinkPadsMethodInfo+    ResolveVideoDecoderMethod "unparent" o = Gst.ObjectUnparentMethodInfo+    ResolveVideoDecoderMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveVideoDecoderMethod "getAllocator" o = VideoDecoderGetAllocatorMethodInfo+    ResolveVideoDecoderMethod "getBaseTime" o = Gst.ElementGetBaseTimeMethodInfo+    ResolveVideoDecoderMethod "getBufferPool" o = VideoDecoderGetBufferPoolMethodInfo+    ResolveVideoDecoderMethod "getBus" o = Gst.ElementGetBusMethodInfo+    ResolveVideoDecoderMethod "getClock" o = Gst.ElementGetClockMethodInfo+    ResolveVideoDecoderMethod "getCompatiblePad" o = Gst.ElementGetCompatiblePadMethodInfo+    ResolveVideoDecoderMethod "getCompatiblePadTemplate" o = Gst.ElementGetCompatiblePadTemplateMethodInfo+    ResolveVideoDecoderMethod "getControlBinding" o = Gst.ObjectGetControlBindingMethodInfo+    ResolveVideoDecoderMethod "getControlRate" o = Gst.ObjectGetControlRateMethodInfo+    ResolveVideoDecoderMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveVideoDecoderMethod "getEstimateRate" o = VideoDecoderGetEstimateRateMethodInfo+    ResolveVideoDecoderMethod "getFactory" o = Gst.ElementGetFactoryMethodInfo+    ResolveVideoDecoderMethod "getFrame" o = VideoDecoderGetFrameMethodInfo+    ResolveVideoDecoderMethod "getFrames" o = VideoDecoderGetFramesMethodInfo+    ResolveVideoDecoderMethod "getGValueArray" o = Gst.ObjectGetGValueArrayMethodInfo+    ResolveVideoDecoderMethod "getLatency" o = VideoDecoderGetLatencyMethodInfo+    ResolveVideoDecoderMethod "getMaxDecodeTime" o = VideoDecoderGetMaxDecodeTimeMethodInfo+    ResolveVideoDecoderMethod "getMaxErrors" o = VideoDecoderGetMaxErrorsMethodInfo+    ResolveVideoDecoderMethod "getName" o = Gst.ObjectGetNameMethodInfo+    ResolveVideoDecoderMethod "getNeedsFormat" o = VideoDecoderGetNeedsFormatMethodInfo+    ResolveVideoDecoderMethod "getOldestFrame" o = VideoDecoderGetOldestFrameMethodInfo+    ResolveVideoDecoderMethod "getOutputState" o = VideoDecoderGetOutputStateMethodInfo+    ResolveVideoDecoderMethod "getPacketized" o = VideoDecoderGetPacketizedMethodInfo+    ResolveVideoDecoderMethod "getParent" o = Gst.ObjectGetParentMethodInfo+    ResolveVideoDecoderMethod "getPathString" o = Gst.ObjectGetPathStringMethodInfo+    ResolveVideoDecoderMethod "getPendingFrameSize" o = VideoDecoderGetPendingFrameSizeMethodInfo+    ResolveVideoDecoderMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveVideoDecoderMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveVideoDecoderMethod "getQosProportion" o = VideoDecoderGetQosProportionMethodInfo+    ResolveVideoDecoderMethod "getRequestPad" o = Gst.ElementGetRequestPadMethodInfo+    ResolveVideoDecoderMethod "getStartTime" o = Gst.ElementGetStartTimeMethodInfo+    ResolveVideoDecoderMethod "getState" o = Gst.ElementGetStateMethodInfo+    ResolveVideoDecoderMethod "getStaticPad" o = Gst.ElementGetStaticPadMethodInfo+    ResolveVideoDecoderMethod "getValue" o = Gst.ObjectGetValueMethodInfo+    ResolveVideoDecoderMethod "getValueArray" o = Gst.ObjectGetValueArrayMethodInfo+    ResolveVideoDecoderMethod "setBaseTime" o = Gst.ElementSetBaseTimeMethodInfo+    ResolveVideoDecoderMethod "setBus" o = Gst.ElementSetBusMethodInfo+    ResolveVideoDecoderMethod "setClock" o = Gst.ElementSetClockMethodInfo+    ResolveVideoDecoderMethod "setContext" o = Gst.ElementSetContextMethodInfo+    ResolveVideoDecoderMethod "setControlBindingDisabled" o = Gst.ObjectSetControlBindingDisabledMethodInfo+    ResolveVideoDecoderMethod "setControlBindingsDisabled" o = Gst.ObjectSetControlBindingsDisabledMethodInfo+    ResolveVideoDecoderMethod "setControlRate" o = Gst.ObjectSetControlRateMethodInfo+    ResolveVideoDecoderMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveVideoDecoderMethod "setEstimateRate" o = VideoDecoderSetEstimateRateMethodInfo+    ResolveVideoDecoderMethod "setLatency" o = VideoDecoderSetLatencyMethodInfo+    ResolveVideoDecoderMethod "setLockedState" o = Gst.ElementSetLockedStateMethodInfo+    ResolveVideoDecoderMethod "setMaxErrors" o = VideoDecoderSetMaxErrorsMethodInfo+    ResolveVideoDecoderMethod "setName" o = Gst.ObjectSetNameMethodInfo+    ResolveVideoDecoderMethod "setNeedsFormat" o = VideoDecoderSetNeedsFormatMethodInfo+    ResolveVideoDecoderMethod "setOutputState" o = VideoDecoderSetOutputStateMethodInfo+    ResolveVideoDecoderMethod "setPacketized" o = VideoDecoderSetPacketizedMethodInfo+    ResolveVideoDecoderMethod "setParent" o = Gst.ObjectSetParentMethodInfo+    ResolveVideoDecoderMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveVideoDecoderMethod "setStartTime" o = Gst.ElementSetStartTimeMethodInfo+    ResolveVideoDecoderMethod "setState" o = Gst.ElementSetStateMethodInfo+    ResolveVideoDecoderMethod "setUseDefaultPadAcceptcaps" o = VideoDecoderSetUseDefaultPadAcceptcapsMethodInfo+    ResolveVideoDecoderMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoDecoderMethod t VideoDecoder, MethodInfo info VideoDecoder p) => IsLabelProxy t (VideoDecoder -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoDecoderMethod t VideoDecoder, MethodInfo info VideoDecoder p) => IsLabel t (VideoDecoder -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList VideoDecoder = VideoDecoderAttributeList+type VideoDecoderAttributeList = ('[ '("name", Gst.ObjectNamePropertyInfo), '("parent", Gst.ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList VideoDecoder = VideoDecoderSignalList+type VideoDecoderSignalList = ('[ '("deepNotify", Gst.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", Gst.ElementPadAddedSignalInfo), '("padRemoved", Gst.ElementPadRemovedSignalInfo)] :: [(Symbol, *)])++-- method VideoDecoder::add_to_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_bytes", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_add_to_frame" gst_video_decoder_add_to_frame :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    Int32 ->                                -- n_bytes : TBasicType TInt32+    IO ()+++videoDecoderAddToFrame ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> Int32                                -- nBytes+    -> m ()                                 -- result+videoDecoderAddToFrame _obj nBytes = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_video_decoder_add_to_frame _obj' nBytes+    touchManagedPtr _obj+    return ()++data VideoDecoderAddToFrameMethodInfo+instance (signature ~ (Int32 -> m ()), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderAddToFrameMethodInfo a signature where+    overloadedMethod _ = videoDecoderAddToFrame++-- method VideoDecoder::allocate_output_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_allocate_output_buffer" gst_video_decoder_allocate_output_buffer :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    IO (Ptr Gst.Buffer)+++videoDecoderAllocateOutputBuffer ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m Gst.Buffer                         -- result+videoDecoderAllocateOutputBuffer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_allocate_output_buffer _obj'+    checkUnexpectedReturnNULL "gst_video_decoder_allocate_output_buffer" result+    result' <- (wrapBoxed Gst.Buffer) result+    touchManagedPtr _obj+    return result'++data VideoDecoderAllocateOutputBufferMethodInfo+instance (signature ~ (m Gst.Buffer), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderAllocateOutputBufferMethodInfo a signature where+    overloadedMethod _ = videoDecoderAllocateOutputBuffer++-- method VideoDecoder::allocate_output_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_allocate_output_frame" gst_video_decoder_allocate_output_frame :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    Ptr VideoCodecFrame ->                  -- frame : TInterface "GstVideo" "VideoCodecFrame"+    IO CUInt+++videoDecoderAllocateOutputFrame ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> VideoCodecFrame                      -- frame+    -> m Gst.FlowReturn                     -- result+videoDecoderAllocateOutputFrame _obj frame = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let frame' = unsafeManagedPtrGetPtr frame+    result <- gst_video_decoder_allocate_output_frame _obj' frame'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr frame+    return result'++data VideoDecoderAllocateOutputFrameMethodInfo+instance (signature ~ (VideoCodecFrame -> m Gst.FlowReturn), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderAllocateOutputFrameMethodInfo a signature where+    overloadedMethod _ = videoDecoderAllocateOutputFrame++-- method VideoDecoder::drop_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_drop_frame" gst_video_decoder_drop_frame :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    Ptr VideoCodecFrame ->                  -- frame : TInterface "GstVideo" "VideoCodecFrame"+    IO CUInt+++videoDecoderDropFrame ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> VideoCodecFrame                      -- frame+    -> m Gst.FlowReturn                     -- result+videoDecoderDropFrame _obj frame = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    frame' <- copyBoxed frame+    result <- gst_video_decoder_drop_frame _obj' frame'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr frame+    return result'++data VideoDecoderDropFrameMethodInfo+instance (signature ~ (VideoCodecFrame -> m Gst.FlowReturn), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderDropFrameMethodInfo a signature where+    overloadedMethod _ = videoDecoderDropFrame++-- method VideoDecoder::finish_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_finish_frame" gst_video_decoder_finish_frame :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    Ptr VideoCodecFrame ->                  -- frame : TInterface "GstVideo" "VideoCodecFrame"+    IO CUInt+++videoDecoderFinishFrame ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> VideoCodecFrame                      -- frame+    -> m Gst.FlowReturn                     -- result+videoDecoderFinishFrame _obj frame = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    frame' <- copyBoxed frame+    result <- gst_video_decoder_finish_frame _obj' frame'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr frame+    return result'++data VideoDecoderFinishFrameMethodInfo+instance (signature ~ (VideoCodecFrame -> m Gst.FlowReturn), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderFinishFrameMethodInfo a signature where+    overloadedMethod _ = videoDecoderFinishFrame++-- method VideoDecoder::get_allocator+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_allocator" gst_video_decoder_get_allocator :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    Ptr (Ptr Gst.Allocator) ->              -- allocator : TInterface "Gst" "Allocator"+    Ptr Gst.AllocationParams ->             -- params : TInterface "Gst" "AllocationParams"+    IO ()+++videoDecoderGetAllocator ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m (Gst.Allocator,Gst.AllocationParams)-- result+videoDecoderGetAllocator _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    allocator <- allocMem :: IO (Ptr (Ptr Gst.Allocator))+    params <- callocBoxedBytes 64 :: IO (Ptr Gst.AllocationParams)+    gst_video_decoder_get_allocator _obj' allocator params+    allocator' <- peek allocator+    allocator'' <- (wrapObject Gst.Allocator) allocator'+    params' <- (wrapBoxed Gst.AllocationParams) params+    touchManagedPtr _obj+    freeMem allocator+    return (allocator'', params')++data VideoDecoderGetAllocatorMethodInfo+instance (signature ~ (m (Gst.Allocator,Gst.AllocationParams)), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetAllocatorMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetAllocator++-- method VideoDecoder::get_buffer_pool+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "BufferPool"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_buffer_pool" gst_video_decoder_get_buffer_pool :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    IO (Ptr Gst.BufferPool)+++videoDecoderGetBufferPool ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m Gst.BufferPool                     -- result+videoDecoderGetBufferPool _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_get_buffer_pool _obj'+    checkUnexpectedReturnNULL "gst_video_decoder_get_buffer_pool" result+    result' <- (wrapObject Gst.BufferPool) result+    touchManagedPtr _obj+    return result'++data VideoDecoderGetBufferPoolMethodInfo+instance (signature ~ (m Gst.BufferPool), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetBufferPoolMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetBufferPool++-- method VideoDecoder::get_estimate_rate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_estimate_rate" gst_video_decoder_get_estimate_rate :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    IO Int32+++videoDecoderGetEstimateRate ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m Int32                              -- result+videoDecoderGetEstimateRate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_get_estimate_rate _obj'+    touchManagedPtr _obj+    return result++data VideoDecoderGetEstimateRateMethodInfo+instance (signature ~ (m Int32), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetEstimateRateMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetEstimateRate++-- method VideoDecoder::get_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame_number", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoCodecFrame"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_frame" gst_video_decoder_get_frame :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    Int32 ->                                -- frame_number : TBasicType TInt32+    IO (Ptr VideoCodecFrame)+++videoDecoderGetFrame ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> Int32                                -- frameNumber+    -> m VideoCodecFrame                    -- result+videoDecoderGetFrame _obj frameNumber = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_get_frame _obj' frameNumber+    checkUnexpectedReturnNULL "gst_video_decoder_get_frame" result+    result' <- (wrapBoxed VideoCodecFrame) result+    touchManagedPtr _obj+    return result'++data VideoDecoderGetFrameMethodInfo+instance (signature ~ (Int32 -> m VideoCodecFrame), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetFrameMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetFrame++-- method VideoDecoder::get_frames+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "GstVideo" "VideoCodecFrame")+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_frames" gst_video_decoder_get_frames :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    IO (Ptr (GList (Ptr VideoCodecFrame)))+++videoDecoderGetFrames ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m [VideoCodecFrame]                  -- result+videoDecoderGetFrames _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_get_frames _obj'+    checkUnexpectedReturnNULL "gst_video_decoder_get_frames" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed VideoCodecFrame) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++data VideoDecoderGetFramesMethodInfo+instance (signature ~ (m [VideoCodecFrame]), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetFramesMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetFrames++-- method VideoDecoder::get_latency+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_latency" gst_video_decoder_get_latency :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    Ptr Word64 ->                           -- min_latency : TBasicType TUInt64+    Ptr Word64 ->                           -- max_latency : TBasicType TUInt64+    IO ()+++videoDecoderGetLatency ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m (Word64,Word64)                    -- result+videoDecoderGetLatency _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    minLatency <- allocMem :: IO (Ptr Word64)+    maxLatency <- allocMem :: IO (Ptr Word64)+    gst_video_decoder_get_latency _obj' minLatency maxLatency+    minLatency' <- peek minLatency+    maxLatency' <- peek maxLatency+    touchManagedPtr _obj+    freeMem minLatency+    freeMem maxLatency+    return (minLatency', maxLatency')++data VideoDecoderGetLatencyMethodInfo+instance (signature ~ (m (Word64,Word64)), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetLatencyMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetLatency++-- method VideoDecoder::get_max_decode_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_max_decode_time" gst_video_decoder_get_max_decode_time :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    Ptr VideoCodecFrame ->                  -- frame : TInterface "GstVideo" "VideoCodecFrame"+    IO Int64+++videoDecoderGetMaxDecodeTime ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> VideoCodecFrame                      -- frame+    -> m Int64                              -- result+videoDecoderGetMaxDecodeTime _obj frame = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let frame' = unsafeManagedPtrGetPtr frame+    result <- gst_video_decoder_get_max_decode_time _obj' frame'+    touchManagedPtr _obj+    touchManagedPtr frame+    return result++data VideoDecoderGetMaxDecodeTimeMethodInfo+instance (signature ~ (VideoCodecFrame -> m Int64), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetMaxDecodeTimeMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetMaxDecodeTime++-- method VideoDecoder::get_max_errors+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_max_errors" gst_video_decoder_get_max_errors :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    IO Int32+++videoDecoderGetMaxErrors ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m Int32                              -- result+videoDecoderGetMaxErrors _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_get_max_errors _obj'+    touchManagedPtr _obj+    return result++data VideoDecoderGetMaxErrorsMethodInfo+instance (signature ~ (m Int32), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetMaxErrorsMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetMaxErrors++-- method VideoDecoder::get_needs_format+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_needs_format" gst_video_decoder_get_needs_format :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    IO CInt+++videoDecoderGetNeedsFormat ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+videoDecoderGetNeedsFormat _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_get_needs_format _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoDecoderGetNeedsFormatMethodInfo+instance (signature ~ (m Bool), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetNeedsFormatMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetNeedsFormat++-- method VideoDecoder::get_oldest_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoCodecFrame"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_oldest_frame" gst_video_decoder_get_oldest_frame :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    IO (Ptr VideoCodecFrame)+++videoDecoderGetOldestFrame ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m VideoCodecFrame                    -- result+videoDecoderGetOldestFrame _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_get_oldest_frame _obj'+    checkUnexpectedReturnNULL "gst_video_decoder_get_oldest_frame" result+    result' <- (wrapBoxed VideoCodecFrame) result+    touchManagedPtr _obj+    return result'++data VideoDecoderGetOldestFrameMethodInfo+instance (signature ~ (m VideoCodecFrame), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetOldestFrameMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetOldestFrame++-- method VideoDecoder::get_output_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoCodecState"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_output_state" gst_video_decoder_get_output_state :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    IO (Ptr VideoCodecState)+++videoDecoderGetOutputState ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m VideoCodecState                    -- result+videoDecoderGetOutputState _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_get_output_state _obj'+    checkUnexpectedReturnNULL "gst_video_decoder_get_output_state" result+    result' <- (wrapBoxed VideoCodecState) result+    touchManagedPtr _obj+    return result'++data VideoDecoderGetOutputStateMethodInfo+instance (signature ~ (m VideoCodecState), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetOutputStateMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetOutputState++-- method VideoDecoder::get_packetized+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_packetized" gst_video_decoder_get_packetized :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    IO CInt+++videoDecoderGetPacketized ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+videoDecoderGetPacketized _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_get_packetized _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoDecoderGetPacketizedMethodInfo+instance (signature ~ (m Bool), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetPacketizedMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetPacketized++-- method VideoDecoder::get_pending_frame_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_pending_frame_size" gst_video_decoder_get_pending_frame_size :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    IO Word64+++videoDecoderGetPendingFrameSize ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m Word64                             -- result+videoDecoderGetPendingFrameSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_get_pending_frame_size _obj'+    touchManagedPtr _obj+    return result++data VideoDecoderGetPendingFrameSizeMethodInfo+instance (signature ~ (m Word64), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetPendingFrameSizeMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetPendingFrameSize++-- method VideoDecoder::get_qos_proportion+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_get_qos_proportion" gst_video_decoder_get_qos_proportion :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    IO CDouble+++videoDecoderGetQosProportion ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m Double                             -- result+videoDecoderGetQosProportion _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_get_qos_proportion _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++data VideoDecoderGetQosProportionMethodInfo+instance (signature ~ (m Double), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderGetQosProportionMethodInfo a signature where+    overloadedMethod _ = videoDecoderGetQosProportion++-- method VideoDecoder::have_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_have_frame" gst_video_decoder_have_frame :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    IO CUInt+++videoDecoderHaveFrame ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m Gst.FlowReturn                     -- result+videoDecoderHaveFrame _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_have_frame _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data VideoDecoderHaveFrameMethodInfo+instance (signature ~ (m Gst.FlowReturn), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderHaveFrameMethodInfo a signature where+    overloadedMethod _ = videoDecoderHaveFrame++-- method VideoDecoder::merge_tags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_merge_tags" gst_video_decoder_merge_tags :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    Ptr Gst.TagList ->                      -- tags : TInterface "Gst" "TagList"+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"+    IO ()+++videoDecoderMergeTags ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> Maybe (Gst.TagList)                  -- tags+    -> Gst.TagMergeMode                     -- mode+    -> m ()                                 -- result+videoDecoderMergeTags _obj tags mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeTags <- case tags of+        Nothing -> return nullPtr+        Just jTags -> do+            let jTags' = unsafeManagedPtrGetPtr jTags+            return jTags'+    let mode' = (fromIntegral . fromEnum) mode+    gst_video_decoder_merge_tags _obj' maybeTags mode'+    touchManagedPtr _obj+    whenJust tags touchManagedPtr+    return ()++data VideoDecoderMergeTagsMethodInfo+instance (signature ~ (Maybe (Gst.TagList) -> Gst.TagMergeMode -> m ()), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderMergeTagsMethodInfo a signature where+    overloadedMethod _ = videoDecoderMergeTags++-- method VideoDecoder::negotiate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_negotiate" gst_video_decoder_negotiate :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    IO CInt+++videoDecoderNegotiate ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+videoDecoderNegotiate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_decoder_negotiate _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoDecoderNegotiateMethodInfo+instance (signature ~ (m Bool), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderNegotiateMethodInfo a signature where+    overloadedMethod _ = videoDecoderNegotiate++-- method VideoDecoder::proxy_getcaps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_proxy_getcaps" gst_video_decoder_proxy_getcaps :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    Ptr Gst.Caps ->                         -- caps : TInterface "Gst" "Caps"+    Ptr Gst.Caps ->                         -- filter : TInterface "Gst" "Caps"+    IO (Ptr Gst.Caps)+++videoDecoderProxyGetcaps ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> Maybe (Gst.Caps)                     -- caps+    -> Maybe (Gst.Caps)                     -- filter+    -> m Gst.Caps                           -- result+videoDecoderProxyGetcaps _obj caps filter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCaps <- case caps of+        Nothing -> return nullPtr+        Just jCaps -> do+            let jCaps' = unsafeManagedPtrGetPtr jCaps+            return jCaps'+    maybeFilter <- case filter of+        Nothing -> return nullPtr+        Just jFilter -> do+            let jFilter' = unsafeManagedPtrGetPtr jFilter+            return jFilter'+    result <- gst_video_decoder_proxy_getcaps _obj' maybeCaps maybeFilter+    checkUnexpectedReturnNULL "gst_video_decoder_proxy_getcaps" result+    result' <- (wrapBoxed Gst.Caps) result+    touchManagedPtr _obj+    whenJust caps touchManagedPtr+    whenJust filter touchManagedPtr+    return result'++data VideoDecoderProxyGetcapsMethodInfo+instance (signature ~ (Maybe (Gst.Caps) -> Maybe (Gst.Caps) -> m Gst.Caps), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderProxyGetcapsMethodInfo a signature where+    overloadedMethod _ = videoDecoderProxyGetcaps++-- method VideoDecoder::release_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_release_frame" gst_video_decoder_release_frame :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    Ptr VideoCodecFrame ->                  -- frame : TInterface "GstVideo" "VideoCodecFrame"+    IO ()+++videoDecoderReleaseFrame ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> VideoCodecFrame                      -- frame+    -> m ()                                 -- result+videoDecoderReleaseFrame _obj frame = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    frame' <- copyBoxed frame+    gst_video_decoder_release_frame _obj' frame'+    touchManagedPtr _obj+    touchManagedPtr frame+    return ()++data VideoDecoderReleaseFrameMethodInfo+instance (signature ~ (VideoCodecFrame -> m ()), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderReleaseFrameMethodInfo a signature where+    overloadedMethod _ = videoDecoderReleaseFrame++-- method VideoDecoder::set_estimate_rate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_set_estimate_rate" gst_video_decoder_set_estimate_rate :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    CInt ->                                 -- enabled : TBasicType TBoolean+    IO ()+++videoDecoderSetEstimateRate ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> Bool                                 -- enabled+    -> m ()                                 -- result+videoDecoderSetEstimateRate _obj enabled = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let enabled' = (fromIntegral . fromEnum) enabled+    gst_video_decoder_set_estimate_rate _obj' enabled'+    touchManagedPtr _obj+    return ()++data VideoDecoderSetEstimateRateMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderSetEstimateRateMethodInfo a signature where+    overloadedMethod _ = videoDecoderSetEstimateRate++-- method VideoDecoder::set_latency+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_set_latency" gst_video_decoder_set_latency :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    Word64 ->                               -- min_latency : TBasicType TUInt64+    Word64 ->                               -- max_latency : TBasicType TUInt64+    IO ()+++videoDecoderSetLatency ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> Word64                               -- minLatency+    -> Word64                               -- maxLatency+    -> m ()                                 -- result+videoDecoderSetLatency _obj minLatency maxLatency = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_video_decoder_set_latency _obj' minLatency maxLatency+    touchManagedPtr _obj+    return ()++data VideoDecoderSetLatencyMethodInfo+instance (signature ~ (Word64 -> Word64 -> m ()), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderSetLatencyMethodInfo a signature where+    overloadedMethod _ = videoDecoderSetLatency++-- method VideoDecoder::set_max_errors+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_set_max_errors" gst_video_decoder_set_max_errors :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    Int32 ->                                -- num : TBasicType TInt32+    IO ()+++videoDecoderSetMaxErrors ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> Int32                                -- num+    -> m ()                                 -- result+videoDecoderSetMaxErrors _obj num = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_video_decoder_set_max_errors _obj' num+    touchManagedPtr _obj+    return ()++data VideoDecoderSetMaxErrorsMethodInfo+instance (signature ~ (Int32 -> m ()), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderSetMaxErrorsMethodInfo a signature where+    overloadedMethod _ = videoDecoderSetMaxErrors++-- method VideoDecoder::set_needs_format+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_set_needs_format" gst_video_decoder_set_needs_format :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    CInt ->                                 -- enabled : TBasicType TBoolean+    IO ()+++videoDecoderSetNeedsFormat ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> Bool                                 -- enabled+    -> m ()                                 -- result+videoDecoderSetNeedsFormat _obj enabled = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let enabled' = (fromIntegral . fromEnum) enabled+    gst_video_decoder_set_needs_format _obj' enabled'+    touchManagedPtr _obj+    return ()++data VideoDecoderSetNeedsFormatMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderSetNeedsFormatMethodInfo a signature where+    overloadedMethod _ = videoDecoderSetNeedsFormat++-- method VideoDecoder::set_output_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fmt", argType = TInterface "GstVideo" "VideoFormat", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "reference", argType = TInterface "GstVideo" "VideoCodecState", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoCodecState"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_set_output_state" gst_video_decoder_set_output_state :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    CUInt ->                                -- fmt : TInterface "GstVideo" "VideoFormat"+    Word32 ->                               -- width : TBasicType TUInt32+    Word32 ->                               -- height : TBasicType TUInt32+    Ptr VideoCodecState ->                  -- reference : TInterface "GstVideo" "VideoCodecState"+    IO (Ptr VideoCodecState)+++videoDecoderSetOutputState ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> VideoFormat                          -- fmt+    -> Word32                               -- width+    -> Word32                               -- height+    -> Maybe (VideoCodecState)              -- reference+    -> m VideoCodecState                    -- result+videoDecoderSetOutputState _obj fmt width height reference = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let fmt' = (fromIntegral . fromEnum) fmt+    maybeReference <- case reference of+        Nothing -> return nullPtr+        Just jReference -> do+            let jReference' = unsafeManagedPtrGetPtr jReference+            return jReference'+    result <- gst_video_decoder_set_output_state _obj' fmt' width height maybeReference+    checkUnexpectedReturnNULL "gst_video_decoder_set_output_state" result+    result' <- (wrapBoxed VideoCodecState) result+    touchManagedPtr _obj+    whenJust reference touchManagedPtr+    return result'++data VideoDecoderSetOutputStateMethodInfo+instance (signature ~ (VideoFormat -> Word32 -> Word32 -> Maybe (VideoCodecState) -> m VideoCodecState), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderSetOutputStateMethodInfo a signature where+    overloadedMethod _ = videoDecoderSetOutputState++-- method VideoDecoder::set_packetized+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "packetized", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_set_packetized" gst_video_decoder_set_packetized :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    CInt ->                                 -- packetized : TBasicType TBoolean+    IO ()+++videoDecoderSetPacketized ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> Bool                                 -- packetized+    -> m ()                                 -- result+videoDecoderSetPacketized _obj packetized = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let packetized' = (fromIntegral . fromEnum) packetized+    gst_video_decoder_set_packetized _obj' packetized'+    touchManagedPtr _obj+    return ()++data VideoDecoderSetPacketizedMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderSetPacketizedMethodInfo a signature where+    overloadedMethod _ = videoDecoderSetPacketized++-- method VideoDecoder::set_use_default_pad_acceptcaps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDecoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "use", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_decoder_set_use_default_pad_acceptcaps" gst_video_decoder_set_use_default_pad_acceptcaps :: +    Ptr VideoDecoder ->                     -- _obj : TInterface "GstVideo" "VideoDecoder"+    CInt ->                                 -- use : TBasicType TBoolean+    IO ()+++videoDecoderSetUseDefaultPadAcceptcaps ::+    (MonadIO m, VideoDecoderK a) =>+    a                                       -- _obj+    -> Bool                                 -- use+    -> m ()                                 -- result+videoDecoderSetUseDefaultPadAcceptcaps _obj use = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use' = (fromIntegral . fromEnum) use+    gst_video_decoder_set_use_default_pad_acceptcaps _obj' use'+    touchManagedPtr _obj+    return ()++data VideoDecoderSetUseDefaultPadAcceptcapsMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, VideoDecoderK a) => MethodInfo VideoDecoderSetUseDefaultPadAcceptcapsMethodInfo a signature where+    overloadedMethod _ = videoDecoderSetUseDefaultPadAcceptcaps++
+ GI/GstVideo/Objects/VideoDecoder.hs-boot view
@@ -0,0 +1,44 @@+module GI.GstVideo.Objects.VideoDecoder where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoDecoder = VideoDecoder (ForeignPtr VideoDecoder)+instance GObject VideoDecoder where+class GObject o => VideoDecoderK o+instance (GObject o, IsDescendantOf VideoDecoder o) => VideoDecoderK o+data VideoDecoderAddToFrameMethodInfo+data VideoDecoderAllocateOutputBufferMethodInfo+data VideoDecoderAllocateOutputFrameMethodInfo+data VideoDecoderDropFrameMethodInfo+data VideoDecoderFinishFrameMethodInfo+data VideoDecoderGetAllocatorMethodInfo+data VideoDecoderGetBufferPoolMethodInfo+data VideoDecoderGetEstimateRateMethodInfo+data VideoDecoderGetFrameMethodInfo+data VideoDecoderGetFramesMethodInfo+data VideoDecoderGetLatencyMethodInfo+data VideoDecoderGetMaxDecodeTimeMethodInfo+data VideoDecoderGetMaxErrorsMethodInfo+data VideoDecoderGetNeedsFormatMethodInfo+data VideoDecoderGetOldestFrameMethodInfo+data VideoDecoderGetOutputStateMethodInfo+data VideoDecoderGetPacketizedMethodInfo+data VideoDecoderGetPendingFrameSizeMethodInfo+data VideoDecoderGetQosProportionMethodInfo+data VideoDecoderHaveFrameMethodInfo+data VideoDecoderMergeTagsMethodInfo+data VideoDecoderNegotiateMethodInfo+data VideoDecoderProxyGetcapsMethodInfo+data VideoDecoderReleaseFrameMethodInfo+data VideoDecoderSetEstimateRateMethodInfo+data VideoDecoderSetLatencyMethodInfo+data VideoDecoderSetMaxErrorsMethodInfo+data VideoDecoderSetNeedsFormatMethodInfo+data VideoDecoderSetOutputStateMethodInfo+data VideoDecoderSetPacketizedMethodInfo+data VideoDecoderSetUseDefaultPadAcceptcapsMethodInfo
+ GI/GstVideo/Objects/VideoEncoder.hs view
@@ -0,0 +1,802 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Objects.VideoEncoder+    ( ++-- * Exported types+    VideoEncoder(..)                        ,+    VideoEncoderK                           ,+    toVideoEncoder                          ,+    noVideoEncoder                          ,+++ -- * Methods+-- ** videoEncoderAllocateOutputBuffer+    VideoEncoderAllocateOutputBufferMethodInfo,+    videoEncoderAllocateOutputBuffer        ,+++-- ** videoEncoderAllocateOutputFrame+    VideoEncoderAllocateOutputFrameMethodInfo,+    videoEncoderAllocateOutputFrame         ,+++-- ** videoEncoderFinishFrame+    VideoEncoderFinishFrameMethodInfo       ,+    videoEncoderFinishFrame                 ,+++-- ** videoEncoderGetAllocator+    VideoEncoderGetAllocatorMethodInfo      ,+    videoEncoderGetAllocator                ,+++-- ** videoEncoderGetFrame+    VideoEncoderGetFrameMethodInfo          ,+    videoEncoderGetFrame                    ,+++-- ** videoEncoderGetFrames+    VideoEncoderGetFramesMethodInfo         ,+    videoEncoderGetFrames                   ,+++-- ** videoEncoderGetLatency+    VideoEncoderGetLatencyMethodInfo        ,+    videoEncoderGetLatency                  ,+++-- ** videoEncoderGetOldestFrame+    VideoEncoderGetOldestFrameMethodInfo    ,+    videoEncoderGetOldestFrame              ,+++-- ** videoEncoderGetOutputState+    VideoEncoderGetOutputStateMethodInfo    ,+    videoEncoderGetOutputState              ,+++-- ** videoEncoderMergeTags+    VideoEncoderMergeTagsMethodInfo         ,+    videoEncoderMergeTags                   ,+++-- ** videoEncoderNegotiate+    VideoEncoderNegotiateMethodInfo         ,+    videoEncoderNegotiate                   ,+++-- ** videoEncoderProxyGetcaps+    VideoEncoderProxyGetcapsMethodInfo      ,+    videoEncoderProxyGetcaps                ,+++-- ** videoEncoderSetHeaders+    VideoEncoderSetHeadersMethodInfo        ,+    videoEncoderSetHeaders                  ,+++-- ** videoEncoderSetLatency+    VideoEncoderSetLatencyMethodInfo        ,+    videoEncoderSetLatency                  ,+++-- ** videoEncoderSetMinPts+    VideoEncoderSetMinPtsMethodInfo         ,+    videoEncoderSetMinPts                   ,+++-- ** videoEncoderSetOutputState+    VideoEncoderSetOutputStateMethodInfo    ,+    videoEncoderSetOutputState              ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gst as Gst++newtype VideoEncoder = VideoEncoder (ForeignPtr VideoEncoder)+foreign import ccall "gst_video_encoder_get_type"+    c_gst_video_encoder_get_type :: IO GType++type instance ParentTypes VideoEncoder = VideoEncoderParentTypes+type VideoEncoderParentTypes = '[Gst.Element, Gst.Object, GObject.Object, Gst.Preset]++instance GObject VideoEncoder where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_video_encoder_get_type+    ++class GObject o => VideoEncoderK o+instance (GObject o, IsDescendantOf VideoEncoder o) => VideoEncoderK o++toVideoEncoder :: VideoEncoderK o => o -> IO VideoEncoder+toVideoEncoder = unsafeCastTo VideoEncoder++noVideoEncoder :: Maybe VideoEncoder+noVideoEncoder = Nothing++type family ResolveVideoEncoderMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoEncoderMethod "abortState" o = Gst.ElementAbortStateMethodInfo+    ResolveVideoEncoderMethod "addControlBinding" o = Gst.ObjectAddControlBindingMethodInfo+    ResolveVideoEncoderMethod "addPad" o = Gst.ElementAddPadMethodInfo+    ResolveVideoEncoderMethod "allocateOutputBuffer" o = VideoEncoderAllocateOutputBufferMethodInfo+    ResolveVideoEncoderMethod "allocateOutputFrame" o = VideoEncoderAllocateOutputFrameMethodInfo+    ResolveVideoEncoderMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveVideoEncoderMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveVideoEncoderMethod "changeState" o = Gst.ElementChangeStateMethodInfo+    ResolveVideoEncoderMethod "continueState" o = Gst.ElementContinueStateMethodInfo+    ResolveVideoEncoderMethod "createAllPads" o = Gst.ElementCreateAllPadsMethodInfo+    ResolveVideoEncoderMethod "defaultError" o = Gst.ObjectDefaultErrorMethodInfo+    ResolveVideoEncoderMethod "deletePreset" o = Gst.PresetDeletePresetMethodInfo+    ResolveVideoEncoderMethod "finishFrame" o = VideoEncoderFinishFrameMethodInfo+    ResolveVideoEncoderMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveVideoEncoderMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveVideoEncoderMethod "hasActiveControlBindings" o = Gst.ObjectHasActiveControlBindingsMethodInfo+    ResolveVideoEncoderMethod "hasAncestor" o = Gst.ObjectHasAncestorMethodInfo+    ResolveVideoEncoderMethod "hasAsAncestor" o = Gst.ObjectHasAsAncestorMethodInfo+    ResolveVideoEncoderMethod "hasAsParent" o = Gst.ObjectHasAsParentMethodInfo+    ResolveVideoEncoderMethod "isEditable" o = Gst.PresetIsEditableMethodInfo+    ResolveVideoEncoderMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveVideoEncoderMethod "isLockedState" o = Gst.ElementIsLockedStateMethodInfo+    ResolveVideoEncoderMethod "iteratePads" o = Gst.ElementIteratePadsMethodInfo+    ResolveVideoEncoderMethod "iterateSinkPads" o = Gst.ElementIterateSinkPadsMethodInfo+    ResolveVideoEncoderMethod "iterateSrcPads" o = Gst.ElementIterateSrcPadsMethodInfo+    ResolveVideoEncoderMethod "link" o = Gst.ElementLinkMethodInfo+    ResolveVideoEncoderMethod "linkFiltered" o = Gst.ElementLinkFilteredMethodInfo+    ResolveVideoEncoderMethod "linkPads" o = Gst.ElementLinkPadsMethodInfo+    ResolveVideoEncoderMethod "linkPadsFiltered" o = Gst.ElementLinkPadsFilteredMethodInfo+    ResolveVideoEncoderMethod "linkPadsFull" o = Gst.ElementLinkPadsFullMethodInfo+    ResolveVideoEncoderMethod "loadPreset" o = Gst.PresetLoadPresetMethodInfo+    ResolveVideoEncoderMethod "lostState" o = Gst.ElementLostStateMethodInfo+    ResolveVideoEncoderMethod "mergeTags" o = VideoEncoderMergeTagsMethodInfo+    ResolveVideoEncoderMethod "messageFull" o = Gst.ElementMessageFullMethodInfo+    ResolveVideoEncoderMethod "negotiate" o = VideoEncoderNegotiateMethodInfo+    ResolveVideoEncoderMethod "noMorePads" o = Gst.ElementNoMorePadsMethodInfo+    ResolveVideoEncoderMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveVideoEncoderMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveVideoEncoderMethod "postMessage" o = Gst.ElementPostMessageMethodInfo+    ResolveVideoEncoderMethod "provideClock" o = Gst.ElementProvideClockMethodInfo+    ResolveVideoEncoderMethod "proxyGetcaps" o = VideoEncoderProxyGetcapsMethodInfo+    ResolveVideoEncoderMethod "query" o = Gst.ElementQueryMethodInfo+    ResolveVideoEncoderMethod "queryConvert" o = Gst.ElementQueryConvertMethodInfo+    ResolveVideoEncoderMethod "queryDuration" o = Gst.ElementQueryDurationMethodInfo+    ResolveVideoEncoderMethod "queryPosition" o = Gst.ElementQueryPositionMethodInfo+    ResolveVideoEncoderMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveVideoEncoderMethod "releaseRequestPad" o = Gst.ElementReleaseRequestPadMethodInfo+    ResolveVideoEncoderMethod "removeControlBinding" o = Gst.ObjectRemoveControlBindingMethodInfo+    ResolveVideoEncoderMethod "removePad" o = Gst.ElementRemovePadMethodInfo+    ResolveVideoEncoderMethod "renamePreset" o = Gst.PresetRenamePresetMethodInfo+    ResolveVideoEncoderMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveVideoEncoderMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveVideoEncoderMethod "requestPad" o = Gst.ElementRequestPadMethodInfo+    ResolveVideoEncoderMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveVideoEncoderMethod "savePreset" o = Gst.PresetSavePresetMethodInfo+    ResolveVideoEncoderMethod "seek" o = Gst.ElementSeekMethodInfo+    ResolveVideoEncoderMethod "seekSimple" o = Gst.ElementSeekSimpleMethodInfo+    ResolveVideoEncoderMethod "sendEvent" o = Gst.ElementSendEventMethodInfo+    ResolveVideoEncoderMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveVideoEncoderMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveVideoEncoderMethod "suggestNextSync" o = Gst.ObjectSuggestNextSyncMethodInfo+    ResolveVideoEncoderMethod "syncStateWithParent" o = Gst.ElementSyncStateWithParentMethodInfo+    ResolveVideoEncoderMethod "syncValues" o = Gst.ObjectSyncValuesMethodInfo+    ResolveVideoEncoderMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveVideoEncoderMethod "unlink" o = Gst.ElementUnlinkMethodInfo+    ResolveVideoEncoderMethod "unlinkPads" o = Gst.ElementUnlinkPadsMethodInfo+    ResolveVideoEncoderMethod "unparent" o = Gst.ObjectUnparentMethodInfo+    ResolveVideoEncoderMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveVideoEncoderMethod "getAllocator" o = VideoEncoderGetAllocatorMethodInfo+    ResolveVideoEncoderMethod "getBaseTime" o = Gst.ElementGetBaseTimeMethodInfo+    ResolveVideoEncoderMethod "getBus" o = Gst.ElementGetBusMethodInfo+    ResolveVideoEncoderMethod "getClock" o = Gst.ElementGetClockMethodInfo+    ResolveVideoEncoderMethod "getCompatiblePad" o = Gst.ElementGetCompatiblePadMethodInfo+    ResolveVideoEncoderMethod "getCompatiblePadTemplate" o = Gst.ElementGetCompatiblePadTemplateMethodInfo+    ResolveVideoEncoderMethod "getControlBinding" o = Gst.ObjectGetControlBindingMethodInfo+    ResolveVideoEncoderMethod "getControlRate" o = Gst.ObjectGetControlRateMethodInfo+    ResolveVideoEncoderMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveVideoEncoderMethod "getFactory" o = Gst.ElementGetFactoryMethodInfo+    ResolveVideoEncoderMethod "getFrame" o = VideoEncoderGetFrameMethodInfo+    ResolveVideoEncoderMethod "getFrames" o = VideoEncoderGetFramesMethodInfo+    ResolveVideoEncoderMethod "getGValueArray" o = Gst.ObjectGetGValueArrayMethodInfo+    ResolveVideoEncoderMethod "getLatency" o = VideoEncoderGetLatencyMethodInfo+    ResolveVideoEncoderMethod "getMeta" o = Gst.PresetGetMetaMethodInfo+    ResolveVideoEncoderMethod "getName" o = Gst.ObjectGetNameMethodInfo+    ResolveVideoEncoderMethod "getOldestFrame" o = VideoEncoderGetOldestFrameMethodInfo+    ResolveVideoEncoderMethod "getOutputState" o = VideoEncoderGetOutputStateMethodInfo+    ResolveVideoEncoderMethod "getParent" o = Gst.ObjectGetParentMethodInfo+    ResolveVideoEncoderMethod "getPathString" o = Gst.ObjectGetPathStringMethodInfo+    ResolveVideoEncoderMethod "getPresetNames" o = Gst.PresetGetPresetNamesMethodInfo+    ResolveVideoEncoderMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveVideoEncoderMethod "getPropertyNames" o = Gst.PresetGetPropertyNamesMethodInfo+    ResolveVideoEncoderMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveVideoEncoderMethod "getRequestPad" o = Gst.ElementGetRequestPadMethodInfo+    ResolveVideoEncoderMethod "getStartTime" o = Gst.ElementGetStartTimeMethodInfo+    ResolveVideoEncoderMethod "getState" o = Gst.ElementGetStateMethodInfo+    ResolveVideoEncoderMethod "getStaticPad" o = Gst.ElementGetStaticPadMethodInfo+    ResolveVideoEncoderMethod "getValue" o = Gst.ObjectGetValueMethodInfo+    ResolveVideoEncoderMethod "getValueArray" o = Gst.ObjectGetValueArrayMethodInfo+    ResolveVideoEncoderMethod "setBaseTime" o = Gst.ElementSetBaseTimeMethodInfo+    ResolveVideoEncoderMethod "setBus" o = Gst.ElementSetBusMethodInfo+    ResolveVideoEncoderMethod "setClock" o = Gst.ElementSetClockMethodInfo+    ResolveVideoEncoderMethod "setContext" o = Gst.ElementSetContextMethodInfo+    ResolveVideoEncoderMethod "setControlBindingDisabled" o = Gst.ObjectSetControlBindingDisabledMethodInfo+    ResolveVideoEncoderMethod "setControlBindingsDisabled" o = Gst.ObjectSetControlBindingsDisabledMethodInfo+    ResolveVideoEncoderMethod "setControlRate" o = Gst.ObjectSetControlRateMethodInfo+    ResolveVideoEncoderMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveVideoEncoderMethod "setHeaders" o = VideoEncoderSetHeadersMethodInfo+    ResolveVideoEncoderMethod "setLatency" o = VideoEncoderSetLatencyMethodInfo+    ResolveVideoEncoderMethod "setLockedState" o = Gst.ElementSetLockedStateMethodInfo+    ResolveVideoEncoderMethod "setMeta" o = Gst.PresetSetMetaMethodInfo+    ResolveVideoEncoderMethod "setMinPts" o = VideoEncoderSetMinPtsMethodInfo+    ResolveVideoEncoderMethod "setName" o = Gst.ObjectSetNameMethodInfo+    ResolveVideoEncoderMethod "setOutputState" o = VideoEncoderSetOutputStateMethodInfo+    ResolveVideoEncoderMethod "setParent" o = Gst.ObjectSetParentMethodInfo+    ResolveVideoEncoderMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveVideoEncoderMethod "setStartTime" o = Gst.ElementSetStartTimeMethodInfo+    ResolveVideoEncoderMethod "setState" o = Gst.ElementSetStateMethodInfo+    ResolveVideoEncoderMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoEncoderMethod t VideoEncoder, MethodInfo info VideoEncoder p) => IsLabelProxy t (VideoEncoder -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoEncoderMethod t VideoEncoder, MethodInfo info VideoEncoder p) => IsLabel t (VideoEncoder -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList VideoEncoder = VideoEncoderAttributeList+type VideoEncoderAttributeList = ('[ '("name", Gst.ObjectNamePropertyInfo), '("parent", Gst.ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList VideoEncoder = VideoEncoderSignalList+type VideoEncoderSignalList = ('[ '("deepNotify", Gst.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", Gst.ElementPadAddedSignalInfo), '("padRemoved", Gst.ElementPadRemovedSignalInfo)] :: [(Symbol, *)])++-- method VideoEncoder::allocate_output_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_allocate_output_buffer" gst_video_encoder_allocate_output_buffer :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    Word64 ->                               -- size : TBasicType TUInt64+    IO (Ptr Gst.Buffer)+++videoEncoderAllocateOutputBuffer ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> Word64                               -- size+    -> m Gst.Buffer                         -- result+videoEncoderAllocateOutputBuffer _obj size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_encoder_allocate_output_buffer _obj' size+    checkUnexpectedReturnNULL "gst_video_encoder_allocate_output_buffer" result+    result' <- (wrapBoxed Gst.Buffer) result+    touchManagedPtr _obj+    return result'++data VideoEncoderAllocateOutputBufferMethodInfo+instance (signature ~ (Word64 -> m Gst.Buffer), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderAllocateOutputBufferMethodInfo a signature where+    overloadedMethod _ = videoEncoderAllocateOutputBuffer++-- method VideoEncoder::allocate_output_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_allocate_output_frame" gst_video_encoder_allocate_output_frame :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    Ptr VideoCodecFrame ->                  -- frame : TInterface "GstVideo" "VideoCodecFrame"+    Word64 ->                               -- size : TBasicType TUInt64+    IO CUInt+++videoEncoderAllocateOutputFrame ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> VideoCodecFrame                      -- frame+    -> Word64                               -- size+    -> m Gst.FlowReturn                     -- result+videoEncoderAllocateOutputFrame _obj frame size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let frame' = unsafeManagedPtrGetPtr frame+    result <- gst_video_encoder_allocate_output_frame _obj' frame' size+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr frame+    return result'++data VideoEncoderAllocateOutputFrameMethodInfo+instance (signature ~ (VideoCodecFrame -> Word64 -> m Gst.FlowReturn), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderAllocateOutputFrameMethodInfo a signature where+    overloadedMethod _ = videoEncoderAllocateOutputFrame++-- method VideoEncoder::finish_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_finish_frame" gst_video_encoder_finish_frame :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    Ptr VideoCodecFrame ->                  -- frame : TInterface "GstVideo" "VideoCodecFrame"+    IO CUInt+++videoEncoderFinishFrame ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> VideoCodecFrame                      -- frame+    -> m Gst.FlowReturn                     -- result+videoEncoderFinishFrame _obj frame = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    frame' <- copyBoxed frame+    result <- gst_video_encoder_finish_frame _obj' frame'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr frame+    return result'++data VideoEncoderFinishFrameMethodInfo+instance (signature ~ (VideoCodecFrame -> m Gst.FlowReturn), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderFinishFrameMethodInfo a signature where+    overloadedMethod _ = videoEncoderFinishFrame++-- method VideoEncoder::get_allocator+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_get_allocator" gst_video_encoder_get_allocator :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    Ptr (Ptr Gst.Allocator) ->              -- allocator : TInterface "Gst" "Allocator"+    Ptr Gst.AllocationParams ->             -- params : TInterface "Gst" "AllocationParams"+    IO ()+++videoEncoderGetAllocator ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> m (Gst.Allocator,Gst.AllocationParams)-- result+videoEncoderGetAllocator _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    allocator <- allocMem :: IO (Ptr (Ptr Gst.Allocator))+    params <- callocBoxedBytes 64 :: IO (Ptr Gst.AllocationParams)+    gst_video_encoder_get_allocator _obj' allocator params+    allocator' <- peek allocator+    allocator'' <- (wrapObject Gst.Allocator) allocator'+    params' <- (wrapBoxed Gst.AllocationParams) params+    touchManagedPtr _obj+    freeMem allocator+    return (allocator'', params')++data VideoEncoderGetAllocatorMethodInfo+instance (signature ~ (m (Gst.Allocator,Gst.AllocationParams)), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderGetAllocatorMethodInfo a signature where+    overloadedMethod _ = videoEncoderGetAllocator++-- method VideoEncoder::get_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame_number", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoCodecFrame"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_get_frame" gst_video_encoder_get_frame :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    Int32 ->                                -- frame_number : TBasicType TInt32+    IO (Ptr VideoCodecFrame)+++videoEncoderGetFrame ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> Int32                                -- frameNumber+    -> m VideoCodecFrame                    -- result+videoEncoderGetFrame _obj frameNumber = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_encoder_get_frame _obj' frameNumber+    checkUnexpectedReturnNULL "gst_video_encoder_get_frame" result+    result' <- (wrapBoxed VideoCodecFrame) result+    touchManagedPtr _obj+    return result'++data VideoEncoderGetFrameMethodInfo+instance (signature ~ (Int32 -> m VideoCodecFrame), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderGetFrameMethodInfo a signature where+    overloadedMethod _ = videoEncoderGetFrame++-- method VideoEncoder::get_frames+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "GstVideo" "VideoCodecFrame")+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_get_frames" gst_video_encoder_get_frames :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    IO (Ptr (GList (Ptr VideoCodecFrame)))+++videoEncoderGetFrames ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> m [VideoCodecFrame]                  -- result+videoEncoderGetFrames _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_encoder_get_frames _obj'+    checkUnexpectedReturnNULL "gst_video_encoder_get_frames" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed VideoCodecFrame) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++data VideoEncoderGetFramesMethodInfo+instance (signature ~ (m [VideoCodecFrame]), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderGetFramesMethodInfo a signature where+    overloadedMethod _ = videoEncoderGetFrames++-- method VideoEncoder::get_latency+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_get_latency" gst_video_encoder_get_latency :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    Ptr Word64 ->                           -- min_latency : TBasicType TUInt64+    Ptr Word64 ->                           -- max_latency : TBasicType TUInt64+    IO ()+++videoEncoderGetLatency ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> m (Word64,Word64)                    -- result+videoEncoderGetLatency _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    minLatency <- allocMem :: IO (Ptr Word64)+    maxLatency <- allocMem :: IO (Ptr Word64)+    gst_video_encoder_get_latency _obj' minLatency maxLatency+    minLatency' <- peek minLatency+    maxLatency' <- peek maxLatency+    touchManagedPtr _obj+    freeMem minLatency+    freeMem maxLatency+    return (minLatency', maxLatency')++data VideoEncoderGetLatencyMethodInfo+instance (signature ~ (m (Word64,Word64)), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderGetLatencyMethodInfo a signature where+    overloadedMethod _ = videoEncoderGetLatency++-- method VideoEncoder::get_oldest_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoCodecFrame"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_get_oldest_frame" gst_video_encoder_get_oldest_frame :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    IO (Ptr VideoCodecFrame)+++videoEncoderGetOldestFrame ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> m VideoCodecFrame                    -- result+videoEncoderGetOldestFrame _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_encoder_get_oldest_frame _obj'+    checkUnexpectedReturnNULL "gst_video_encoder_get_oldest_frame" result+    result' <- (wrapBoxed VideoCodecFrame) result+    touchManagedPtr _obj+    return result'++data VideoEncoderGetOldestFrameMethodInfo+instance (signature ~ (m VideoCodecFrame), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderGetOldestFrameMethodInfo a signature where+    overloadedMethod _ = videoEncoderGetOldestFrame++-- method VideoEncoder::get_output_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoCodecState"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_get_output_state" gst_video_encoder_get_output_state :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    IO (Ptr VideoCodecState)+++videoEncoderGetOutputState ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> m VideoCodecState                    -- result+videoEncoderGetOutputState _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_encoder_get_output_state _obj'+    checkUnexpectedReturnNULL "gst_video_encoder_get_output_state" result+    result' <- (wrapBoxed VideoCodecState) result+    touchManagedPtr _obj+    return result'++data VideoEncoderGetOutputStateMethodInfo+instance (signature ~ (m VideoCodecState), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderGetOutputStateMethodInfo a signature where+    overloadedMethod _ = videoEncoderGetOutputState++-- method VideoEncoder::merge_tags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_merge_tags" gst_video_encoder_merge_tags :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    Ptr Gst.TagList ->                      -- tags : TInterface "Gst" "TagList"+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"+    IO ()+++videoEncoderMergeTags ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> Maybe (Gst.TagList)                  -- tags+    -> Gst.TagMergeMode                     -- mode+    -> m ()                                 -- result+videoEncoderMergeTags _obj tags mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeTags <- case tags of+        Nothing -> return nullPtr+        Just jTags -> do+            let jTags' = unsafeManagedPtrGetPtr jTags+            return jTags'+    let mode' = (fromIntegral . fromEnum) mode+    gst_video_encoder_merge_tags _obj' maybeTags mode'+    touchManagedPtr _obj+    whenJust tags touchManagedPtr+    return ()++data VideoEncoderMergeTagsMethodInfo+instance (signature ~ (Maybe (Gst.TagList) -> Gst.TagMergeMode -> m ()), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderMergeTagsMethodInfo a signature where+    overloadedMethod _ = videoEncoderMergeTags++-- method VideoEncoder::negotiate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_negotiate" gst_video_encoder_negotiate :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    IO CInt+++videoEncoderNegotiate ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+videoEncoderNegotiate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_video_encoder_negotiate _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoEncoderNegotiateMethodInfo+instance (signature ~ (m Bool), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderNegotiateMethodInfo a signature where+    overloadedMethod _ = videoEncoderNegotiate++-- method VideoEncoder::proxy_getcaps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_proxy_getcaps" gst_video_encoder_proxy_getcaps :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    Ptr Gst.Caps ->                         -- caps : TInterface "Gst" "Caps"+    Ptr Gst.Caps ->                         -- filter : TInterface "Gst" "Caps"+    IO (Ptr Gst.Caps)+++videoEncoderProxyGetcaps ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> Maybe (Gst.Caps)                     -- caps+    -> Maybe (Gst.Caps)                     -- filter+    -> m Gst.Caps                           -- result+videoEncoderProxyGetcaps _obj caps filter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCaps <- case caps of+        Nothing -> return nullPtr+        Just jCaps -> do+            let jCaps' = unsafeManagedPtrGetPtr jCaps+            return jCaps'+    maybeFilter <- case filter of+        Nothing -> return nullPtr+        Just jFilter -> do+            let jFilter' = unsafeManagedPtrGetPtr jFilter+            return jFilter'+    result <- gst_video_encoder_proxy_getcaps _obj' maybeCaps maybeFilter+    checkUnexpectedReturnNULL "gst_video_encoder_proxy_getcaps" result+    result' <- (wrapBoxed Gst.Caps) result+    touchManagedPtr _obj+    whenJust caps touchManagedPtr+    whenJust filter touchManagedPtr+    return result'++data VideoEncoderProxyGetcapsMethodInfo+instance (signature ~ (Maybe (Gst.Caps) -> Maybe (Gst.Caps) -> m Gst.Caps), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderProxyGetcapsMethodInfo a signature where+    overloadedMethod _ = videoEncoderProxyGetcaps++-- method VideoEncoder::set_headers+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "headers", argType = TGList (TInterface "Gst" "Buffer"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_set_headers" gst_video_encoder_set_headers :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    Ptr (GList (Ptr Gst.Buffer)) ->         -- headers : TGList (TInterface "Gst" "Buffer")+    IO ()+++videoEncoderSetHeaders ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> [Gst.Buffer]                         -- headers+    -> m ()                                 -- result+videoEncoderSetHeaders _obj headers = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    headers' <- mapM copyBoxed headers+    headers'' <- packGList headers'+    gst_video_encoder_set_headers _obj' headers''+    touchManagedPtr _obj+    mapM_ touchManagedPtr headers+    return ()++data VideoEncoderSetHeadersMethodInfo+instance (signature ~ ([Gst.Buffer] -> m ()), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderSetHeadersMethodInfo a signature where+    overloadedMethod _ = videoEncoderSetHeaders++-- method VideoEncoder::set_latency+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_set_latency" gst_video_encoder_set_latency :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    Word64 ->                               -- min_latency : TBasicType TUInt64+    Word64 ->                               -- max_latency : TBasicType TUInt64+    IO ()+++videoEncoderSetLatency ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> Word64                               -- minLatency+    -> Word64                               -- maxLatency+    -> m ()                                 -- result+videoEncoderSetLatency _obj minLatency maxLatency = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_video_encoder_set_latency _obj' minLatency maxLatency+    touchManagedPtr _obj+    return ()++data VideoEncoderSetLatencyMethodInfo+instance (signature ~ (Word64 -> Word64 -> m ()), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderSetLatencyMethodInfo a signature where+    overloadedMethod _ = videoEncoderSetLatency++-- method VideoEncoder::set_min_pts+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_pts", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_set_min_pts" gst_video_encoder_set_min_pts :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    Word64 ->                               -- min_pts : TBasicType TUInt64+    IO ()+++videoEncoderSetMinPts ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> Word64                               -- minPts+    -> m ()                                 -- result+videoEncoderSetMinPts _obj minPts = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_video_encoder_set_min_pts _obj' minPts+    touchManagedPtr _obj+    return ()++data VideoEncoderSetMinPtsMethodInfo+instance (signature ~ (Word64 -> m ()), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderSetMinPtsMethodInfo a signature where+    overloadedMethod _ = videoEncoderSetMinPts++-- method VideoEncoder::set_output_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoEncoder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "reference", argType = TInterface "GstVideo" "VideoCodecState", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoCodecState"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_encoder_set_output_state" gst_video_encoder_set_output_state :: +    Ptr VideoEncoder ->                     -- _obj : TInterface "GstVideo" "VideoEncoder"+    Ptr Gst.Caps ->                         -- caps : TInterface "Gst" "Caps"+    Ptr VideoCodecState ->                  -- reference : TInterface "GstVideo" "VideoCodecState"+    IO (Ptr VideoCodecState)+++videoEncoderSetOutputState ::+    (MonadIO m, VideoEncoderK a) =>+    a                                       -- _obj+    -> Gst.Caps                             -- caps+    -> Maybe (VideoCodecState)              -- reference+    -> m VideoCodecState                    -- result+videoEncoderSetOutputState _obj caps reference = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    caps' <- copyBoxed caps+    maybeReference <- case reference of+        Nothing -> return nullPtr+        Just jReference -> do+            let jReference' = unsafeManagedPtrGetPtr jReference+            return jReference'+    result <- gst_video_encoder_set_output_state _obj' caps' maybeReference+    checkUnexpectedReturnNULL "gst_video_encoder_set_output_state" result+    result' <- (wrapBoxed VideoCodecState) result+    touchManagedPtr _obj+    touchManagedPtr caps+    whenJust reference touchManagedPtr+    return result'++data VideoEncoderSetOutputStateMethodInfo+instance (signature ~ (Gst.Caps -> Maybe (VideoCodecState) -> m VideoCodecState), MonadIO m, VideoEncoderK a) => MethodInfo VideoEncoderSetOutputStateMethodInfo a signature where+    overloadedMethod _ = videoEncoderSetOutputState++
+ GI/GstVideo/Objects/VideoEncoder.hs-boot view
@@ -0,0 +1,29 @@+module GI.GstVideo.Objects.VideoEncoder where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoEncoder = VideoEncoder (ForeignPtr VideoEncoder)+instance GObject VideoEncoder where+class GObject o => VideoEncoderK o+instance (GObject o, IsDescendantOf VideoEncoder o) => VideoEncoderK o+data VideoEncoderAllocateOutputBufferMethodInfo+data VideoEncoderAllocateOutputFrameMethodInfo+data VideoEncoderFinishFrameMethodInfo+data VideoEncoderGetAllocatorMethodInfo+data VideoEncoderGetFrameMethodInfo+data VideoEncoderGetFramesMethodInfo+data VideoEncoderGetLatencyMethodInfo+data VideoEncoderGetOldestFrameMethodInfo+data VideoEncoderGetOutputStateMethodInfo+data VideoEncoderMergeTagsMethodInfo+data VideoEncoderNegotiateMethodInfo+data VideoEncoderProxyGetcapsMethodInfo+data VideoEncoderSetHeadersMethodInfo+data VideoEncoderSetLatencyMethodInfo+data VideoEncoderSetMinPtsMethodInfo+data VideoEncoderSetOutputStateMethodInfo
+ GI/GstVideo/Objects/VideoFilter.hs view
@@ -0,0 +1,178 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Objects.VideoFilter+    ( ++-- * Exported types+    VideoFilter(..)                         ,+    VideoFilterK                            ,+    toVideoFilter                           ,+    noVideoFilter                           ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gst as Gst+import qualified GI.GstBase as GstBase++newtype VideoFilter = VideoFilter (ForeignPtr VideoFilter)+foreign import ccall "gst_video_filter_get_type"+    c_gst_video_filter_get_type :: IO GType++type instance ParentTypes VideoFilter = VideoFilterParentTypes+type VideoFilterParentTypes = '[GstBase.BaseTransform, Gst.Element, Gst.Object, GObject.Object]++instance GObject VideoFilter where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_video_filter_get_type+    ++class GObject o => VideoFilterK o+instance (GObject o, IsDescendantOf VideoFilter o) => VideoFilterK o++toVideoFilter :: VideoFilterK o => o -> IO VideoFilter+toVideoFilter = unsafeCastTo VideoFilter++noVideoFilter :: Maybe VideoFilter+noVideoFilter = Nothing++type family ResolveVideoFilterMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoFilterMethod "abortState" o = Gst.ElementAbortStateMethodInfo+    ResolveVideoFilterMethod "addControlBinding" o = Gst.ObjectAddControlBindingMethodInfo+    ResolveVideoFilterMethod "addPad" o = Gst.ElementAddPadMethodInfo+    ResolveVideoFilterMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveVideoFilterMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveVideoFilterMethod "changeState" o = Gst.ElementChangeStateMethodInfo+    ResolveVideoFilterMethod "continueState" o = Gst.ElementContinueStateMethodInfo+    ResolveVideoFilterMethod "createAllPads" o = Gst.ElementCreateAllPadsMethodInfo+    ResolveVideoFilterMethod "defaultError" o = Gst.ObjectDefaultErrorMethodInfo+    ResolveVideoFilterMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveVideoFilterMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveVideoFilterMethod "hasActiveControlBindings" o = Gst.ObjectHasActiveControlBindingsMethodInfo+    ResolveVideoFilterMethod "hasAncestor" o = Gst.ObjectHasAncestorMethodInfo+    ResolveVideoFilterMethod "hasAsAncestor" o = Gst.ObjectHasAsAncestorMethodInfo+    ResolveVideoFilterMethod "hasAsParent" o = Gst.ObjectHasAsParentMethodInfo+    ResolveVideoFilterMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveVideoFilterMethod "isInPlace" o = GstBase.BaseTransformIsInPlaceMethodInfo+    ResolveVideoFilterMethod "isLockedState" o = Gst.ElementIsLockedStateMethodInfo+    ResolveVideoFilterMethod "isPassthrough" o = GstBase.BaseTransformIsPassthroughMethodInfo+    ResolveVideoFilterMethod "isQosEnabled" o = GstBase.BaseTransformIsQosEnabledMethodInfo+    ResolveVideoFilterMethod "iteratePads" o = Gst.ElementIteratePadsMethodInfo+    ResolveVideoFilterMethod "iterateSinkPads" o = Gst.ElementIterateSinkPadsMethodInfo+    ResolveVideoFilterMethod "iterateSrcPads" o = Gst.ElementIterateSrcPadsMethodInfo+    ResolveVideoFilterMethod "link" o = Gst.ElementLinkMethodInfo+    ResolveVideoFilterMethod "linkFiltered" o = Gst.ElementLinkFilteredMethodInfo+    ResolveVideoFilterMethod "linkPads" o = Gst.ElementLinkPadsMethodInfo+    ResolveVideoFilterMethod "linkPadsFiltered" o = Gst.ElementLinkPadsFilteredMethodInfo+    ResolveVideoFilterMethod "linkPadsFull" o = Gst.ElementLinkPadsFullMethodInfo+    ResolveVideoFilterMethod "lostState" o = Gst.ElementLostStateMethodInfo+    ResolveVideoFilterMethod "messageFull" o = Gst.ElementMessageFullMethodInfo+    ResolveVideoFilterMethod "noMorePads" o = Gst.ElementNoMorePadsMethodInfo+    ResolveVideoFilterMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveVideoFilterMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveVideoFilterMethod "postMessage" o = Gst.ElementPostMessageMethodInfo+    ResolveVideoFilterMethod "provideClock" o = Gst.ElementProvideClockMethodInfo+    ResolveVideoFilterMethod "query" o = Gst.ElementQueryMethodInfo+    ResolveVideoFilterMethod "queryConvert" o = Gst.ElementQueryConvertMethodInfo+    ResolveVideoFilterMethod "queryDuration" o = Gst.ElementQueryDurationMethodInfo+    ResolveVideoFilterMethod "queryPosition" o = Gst.ElementQueryPositionMethodInfo+    ResolveVideoFilterMethod "reconfigureSink" o = GstBase.BaseTransformReconfigureSinkMethodInfo+    ResolveVideoFilterMethod "reconfigureSrc" o = GstBase.BaseTransformReconfigureSrcMethodInfo+    ResolveVideoFilterMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveVideoFilterMethod "releaseRequestPad" o = Gst.ElementReleaseRequestPadMethodInfo+    ResolveVideoFilterMethod "removeControlBinding" o = Gst.ObjectRemoveControlBindingMethodInfo+    ResolveVideoFilterMethod "removePad" o = Gst.ElementRemovePadMethodInfo+    ResolveVideoFilterMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveVideoFilterMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveVideoFilterMethod "requestPad" o = Gst.ElementRequestPadMethodInfo+    ResolveVideoFilterMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveVideoFilterMethod "seek" o = Gst.ElementSeekMethodInfo+    ResolveVideoFilterMethod "seekSimple" o = Gst.ElementSeekSimpleMethodInfo+    ResolveVideoFilterMethod "sendEvent" o = Gst.ElementSendEventMethodInfo+    ResolveVideoFilterMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveVideoFilterMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveVideoFilterMethod "suggestNextSync" o = Gst.ObjectSuggestNextSyncMethodInfo+    ResolveVideoFilterMethod "syncStateWithParent" o = Gst.ElementSyncStateWithParentMethodInfo+    ResolveVideoFilterMethod "syncValues" o = Gst.ObjectSyncValuesMethodInfo+    ResolveVideoFilterMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveVideoFilterMethod "unlink" o = Gst.ElementUnlinkMethodInfo+    ResolveVideoFilterMethod "unlinkPads" o = Gst.ElementUnlinkPadsMethodInfo+    ResolveVideoFilterMethod "unparent" o = Gst.ObjectUnparentMethodInfo+    ResolveVideoFilterMethod "updateQos" o = GstBase.BaseTransformUpdateQosMethodInfo+    ResolveVideoFilterMethod "updateSrcCaps" o = GstBase.BaseTransformUpdateSrcCapsMethodInfo+    ResolveVideoFilterMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveVideoFilterMethod "getAllocator" o = GstBase.BaseTransformGetAllocatorMethodInfo+    ResolveVideoFilterMethod "getBaseTime" o = Gst.ElementGetBaseTimeMethodInfo+    ResolveVideoFilterMethod "getBufferPool" o = GstBase.BaseTransformGetBufferPoolMethodInfo+    ResolveVideoFilterMethod "getBus" o = Gst.ElementGetBusMethodInfo+    ResolveVideoFilterMethod "getClock" o = Gst.ElementGetClockMethodInfo+    ResolveVideoFilterMethod "getCompatiblePad" o = Gst.ElementGetCompatiblePadMethodInfo+    ResolveVideoFilterMethod "getCompatiblePadTemplate" o = Gst.ElementGetCompatiblePadTemplateMethodInfo+    ResolveVideoFilterMethod "getControlBinding" o = Gst.ObjectGetControlBindingMethodInfo+    ResolveVideoFilterMethod "getControlRate" o = Gst.ObjectGetControlRateMethodInfo+    ResolveVideoFilterMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveVideoFilterMethod "getFactory" o = Gst.ElementGetFactoryMethodInfo+    ResolveVideoFilterMethod "getGValueArray" o = Gst.ObjectGetGValueArrayMethodInfo+    ResolveVideoFilterMethod "getName" o = Gst.ObjectGetNameMethodInfo+    ResolveVideoFilterMethod "getParent" o = Gst.ObjectGetParentMethodInfo+    ResolveVideoFilterMethod "getPathString" o = Gst.ObjectGetPathStringMethodInfo+    ResolveVideoFilterMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveVideoFilterMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveVideoFilterMethod "getRequestPad" o = Gst.ElementGetRequestPadMethodInfo+    ResolveVideoFilterMethod "getStartTime" o = Gst.ElementGetStartTimeMethodInfo+    ResolveVideoFilterMethod "getState" o = Gst.ElementGetStateMethodInfo+    ResolveVideoFilterMethod "getStaticPad" o = Gst.ElementGetStaticPadMethodInfo+    ResolveVideoFilterMethod "getValue" o = Gst.ObjectGetValueMethodInfo+    ResolveVideoFilterMethod "getValueArray" o = Gst.ObjectGetValueArrayMethodInfo+    ResolveVideoFilterMethod "setBaseTime" o = Gst.ElementSetBaseTimeMethodInfo+    ResolveVideoFilterMethod "setBus" o = Gst.ElementSetBusMethodInfo+    ResolveVideoFilterMethod "setClock" o = Gst.ElementSetClockMethodInfo+    ResolveVideoFilterMethod "setContext" o = Gst.ElementSetContextMethodInfo+    ResolveVideoFilterMethod "setControlBindingDisabled" o = Gst.ObjectSetControlBindingDisabledMethodInfo+    ResolveVideoFilterMethod "setControlBindingsDisabled" o = Gst.ObjectSetControlBindingsDisabledMethodInfo+    ResolveVideoFilterMethod "setControlRate" o = Gst.ObjectSetControlRateMethodInfo+    ResolveVideoFilterMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveVideoFilterMethod "setGapAware" o = GstBase.BaseTransformSetGapAwareMethodInfo+    ResolveVideoFilterMethod "setInPlace" o = GstBase.BaseTransformSetInPlaceMethodInfo+    ResolveVideoFilterMethod "setLockedState" o = Gst.ElementSetLockedStateMethodInfo+    ResolveVideoFilterMethod "setName" o = Gst.ObjectSetNameMethodInfo+    ResolveVideoFilterMethod "setParent" o = Gst.ObjectSetParentMethodInfo+    ResolveVideoFilterMethod "setPassthrough" o = GstBase.BaseTransformSetPassthroughMethodInfo+    ResolveVideoFilterMethod "setPreferPassthrough" o = GstBase.BaseTransformSetPreferPassthroughMethodInfo+    ResolveVideoFilterMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveVideoFilterMethod "setQosEnabled" o = GstBase.BaseTransformSetQosEnabledMethodInfo+    ResolveVideoFilterMethod "setStartTime" o = Gst.ElementSetStartTimeMethodInfo+    ResolveVideoFilterMethod "setState" o = Gst.ElementSetStateMethodInfo+    ResolveVideoFilterMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoFilterMethod t VideoFilter, MethodInfo info VideoFilter p) => IsLabelProxy t (VideoFilter -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoFilterMethod t VideoFilter, MethodInfo info VideoFilter p) => IsLabel t (VideoFilter -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList VideoFilter = VideoFilterAttributeList+type VideoFilterAttributeList = ('[ '("name", Gst.ObjectNamePropertyInfo), '("parent", Gst.ObjectParentPropertyInfo), '("qos", GstBase.BaseTransformQosPropertyInfo)] :: [(Symbol, *)])++type instance SignalList VideoFilter = VideoFilterSignalList+type VideoFilterSignalList = ('[ '("deepNotify", Gst.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", Gst.ElementPadAddedSignalInfo), '("padRemoved", Gst.ElementPadRemovedSignalInfo)] :: [(Symbol, *)])++
+ GI/GstVideo/Objects/VideoFilter.hs-boot view
@@ -0,0 +1,13 @@+module GI.GstVideo.Objects.VideoFilter where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoFilter = VideoFilter (ForeignPtr VideoFilter)+instance GObject VideoFilter where+class GObject o => VideoFilterK o+instance (GObject o, IsDescendantOf VideoFilter o) => VideoFilterK o
+ GI/GstVideo/Objects/VideoSink.hs view
@@ -0,0 +1,266 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Objects.VideoSink+    ( ++-- * Exported types+    VideoSink(..)                           ,+    VideoSinkK                              ,+    toVideoSink                             ,+    noVideoSink                             ,+++ -- * Methods+-- ** videoSinkCenterRect+    videoSinkCenterRect                     ,+++++ -- * Properties+-- ** ShowPrerollFrame+    VideoSinkShowPrerollFramePropertyInfo   ,+    constructVideoSinkShowPrerollFrame      ,+    getVideoSinkShowPrerollFrame            ,+    setVideoSinkShowPrerollFrame            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gst as Gst+import qualified GI.GstBase as GstBase++newtype VideoSink = VideoSink (ForeignPtr VideoSink)+foreign import ccall "gst_video_sink_get_type"+    c_gst_video_sink_get_type :: IO GType++type instance ParentTypes VideoSink = VideoSinkParentTypes+type VideoSinkParentTypes = '[GstBase.BaseSink, Gst.Element, Gst.Object, GObject.Object]++instance GObject VideoSink where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_video_sink_get_type+    ++class GObject o => VideoSinkK o+instance (GObject o, IsDescendantOf VideoSink o) => VideoSinkK o++toVideoSink :: VideoSinkK o => o -> IO VideoSink+toVideoSink = unsafeCastTo VideoSink++noVideoSink :: Maybe VideoSink+noVideoSink = Nothing++type family ResolveVideoSinkMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoSinkMethod "abortState" o = Gst.ElementAbortStateMethodInfo+    ResolveVideoSinkMethod "addControlBinding" o = Gst.ObjectAddControlBindingMethodInfo+    ResolveVideoSinkMethod "addPad" o = Gst.ElementAddPadMethodInfo+    ResolveVideoSinkMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveVideoSinkMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveVideoSinkMethod "changeState" o = Gst.ElementChangeStateMethodInfo+    ResolveVideoSinkMethod "continueState" o = Gst.ElementContinueStateMethodInfo+    ResolveVideoSinkMethod "createAllPads" o = Gst.ElementCreateAllPadsMethodInfo+    ResolveVideoSinkMethod "defaultError" o = Gst.ObjectDefaultErrorMethodInfo+    ResolveVideoSinkMethod "doPreroll" o = GstBase.BaseSinkDoPrerollMethodInfo+    ResolveVideoSinkMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveVideoSinkMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveVideoSinkMethod "hasActiveControlBindings" o = Gst.ObjectHasActiveControlBindingsMethodInfo+    ResolveVideoSinkMethod "hasAncestor" o = Gst.ObjectHasAncestorMethodInfo+    ResolveVideoSinkMethod "hasAsAncestor" o = Gst.ObjectHasAsAncestorMethodInfo+    ResolveVideoSinkMethod "hasAsParent" o = Gst.ObjectHasAsParentMethodInfo+    ResolveVideoSinkMethod "isAsyncEnabled" o = GstBase.BaseSinkIsAsyncEnabledMethodInfo+    ResolveVideoSinkMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveVideoSinkMethod "isLastSampleEnabled" o = GstBase.BaseSinkIsLastSampleEnabledMethodInfo+    ResolveVideoSinkMethod "isLockedState" o = Gst.ElementIsLockedStateMethodInfo+    ResolveVideoSinkMethod "isQosEnabled" o = GstBase.BaseSinkIsQosEnabledMethodInfo+    ResolveVideoSinkMethod "iteratePads" o = Gst.ElementIteratePadsMethodInfo+    ResolveVideoSinkMethod "iterateSinkPads" o = Gst.ElementIterateSinkPadsMethodInfo+    ResolveVideoSinkMethod "iterateSrcPads" o = Gst.ElementIterateSrcPadsMethodInfo+    ResolveVideoSinkMethod "link" o = Gst.ElementLinkMethodInfo+    ResolveVideoSinkMethod "linkFiltered" o = Gst.ElementLinkFilteredMethodInfo+    ResolveVideoSinkMethod "linkPads" o = Gst.ElementLinkPadsMethodInfo+    ResolveVideoSinkMethod "linkPadsFiltered" o = Gst.ElementLinkPadsFilteredMethodInfo+    ResolveVideoSinkMethod "linkPadsFull" o = Gst.ElementLinkPadsFullMethodInfo+    ResolveVideoSinkMethod "lostState" o = Gst.ElementLostStateMethodInfo+    ResolveVideoSinkMethod "messageFull" o = Gst.ElementMessageFullMethodInfo+    ResolveVideoSinkMethod "noMorePads" o = Gst.ElementNoMorePadsMethodInfo+    ResolveVideoSinkMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveVideoSinkMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveVideoSinkMethod "postMessage" o = Gst.ElementPostMessageMethodInfo+    ResolveVideoSinkMethod "provideClock" o = Gst.ElementProvideClockMethodInfo+    ResolveVideoSinkMethod "query" o = Gst.ElementQueryMethodInfo+    ResolveVideoSinkMethod "queryConvert" o = Gst.ElementQueryConvertMethodInfo+    ResolveVideoSinkMethod "queryDuration" o = Gst.ElementQueryDurationMethodInfo+    ResolveVideoSinkMethod "queryLatency" o = GstBase.BaseSinkQueryLatencyMethodInfo+    ResolveVideoSinkMethod "queryPosition" o = Gst.ElementQueryPositionMethodInfo+    ResolveVideoSinkMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveVideoSinkMethod "releaseRequestPad" o = Gst.ElementReleaseRequestPadMethodInfo+    ResolveVideoSinkMethod "removeControlBinding" o = Gst.ObjectRemoveControlBindingMethodInfo+    ResolveVideoSinkMethod "removePad" o = Gst.ElementRemovePadMethodInfo+    ResolveVideoSinkMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveVideoSinkMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveVideoSinkMethod "requestPad" o = Gst.ElementRequestPadMethodInfo+    ResolveVideoSinkMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveVideoSinkMethod "seek" o = Gst.ElementSeekMethodInfo+    ResolveVideoSinkMethod "seekSimple" o = Gst.ElementSeekSimpleMethodInfo+    ResolveVideoSinkMethod "sendEvent" o = Gst.ElementSendEventMethodInfo+    ResolveVideoSinkMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveVideoSinkMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveVideoSinkMethod "suggestNextSync" o = Gst.ObjectSuggestNextSyncMethodInfo+    ResolveVideoSinkMethod "syncStateWithParent" o = Gst.ElementSyncStateWithParentMethodInfo+    ResolveVideoSinkMethod "syncValues" o = Gst.ObjectSyncValuesMethodInfo+    ResolveVideoSinkMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveVideoSinkMethod "unlink" o = Gst.ElementUnlinkMethodInfo+    ResolveVideoSinkMethod "unlinkPads" o = Gst.ElementUnlinkPadsMethodInfo+    ResolveVideoSinkMethod "unparent" o = Gst.ObjectUnparentMethodInfo+    ResolveVideoSinkMethod "wait" o = GstBase.BaseSinkWaitMethodInfo+    ResolveVideoSinkMethod "waitClock" o = GstBase.BaseSinkWaitClockMethodInfo+    ResolveVideoSinkMethod "waitPreroll" o = GstBase.BaseSinkWaitPrerollMethodInfo+    ResolveVideoSinkMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveVideoSinkMethod "getBaseTime" o = Gst.ElementGetBaseTimeMethodInfo+    ResolveVideoSinkMethod "getBlocksize" o = GstBase.BaseSinkGetBlocksizeMethodInfo+    ResolveVideoSinkMethod "getBus" o = Gst.ElementGetBusMethodInfo+    ResolveVideoSinkMethod "getClock" o = Gst.ElementGetClockMethodInfo+    ResolveVideoSinkMethod "getCompatiblePad" o = Gst.ElementGetCompatiblePadMethodInfo+    ResolveVideoSinkMethod "getCompatiblePadTemplate" o = Gst.ElementGetCompatiblePadTemplateMethodInfo+    ResolveVideoSinkMethod "getControlBinding" o = Gst.ObjectGetControlBindingMethodInfo+    ResolveVideoSinkMethod "getControlRate" o = Gst.ObjectGetControlRateMethodInfo+    ResolveVideoSinkMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveVideoSinkMethod "getFactory" o = Gst.ElementGetFactoryMethodInfo+    ResolveVideoSinkMethod "getGValueArray" o = Gst.ObjectGetGValueArrayMethodInfo+    ResolveVideoSinkMethod "getLastSample" o = GstBase.BaseSinkGetLastSampleMethodInfo+    ResolveVideoSinkMethod "getLatency" o = GstBase.BaseSinkGetLatencyMethodInfo+    ResolveVideoSinkMethod "getMaxBitrate" o = GstBase.BaseSinkGetMaxBitrateMethodInfo+    ResolveVideoSinkMethod "getMaxLateness" o = GstBase.BaseSinkGetMaxLatenessMethodInfo+    ResolveVideoSinkMethod "getName" o = Gst.ObjectGetNameMethodInfo+    ResolveVideoSinkMethod "getParent" o = Gst.ObjectGetParentMethodInfo+    ResolveVideoSinkMethod "getPathString" o = Gst.ObjectGetPathStringMethodInfo+    ResolveVideoSinkMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveVideoSinkMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveVideoSinkMethod "getRenderDelay" o = GstBase.BaseSinkGetRenderDelayMethodInfo+    ResolveVideoSinkMethod "getRequestPad" o = Gst.ElementGetRequestPadMethodInfo+    ResolveVideoSinkMethod "getStartTime" o = Gst.ElementGetStartTimeMethodInfo+    ResolveVideoSinkMethod "getState" o = Gst.ElementGetStateMethodInfo+    ResolveVideoSinkMethod "getStaticPad" o = Gst.ElementGetStaticPadMethodInfo+    ResolveVideoSinkMethod "getSync" o = GstBase.BaseSinkGetSyncMethodInfo+    ResolveVideoSinkMethod "getThrottleTime" o = GstBase.BaseSinkGetThrottleTimeMethodInfo+    ResolveVideoSinkMethod "getTsOffset" o = GstBase.BaseSinkGetTsOffsetMethodInfo+    ResolveVideoSinkMethod "getValue" o = Gst.ObjectGetValueMethodInfo+    ResolveVideoSinkMethod "getValueArray" o = Gst.ObjectGetValueArrayMethodInfo+    ResolveVideoSinkMethod "setAsyncEnabled" o = GstBase.BaseSinkSetAsyncEnabledMethodInfo+    ResolveVideoSinkMethod "setBaseTime" o = Gst.ElementSetBaseTimeMethodInfo+    ResolveVideoSinkMethod "setBlocksize" o = GstBase.BaseSinkSetBlocksizeMethodInfo+    ResolveVideoSinkMethod "setBus" o = Gst.ElementSetBusMethodInfo+    ResolveVideoSinkMethod "setClock" o = Gst.ElementSetClockMethodInfo+    ResolveVideoSinkMethod "setContext" o = Gst.ElementSetContextMethodInfo+    ResolveVideoSinkMethod "setControlBindingDisabled" o = Gst.ObjectSetControlBindingDisabledMethodInfo+    ResolveVideoSinkMethod "setControlBindingsDisabled" o = Gst.ObjectSetControlBindingsDisabledMethodInfo+    ResolveVideoSinkMethod "setControlRate" o = Gst.ObjectSetControlRateMethodInfo+    ResolveVideoSinkMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveVideoSinkMethod "setLastSampleEnabled" o = GstBase.BaseSinkSetLastSampleEnabledMethodInfo+    ResolveVideoSinkMethod "setLockedState" o = Gst.ElementSetLockedStateMethodInfo+    ResolveVideoSinkMethod "setMaxBitrate" o = GstBase.BaseSinkSetMaxBitrateMethodInfo+    ResolveVideoSinkMethod "setMaxLateness" o = GstBase.BaseSinkSetMaxLatenessMethodInfo+    ResolveVideoSinkMethod "setName" o = Gst.ObjectSetNameMethodInfo+    ResolveVideoSinkMethod "setParent" o = Gst.ObjectSetParentMethodInfo+    ResolveVideoSinkMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveVideoSinkMethod "setQosEnabled" o = GstBase.BaseSinkSetQosEnabledMethodInfo+    ResolveVideoSinkMethod "setRenderDelay" o = GstBase.BaseSinkSetRenderDelayMethodInfo+    ResolveVideoSinkMethod "setStartTime" o = Gst.ElementSetStartTimeMethodInfo+    ResolveVideoSinkMethod "setState" o = Gst.ElementSetStateMethodInfo+    ResolveVideoSinkMethod "setSync" o = GstBase.BaseSinkSetSyncMethodInfo+    ResolveVideoSinkMethod "setThrottleTime" o = GstBase.BaseSinkSetThrottleTimeMethodInfo+    ResolveVideoSinkMethod "setTsOffset" o = GstBase.BaseSinkSetTsOffsetMethodInfo+    ResolveVideoSinkMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoSinkMethod t VideoSink, MethodInfo info VideoSink p) => IsLabelProxy t (VideoSink -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoSinkMethod t VideoSink, MethodInfo info VideoSink p) => IsLabel t (VideoSink -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- VVV Prop "show-preroll-frame"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getVideoSinkShowPrerollFrame :: (MonadIO m, VideoSinkK o) => o -> m Bool+getVideoSinkShowPrerollFrame obj = liftIO $ getObjectPropertyBool obj "show-preroll-frame"++setVideoSinkShowPrerollFrame :: (MonadIO m, VideoSinkK o) => o -> Bool -> m ()+setVideoSinkShowPrerollFrame obj val = liftIO $ setObjectPropertyBool obj "show-preroll-frame" val++constructVideoSinkShowPrerollFrame :: Bool -> IO ([Char], GValue)+constructVideoSinkShowPrerollFrame val = constructObjectPropertyBool "show-preroll-frame" val++data VideoSinkShowPrerollFramePropertyInfo+instance AttrInfo VideoSinkShowPrerollFramePropertyInfo where+    type AttrAllowedOps VideoSinkShowPrerollFramePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint VideoSinkShowPrerollFramePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint VideoSinkShowPrerollFramePropertyInfo = VideoSinkK+    type AttrGetType VideoSinkShowPrerollFramePropertyInfo = Bool+    type AttrLabel VideoSinkShowPrerollFramePropertyInfo = "show-preroll-frame"+    attrGet _ = getVideoSinkShowPrerollFrame+    attrSet _ = setVideoSinkShowPrerollFrame+    attrConstruct _ = constructVideoSinkShowPrerollFrame++type instance AttributeList VideoSink = VideoSinkAttributeList+type VideoSinkAttributeList = ('[ '("async", GstBase.BaseSinkAsyncPropertyInfo), '("blocksize", GstBase.BaseSinkBlocksizePropertyInfo), '("enableLastSample", GstBase.BaseSinkEnableLastSamplePropertyInfo), '("lastSample", GstBase.BaseSinkLastSamplePropertyInfo), '("maxBitrate", GstBase.BaseSinkMaxBitratePropertyInfo), '("maxLateness", GstBase.BaseSinkMaxLatenessPropertyInfo), '("name", Gst.ObjectNamePropertyInfo), '("parent", Gst.ObjectParentPropertyInfo), '("qos", GstBase.BaseSinkQosPropertyInfo), '("renderDelay", GstBase.BaseSinkRenderDelayPropertyInfo), '("showPrerollFrame", VideoSinkShowPrerollFramePropertyInfo), '("sync", GstBase.BaseSinkSyncPropertyInfo), '("throttleTime", GstBase.BaseSinkThrottleTimePropertyInfo), '("tsOffset", GstBase.BaseSinkTsOffsetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList VideoSink = VideoSinkSignalList+type VideoSinkSignalList = ('[ '("deepNotify", Gst.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", Gst.ElementPadAddedSignalInfo), '("padRemoved", Gst.ElementPadRemovedSignalInfo)] :: [(Symbol, *)])++-- method VideoSink::center_rect+-- method type : MemberFunction+-- Args : [Arg {argCName = "src", argType = TInterface "GstVideo" "VideoRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dst", argType = TInterface "GstVideo" "VideoRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface "GstVideo" "VideoRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scaling", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_sink_center_rect" gst_video_sink_center_rect :: +    Ptr VideoRectangle ->                   -- src : TInterface "GstVideo" "VideoRectangle"+    Ptr VideoRectangle ->                   -- dst : TInterface "GstVideo" "VideoRectangle"+    Ptr VideoRectangle ->                   -- result : TInterface "GstVideo" "VideoRectangle"+    CInt ->                                 -- scaling : TBasicType TBoolean+    IO ()+++videoSinkCenterRect ::+    (MonadIO m) =>+    VideoRectangle                          -- src+    -> VideoRectangle                       -- dst+    -> VideoRectangle                       -- result_+    -> Bool                                 -- scaling+    -> m ()                                 -- result+videoSinkCenterRect src dst result_ scaling = liftIO $ do+    let src' = unsafeManagedPtrGetPtr src+    let dst' = unsafeManagedPtrGetPtr dst+    let result_' = unsafeManagedPtrGetPtr result_+    let scaling' = (fromIntegral . fromEnum) scaling+    gst_video_sink_center_rect src' dst' result_' scaling'+    touchManagedPtr src+    touchManagedPtr dst+    touchManagedPtr result_+    return ()++
+ GI/GstVideo/Objects/VideoSink.hs-boot view
@@ -0,0 +1,14 @@+module GI.GstVideo.Objects.VideoSink where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoSink = VideoSink (ForeignPtr VideoSink)+instance GObject VideoSink where+class GObject o => VideoSinkK o+instance (GObject o, IsDescendantOf VideoSink o) => VideoSinkK o+data VideoSinkShowPrerollFramePropertyInfo
+ GI/GstVideo/Structs.hs view
@@ -0,0 +1,69 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Structs+    (     module GI.GstVideo.Structs.VideoAlignment,+    module GI.GstVideo.Structs.VideoChromaResample,+    module GI.GstVideo.Structs.VideoCodecFrame,+    module GI.GstVideo.Structs.VideoCodecState,+    module GI.GstVideo.Structs.VideoColorPrimariesInfo,+    module GI.GstVideo.Structs.VideoColorimetry,+    module GI.GstVideo.Structs.VideoConverter,+    module GI.GstVideo.Structs.VideoCropMeta,+    module GI.GstVideo.Structs.VideoDither  ,+    module GI.GstVideo.Structs.VideoFormatInfo,+    module GI.GstVideo.Structs.VideoFrame   ,+    module GI.GstVideo.Structs.VideoGLTextureUploadMeta,+    module GI.GstVideo.Structs.VideoInfo    ,+    module GI.GstVideo.Structs.VideoMeta    ,+    module GI.GstVideo.Structs.VideoMetaTransform,+    module GI.GstVideo.Structs.VideoOverlayComposition,+    module GI.GstVideo.Structs.VideoOverlayCompositionMeta,+    module GI.GstVideo.Structs.VideoOverlayRectangle,+    module GI.GstVideo.Structs.VideoRectangle,+    module GI.GstVideo.Structs.VideoRegionOfInterestMeta,+    module GI.GstVideo.Structs.VideoResampler,+    module GI.GstVideo.Structs.VideoScaler  ,+++    ) where++import GI.GstVideo.Structs.VideoAlignment+import GI.GstVideo.Structs.VideoChromaResample+import GI.GstVideo.Structs.VideoCodecFrame+import GI.GstVideo.Structs.VideoCodecState+import GI.GstVideo.Structs.VideoColorPrimariesInfo+import GI.GstVideo.Structs.VideoColorimetry+import GI.GstVideo.Structs.VideoConverter+import GI.GstVideo.Structs.VideoCropMeta+import GI.GstVideo.Structs.VideoDither+import GI.GstVideo.Structs.VideoFormatInfo+import GI.GstVideo.Structs.VideoFrame+import GI.GstVideo.Structs.VideoGLTextureUploadMeta+import GI.GstVideo.Structs.VideoInfo+import GI.GstVideo.Structs.VideoMeta+import GI.GstVideo.Structs.VideoMetaTransform+import GI.GstVideo.Structs.VideoOverlayComposition+import GI.GstVideo.Structs.VideoOverlayCompositionMeta+import GI.GstVideo.Structs.VideoOverlayRectangle+import GI.GstVideo.Structs.VideoRectangle+import GI.GstVideo.Structs.VideoRegionOfInterestMeta+import GI.GstVideo.Structs.VideoResampler+import GI.GstVideo.Structs.VideoScaler++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++
+ GI/GstVideo/Structs/VideoAlignment.hs view
@@ -0,0 +1,130 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Extra alignment paramters for the memory of video buffers. This+structure is usually used to configure the bufferpool if it supports the+#GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT.+-}++module GI.GstVideo.Structs.VideoAlignment+    ( ++-- * Exported types+    VideoAlignment(..)                      ,+    newZeroVideoAlignment                   ,+    noVideoAlignment                        ,+++ -- * Methods+-- ** videoAlignmentReset+    VideoAlignmentResetMethodInfo           ,+    videoAlignmentReset                     ,+++++ -- * Properties+-- ** PaddingBottom+    videoAlignmentReadPaddingBottom         ,+++-- ** PaddingLeft+    videoAlignmentReadPaddingLeft           ,+++-- ** PaddingRight+    videoAlignmentReadPaddingRight          ,+++-- ** PaddingTop+    videoAlignmentReadPaddingTop            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++newtype VideoAlignment = VideoAlignment (ForeignPtr VideoAlignment)+-- | Construct a `VideoAlignment` struct initialized to zero.+newZeroVideoAlignment :: MonadIO m => m VideoAlignment+newZeroVideoAlignment = liftIO $ callocBytes 32 >>= wrapPtr VideoAlignment++noVideoAlignment :: Maybe VideoAlignment+noVideoAlignment = Nothing++videoAlignmentReadPaddingTop :: VideoAlignment -> IO Word32+videoAlignmentReadPaddingTop s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Word32+    return val++videoAlignmentReadPaddingBottom :: VideoAlignment -> IO Word32+videoAlignmentReadPaddingBottom s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 4) :: IO Word32+    return val++videoAlignmentReadPaddingLeft :: VideoAlignment -> IO Word32+videoAlignmentReadPaddingLeft s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO Word32+    return val++videoAlignmentReadPaddingRight :: VideoAlignment -> IO Word32+videoAlignmentReadPaddingRight s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 12) :: IO Word32+    return val++-- XXX Skipped getter for "VideoAlignment:stride_align" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt32)"++-- method VideoAlignment::reset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoAlignment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_alignment_reset" gst_video_alignment_reset :: +    Ptr VideoAlignment ->                   -- _obj : TInterface "GstVideo" "VideoAlignment"+    IO ()+++videoAlignmentReset ::+    (MonadIO m) =>+    VideoAlignment                          -- _obj+    -> m ()                                 -- result+videoAlignmentReset _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_alignment_reset _obj'+    touchManagedPtr _obj+    return ()++data VideoAlignmentResetMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoAlignmentResetMethodInfo VideoAlignment signature where+    overloadedMethod _ = videoAlignmentReset++type family ResolveVideoAlignmentMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoAlignmentMethod "reset" o = VideoAlignmentResetMethodInfo+    ResolveVideoAlignmentMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoAlignmentMethod t VideoAlignment, MethodInfo info VideoAlignment p) => IsLabelProxy t (VideoAlignment -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoAlignmentMethod t VideoAlignment, MethodInfo info VideoAlignment p) => IsLabel t (VideoAlignment -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoAlignment.hs-boot view
@@ -0,0 +1,11 @@+module GI.GstVideo.Structs.VideoAlignment where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoAlignment = VideoAlignment (ForeignPtr VideoAlignment)+data VideoAlignmentResetMethodInfo
+ GI/GstVideo/Structs/VideoChromaResample.hs view
@@ -0,0 +1,117 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Structs.VideoChromaResample+    ( ++-- * Exported types+    VideoChromaResample(..)                 ,+    noVideoChromaResample                   ,+++ -- * Methods+-- ** videoChromaResampleFree+    VideoChromaResampleFreeMethodInfo       ,+    videoChromaResampleFree                 ,+++-- ** videoChromaResampleGetInfo+    VideoChromaResampleGetInfoMethodInfo    ,+    videoChromaResampleGetInfo              ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++newtype VideoChromaResample = VideoChromaResample (ForeignPtr VideoChromaResample)+noVideoChromaResample :: Maybe VideoChromaResample+noVideoChromaResample = Nothing++-- method VideoChromaResample::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoChromaResample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_chroma_resample_free" gst_video_chroma_resample_free :: +    Ptr VideoChromaResample ->              -- _obj : TInterface "GstVideo" "VideoChromaResample"+    IO ()+++videoChromaResampleFree ::+    (MonadIO m) =>+    VideoChromaResample                     -- _obj+    -> m ()                                 -- result+videoChromaResampleFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_chroma_resample_free _obj'+    touchManagedPtr _obj+    return ()++data VideoChromaResampleFreeMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoChromaResampleFreeMethodInfo VideoChromaResample signature where+    overloadedMethod _ = videoChromaResampleFree++-- method VideoChromaResample::get_info+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoChromaResample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_lines", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_chroma_resample_get_info" gst_video_chroma_resample_get_info :: +    Ptr VideoChromaResample ->              -- _obj : TInterface "GstVideo" "VideoChromaResample"+    Word32 ->                               -- n_lines : TBasicType TUInt32+    Int32 ->                                -- offset : TBasicType TInt32+    IO ()+++videoChromaResampleGetInfo ::+    (MonadIO m) =>+    VideoChromaResample                     -- _obj+    -> Word32                               -- nLines+    -> Int32                                -- offset+    -> m ()                                 -- result+videoChromaResampleGetInfo _obj nLines offset = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_chroma_resample_get_info _obj' nLines offset+    touchManagedPtr _obj+    return ()++data VideoChromaResampleGetInfoMethodInfo+instance (signature ~ (Word32 -> Int32 -> m ()), MonadIO m) => MethodInfo VideoChromaResampleGetInfoMethodInfo VideoChromaResample signature where+    overloadedMethod _ = videoChromaResampleGetInfo++type family ResolveVideoChromaResampleMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoChromaResampleMethod "free" o = VideoChromaResampleFreeMethodInfo+    ResolveVideoChromaResampleMethod "getInfo" o = VideoChromaResampleGetInfoMethodInfo+    ResolveVideoChromaResampleMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoChromaResampleMethod t VideoChromaResample, MethodInfo info VideoChromaResample p) => IsLabelProxy t (VideoChromaResample -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoChromaResampleMethod t VideoChromaResample, MethodInfo info VideoChromaResample p) => IsLabel t (VideoChromaResample -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoChromaResample.hs-boot view
@@ -0,0 +1,12 @@+module GI.GstVideo.Structs.VideoChromaResample where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoChromaResample = VideoChromaResample (ForeignPtr VideoChromaResample)+data VideoChromaResampleFreeMethodInfo+data VideoChromaResampleGetInfoMethodInfo
+ GI/GstVideo/Structs/VideoCodecFrame.hs view
@@ -0,0 +1,299 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #GstVideoCodecFrame represents a video frame both in raw and+encoded form.+-}++module GI.GstVideo.Structs.VideoCodecFrame+    ( ++-- * Exported types+    VideoCodecFrame(..)                     ,+    newZeroVideoCodecFrame                  ,+    noVideoCodecFrame                       ,+++ -- * Methods+-- ** videoCodecFrameGetUserData+    VideoCodecFrameGetUserDataMethodInfo    ,+    videoCodecFrameGetUserData              ,+++-- ** videoCodecFrameRef+    VideoCodecFrameRefMethodInfo            ,+    videoCodecFrameRef                      ,+++-- ** videoCodecFrameSetUserData+    VideoCodecFrameSetUserDataMethodInfo    ,+    videoCodecFrameSetUserData              ,+++-- ** videoCodecFrameUnref+    VideoCodecFrameUnrefMethodInfo          ,+    videoCodecFrameUnref                    ,+++++ -- * Properties+-- ** Deadline+    videoCodecFrameReadDeadline             ,+++-- ** DecodeFrameNumber+    videoCodecFrameReadDecodeFrameNumber    ,+++-- ** DistanceFromSync+    videoCodecFrameReadDistanceFromSync     ,+++-- ** Dts+    videoCodecFrameReadDts                  ,+++-- ** Duration+    videoCodecFrameReadDuration             ,+++-- ** InputBuffer+    videoCodecFrameReadInputBuffer          ,+++-- ** OutputBuffer+    videoCodecFrameReadOutputBuffer         ,+++-- ** PresentationFrameNumber+    videoCodecFrameReadPresentationFrameNumber,+++-- ** Pts+    videoCodecFrameReadPts                  ,+++-- ** SystemFrameNumber+    videoCodecFrameReadSystemFrameNumber    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.GLib as GLib+import qualified GI.Gst as Gst++newtype VideoCodecFrame = VideoCodecFrame (ForeignPtr VideoCodecFrame)+foreign import ccall "gst_video_codec_frame_get_type" c_gst_video_codec_frame_get_type :: +    IO GType++instance BoxedObject VideoCodecFrame where+    boxedType _ = c_gst_video_codec_frame_get_type++-- | Construct a `VideoCodecFrame` struct initialized to zero.+newZeroVideoCodecFrame :: MonadIO m => m VideoCodecFrame+newZeroVideoCodecFrame = liftIO $ callocBoxedBytes 104 >>= wrapBoxed VideoCodecFrame++noVideoCodecFrame :: Maybe VideoCodecFrame+noVideoCodecFrame = Nothing++videoCodecFrameReadSystemFrameNumber :: VideoCodecFrame -> IO Word32+videoCodecFrameReadSystemFrameNumber s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO Word32+    return val++videoCodecFrameReadDecodeFrameNumber :: VideoCodecFrame -> IO Word32+videoCodecFrameReadDecodeFrameNumber s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 12) :: IO Word32+    return val++videoCodecFrameReadPresentationFrameNumber :: VideoCodecFrame -> IO Word32+videoCodecFrameReadPresentationFrameNumber s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO Word32+    return val++videoCodecFrameReadDts :: VideoCodecFrame -> IO Word64+videoCodecFrameReadDts s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO Word64+    return val++videoCodecFrameReadPts :: VideoCodecFrame -> IO Word64+videoCodecFrameReadPts s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO Word64+    return val++videoCodecFrameReadDuration :: VideoCodecFrame -> IO Word64+videoCodecFrameReadDuration s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 40) :: IO Word64+    return val++videoCodecFrameReadDistanceFromSync :: VideoCodecFrame -> IO Int32+videoCodecFrameReadDistanceFromSync s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 48) :: IO Int32+    return val++videoCodecFrameReadInputBuffer :: VideoCodecFrame -> IO Gst.Buffer+videoCodecFrameReadInputBuffer s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 56) :: IO (Ptr Gst.Buffer)+    val' <- (newBoxed Gst.Buffer) val+    return val'++videoCodecFrameReadOutputBuffer :: VideoCodecFrame -> IO Gst.Buffer+videoCodecFrameReadOutputBuffer s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 64) :: IO (Ptr Gst.Buffer)+    val' <- (newBoxed Gst.Buffer) val+    return val'++videoCodecFrameReadDeadline :: VideoCodecFrame -> IO Word64+videoCodecFrameReadDeadline s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 72) :: IO Word64+    return val++-- method VideoCodecFrame::get_user_data+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_codec_frame_get_user_data" gst_video_codec_frame_get_user_data :: +    Ptr VideoCodecFrame ->                  -- _obj : TInterface "GstVideo" "VideoCodecFrame"+    IO ()+++videoCodecFrameGetUserData ::+    (MonadIO m) =>+    VideoCodecFrame                         -- _obj+    -> m ()                                 -- result+videoCodecFrameGetUserData _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_codec_frame_get_user_data _obj'+    touchManagedPtr _obj+    return ()++data VideoCodecFrameGetUserDataMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoCodecFrameGetUserDataMethodInfo VideoCodecFrame signature where+    overloadedMethod _ = videoCodecFrameGetUserData++-- method VideoCodecFrame::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoCodecFrame"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_codec_frame_ref" gst_video_codec_frame_ref :: +    Ptr VideoCodecFrame ->                  -- _obj : TInterface "GstVideo" "VideoCodecFrame"+    IO (Ptr VideoCodecFrame)+++videoCodecFrameRef ::+    (MonadIO m) =>+    VideoCodecFrame                         -- _obj+    -> m VideoCodecFrame                    -- result+videoCodecFrameRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_codec_frame_ref _obj'+    checkUnexpectedReturnNULL "gst_video_codec_frame_ref" result+    result' <- (wrapBoxed VideoCodecFrame) result+    touchManagedPtr _obj+    return result'++data VideoCodecFrameRefMethodInfo+instance (signature ~ (m VideoCodecFrame), MonadIO m) => MethodInfo VideoCodecFrameRefMethodInfo VideoCodecFrame signature where+    overloadedMethod _ = videoCodecFrameRef++-- method VideoCodecFrame::set_user_data+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_codec_frame_set_user_data" gst_video_codec_frame_set_user_data :: +    Ptr VideoCodecFrame ->                  -- _obj : TInterface "GstVideo" "VideoCodecFrame"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++videoCodecFrameSetUserData ::+    (MonadIO m) =>+    VideoCodecFrame                         -- _obj+    -> GLib.DestroyNotify                   -- notify+    -> m ()                                 -- result+videoCodecFrameSetUserData _obj notify = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    ptrnotify <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))+    notify' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptrnotify) notify)+    poke ptrnotify notify'+    let userData = nullPtr+    gst_video_codec_frame_set_user_data _obj' userData notify'+    touchManagedPtr _obj+    return ()++data VideoCodecFrameSetUserDataMethodInfo+instance (signature ~ (GLib.DestroyNotify -> m ()), MonadIO m) => MethodInfo VideoCodecFrameSetUserDataMethodInfo VideoCodecFrame signature where+    overloadedMethod _ = videoCodecFrameSetUserData++-- method VideoCodecFrame::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoCodecFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_codec_frame_unref" gst_video_codec_frame_unref :: +    Ptr VideoCodecFrame ->                  -- _obj : TInterface "GstVideo" "VideoCodecFrame"+    IO ()+++videoCodecFrameUnref ::+    (MonadIO m) =>+    VideoCodecFrame                         -- _obj+    -> m ()                                 -- result+videoCodecFrameUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_codec_frame_unref _obj'+    touchManagedPtr _obj+    return ()++data VideoCodecFrameUnrefMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoCodecFrameUnrefMethodInfo VideoCodecFrame signature where+    overloadedMethod _ = videoCodecFrameUnref++type family ResolveVideoCodecFrameMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoCodecFrameMethod "ref" o = VideoCodecFrameRefMethodInfo+    ResolveVideoCodecFrameMethod "unref" o = VideoCodecFrameUnrefMethodInfo+    ResolveVideoCodecFrameMethod "getUserData" o = VideoCodecFrameGetUserDataMethodInfo+    ResolveVideoCodecFrameMethod "setUserData" o = VideoCodecFrameSetUserDataMethodInfo+    ResolveVideoCodecFrameMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoCodecFrameMethod t VideoCodecFrame, MethodInfo info VideoCodecFrame p) => IsLabelProxy t (VideoCodecFrame -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoCodecFrameMethod t VideoCodecFrame, MethodInfo info VideoCodecFrame p) => IsLabel t (VideoCodecFrame -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoCodecFrame.hs-boot view
@@ -0,0 +1,15 @@+module GI.GstVideo.Structs.VideoCodecFrame where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoCodecFrame = VideoCodecFrame (ForeignPtr VideoCodecFrame)+instance BoxedObject VideoCodecFrame where+data VideoCodecFrameGetUserDataMethodInfo+data VideoCodecFrameRefMethodInfo+data VideoCodecFrameSetUserDataMethodInfo+data VideoCodecFrameUnrefMethodInfo
+ GI/GstVideo/Structs/VideoCodecState.hs view
@@ -0,0 +1,170 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Structure representing the state of an incoming or outgoing video+stream for encoders and decoders.++Decoders and encoders will receive such a state through their+respective @set_format vmethods.++Decoders and encoders can set the downstream state, by using the+@gst_video_decoder_set_output_state() or+@gst_video_encoder_set_output_state() methods.+-}++module GI.GstVideo.Structs.VideoCodecState+    ( ++-- * Exported types+    VideoCodecState(..)                     ,+    newZeroVideoCodecState                  ,+    noVideoCodecState                       ,+++ -- * Methods+-- ** videoCodecStateRef+    VideoCodecStateRefMethodInfo            ,+    videoCodecStateRef                      ,+++-- ** videoCodecStateUnref+    VideoCodecStateUnrefMethodInfo          ,+    videoCodecStateUnref                    ,+++++ -- * Properties+-- ** Caps+    videoCodecStateReadCaps                 ,+++-- ** CodecData+    videoCodecStateReadCodecData            ,+++-- ** Info+    videoCodecStateReadInfo                 ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.Gst as Gst++newtype VideoCodecState = VideoCodecState (ForeignPtr VideoCodecState)+foreign import ccall "gst_video_codec_state_get_type" c_gst_video_codec_state_get_type :: +    IO GType++instance BoxedObject VideoCodecState where+    boxedType _ = c_gst_video_codec_state_get_type++-- | Construct a `VideoCodecState` struct initialized to zero.+newZeroVideoCodecState :: MonadIO m => m VideoCodecState+newZeroVideoCodecState = liftIO $ callocBoxedBytes 304 >>= wrapBoxed VideoCodecState++noVideoCodecState :: Maybe VideoCodecState+noVideoCodecState = Nothing++videoCodecStateReadInfo :: VideoCodecState -> IO VideoInfo+videoCodecStateReadInfo s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO (Ptr VideoInfo)+    val' <- (newBoxed VideoInfo) val+    return val'++videoCodecStateReadCaps :: VideoCodecState -> IO Gst.Caps+videoCodecStateReadCaps s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 128) :: IO (Ptr Gst.Caps)+    val' <- (newBoxed Gst.Caps) val+    return val'++videoCodecStateReadCodecData :: VideoCodecState -> IO Gst.Buffer+videoCodecStateReadCodecData s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 136) :: IO (Ptr Gst.Buffer)+    val' <- (newBoxed Gst.Buffer) val+    return val'++-- method VideoCodecState::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoCodecState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoCodecState"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_codec_state_ref" gst_video_codec_state_ref :: +    Ptr VideoCodecState ->                  -- _obj : TInterface "GstVideo" "VideoCodecState"+    IO (Ptr VideoCodecState)+++videoCodecStateRef ::+    (MonadIO m) =>+    VideoCodecState                         -- _obj+    -> m VideoCodecState                    -- result+videoCodecStateRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_codec_state_ref _obj'+    checkUnexpectedReturnNULL "gst_video_codec_state_ref" result+    result' <- (wrapBoxed VideoCodecState) result+    touchManagedPtr _obj+    return result'++data VideoCodecStateRefMethodInfo+instance (signature ~ (m VideoCodecState), MonadIO m) => MethodInfo VideoCodecStateRefMethodInfo VideoCodecState signature where+    overloadedMethod _ = videoCodecStateRef++-- method VideoCodecState::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoCodecState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_codec_state_unref" gst_video_codec_state_unref :: +    Ptr VideoCodecState ->                  -- _obj : TInterface "GstVideo" "VideoCodecState"+    IO ()+++videoCodecStateUnref ::+    (MonadIO m) =>+    VideoCodecState                         -- _obj+    -> m ()                                 -- result+videoCodecStateUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_codec_state_unref _obj'+    touchManagedPtr _obj+    return ()++data VideoCodecStateUnrefMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoCodecStateUnrefMethodInfo VideoCodecState signature where+    overloadedMethod _ = videoCodecStateUnref++type family ResolveVideoCodecStateMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoCodecStateMethod "ref" o = VideoCodecStateRefMethodInfo+    ResolveVideoCodecStateMethod "unref" o = VideoCodecStateUnrefMethodInfo+    ResolveVideoCodecStateMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoCodecStateMethod t VideoCodecState, MethodInfo info VideoCodecState p) => IsLabelProxy t (VideoCodecState -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoCodecStateMethod t VideoCodecState, MethodInfo info VideoCodecState p) => IsLabel t (VideoCodecState -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoCodecState.hs-boot view
@@ -0,0 +1,13 @@+module GI.GstVideo.Structs.VideoCodecState where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoCodecState = VideoCodecState (ForeignPtr VideoCodecState)+instance BoxedObject VideoCodecState where+data VideoCodecStateRefMethodInfo+data VideoCodecStateUnrefMethodInfo
+ GI/GstVideo/Structs/VideoColorPrimariesInfo.hs view
@@ -0,0 +1,146 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Structure describing the chromaticity coordinates of an RGB system. These+values can be used to construct a matrix to transform RGB to and from the+XYZ colorspace.+-}++module GI.GstVideo.Structs.VideoColorPrimariesInfo+    ( ++-- * Exported types+    VideoColorPrimariesInfo(..)             ,+    newZeroVideoColorPrimariesInfo          ,+    noVideoColorPrimariesInfo               ,+++ -- * Properties+-- ** Bx+    videoColorPrimariesInfoReadBx           ,+++-- ** By+    videoColorPrimariesInfoReadBy           ,+++-- ** Gx+    videoColorPrimariesInfoReadGx           ,+++-- ** Gy+    videoColorPrimariesInfoReadGy           ,+++-- ** Primaries+    videoColorPrimariesInfoReadPrimaries    ,+++-- ** Rx+    videoColorPrimariesInfoReadRx           ,+++-- ** Ry+    videoColorPrimariesInfoReadRy           ,+++-- ** Wx+    videoColorPrimariesInfoReadWx           ,+++-- ** Wy+    videoColorPrimariesInfoReadWy           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++newtype VideoColorPrimariesInfo = VideoColorPrimariesInfo (ForeignPtr VideoColorPrimariesInfo)+-- | Construct a `VideoColorPrimariesInfo` struct initialized to zero.+newZeroVideoColorPrimariesInfo :: MonadIO m => m VideoColorPrimariesInfo+newZeroVideoColorPrimariesInfo = liftIO $ callocBytes 72 >>= wrapPtr VideoColorPrimariesInfo++noVideoColorPrimariesInfo :: Maybe VideoColorPrimariesInfo+noVideoColorPrimariesInfo = Nothing++videoColorPrimariesInfoReadPrimaries :: VideoColorPrimariesInfo -> IO VideoColorPrimaries+videoColorPrimariesInfoReadPrimaries s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++videoColorPrimariesInfoReadWx :: VideoColorPrimariesInfo -> IO Double+videoColorPrimariesInfoReadWx s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CDouble+    let val' = realToFrac val+    return val'++videoColorPrimariesInfoReadWy :: VideoColorPrimariesInfo -> IO Double+videoColorPrimariesInfoReadWy s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CDouble+    let val' = realToFrac val+    return val'++videoColorPrimariesInfoReadRx :: VideoColorPrimariesInfo -> IO Double+videoColorPrimariesInfoReadRx s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO CDouble+    let val' = realToFrac val+    return val'++videoColorPrimariesInfoReadRy :: VideoColorPrimariesInfo -> IO Double+videoColorPrimariesInfoReadRy s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO CDouble+    let val' = realToFrac val+    return val'++videoColorPrimariesInfoReadGx :: VideoColorPrimariesInfo -> IO Double+videoColorPrimariesInfoReadGx s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 40) :: IO CDouble+    let val' = realToFrac val+    return val'++videoColorPrimariesInfoReadGy :: VideoColorPrimariesInfo -> IO Double+videoColorPrimariesInfoReadGy s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 48) :: IO CDouble+    let val' = realToFrac val+    return val'++videoColorPrimariesInfoReadBx :: VideoColorPrimariesInfo -> IO Double+videoColorPrimariesInfoReadBx s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 56) :: IO CDouble+    let val' = realToFrac val+    return val'++videoColorPrimariesInfoReadBy :: VideoColorPrimariesInfo -> IO Double+videoColorPrimariesInfoReadBy s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 64) :: IO CDouble+    let val' = realToFrac val+    return val'++type family ResolveVideoColorPrimariesInfoMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoColorPrimariesInfoMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoColorPrimariesInfoMethod t VideoColorPrimariesInfo, MethodInfo info VideoColorPrimariesInfo p) => IsLabelProxy t (VideoColorPrimariesInfo -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoColorPrimariesInfoMethod t VideoColorPrimariesInfo, MethodInfo info VideoColorPrimariesInfo p) => IsLabel t (VideoColorPrimariesInfo -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoColorPrimariesInfo.hs-boot view
@@ -0,0 +1,10 @@+module GI.GstVideo.Structs.VideoColorPrimariesInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoColorPrimariesInfo = VideoColorPrimariesInfo (ForeignPtr VideoColorPrimariesInfo)
+ GI/GstVideo/Structs/VideoColorimetry.hs view
@@ -0,0 +1,247 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Structure describing the color info.+-}++module GI.GstVideo.Structs.VideoColorimetry+    ( ++-- * Exported types+    VideoColorimetry(..)                    ,+    newZeroVideoColorimetry                 ,+    noVideoColorimetry                      ,+++ -- * Methods+-- ** videoColorimetryFromString+    VideoColorimetryFromStringMethodInfo    ,+    videoColorimetryFromString              ,+++-- ** videoColorimetryIsEqual+    VideoColorimetryIsEqualMethodInfo       ,+    videoColorimetryIsEqual                 ,+++-- ** videoColorimetryMatches+    VideoColorimetryMatchesMethodInfo       ,+    videoColorimetryMatches                 ,+++-- ** videoColorimetryToString+    VideoColorimetryToStringMethodInfo      ,+    videoColorimetryToString                ,+++++ -- * Properties+-- ** Matrix+    videoColorimetryReadMatrix              ,+++-- ** Primaries+    videoColorimetryReadPrimaries           ,+++-- ** Range+    videoColorimetryReadRange               ,+++-- ** Transfer+    videoColorimetryReadTransfer            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++newtype VideoColorimetry = VideoColorimetry (ForeignPtr VideoColorimetry)+-- | Construct a `VideoColorimetry` struct initialized to zero.+newZeroVideoColorimetry :: MonadIO m => m VideoColorimetry+newZeroVideoColorimetry = liftIO $ callocBytes 16 >>= wrapPtr VideoColorimetry++noVideoColorimetry :: Maybe VideoColorimetry+noVideoColorimetry = Nothing++videoColorimetryReadRange :: VideoColorimetry -> IO VideoColorRange+videoColorimetryReadRange s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++videoColorimetryReadMatrix :: VideoColorimetry -> IO VideoColorMatrix+videoColorimetryReadMatrix s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 4) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++videoColorimetryReadTransfer :: VideoColorimetry -> IO VideoTransferFunction+videoColorimetryReadTransfer s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++videoColorimetryReadPrimaries :: VideoColorimetry -> IO VideoColorPrimaries+videoColorimetryReadPrimaries s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 12) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++-- method VideoColorimetry::from_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoColorimetry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_colorimetry_from_string" gst_video_colorimetry_from_string :: +    Ptr VideoColorimetry ->                 -- _obj : TInterface "GstVideo" "VideoColorimetry"+    CString ->                              -- color : TBasicType TUTF8+    IO CInt+++videoColorimetryFromString ::+    (MonadIO m) =>+    VideoColorimetry                        -- _obj+    -> T.Text                               -- color+    -> m Bool                               -- result+videoColorimetryFromString _obj color = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    color' <- textToCString color+    result <- gst_video_colorimetry_from_string _obj' color'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem color'+    return result'++data VideoColorimetryFromStringMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo VideoColorimetryFromStringMethodInfo VideoColorimetry signature where+    overloadedMethod _ = videoColorimetryFromString++-- method VideoColorimetry::is_equal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoColorimetry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "other", argType = TInterface "GstVideo" "VideoColorimetry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_colorimetry_is_equal" gst_video_colorimetry_is_equal :: +    Ptr VideoColorimetry ->                 -- _obj : TInterface "GstVideo" "VideoColorimetry"+    Ptr VideoColorimetry ->                 -- other : TInterface "GstVideo" "VideoColorimetry"+    IO CInt+++videoColorimetryIsEqual ::+    (MonadIO m) =>+    VideoColorimetry                        -- _obj+    -> VideoColorimetry                     -- other+    -> m Bool                               -- result+videoColorimetryIsEqual _obj other = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let other' = unsafeManagedPtrGetPtr other+    result <- gst_video_colorimetry_is_equal _obj' other'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr other+    return result'++data VideoColorimetryIsEqualMethodInfo+instance (signature ~ (VideoColorimetry -> m Bool), MonadIO m) => MethodInfo VideoColorimetryIsEqualMethodInfo VideoColorimetry signature where+    overloadedMethod _ = videoColorimetryIsEqual++-- method VideoColorimetry::matches+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoColorimetry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_colorimetry_matches" gst_video_colorimetry_matches :: +    Ptr VideoColorimetry ->                 -- _obj : TInterface "GstVideo" "VideoColorimetry"+    CString ->                              -- color : TBasicType TUTF8+    IO CInt+++videoColorimetryMatches ::+    (MonadIO m) =>+    VideoColorimetry                        -- _obj+    -> T.Text                               -- color+    -> m Bool                               -- result+videoColorimetryMatches _obj color = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    color' <- textToCString color+    result <- gst_video_colorimetry_matches _obj' color'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem color'+    return result'++data VideoColorimetryMatchesMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo VideoColorimetryMatchesMethodInfo VideoColorimetry signature where+    overloadedMethod _ = videoColorimetryMatches++-- method VideoColorimetry::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoColorimetry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_colorimetry_to_string" gst_video_colorimetry_to_string :: +    Ptr VideoColorimetry ->                 -- _obj : TInterface "GstVideo" "VideoColorimetry"+    IO CString+++videoColorimetryToString ::+    (MonadIO m) =>+    VideoColorimetry                        -- _obj+    -> m T.Text                             -- result+videoColorimetryToString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_colorimetry_to_string _obj'+    checkUnexpectedReturnNULL "gst_video_colorimetry_to_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data VideoColorimetryToStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo VideoColorimetryToStringMethodInfo VideoColorimetry signature where+    overloadedMethod _ = videoColorimetryToString++type family ResolveVideoColorimetryMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoColorimetryMethod "fromString" o = VideoColorimetryFromStringMethodInfo+    ResolveVideoColorimetryMethod "isEqual" o = VideoColorimetryIsEqualMethodInfo+    ResolveVideoColorimetryMethod "matches" o = VideoColorimetryMatchesMethodInfo+    ResolveVideoColorimetryMethod "toString" o = VideoColorimetryToStringMethodInfo+    ResolveVideoColorimetryMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoColorimetryMethod t VideoColorimetry, MethodInfo info VideoColorimetry p) => IsLabelProxy t (VideoColorimetry -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoColorimetryMethod t VideoColorimetry, MethodInfo info VideoColorimetry p) => IsLabel t (VideoColorimetry -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoColorimetry.hs-boot view
@@ -0,0 +1,14 @@+module GI.GstVideo.Structs.VideoColorimetry where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoColorimetry = VideoColorimetry (ForeignPtr VideoColorimetry)+data VideoColorimetryFromStringMethodInfo+data VideoColorimetryIsEqualMethodInfo+data VideoColorimetryMatchesMethodInfo+data VideoColorimetryToStringMethodInfo
+ GI/GstVideo/Structs/VideoConverter.hs view
@@ -0,0 +1,195 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.GstVideo.Structs.VideoConverter+    ( ++-- * Exported types+    VideoConverter(..)                      ,+    noVideoConverter                        ,+++ -- * Methods+-- ** videoConverterFrame+    VideoConverterFrameMethodInfo           ,+    videoConverterFrame                     ,+++-- ** videoConverterFree+    VideoConverterFreeMethodInfo            ,+    videoConverterFree                      ,+++-- ** videoConverterGetConfig+    VideoConverterGetConfigMethodInfo       ,+    videoConverterGetConfig                 ,+++-- ** videoConverterSetConfig+    VideoConverterSetConfigMethodInfo       ,+    videoConverterSetConfig                 ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.Gst as Gst++newtype VideoConverter = VideoConverter (ForeignPtr VideoConverter)+noVideoConverter :: Maybe VideoConverter+noVideoConverter = Nothing++-- method VideoConverter::frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoConverter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "GstVideo" "VideoFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "GstVideo" "VideoFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_converter_frame" gst_video_converter_frame :: +    Ptr VideoConverter ->                   -- _obj : TInterface "GstVideo" "VideoConverter"+    Ptr VideoFrame ->                       -- src : TInterface "GstVideo" "VideoFrame"+    Ptr VideoFrame ->                       -- dest : TInterface "GstVideo" "VideoFrame"+    IO ()+++videoConverterFrame ::+    (MonadIO m) =>+    VideoConverter                          -- _obj+    -> VideoFrame                           -- src+    -> VideoFrame                           -- dest+    -> m ()                                 -- result+videoConverterFrame _obj src dest = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let src' = unsafeManagedPtrGetPtr src+    let dest' = unsafeManagedPtrGetPtr dest+    gst_video_converter_frame _obj' src' dest'+    touchManagedPtr _obj+    touchManagedPtr src+    touchManagedPtr dest+    return ()++data VideoConverterFrameMethodInfo+instance (signature ~ (VideoFrame -> VideoFrame -> m ()), MonadIO m) => MethodInfo VideoConverterFrameMethodInfo VideoConverter signature where+    overloadedMethod _ = videoConverterFrame++-- method VideoConverter::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoConverter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_converter_free" gst_video_converter_free :: +    Ptr VideoConverter ->                   -- _obj : TInterface "GstVideo" "VideoConverter"+    IO ()+++videoConverterFree ::+    (MonadIO m) =>+    VideoConverter                          -- _obj+    -> m ()                                 -- result+videoConverterFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_converter_free _obj'+    touchManagedPtr _obj+    return ()++data VideoConverterFreeMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoConverterFreeMethodInfo VideoConverter signature where+    overloadedMethod _ = videoConverterFree++-- method VideoConverter::get_config+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoConverter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_converter_get_config" gst_video_converter_get_config :: +    Ptr VideoConverter ->                   -- _obj : TInterface "GstVideo" "VideoConverter"+    IO (Ptr Gst.Structure)+++videoConverterGetConfig ::+    (MonadIO m) =>+    VideoConverter                          -- _obj+    -> m Gst.Structure                      -- result+videoConverterGetConfig _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_converter_get_config _obj'+    checkUnexpectedReturnNULL "gst_video_converter_get_config" result+    result' <- (newBoxed Gst.Structure) result+    touchManagedPtr _obj+    return result'++data VideoConverterGetConfigMethodInfo+instance (signature ~ (m Gst.Structure), MonadIO m) => MethodInfo VideoConverterGetConfigMethodInfo VideoConverter signature where+    overloadedMethod _ = videoConverterGetConfig++-- method VideoConverter::set_config+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoConverter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_converter_set_config" gst_video_converter_set_config :: +    Ptr VideoConverter ->                   -- _obj : TInterface "GstVideo" "VideoConverter"+    Ptr Gst.Structure ->                    -- config : TInterface "Gst" "Structure"+    IO CInt+++videoConverterSetConfig ::+    (MonadIO m) =>+    VideoConverter                          -- _obj+    -> Gst.Structure                        -- config+    -> m Bool                               -- result+videoConverterSetConfig _obj config = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    config' <- copyBoxed config+    result <- gst_video_converter_set_config _obj' config'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr config+    return result'++data VideoConverterSetConfigMethodInfo+instance (signature ~ (Gst.Structure -> m Bool), MonadIO m) => MethodInfo VideoConverterSetConfigMethodInfo VideoConverter signature where+    overloadedMethod _ = videoConverterSetConfig++type family ResolveVideoConverterMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoConverterMethod "frame" o = VideoConverterFrameMethodInfo+    ResolveVideoConverterMethod "free" o = VideoConverterFreeMethodInfo+    ResolveVideoConverterMethod "getConfig" o = VideoConverterGetConfigMethodInfo+    ResolveVideoConverterMethod "setConfig" o = VideoConverterSetConfigMethodInfo+    ResolveVideoConverterMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoConverterMethod t VideoConverter, MethodInfo info VideoConverter p) => IsLabelProxy t (VideoConverter -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoConverterMethod t VideoConverter, MethodInfo info VideoConverter p) => IsLabel t (VideoConverter -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoConverter.hs-boot view
@@ -0,0 +1,14 @@+module GI.GstVideo.Structs.VideoConverter where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoConverter = VideoConverter (ForeignPtr VideoConverter)+data VideoConverterFrameMethodInfo+data VideoConverterFreeMethodInfo+data VideoConverterGetConfigMethodInfo+data VideoConverterSetConfigMethodInfo
+ GI/GstVideo/Structs/VideoCropMeta.hs view
@@ -0,0 +1,129 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Extra buffer metadata describing image cropping.+-}++module GI.GstVideo.Structs.VideoCropMeta+    ( ++-- * Exported types+    VideoCropMeta(..)                       ,+    newZeroVideoCropMeta                    ,+    noVideoCropMeta                         ,+++ -- * Methods+-- ** videoCropMetaGetInfo+    videoCropMetaGetInfo                    ,+++++ -- * Properties+-- ** Height+    videoCropMetaReadHeight                 ,+++-- ** Meta+    videoCropMetaReadMeta                   ,+++-- ** Width+    videoCropMetaReadWidth                  ,+++-- ** X+    videoCropMetaReadX                      ,+++-- ** Y+    videoCropMetaReadY                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.Gst as Gst++newtype VideoCropMeta = VideoCropMeta (ForeignPtr VideoCropMeta)+-- | Construct a `VideoCropMeta` struct initialized to zero.+newZeroVideoCropMeta :: MonadIO m => m VideoCropMeta+newZeroVideoCropMeta = liftIO $ callocBytes 32 >>= wrapPtr VideoCropMeta++noVideoCropMeta :: Maybe VideoCropMeta+noVideoCropMeta = Nothing++videoCropMetaReadMeta :: VideoCropMeta -> IO Gst.Meta+videoCropMetaReadMeta s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Gst.Meta)+    val' <- (newPtr 16 Gst.Meta) val+    return val'++videoCropMetaReadX :: VideoCropMeta -> IO Word32+videoCropMetaReadX s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO Word32+    return val++videoCropMetaReadY :: VideoCropMeta -> IO Word32+videoCropMetaReadY s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 20) :: IO Word32+    return val++videoCropMetaReadWidth :: VideoCropMeta -> IO Word32+videoCropMetaReadWidth s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO Word32+    return val++videoCropMetaReadHeight :: VideoCropMeta -> IO Word32+videoCropMetaReadHeight s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 28) :: IO Word32+    return val++-- method VideoCropMeta::get_info+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "MetaInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_crop_meta_get_info" gst_video_crop_meta_get_info :: +    IO (Ptr Gst.MetaInfo)+++videoCropMetaGetInfo ::+    (MonadIO m) =>+    m Gst.MetaInfo                          -- result+videoCropMetaGetInfo  = liftIO $ do+    result <- gst_video_crop_meta_get_info+    checkUnexpectedReturnNULL "gst_video_crop_meta_get_info" result+    result' <- (newPtr 80 Gst.MetaInfo) result+    return result'++type family ResolveVideoCropMetaMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoCropMetaMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoCropMetaMethod t VideoCropMeta, MethodInfo info VideoCropMeta p) => IsLabelProxy t (VideoCropMeta -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoCropMetaMethod t VideoCropMeta, MethodInfo info VideoCropMeta p) => IsLabel t (VideoCropMeta -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoCropMeta.hs-boot view
@@ -0,0 +1,10 @@+module GI.GstVideo.Structs.VideoCropMeta where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoCropMeta = VideoCropMeta (ForeignPtr VideoCropMeta)
+ GI/GstVideo/Structs/VideoDither.hs view
@@ -0,0 +1,124 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++GstVideoDither provides implementations of several dithering algorithms+that can be applied to lines of video pixels to quantize and dither them.+-}++module GI.GstVideo.Structs.VideoDither+    ( ++-- * Exported types+    VideoDither(..)                         ,+    noVideoDither                           ,+++ -- * Methods+-- ** videoDitherFree+    VideoDitherFreeMethodInfo               ,+    videoDitherFree                         ,+++-- ** videoDitherLine+    VideoDitherLineMethodInfo               ,+    videoDitherLine                         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++newtype VideoDither = VideoDither (ForeignPtr VideoDither)+noVideoDither :: Maybe VideoDither+noVideoDither = Nothing++-- method VideoDither::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDither", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_dither_free" gst_video_dither_free :: +    Ptr VideoDither ->                      -- _obj : TInterface "GstVideo" "VideoDither"+    IO ()+++videoDitherFree ::+    (MonadIO m) =>+    VideoDither                             -- _obj+    -> m ()                                 -- result+videoDitherFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_dither_free _obj'+    touchManagedPtr _obj+    return ()++data VideoDitherFreeMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoDitherFreeMethodInfo VideoDither signature where+    overloadedMethod _ = videoDitherFree++-- method VideoDither::line+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoDither", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_dither_line" gst_video_dither_line :: +    Ptr VideoDither ->                      -- _obj : TInterface "GstVideo" "VideoDither"+    Ptr () ->                               -- line : TBasicType TVoid+    Word32 ->                               -- x : TBasicType TUInt32+    Word32 ->                               -- y : TBasicType TUInt32+    Word32 ->                               -- width : TBasicType TUInt32+    IO ()+++videoDitherLine ::+    (MonadIO m) =>+    VideoDither                             -- _obj+    -> Ptr ()                               -- line+    -> Word32                               -- x+    -> Word32                               -- y+    -> Word32                               -- width+    -> m ()                                 -- result+videoDitherLine _obj line x y width = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_dither_line _obj' line x y width+    touchManagedPtr _obj+    return ()++data VideoDitherLineMethodInfo+instance (signature ~ (Ptr () -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m) => MethodInfo VideoDitherLineMethodInfo VideoDither signature where+    overloadedMethod _ = videoDitherLine++type family ResolveVideoDitherMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoDitherMethod "free" o = VideoDitherFreeMethodInfo+    ResolveVideoDitherMethod "line" o = VideoDitherLineMethodInfo+    ResolveVideoDitherMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoDitherMethod t VideoDither, MethodInfo info VideoDither p) => IsLabelProxy t (VideoDither -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoDitherMethod t VideoDither, MethodInfo info VideoDither p) => IsLabel t (VideoDither -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoDither.hs-boot view
@@ -0,0 +1,12 @@+module GI.GstVideo.Structs.VideoDither where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoDither = VideoDither (ForeignPtr VideoDither)+data VideoDitherFreeMethodInfo+data VideoDitherLineMethodInfo
+ GI/GstVideo/Structs/VideoFormatInfo.hs view
@@ -0,0 +1,188 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Information for a video format.+-}++module GI.GstVideo.Structs.VideoFormatInfo+    ( ++-- * Exported types+    VideoFormatInfo(..)                     ,+    newZeroVideoFormatInfo                  ,+    noVideoFormatInfo                       ,+++ -- * Properties+-- ** Bits+    videoFormatInfoReadBits                 ,+++-- ** Description+    videoFormatInfoReadDescription          ,+++-- ** Flags+    videoFormatInfoReadFlags                ,+++-- ** Format+    videoFormatInfoReadFormat               ,+++-- ** NComponents+    videoFormatInfoReadNComponents          ,+++-- ** NPlanes+    videoFormatInfoReadNPlanes              ,+++-- ** Name+    videoFormatInfoReadName                 ,+++-- ** PackLines+    videoFormatInfoReadPackLines            ,+++-- ** TileHs+    videoFormatInfoReadTileHs               ,+++-- ** TileMode+    videoFormatInfoReadTileMode             ,+++-- ** TileWs+    videoFormatInfoReadTileWs               ,+++-- ** UnpackFormat+    videoFormatInfoReadUnpackFormat         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++newtype VideoFormatInfo = VideoFormatInfo (ForeignPtr VideoFormatInfo)+-- | Construct a `VideoFormatInfo` struct initialized to zero.+newZeroVideoFormatInfo :: MonadIO m => m VideoFormatInfo+newZeroVideoFormatInfo = liftIO $ callocBytes 232 >>= wrapPtr VideoFormatInfo++noVideoFormatInfo :: Maybe VideoFormatInfo+noVideoFormatInfo = Nothing++videoFormatInfoReadFormat :: VideoFormatInfo -> IO VideoFormat+videoFormatInfoReadFormat s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++videoFormatInfoReadName :: VideoFormatInfo -> IO T.Text+videoFormatInfoReadName s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++videoFormatInfoReadDescription :: VideoFormatInfo -> IO T.Text+videoFormatInfoReadDescription s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CString+    val' <- cstringToText val+    return val'++videoFormatInfoReadFlags :: VideoFormatInfo -> IO [VideoFormatFlags]+videoFormatInfoReadFlags s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO CUInt+    let val' = wordToGFlags val+    return val'++videoFormatInfoReadBits :: VideoFormatInfo -> IO Word32+videoFormatInfoReadBits s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 28) :: IO Word32+    return val++videoFormatInfoReadNComponents :: VideoFormatInfo -> IO Word32+videoFormatInfoReadNComponents s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO Word32+    return val++-- XXX Skipped getter for "VideoFormatInfo:shift" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt32)"++-- XXX Skipped getter for "VideoFormatInfo:depth" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt32)"++-- XXX Skipped getter for "VideoFormatInfo:pixel_stride" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TInt32)"++videoFormatInfoReadNPlanes :: VideoFormatInfo -> IO Word32+videoFormatInfoReadNPlanes s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 84) :: IO Word32+    return val++-- XXX Skipped getter for "VideoFormatInfo:plane" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt32)"++-- XXX Skipped getter for "VideoFormatInfo:poffset" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt32)"++-- XXX Skipped getter for "VideoFormatInfo:w_sub" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt32)"++-- XXX Skipped getter for "VideoFormatInfo:h_sub" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt32)"++videoFormatInfoReadUnpackFormat :: VideoFormatInfo -> IO VideoFormat+videoFormatInfoReadUnpackFormat s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 152) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++-- XXX Skipped getter for "VideoFormatInfo:unpack_func" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++videoFormatInfoReadPackLines :: VideoFormatInfo -> IO Int32+videoFormatInfoReadPackLines s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 168) :: IO Int32+    return val++-- XXX Skipped getter for "VideoFormatInfo:pack_func" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++videoFormatInfoReadTileMode :: VideoFormatInfo -> IO VideoTileMode+videoFormatInfoReadTileMode s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 184) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++videoFormatInfoReadTileWs :: VideoFormatInfo -> IO Word32+videoFormatInfoReadTileWs s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 188) :: IO Word32+    return val++videoFormatInfoReadTileHs :: VideoFormatInfo -> IO Word32+videoFormatInfoReadTileHs s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 192) :: IO Word32+    return val++-- XXX Skipped getter for "VideoFormatInfo:_gst_reserved" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TVoid)"++type family ResolveVideoFormatInfoMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoFormatInfoMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoFormatInfoMethod t VideoFormatInfo, MethodInfo info VideoFormatInfo p) => IsLabelProxy t (VideoFormatInfo -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoFormatInfoMethod t VideoFormatInfo, MethodInfo info VideoFormatInfo p) => IsLabel t (VideoFormatInfo -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoFormatInfo.hs-boot view
@@ -0,0 +1,10 @@+module GI.GstVideo.Structs.VideoFormatInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoFormatInfo = VideoFormatInfo (ForeignPtr VideoFormatInfo)
+ GI/GstVideo/Structs/VideoFrame.hs view
@@ -0,0 +1,313 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A video frame obtained from gst_video_frame_map()+-}++module GI.GstVideo.Structs.VideoFrame+    ( ++-- * Exported types+    VideoFrame(..)                          ,+    newZeroVideoFrame                       ,+    noVideoFrame                            ,+++ -- * Methods+-- ** videoFrameCopy+    VideoFrameCopyMethodInfo                ,+    videoFrameCopy                          ,+++-- ** videoFrameCopyPlane+    VideoFrameCopyPlaneMethodInfo           ,+    videoFrameCopyPlane                     ,+++-- ** videoFrameMap+    VideoFrameMapMethodInfo                 ,+    videoFrameMap                           ,+++-- ** videoFrameMapId+    VideoFrameMapIdMethodInfo               ,+    videoFrameMapId                         ,+++-- ** videoFrameUnmap+    VideoFrameUnmapMethodInfo               ,+    videoFrameUnmap                         ,+++++ -- * Properties+-- ** Buffer+    videoFrameReadBuffer                    ,+++-- ** Flags+    videoFrameReadFlags                     ,+++-- ** Id+    videoFrameReadId                        ,+++-- ** Info+    videoFrameReadInfo                      ,+++-- ** Meta+    videoFrameReadMeta                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.Gst as Gst++newtype VideoFrame = VideoFrame (ForeignPtr VideoFrame)+-- | Construct a `VideoFrame` struct initialized to zero.+newZeroVideoFrame :: MonadIO m => m VideoFrame+newZeroVideoFrame = liftIO $ callocBytes 632 >>= wrapPtr VideoFrame++noVideoFrame :: Maybe VideoFrame+noVideoFrame = Nothing++videoFrameReadInfo :: VideoFrame -> IO VideoInfo+videoFrameReadInfo s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr VideoInfo)+    val' <- (newBoxed VideoInfo) val+    return val'++videoFrameReadFlags :: VideoFrame -> IO [VideoFrameFlags]+videoFrameReadFlags s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 120) :: IO CUInt+    let val' = wordToGFlags val+    return val'++videoFrameReadBuffer :: VideoFrame -> IO Gst.Buffer+videoFrameReadBuffer s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 128) :: IO (Ptr Gst.Buffer)+    val' <- (newBoxed Gst.Buffer) val+    return val'++videoFrameReadMeta :: VideoFrame -> IO (Ptr ())+videoFrameReadMeta s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 136) :: IO (Ptr ())+    return val++videoFrameReadId :: VideoFrame -> IO Int32+videoFrameReadId s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 144) :: IO Int32+    return val++-- XXX Skipped getter for "VideoFrame:data" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TVoid)"++-- XXX Skipped getter for "VideoFrame:map" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TInterface \"Gst\" \"MapInfo\")"++-- method VideoFrame::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "GstVideo" "VideoFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_frame_copy" gst_video_frame_copy :: +    Ptr VideoFrame ->                       -- _obj : TInterface "GstVideo" "VideoFrame"+    Ptr VideoFrame ->                       -- src : TInterface "GstVideo" "VideoFrame"+    IO CInt+++videoFrameCopy ::+    (MonadIO m) =>+    VideoFrame                              -- _obj+    -> VideoFrame                           -- src+    -> m Bool                               -- result+videoFrameCopy _obj src = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let src' = unsafeManagedPtrGetPtr src+    result <- gst_video_frame_copy _obj' src'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr src+    return result'++data VideoFrameCopyMethodInfo+instance (signature ~ (VideoFrame -> m Bool), MonadIO m) => MethodInfo VideoFrameCopyMethodInfo VideoFrame signature where+    overloadedMethod _ = videoFrameCopy++-- method VideoFrame::copy_plane+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "GstVideo" "VideoFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_frame_copy_plane" gst_video_frame_copy_plane :: +    Ptr VideoFrame ->                       -- _obj : TInterface "GstVideo" "VideoFrame"+    Ptr VideoFrame ->                       -- src : TInterface "GstVideo" "VideoFrame"+    Word32 ->                               -- plane : TBasicType TUInt32+    IO CInt+++videoFrameCopyPlane ::+    (MonadIO m) =>+    VideoFrame                              -- _obj+    -> VideoFrame                           -- src+    -> Word32                               -- plane+    -> m Bool                               -- result+videoFrameCopyPlane _obj src plane = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let src' = unsafeManagedPtrGetPtr src+    result <- gst_video_frame_copy_plane _obj' src' plane+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr src+    return result'++data VideoFrameCopyPlaneMethodInfo+instance (signature ~ (VideoFrame -> Word32 -> m Bool), MonadIO m) => MethodInfo VideoFrameCopyPlaneMethodInfo VideoFrame signature where+    overloadedMethod _ = videoFrameCopyPlane++-- method VideoFrame::map+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "MapFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_frame_map" gst_video_frame_map :: +    Ptr VideoFrame ->                       -- _obj : TInterface "GstVideo" "VideoFrame"+    Ptr VideoInfo ->                        -- info : TInterface "GstVideo" "VideoInfo"+    Ptr Gst.Buffer ->                       -- buffer : TInterface "Gst" "Buffer"+    CUInt ->                                -- flags : TInterface "Gst" "MapFlags"+    IO CInt+++videoFrameMap ::+    (MonadIO m) =>+    VideoFrame                              -- _obj+    -> VideoInfo                            -- info+    -> Gst.Buffer                           -- buffer+    -> [Gst.MapFlags]                       -- flags+    -> m Bool                               -- result+videoFrameMap _obj info buffer flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let info' = unsafeManagedPtrGetPtr info+    let buffer' = unsafeManagedPtrGetPtr buffer+    let flags' = gflagsToWord flags+    result <- gst_video_frame_map _obj' info' buffer' flags'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr info+    touchManagedPtr buffer+    return result'++data VideoFrameMapMethodInfo+instance (signature ~ (VideoInfo -> Gst.Buffer -> [Gst.MapFlags] -> m Bool), MonadIO m) => MethodInfo VideoFrameMapMethodInfo VideoFrame signature where+    overloadedMethod _ = videoFrameMap++-- method VideoFrame::map_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "MapFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_frame_map_id" gst_video_frame_map_id :: +    Ptr VideoFrame ->                       -- _obj : TInterface "GstVideo" "VideoFrame"+    Ptr VideoInfo ->                        -- info : TInterface "GstVideo" "VideoInfo"+    Ptr Gst.Buffer ->                       -- buffer : TInterface "Gst" "Buffer"+    Int32 ->                                -- id : TBasicType TInt32+    CUInt ->                                -- flags : TInterface "Gst" "MapFlags"+    IO CInt+++videoFrameMapId ::+    (MonadIO m) =>+    VideoFrame                              -- _obj+    -> VideoInfo                            -- info+    -> Gst.Buffer                           -- buffer+    -> Int32                                -- id+    -> [Gst.MapFlags]                       -- flags+    -> m Bool                               -- result+videoFrameMapId _obj info buffer id flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let info' = unsafeManagedPtrGetPtr info+    let buffer' = unsafeManagedPtrGetPtr buffer+    let flags' = gflagsToWord flags+    result <- gst_video_frame_map_id _obj' info' buffer' id flags'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr info+    touchManagedPtr buffer+    return result'++data VideoFrameMapIdMethodInfo+instance (signature ~ (VideoInfo -> Gst.Buffer -> Int32 -> [Gst.MapFlags] -> m Bool), MonadIO m) => MethodInfo VideoFrameMapIdMethodInfo VideoFrame signature where+    overloadedMethod _ = videoFrameMapId++-- method VideoFrame::unmap+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_frame_unmap" gst_video_frame_unmap :: +    Ptr VideoFrame ->                       -- _obj : TInterface "GstVideo" "VideoFrame"+    IO ()+++videoFrameUnmap ::+    (MonadIO m) =>+    VideoFrame                              -- _obj+    -> m ()                                 -- result+videoFrameUnmap _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_frame_unmap _obj'+    touchManagedPtr _obj+    return ()++data VideoFrameUnmapMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoFrameUnmapMethodInfo VideoFrame signature where+    overloadedMethod _ = videoFrameUnmap++type family ResolveVideoFrameMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoFrameMethod "copy" o = VideoFrameCopyMethodInfo+    ResolveVideoFrameMethod "copyPlane" o = VideoFrameCopyPlaneMethodInfo+    ResolveVideoFrameMethod "map" o = VideoFrameMapMethodInfo+    ResolveVideoFrameMethod "mapId" o = VideoFrameMapIdMethodInfo+    ResolveVideoFrameMethod "unmap" o = VideoFrameUnmapMethodInfo+    ResolveVideoFrameMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoFrameMethod t VideoFrame, MethodInfo info VideoFrame p) => IsLabelProxy t (VideoFrame -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoFrameMethod t VideoFrame, MethodInfo info VideoFrame p) => IsLabel t (VideoFrame -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoFrame.hs-boot view
@@ -0,0 +1,15 @@+module GI.GstVideo.Structs.VideoFrame where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoFrame = VideoFrame (ForeignPtr VideoFrame)+data VideoFrameCopyMethodInfo+data VideoFrameCopyPlaneMethodInfo+data VideoFrameMapMethodInfo+data VideoFrameMapIdMethodInfo+data VideoFrameUnmapMethodInfo
+ GI/GstVideo/Structs/VideoGLTextureUploadMeta.hs view
@@ -0,0 +1,153 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Extra buffer metadata for uploading a buffer to an OpenGL texture+ID. The caller of gst_video_gl_texture_upload_meta_upload() must+have OpenGL set up and call this from a thread where it is valid+to upload something to an OpenGL texture.+-}++module GI.GstVideo.Structs.VideoGLTextureUploadMeta+    ( ++-- * Exported types+    VideoGLTextureUploadMeta(..)            ,+    newZeroVideoGLTextureUploadMeta         ,+    noVideoGLTextureUploadMeta              ,+++ -- * Methods+-- ** videoGLTextureUploadMetaGetInfo+    videoGLTextureUploadMetaGetInfo         ,+++-- ** videoGLTextureUploadMetaUpload+    VideoGLTextureUploadMetaUploadMethodInfo,+    videoGLTextureUploadMetaUpload          ,+++++ -- * Properties+-- ** Meta+    videoGLTextureUploadMetaReadMeta        ,+++-- ** NTextures+    videoGLTextureUploadMetaReadNTextures   ,+++-- ** TextureOrientation+    videoGLTextureUploadMetaReadTextureOrientation,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.Gst as Gst++newtype VideoGLTextureUploadMeta = VideoGLTextureUploadMeta (ForeignPtr VideoGLTextureUploadMeta)+-- | Construct a `VideoGLTextureUploadMeta` struct initialized to zero.+newZeroVideoGLTextureUploadMeta :: MonadIO m => m VideoGLTextureUploadMeta+newZeroVideoGLTextureUploadMeta = liftIO $ callocBytes 80 >>= wrapPtr VideoGLTextureUploadMeta++noVideoGLTextureUploadMeta :: Maybe VideoGLTextureUploadMeta+noVideoGLTextureUploadMeta = Nothing++videoGLTextureUploadMetaReadMeta :: VideoGLTextureUploadMeta -> IO Gst.Meta+videoGLTextureUploadMetaReadMeta s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Gst.Meta)+    val' <- (newPtr 16 Gst.Meta) val+    return val'++videoGLTextureUploadMetaReadTextureOrientation :: VideoGLTextureUploadMeta -> IO VideoGLTextureOrientation+videoGLTextureUploadMetaReadTextureOrientation s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++videoGLTextureUploadMetaReadNTextures :: VideoGLTextureUploadMeta -> IO Word32+videoGLTextureUploadMetaReadNTextures s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 20) :: IO Word32+    return val++-- XXX Skipped getter for "VideoGLTextureUploadMeta:texture_type" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TInterface \"GstVideo\" \"VideoGLTextureType\")"++-- method VideoGLTextureUploadMeta::upload+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoGLTextureUploadMeta", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "texture_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_gl_texture_upload_meta_upload" gst_video_gl_texture_upload_meta_upload :: +    Ptr VideoGLTextureUploadMeta ->         -- _obj : TInterface "GstVideo" "VideoGLTextureUploadMeta"+    Word32 ->                               -- texture_id : TBasicType TUInt32+    IO CInt+++videoGLTextureUploadMetaUpload ::+    (MonadIO m) =>+    VideoGLTextureUploadMeta                -- _obj+    -> Word32                               -- textureId+    -> m Bool                               -- result+videoGLTextureUploadMetaUpload _obj textureId = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_gl_texture_upload_meta_upload _obj' textureId+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoGLTextureUploadMetaUploadMethodInfo+instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo VideoGLTextureUploadMetaUploadMethodInfo VideoGLTextureUploadMeta signature where+    overloadedMethod _ = videoGLTextureUploadMetaUpload++-- method VideoGLTextureUploadMeta::get_info+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "MetaInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_gl_texture_upload_meta_get_info" gst_video_gl_texture_upload_meta_get_info :: +    IO (Ptr Gst.MetaInfo)+++videoGLTextureUploadMetaGetInfo ::+    (MonadIO m) =>+    m Gst.MetaInfo                          -- result+videoGLTextureUploadMetaGetInfo  = liftIO $ do+    result <- gst_video_gl_texture_upload_meta_get_info+    checkUnexpectedReturnNULL "gst_video_gl_texture_upload_meta_get_info" result+    result' <- (newPtr 80 Gst.MetaInfo) result+    return result'++type family ResolveVideoGLTextureUploadMetaMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoGLTextureUploadMetaMethod "upload" o = VideoGLTextureUploadMetaUploadMethodInfo+    ResolveVideoGLTextureUploadMetaMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoGLTextureUploadMetaMethod t VideoGLTextureUploadMeta, MethodInfo info VideoGLTextureUploadMeta p) => IsLabelProxy t (VideoGLTextureUploadMeta -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoGLTextureUploadMetaMethod t VideoGLTextureUploadMeta, MethodInfo info VideoGLTextureUploadMeta p) => IsLabel t (VideoGLTextureUploadMeta -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoGLTextureUploadMeta.hs-boot view
@@ -0,0 +1,11 @@+module GI.GstVideo.Structs.VideoGLTextureUploadMeta where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoGLTextureUploadMeta = VideoGLTextureUploadMeta (ForeignPtr VideoGLTextureUploadMeta)+data VideoGLTextureUploadMetaUploadMethodInfo
+ GI/GstVideo/Structs/VideoInfo.hs view
@@ -0,0 +1,553 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Information describing image properties. This information can be filled+in from GstCaps with gst_video_info_from_caps(). The information is also used+to store the specific video info when mapping a video frame with+gst_video_frame_map().++Use the provided macros to access the info in this structure.+-}++module GI.GstVideo.Structs.VideoInfo+    ( ++-- * Exported types+    VideoInfo(..)                           ,+    newZeroVideoInfo                        ,+    noVideoInfo                             ,+++ -- * Methods+-- ** videoInfoAlign+    VideoInfoAlignMethodInfo                ,+    videoInfoAlign                          ,+++-- ** videoInfoConvert+    VideoInfoConvertMethodInfo              ,+    videoInfoConvert                        ,+++-- ** videoInfoCopy+    VideoInfoCopyMethodInfo                 ,+    videoInfoCopy                           ,+++-- ** videoInfoFree+    VideoInfoFreeMethodInfo                 ,+    videoInfoFree                           ,+++-- ** videoInfoFromCaps+    VideoInfoFromCapsMethodInfo             ,+    videoInfoFromCaps                       ,+++-- ** videoInfoInit+    VideoInfoInitMethodInfo                 ,+    videoInfoInit                           ,+++-- ** videoInfoIsEqual+    VideoInfoIsEqualMethodInfo              ,+    videoInfoIsEqual                        ,+++-- ** videoInfoNew+    videoInfoNew                            ,+++-- ** videoInfoSetFormat+    VideoInfoSetFormatMethodInfo            ,+    videoInfoSetFormat                      ,+++-- ** videoInfoToCaps+    VideoInfoToCapsMethodInfo               ,+    videoInfoToCaps                         ,+++++ -- * Properties+-- ** ChromaSite+    videoInfoReadChromaSite                 ,+++-- ** Colorimetry+    videoInfoReadColorimetry                ,+++-- ** Finfo+    videoInfoReadFinfo                      ,+++-- ** Flags+    videoInfoReadFlags                      ,+++-- ** FpsD+    videoInfoReadFpsD                       ,+++-- ** FpsN+    videoInfoReadFpsN                       ,+++-- ** Height+    videoInfoReadHeight                     ,+++-- ** InterlaceMode+    videoInfoReadInterlaceMode              ,+++-- ** ParD+    videoInfoReadParD                       ,+++-- ** ParN+    videoInfoReadParN                       ,+++-- ** Size+    videoInfoReadSize                       ,+++-- ** Views+    videoInfoReadViews                      ,+++-- ** Width+    videoInfoReadWidth                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.Gst as Gst++newtype VideoInfo = VideoInfo (ForeignPtr VideoInfo)+foreign import ccall "gst_video_info_get_type" c_gst_video_info_get_type :: +    IO GType++instance BoxedObject VideoInfo where+    boxedType _ = c_gst_video_info_get_type++-- | Construct a `VideoInfo` struct initialized to zero.+newZeroVideoInfo :: MonadIO m => m VideoInfo+newZeroVideoInfo = liftIO $ callocBoxedBytes 120 >>= wrapBoxed VideoInfo++noVideoInfo :: Maybe VideoInfo+noVideoInfo = Nothing++videoInfoReadFinfo :: VideoInfo -> IO VideoFormatInfo+videoInfoReadFinfo s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr VideoFormatInfo)+    val' <- (newPtr 232 VideoFormatInfo) val+    return val'++videoInfoReadInterlaceMode :: VideoInfo -> IO VideoInterlaceMode+videoInfoReadInterlaceMode s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++videoInfoReadFlags :: VideoInfo -> IO [VideoFlags]+videoInfoReadFlags s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 12) :: IO CUInt+    let val' = wordToGFlags val+    return val'++videoInfoReadWidth :: VideoInfo -> IO Int32+videoInfoReadWidth s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO Int32+    return val++videoInfoReadHeight :: VideoInfo -> IO Int32+videoInfoReadHeight s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 20) :: IO Int32+    return val++videoInfoReadSize :: VideoInfo -> IO Word64+videoInfoReadSize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO Word64+    return val++videoInfoReadViews :: VideoInfo -> IO Int32+videoInfoReadViews s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO Int32+    return val++videoInfoReadChromaSite :: VideoInfo -> IO [VideoChromaSite]+videoInfoReadChromaSite s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 36) :: IO CUInt+    let val' = wordToGFlags val+    return val'++videoInfoReadColorimetry :: VideoInfo -> IO VideoColorimetry+videoInfoReadColorimetry s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 40) :: IO (Ptr VideoColorimetry)+    val' <- (newPtr 16 VideoColorimetry) val+    return val'++videoInfoReadParN :: VideoInfo -> IO Int32+videoInfoReadParN s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 56) :: IO Int32+    return val++videoInfoReadParD :: VideoInfo -> IO Int32+videoInfoReadParD s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 60) :: IO Int32+    return val++videoInfoReadFpsN :: VideoInfo -> IO Int32+videoInfoReadFpsN s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 64) :: IO Int32+    return val++videoInfoReadFpsD :: VideoInfo -> IO Int32+videoInfoReadFpsD s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 68) :: IO Int32+    return val++-- XXX Skipped getter for "VideoInfo:offset" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt64)"++-- XXX Skipped getter for "VideoInfo:stride" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TInt32)"++-- method VideoInfo::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_info_new" gst_video_info_new :: +    IO (Ptr VideoInfo)+++videoInfoNew ::+    (MonadIO m) =>+    m VideoInfo                             -- result+videoInfoNew  = liftIO $ do+    result <- gst_video_info_new+    checkUnexpectedReturnNULL "gst_video_info_new" result+    result' <- (wrapBoxed VideoInfo) result+    return result'++-- method VideoInfo::align+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TInterface "GstVideo" "VideoAlignment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_info_align" gst_video_info_align :: +    Ptr VideoInfo ->                        -- _obj : TInterface "GstVideo" "VideoInfo"+    Ptr VideoAlignment ->                   -- align : TInterface "GstVideo" "VideoAlignment"+    IO ()+++videoInfoAlign ::+    (MonadIO m) =>+    VideoInfo                               -- _obj+    -> VideoAlignment                       -- align+    -> m ()                                 -- result+videoInfoAlign _obj align = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let align' = unsafeManagedPtrGetPtr align+    gst_video_info_align _obj' align'+    touchManagedPtr _obj+    touchManagedPtr align+    return ()++data VideoInfoAlignMethodInfo+instance (signature ~ (VideoAlignment -> m ()), MonadIO m) => MethodInfo VideoInfoAlignMethodInfo VideoInfo signature where+    overloadedMethod _ = videoInfoAlign++-- method VideoInfo::convert+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_info_convert" gst_video_info_convert :: +    Ptr VideoInfo ->                        -- _obj : TInterface "GstVideo" "VideoInfo"+    CUInt ->                                -- src_format : TInterface "Gst" "Format"+    Int64 ->                                -- src_value : TBasicType TInt64+    CUInt ->                                -- dest_format : TInterface "Gst" "Format"+    Int64 ->                                -- dest_value : TBasicType TInt64+    IO CInt+++videoInfoConvert ::+    (MonadIO m) =>+    VideoInfo                               -- _obj+    -> Gst.Format                           -- srcFormat+    -> Int64                                -- srcValue+    -> Gst.Format                           -- destFormat+    -> Int64                                -- destValue+    -> m Bool                               -- result+videoInfoConvert _obj srcFormat srcValue destFormat destValue = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let srcFormat' = (fromIntegral . fromEnum) srcFormat+    let destFormat' = (fromIntegral . fromEnum) destFormat+    result <- gst_video_info_convert _obj' srcFormat' srcValue destFormat' destValue+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data VideoInfoConvertMethodInfo+instance (signature ~ (Gst.Format -> Int64 -> Gst.Format -> Int64 -> m Bool), MonadIO m) => MethodInfo VideoInfoConvertMethodInfo VideoInfo signature where+    overloadedMethod _ = videoInfoConvert++-- method VideoInfo::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_info_copy" gst_video_info_copy :: +    Ptr VideoInfo ->                        -- _obj : TInterface "GstVideo" "VideoInfo"+    IO (Ptr VideoInfo)+++videoInfoCopy ::+    (MonadIO m) =>+    VideoInfo                               -- _obj+    -> m VideoInfo                          -- result+videoInfoCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_info_copy _obj'+    checkUnexpectedReturnNULL "gst_video_info_copy" result+    result' <- (wrapBoxed VideoInfo) result+    touchManagedPtr _obj+    return result'++data VideoInfoCopyMethodInfo+instance (signature ~ (m VideoInfo), MonadIO m) => MethodInfo VideoInfoCopyMethodInfo VideoInfo signature where+    overloadedMethod _ = videoInfoCopy++-- method VideoInfo::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_info_free" gst_video_info_free :: +    Ptr VideoInfo ->                        -- _obj : TInterface "GstVideo" "VideoInfo"+    IO ()+++videoInfoFree ::+    (MonadIO m) =>+    VideoInfo                               -- _obj+    -> m ()                                 -- result+videoInfoFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_info_free _obj'+    touchManagedPtr _obj+    return ()++data VideoInfoFreeMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoInfoFreeMethodInfo VideoInfo signature where+    overloadedMethod _ = videoInfoFree++-- method VideoInfo::from_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_info_from_caps" gst_video_info_from_caps :: +    Ptr VideoInfo ->                        -- _obj : TInterface "GstVideo" "VideoInfo"+    Ptr Gst.Caps ->                         -- caps : TInterface "Gst" "Caps"+    IO CInt+++videoInfoFromCaps ::+    (MonadIO m) =>+    VideoInfo                               -- _obj+    -> Gst.Caps                             -- caps+    -> m Bool                               -- result+videoInfoFromCaps _obj caps = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let caps' = unsafeManagedPtrGetPtr caps+    result <- gst_video_info_from_caps _obj' caps'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr caps+    return result'++data VideoInfoFromCapsMethodInfo+instance (signature ~ (Gst.Caps -> m Bool), MonadIO m) => MethodInfo VideoInfoFromCapsMethodInfo VideoInfo signature where+    overloadedMethod _ = videoInfoFromCaps++-- method VideoInfo::init+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_info_init" gst_video_info_init :: +    Ptr VideoInfo ->                        -- _obj : TInterface "GstVideo" "VideoInfo"+    IO ()+++videoInfoInit ::+    (MonadIO m) =>+    VideoInfo                               -- _obj+    -> m ()                                 -- result+videoInfoInit _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_info_init _obj'+    touchManagedPtr _obj+    return ()++data VideoInfoInitMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoInfoInitMethodInfo VideoInfo signature where+    overloadedMethod _ = videoInfoInit++-- method VideoInfo::is_equal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "other", argType = TInterface "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_info_is_equal" gst_video_info_is_equal :: +    Ptr VideoInfo ->                        -- _obj : TInterface "GstVideo" "VideoInfo"+    Ptr VideoInfo ->                        -- other : TInterface "GstVideo" "VideoInfo"+    IO CInt+++videoInfoIsEqual ::+    (MonadIO m) =>+    VideoInfo                               -- _obj+    -> VideoInfo                            -- other+    -> m Bool                               -- result+videoInfoIsEqual _obj other = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let other' = unsafeManagedPtrGetPtr other+    result <- gst_video_info_is_equal _obj' other'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr other+    return result'++data VideoInfoIsEqualMethodInfo+instance (signature ~ (VideoInfo -> m Bool), MonadIO m) => MethodInfo VideoInfoIsEqualMethodInfo VideoInfo signature where+    overloadedMethod _ = videoInfoIsEqual++-- method VideoInfo::set_format+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "GstVideo" "VideoFormat", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_info_set_format" gst_video_info_set_format :: +    Ptr VideoInfo ->                        -- _obj : TInterface "GstVideo" "VideoInfo"+    CUInt ->                                -- format : TInterface "GstVideo" "VideoFormat"+    Word32 ->                               -- width : TBasicType TUInt32+    Word32 ->                               -- height : TBasicType TUInt32+    IO ()+++videoInfoSetFormat ::+    (MonadIO m) =>+    VideoInfo                               -- _obj+    -> VideoFormat                          -- format+    -> Word32                               -- width+    -> Word32                               -- height+    -> m ()                                 -- result+videoInfoSetFormat _obj format width height = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    gst_video_info_set_format _obj' format' width height+    touchManagedPtr _obj+    return ()++data VideoInfoSetFormatMethodInfo+instance (signature ~ (VideoFormat -> Word32 -> Word32 -> m ()), MonadIO m) => MethodInfo VideoInfoSetFormatMethodInfo VideoInfo signature where+    overloadedMethod _ = videoInfoSetFormat++-- method VideoInfo::to_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_info_to_caps" gst_video_info_to_caps :: +    Ptr VideoInfo ->                        -- _obj : TInterface "GstVideo" "VideoInfo"+    IO (Ptr Gst.Caps)+++videoInfoToCaps ::+    (MonadIO m) =>+    VideoInfo                               -- _obj+    -> m Gst.Caps                           -- result+videoInfoToCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_info_to_caps _obj'+    checkUnexpectedReturnNULL "gst_video_info_to_caps" result+    result' <- (wrapBoxed Gst.Caps) result+    touchManagedPtr _obj+    return result'++data VideoInfoToCapsMethodInfo+instance (signature ~ (m Gst.Caps), MonadIO m) => MethodInfo VideoInfoToCapsMethodInfo VideoInfo signature where+    overloadedMethod _ = videoInfoToCaps++type family ResolveVideoInfoMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoInfoMethod "align" o = VideoInfoAlignMethodInfo+    ResolveVideoInfoMethod "convert" o = VideoInfoConvertMethodInfo+    ResolveVideoInfoMethod "copy" o = VideoInfoCopyMethodInfo+    ResolveVideoInfoMethod "free" o = VideoInfoFreeMethodInfo+    ResolveVideoInfoMethod "fromCaps" o = VideoInfoFromCapsMethodInfo+    ResolveVideoInfoMethod "init" o = VideoInfoInitMethodInfo+    ResolveVideoInfoMethod "isEqual" o = VideoInfoIsEqualMethodInfo+    ResolveVideoInfoMethod "toCaps" o = VideoInfoToCapsMethodInfo+    ResolveVideoInfoMethod "setFormat" o = VideoInfoSetFormatMethodInfo+    ResolveVideoInfoMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoInfoMethod t VideoInfo, MethodInfo info VideoInfo p) => IsLabelProxy t (VideoInfo -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoInfoMethod t VideoInfo, MethodInfo info VideoInfo p) => IsLabel t (VideoInfo -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoInfo.hs-boot view
@@ -0,0 +1,20 @@+module GI.GstVideo.Structs.VideoInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoInfo = VideoInfo (ForeignPtr VideoInfo)+instance BoxedObject VideoInfo where+data VideoInfoAlignMethodInfo+data VideoInfoConvertMethodInfo+data VideoInfoCopyMethodInfo+data VideoInfoFreeMethodInfo+data VideoInfoFromCapsMethodInfo+data VideoInfoInitMethodInfo+data VideoInfoIsEqualMethodInfo+data VideoInfoSetFormatMethodInfo+data VideoInfoToCapsMethodInfo
+ GI/GstVideo/Structs/VideoMeta.hs view
@@ -0,0 +1,254 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Extra buffer metadata describing image properties+-}++module GI.GstVideo.Structs.VideoMeta+    ( ++-- * Exported types+    VideoMeta(..)                           ,+    newZeroVideoMeta                        ,+    noVideoMeta                             ,+++ -- * Methods+-- ** videoMetaGetInfo+    videoMetaGetInfo                        ,+++-- ** videoMetaMap+    VideoMetaMapMethodInfo                  ,+    videoMetaMap                            ,+++-- ** videoMetaUnmap+    VideoMetaUnmapMethodInfo                ,+    videoMetaUnmap                          ,+++++ -- * Properties+-- ** Buffer+    videoMetaReadBuffer                     ,+++-- ** Flags+    videoMetaReadFlags                      ,+++-- ** Format+    videoMetaReadFormat                     ,+++-- ** Height+    videoMetaReadHeight                     ,+++-- ** Id+    videoMetaReadId                         ,+++-- ** Meta+    videoMetaReadMeta                       ,+++-- ** NPlanes+    videoMetaReadNPlanes                    ,+++-- ** Width+    videoMetaReadWidth                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.Gst as Gst++newtype VideoMeta = VideoMeta (ForeignPtr VideoMeta)+-- | Construct a `VideoMeta` struct initialized to zero.+newZeroVideoMeta :: MonadIO m => m VideoMeta+newZeroVideoMeta = liftIO $ callocBytes 112 >>= wrapPtr VideoMeta++noVideoMeta :: Maybe VideoMeta+noVideoMeta = Nothing++videoMetaReadMeta :: VideoMeta -> IO Gst.Meta+videoMetaReadMeta s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Gst.Meta)+    val' <- (newPtr 16 Gst.Meta) val+    return val'++videoMetaReadBuffer :: VideoMeta -> IO Gst.Buffer+videoMetaReadBuffer s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr Gst.Buffer)+    val' <- (newBoxed Gst.Buffer) val+    return val'++videoMetaReadFlags :: VideoMeta -> IO [VideoFrameFlags]+videoMetaReadFlags s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO CUInt+    let val' = wordToGFlags val+    return val'++videoMetaReadFormat :: VideoMeta -> IO VideoFormat+videoMetaReadFormat s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 28) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++videoMetaReadId :: VideoMeta -> IO Int32+videoMetaReadId s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO Int32+    return val++videoMetaReadWidth :: VideoMeta -> IO Word32+videoMetaReadWidth s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 36) :: IO Word32+    return val++videoMetaReadHeight :: VideoMeta -> IO Word32+videoMetaReadHeight s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 40) :: IO Word32+    return val++videoMetaReadNPlanes :: VideoMeta -> IO Word32+videoMetaReadNPlanes s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 44) :: IO Word32+    return val++-- XXX Skipped getter for "VideoMeta:offset" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt64)"++-- XXX Skipped getter for "VideoMeta:stride" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TInt32)"++-- XXX Skipped getter for "VideoMeta:map" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "VideoMeta:unmap" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- method VideoMeta::map+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoMeta", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "MapFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_meta_map" gst_video_meta_map :: +    Ptr VideoMeta ->                        -- _obj : TInterface "GstVideo" "VideoMeta"+    Word32 ->                               -- plane : TBasicType TUInt32+    Ptr Gst.MapInfo ->                      -- info : TInterface "Gst" "MapInfo"+    Ptr () ->                               -- data : TBasicType TVoid+    Int32 ->                                -- stride : TBasicType TInt32+    CUInt ->                                -- flags : TInterface "Gst" "MapFlags"+    IO CInt+++videoMetaMap ::+    (MonadIO m) =>+    VideoMeta                               -- _obj+    -> Word32                               -- plane+    -> Gst.MapInfo                          -- info+    -> Ptr ()                               -- data_+    -> Int32                                -- stride+    -> [Gst.MapFlags]                       -- flags+    -> m Bool                               -- result+videoMetaMap _obj plane info data_ stride flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let info' = unsafeManagedPtrGetPtr info+    let flags' = gflagsToWord flags+    result <- gst_video_meta_map _obj' plane info' data_ stride flags'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr info+    return result'++data VideoMetaMapMethodInfo+instance (signature ~ (Word32 -> Gst.MapInfo -> Ptr () -> Int32 -> [Gst.MapFlags] -> m Bool), MonadIO m) => MethodInfo VideoMetaMapMethodInfo VideoMeta signature where+    overloadedMethod _ = videoMetaMap++-- method VideoMeta::unmap+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoMeta", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_meta_unmap" gst_video_meta_unmap :: +    Ptr VideoMeta ->                        -- _obj : TInterface "GstVideo" "VideoMeta"+    Word32 ->                               -- plane : TBasicType TUInt32+    Ptr Gst.MapInfo ->                      -- info : TInterface "Gst" "MapInfo"+    IO CInt+++videoMetaUnmap ::+    (MonadIO m) =>+    VideoMeta                               -- _obj+    -> Word32                               -- plane+    -> Gst.MapInfo                          -- info+    -> m Bool                               -- result+videoMetaUnmap _obj plane info = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let info' = unsafeManagedPtrGetPtr info+    result <- gst_video_meta_unmap _obj' plane info'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr info+    return result'++data VideoMetaUnmapMethodInfo+instance (signature ~ (Word32 -> Gst.MapInfo -> m Bool), MonadIO m) => MethodInfo VideoMetaUnmapMethodInfo VideoMeta signature where+    overloadedMethod _ = videoMetaUnmap++-- method VideoMeta::get_info+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "MetaInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_meta_get_info" gst_video_meta_get_info :: +    IO (Ptr Gst.MetaInfo)+++videoMetaGetInfo ::+    (MonadIO m) =>+    m Gst.MetaInfo                          -- result+videoMetaGetInfo  = liftIO $ do+    result <- gst_video_meta_get_info+    checkUnexpectedReturnNULL "gst_video_meta_get_info" result+    result' <- (newPtr 80 Gst.MetaInfo) result+    return result'++type family ResolveVideoMetaMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoMetaMethod "map" o = VideoMetaMapMethodInfo+    ResolveVideoMetaMethod "unmap" o = VideoMetaUnmapMethodInfo+    ResolveVideoMetaMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoMetaMethod t VideoMeta, MethodInfo info VideoMeta p) => IsLabelProxy t (VideoMeta -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoMetaMethod t VideoMeta, MethodInfo info VideoMeta p) => IsLabel t (VideoMeta -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoMeta.hs-boot view
@@ -0,0 +1,12 @@+module GI.GstVideo.Structs.VideoMeta where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoMeta = VideoMeta (ForeignPtr VideoMeta)+data VideoMetaMapMethodInfo+data VideoMetaUnmapMethodInfo
+ GI/GstVideo/Structs/VideoMetaTransform.hs view
@@ -0,0 +1,101 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Extra data passed to a video transform #GstMetaTransformFunction such as:+"gst-video-scale".+-}++module GI.GstVideo.Structs.VideoMetaTransform+    ( ++-- * Exported types+    VideoMetaTransform(..)                  ,+    newZeroVideoMetaTransform               ,+    noVideoMetaTransform                    ,+++ -- * Methods+-- ** videoMetaTransformScaleGetQuark+    videoMetaTransformScaleGetQuark         ,+++++ -- * Properties+-- ** InInfo+    videoMetaTransformReadInInfo            ,+++-- ** OutInfo+    videoMetaTransformReadOutInfo           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++newtype VideoMetaTransform = VideoMetaTransform (ForeignPtr VideoMetaTransform)+-- | Construct a `VideoMetaTransform` struct initialized to zero.+newZeroVideoMetaTransform :: MonadIO m => m VideoMetaTransform+newZeroVideoMetaTransform = liftIO $ callocBytes 16 >>= wrapPtr VideoMetaTransform++noVideoMetaTransform :: Maybe VideoMetaTransform+noVideoMetaTransform = Nothing++videoMetaTransformReadInInfo :: VideoMetaTransform -> IO VideoInfo+videoMetaTransformReadInInfo s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr VideoInfo)+    val' <- (newBoxed VideoInfo) val+    return val'++videoMetaTransformReadOutInfo :: VideoMetaTransform -> IO VideoInfo+videoMetaTransformReadOutInfo s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO (Ptr VideoInfo)+    val' <- (newBoxed VideoInfo) val+    return val'++-- method VideoMetaTransform::scale_get_quark+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_meta_transform_scale_get_quark" gst_video_meta_transform_scale_get_quark :: +    IO Word32+++videoMetaTransformScaleGetQuark ::+    (MonadIO m) =>+    m Word32                                -- result+videoMetaTransformScaleGetQuark  = liftIO $ do+    result <- gst_video_meta_transform_scale_get_quark+    return result++type family ResolveVideoMetaTransformMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoMetaTransformMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoMetaTransformMethod t VideoMetaTransform, MethodInfo info VideoMetaTransform p) => IsLabelProxy t (VideoMetaTransform -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoMetaTransformMethod t VideoMetaTransform, MethodInfo info VideoMetaTransform p) => IsLabel t (VideoMetaTransform -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoMetaTransform.hs-boot view
@@ -0,0 +1,10 @@+module GI.GstVideo.Structs.VideoMetaTransform where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoMetaTransform = VideoMetaTransform (ForeignPtr VideoMetaTransform)
+ GI/GstVideo/Structs/VideoOverlayComposition.hs view
@@ -0,0 +1,362 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++<refsect2>+<para>+Functions to create and handle overlay compositions on video buffers.+</para>+<para>+An overlay composition describes one or more overlay rectangles to be+blended on top of a video buffer.+</para>+<para>+This API serves two main purposes:+<itemizedlist>+<listitem>+it can be used to attach overlay information (subtitles or logos)+to non-raw video buffers such as GL/VAAPI/VDPAU surfaces. The actual+blending of the overlay can then be done by e.g. the video sink that+processes these non-raw buffers.+</listitem>+<listitem>+it can also be used to blend overlay rectangles on top of raw video+buffers, thus consolidating blending functionality for raw video in+one place.+</listitem>+Together, this allows existing overlay elements to easily handle raw+and non-raw video as input in without major changes (once the overlays+have been put into a #GstOverlayComposition object anyway) - for raw+video the overlay can just use the blending function to blend the data+on top of the video, and for surface buffers it can just attach them to+the buffer and let the sink render the overlays.+</itemizedlist>+</para>+</refsect2>+-}++module GI.GstVideo.Structs.VideoOverlayComposition+    ( ++-- * Exported types+    VideoOverlayComposition(..)             ,+    noVideoOverlayComposition               ,+++ -- * Methods+-- ** videoOverlayCompositionAddRectangle+    VideoOverlayCompositionAddRectangleMethodInfo,+    videoOverlayCompositionAddRectangle     ,+++-- ** videoOverlayCompositionBlend+    VideoOverlayCompositionBlendMethodInfo  ,+    videoOverlayCompositionBlend            ,+++-- ** videoOverlayCompositionCopy+    VideoOverlayCompositionCopyMethodInfo   ,+    videoOverlayCompositionCopy             ,+++-- ** videoOverlayCompositionGetRectangle+    VideoOverlayCompositionGetRectangleMethodInfo,+    videoOverlayCompositionGetRectangle     ,+++-- ** videoOverlayCompositionGetSeqnum+    VideoOverlayCompositionGetSeqnumMethodInfo,+    videoOverlayCompositionGetSeqnum        ,+++-- ** videoOverlayCompositionMakeWritable+    VideoOverlayCompositionMakeWritableMethodInfo,+    videoOverlayCompositionMakeWritable     ,+++-- ** videoOverlayCompositionNRectangles+    VideoOverlayCompositionNRectanglesMethodInfo,+    videoOverlayCompositionNRectangles      ,+++-- ** videoOverlayCompositionNew+    videoOverlayCompositionNew              ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++newtype VideoOverlayComposition = VideoOverlayComposition (ForeignPtr VideoOverlayComposition)+foreign import ccall "gst_video_overlay_composition_get_type" c_gst_video_overlay_composition_get_type :: +    IO GType++instance BoxedObject VideoOverlayComposition where+    boxedType _ = c_gst_video_overlay_composition_get_type++noVideoOverlayComposition :: Maybe VideoOverlayComposition+noVideoOverlayComposition = Nothing++-- method VideoOverlayComposition::new+-- method type : Constructor+-- Args : [Arg {argCName = "rectangle", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoOverlayComposition"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_composition_new" gst_video_overlay_composition_new :: +    Ptr VideoOverlayRectangle ->            -- rectangle : TInterface "GstVideo" "VideoOverlayRectangle"+    IO (Ptr VideoOverlayComposition)+++videoOverlayCompositionNew ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- rectangle+    -> m VideoOverlayComposition            -- result+videoOverlayCompositionNew rectangle = liftIO $ do+    let rectangle' = unsafeManagedPtrGetPtr rectangle+    result <- gst_video_overlay_composition_new rectangle'+    checkUnexpectedReturnNULL "gst_video_overlay_composition_new" result+    result' <- (wrapBoxed VideoOverlayComposition) result+    touchManagedPtr rectangle+    return result'++-- method VideoOverlayComposition::add_rectangle+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayComposition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rectangle", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_composition_add_rectangle" gst_video_overlay_composition_add_rectangle :: +    Ptr VideoOverlayComposition ->          -- _obj : TInterface "GstVideo" "VideoOverlayComposition"+    Ptr VideoOverlayRectangle ->            -- rectangle : TInterface "GstVideo" "VideoOverlayRectangle"+    IO ()+++videoOverlayCompositionAddRectangle ::+    (MonadIO m) =>+    VideoOverlayComposition                 -- _obj+    -> VideoOverlayRectangle                -- rectangle+    -> m ()                                 -- result+videoOverlayCompositionAddRectangle _obj rectangle = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let rectangle' = unsafeManagedPtrGetPtr rectangle+    gst_video_overlay_composition_add_rectangle _obj' rectangle'+    touchManagedPtr _obj+    touchManagedPtr rectangle+    return ()++data VideoOverlayCompositionAddRectangleMethodInfo+instance (signature ~ (VideoOverlayRectangle -> m ()), MonadIO m) => MethodInfo VideoOverlayCompositionAddRectangleMethodInfo VideoOverlayComposition signature where+    overloadedMethod _ = videoOverlayCompositionAddRectangle++-- method VideoOverlayComposition::blend+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayComposition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "video_buf", argType = TInterface "GstVideo" "VideoFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_composition_blend" gst_video_overlay_composition_blend :: +    Ptr VideoOverlayComposition ->          -- _obj : TInterface "GstVideo" "VideoOverlayComposition"+    Ptr VideoFrame ->                       -- video_buf : TInterface "GstVideo" "VideoFrame"+    IO CInt+++videoOverlayCompositionBlend ::+    (MonadIO m) =>+    VideoOverlayComposition                 -- _obj+    -> VideoFrame                           -- videoBuf+    -> m Bool                               -- result+videoOverlayCompositionBlend _obj videoBuf = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let videoBuf' = unsafeManagedPtrGetPtr videoBuf+    result <- gst_video_overlay_composition_blend _obj' videoBuf'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr videoBuf+    return result'++data VideoOverlayCompositionBlendMethodInfo+instance (signature ~ (VideoFrame -> m Bool), MonadIO m) => MethodInfo VideoOverlayCompositionBlendMethodInfo VideoOverlayComposition signature where+    overloadedMethod _ = videoOverlayCompositionBlend++-- method VideoOverlayComposition::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayComposition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoOverlayComposition"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_composition_copy" gst_video_overlay_composition_copy :: +    Ptr VideoOverlayComposition ->          -- _obj : TInterface "GstVideo" "VideoOverlayComposition"+    IO (Ptr VideoOverlayComposition)+++videoOverlayCompositionCopy ::+    (MonadIO m) =>+    VideoOverlayComposition                 -- _obj+    -> m VideoOverlayComposition            -- result+videoOverlayCompositionCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_overlay_composition_copy _obj'+    checkUnexpectedReturnNULL "gst_video_overlay_composition_copy" result+    result' <- (wrapBoxed VideoOverlayComposition) result+    touchManagedPtr _obj+    return result'++data VideoOverlayCompositionCopyMethodInfo+instance (signature ~ (m VideoOverlayComposition), MonadIO m) => MethodInfo VideoOverlayCompositionCopyMethodInfo VideoOverlayComposition signature where+    overloadedMethod _ = videoOverlayCompositionCopy++-- method VideoOverlayComposition::get_rectangle+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayComposition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoOverlayRectangle"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_composition_get_rectangle" gst_video_overlay_composition_get_rectangle :: +    Ptr VideoOverlayComposition ->          -- _obj : TInterface "GstVideo" "VideoOverlayComposition"+    Word32 ->                               -- n : TBasicType TUInt32+    IO (Ptr VideoOverlayRectangle)+++videoOverlayCompositionGetRectangle ::+    (MonadIO m) =>+    VideoOverlayComposition                 -- _obj+    -> Word32                               -- n+    -> m VideoOverlayRectangle              -- result+videoOverlayCompositionGetRectangle _obj n = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_overlay_composition_get_rectangle _obj' n+    checkUnexpectedReturnNULL "gst_video_overlay_composition_get_rectangle" result+    result' <- (newBoxed VideoOverlayRectangle) result+    touchManagedPtr _obj+    return result'++data VideoOverlayCompositionGetRectangleMethodInfo+instance (signature ~ (Word32 -> m VideoOverlayRectangle), MonadIO m) => MethodInfo VideoOverlayCompositionGetRectangleMethodInfo VideoOverlayComposition signature where+    overloadedMethod _ = videoOverlayCompositionGetRectangle++-- method VideoOverlayComposition::get_seqnum+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayComposition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_composition_get_seqnum" gst_video_overlay_composition_get_seqnum :: +    Ptr VideoOverlayComposition ->          -- _obj : TInterface "GstVideo" "VideoOverlayComposition"+    IO Word32+++videoOverlayCompositionGetSeqnum ::+    (MonadIO m) =>+    VideoOverlayComposition                 -- _obj+    -> m Word32                             -- result+videoOverlayCompositionGetSeqnum _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_overlay_composition_get_seqnum _obj'+    touchManagedPtr _obj+    return result++data VideoOverlayCompositionGetSeqnumMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo VideoOverlayCompositionGetSeqnumMethodInfo VideoOverlayComposition signature where+    overloadedMethod _ = videoOverlayCompositionGetSeqnum++-- method VideoOverlayComposition::make_writable+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayComposition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoOverlayComposition"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_composition_make_writable" gst_video_overlay_composition_make_writable :: +    Ptr VideoOverlayComposition ->          -- _obj : TInterface "GstVideo" "VideoOverlayComposition"+    IO (Ptr VideoOverlayComposition)+++videoOverlayCompositionMakeWritable ::+    (MonadIO m) =>+    VideoOverlayComposition                 -- _obj+    -> m VideoOverlayComposition            -- result+videoOverlayCompositionMakeWritable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_overlay_composition_make_writable _obj'+    checkUnexpectedReturnNULL "gst_video_overlay_composition_make_writable" result+    result' <- (wrapBoxed VideoOverlayComposition) result+    touchManagedPtr _obj+    return result'++data VideoOverlayCompositionMakeWritableMethodInfo+instance (signature ~ (m VideoOverlayComposition), MonadIO m) => MethodInfo VideoOverlayCompositionMakeWritableMethodInfo VideoOverlayComposition signature where+    overloadedMethod _ = videoOverlayCompositionMakeWritable++-- method VideoOverlayComposition::n_rectangles+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayComposition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_composition_n_rectangles" gst_video_overlay_composition_n_rectangles :: +    Ptr VideoOverlayComposition ->          -- _obj : TInterface "GstVideo" "VideoOverlayComposition"+    IO Word32+++videoOverlayCompositionNRectangles ::+    (MonadIO m) =>+    VideoOverlayComposition                 -- _obj+    -> m Word32                             -- result+videoOverlayCompositionNRectangles _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_overlay_composition_n_rectangles _obj'+    touchManagedPtr _obj+    return result++data VideoOverlayCompositionNRectanglesMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo VideoOverlayCompositionNRectanglesMethodInfo VideoOverlayComposition signature where+    overloadedMethod _ = videoOverlayCompositionNRectangles++type family ResolveVideoOverlayCompositionMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoOverlayCompositionMethod "addRectangle" o = VideoOverlayCompositionAddRectangleMethodInfo+    ResolveVideoOverlayCompositionMethod "blend" o = VideoOverlayCompositionBlendMethodInfo+    ResolveVideoOverlayCompositionMethod "copy" o = VideoOverlayCompositionCopyMethodInfo+    ResolveVideoOverlayCompositionMethod "makeWritable" o = VideoOverlayCompositionMakeWritableMethodInfo+    ResolveVideoOverlayCompositionMethod "nRectangles" o = VideoOverlayCompositionNRectanglesMethodInfo+    ResolveVideoOverlayCompositionMethod "getRectangle" o = VideoOverlayCompositionGetRectangleMethodInfo+    ResolveVideoOverlayCompositionMethod "getSeqnum" o = VideoOverlayCompositionGetSeqnumMethodInfo+    ResolveVideoOverlayCompositionMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoOverlayCompositionMethod t VideoOverlayComposition, MethodInfo info VideoOverlayComposition p) => IsLabelProxy t (VideoOverlayComposition -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoOverlayCompositionMethod t VideoOverlayComposition, MethodInfo info VideoOverlayComposition p) => IsLabel t (VideoOverlayComposition -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoOverlayComposition.hs-boot view
@@ -0,0 +1,18 @@+module GI.GstVideo.Structs.VideoOverlayComposition where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoOverlayComposition = VideoOverlayComposition (ForeignPtr VideoOverlayComposition)+instance BoxedObject VideoOverlayComposition where+data VideoOverlayCompositionAddRectangleMethodInfo+data VideoOverlayCompositionBlendMethodInfo+data VideoOverlayCompositionCopyMethodInfo+data VideoOverlayCompositionGetRectangleMethodInfo+data VideoOverlayCompositionGetSeqnumMethodInfo+data VideoOverlayCompositionMakeWritableMethodInfo+data VideoOverlayCompositionNRectanglesMethodInfo
+ GI/GstVideo/Structs/VideoOverlayCompositionMeta.hs view
@@ -0,0 +1,103 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Extra buffer metadata describing image overlay data.+-}++module GI.GstVideo.Structs.VideoOverlayCompositionMeta+    ( ++-- * Exported types+    VideoOverlayCompositionMeta(..)         ,+    newZeroVideoOverlayCompositionMeta      ,+    noVideoOverlayCompositionMeta           ,+++ -- * Methods+-- ** videoOverlayCompositionMetaGetInfo+    videoOverlayCompositionMetaGetInfo      ,+++++ -- * Properties+-- ** Meta+    videoOverlayCompositionMetaReadMeta     ,+++-- ** Overlay+    videoOverlayCompositionMetaReadOverlay  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.Gst as Gst++newtype VideoOverlayCompositionMeta = VideoOverlayCompositionMeta (ForeignPtr VideoOverlayCompositionMeta)+-- | Construct a `VideoOverlayCompositionMeta` struct initialized to zero.+newZeroVideoOverlayCompositionMeta :: MonadIO m => m VideoOverlayCompositionMeta+newZeroVideoOverlayCompositionMeta = liftIO $ callocBytes 24 >>= wrapPtr VideoOverlayCompositionMeta++noVideoOverlayCompositionMeta :: Maybe VideoOverlayCompositionMeta+noVideoOverlayCompositionMeta = Nothing++videoOverlayCompositionMetaReadMeta :: VideoOverlayCompositionMeta -> IO Gst.Meta+videoOverlayCompositionMetaReadMeta s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Gst.Meta)+    val' <- (newPtr 16 Gst.Meta) val+    return val'++videoOverlayCompositionMetaReadOverlay :: VideoOverlayCompositionMeta -> IO VideoOverlayComposition+videoOverlayCompositionMetaReadOverlay s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr VideoOverlayComposition)+    val' <- (newBoxed VideoOverlayComposition) val+    return val'++-- method VideoOverlayCompositionMeta::get_info+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "MetaInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_composition_meta_get_info" gst_video_overlay_composition_meta_get_info :: +    IO (Ptr Gst.MetaInfo)+++videoOverlayCompositionMetaGetInfo ::+    (MonadIO m) =>+    m Gst.MetaInfo                          -- result+videoOverlayCompositionMetaGetInfo  = liftIO $ do+    result <- gst_video_overlay_composition_meta_get_info+    checkUnexpectedReturnNULL "gst_video_overlay_composition_meta_get_info" result+    result' <- (newPtr 80 Gst.MetaInfo) result+    return result'++type family ResolveVideoOverlayCompositionMetaMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoOverlayCompositionMetaMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoOverlayCompositionMetaMethod t VideoOverlayCompositionMeta, MethodInfo info VideoOverlayCompositionMeta p) => IsLabelProxy t (VideoOverlayCompositionMeta -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoOverlayCompositionMetaMethod t VideoOverlayCompositionMeta, MethodInfo info VideoOverlayCompositionMeta p) => IsLabel t (VideoOverlayCompositionMeta -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoOverlayCompositionMeta.hs-boot view
@@ -0,0 +1,10 @@+module GI.GstVideo.Structs.VideoOverlayCompositionMeta where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoOverlayCompositionMeta = VideoOverlayCompositionMeta (ForeignPtr VideoOverlayCompositionMeta)
+ GI/GstVideo/Structs/VideoOverlayRectangle.hs view
@@ -0,0 +1,588 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++An opaque video overlay rectangle object. A rectangle contains a single+overlay rectangle which can be added to a composition.+-}++module GI.GstVideo.Structs.VideoOverlayRectangle+    ( ++-- * Exported types+    VideoOverlayRectangle(..)               ,+    noVideoOverlayRectangle                 ,+++ -- * Methods+-- ** videoOverlayRectangleCopy+    VideoOverlayRectangleCopyMethodInfo     ,+    videoOverlayRectangleCopy               ,+++-- ** videoOverlayRectangleGetFlags+    VideoOverlayRectangleGetFlagsMethodInfo ,+    videoOverlayRectangleGetFlags           ,+++-- ** videoOverlayRectangleGetGlobalAlpha+    VideoOverlayRectangleGetGlobalAlphaMethodInfo,+    videoOverlayRectangleGetGlobalAlpha     ,+++-- ** videoOverlayRectangleGetPixelsArgb+    VideoOverlayRectangleGetPixelsArgbMethodInfo,+    videoOverlayRectangleGetPixelsArgb      ,+++-- ** videoOverlayRectangleGetPixelsAyuv+    VideoOverlayRectangleGetPixelsAyuvMethodInfo,+    videoOverlayRectangleGetPixelsAyuv      ,+++-- ** videoOverlayRectangleGetPixelsRaw+    VideoOverlayRectangleGetPixelsRawMethodInfo,+    videoOverlayRectangleGetPixelsRaw       ,+++-- ** videoOverlayRectangleGetPixelsUnscaledArgb+    VideoOverlayRectangleGetPixelsUnscaledArgbMethodInfo,+    videoOverlayRectangleGetPixelsUnscaledArgb,+++-- ** videoOverlayRectangleGetPixelsUnscaledAyuv+    VideoOverlayRectangleGetPixelsUnscaledAyuvMethodInfo,+    videoOverlayRectangleGetPixelsUnscaledAyuv,+++-- ** videoOverlayRectangleGetPixelsUnscaledRaw+    VideoOverlayRectangleGetPixelsUnscaledRawMethodInfo,+    videoOverlayRectangleGetPixelsUnscaledRaw,+++-- ** videoOverlayRectangleGetRenderRectangle+    VideoOverlayRectangleGetRenderRectangleMethodInfo,+    videoOverlayRectangleGetRenderRectangle ,+++-- ** videoOverlayRectangleGetSeqnum+    VideoOverlayRectangleGetSeqnumMethodInfo,+    videoOverlayRectangleGetSeqnum          ,+++-- ** videoOverlayRectangleNewRaw+    videoOverlayRectangleNewRaw             ,+++-- ** videoOverlayRectangleSetGlobalAlpha+    VideoOverlayRectangleSetGlobalAlphaMethodInfo,+    videoOverlayRectangleSetGlobalAlpha     ,+++-- ** videoOverlayRectangleSetRenderRectangle+    VideoOverlayRectangleSetRenderRectangleMethodInfo,+    videoOverlayRectangleSetRenderRectangle ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.Gst as Gst++newtype VideoOverlayRectangle = VideoOverlayRectangle (ForeignPtr VideoOverlayRectangle)+foreign import ccall "gst_video_overlay_rectangle_get_type" c_gst_video_overlay_rectangle_get_type :: +    IO GType++instance BoxedObject VideoOverlayRectangle where+    boxedType _ = c_gst_video_overlay_rectangle_get_type++noVideoOverlayRectangle :: Maybe VideoOverlayRectangle+noVideoOverlayRectangle = Nothing++-- method VideoOverlayRectangle::new_raw+-- method type : Constructor+-- Args : [Arg {argCName = "pixels", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_height", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "GstVideo" "VideoOverlayFormatFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoOverlayRectangle"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_new_raw" gst_video_overlay_rectangle_new_raw :: +    Ptr Gst.Buffer ->                       -- pixels : TInterface "Gst" "Buffer"+    Int32 ->                                -- render_x : TBasicType TInt32+    Int32 ->                                -- render_y : TBasicType TInt32+    Word32 ->                               -- render_width : TBasicType TUInt32+    Word32 ->                               -- render_height : TBasicType TUInt32+    CUInt ->                                -- flags : TInterface "GstVideo" "VideoOverlayFormatFlags"+    IO (Ptr VideoOverlayRectangle)+++videoOverlayRectangleNewRaw ::+    (MonadIO m) =>+    Gst.Buffer                              -- pixels+    -> Int32                                -- renderX+    -> Int32                                -- renderY+    -> Word32                               -- renderWidth+    -> Word32                               -- renderHeight+    -> VideoOverlayFormatFlags              -- flags+    -> m VideoOverlayRectangle              -- result+videoOverlayRectangleNewRaw pixels renderX renderY renderWidth renderHeight flags = liftIO $ do+    let pixels' = unsafeManagedPtrGetPtr pixels+    let flags' = (fromIntegral . fromEnum) flags+    result <- gst_video_overlay_rectangle_new_raw pixels' renderX renderY renderWidth renderHeight flags'+    checkUnexpectedReturnNULL "gst_video_overlay_rectangle_new_raw" result+    result' <- (wrapBoxed VideoOverlayRectangle) result+    touchManagedPtr pixels+    return result'++-- method VideoOverlayRectangle::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoOverlayRectangle"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_copy" gst_video_overlay_rectangle_copy :: +    Ptr VideoOverlayRectangle ->            -- _obj : TInterface "GstVideo" "VideoOverlayRectangle"+    IO (Ptr VideoOverlayRectangle)+++videoOverlayRectangleCopy ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- _obj+    -> m VideoOverlayRectangle              -- result+videoOverlayRectangleCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_overlay_rectangle_copy _obj'+    checkUnexpectedReturnNULL "gst_video_overlay_rectangle_copy" result+    result' <- (wrapBoxed VideoOverlayRectangle) result+    touchManagedPtr _obj+    return result'++data VideoOverlayRectangleCopyMethodInfo+instance (signature ~ (m VideoOverlayRectangle), MonadIO m) => MethodInfo VideoOverlayRectangleCopyMethodInfo VideoOverlayRectangle signature where+    overloadedMethod _ = videoOverlayRectangleCopy++-- method VideoOverlayRectangle::get_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GstVideo" "VideoOverlayFormatFlags"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_get_flags" gst_video_overlay_rectangle_get_flags :: +    Ptr VideoOverlayRectangle ->            -- _obj : TInterface "GstVideo" "VideoOverlayRectangle"+    IO CUInt+++videoOverlayRectangleGetFlags ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- _obj+    -> m VideoOverlayFormatFlags            -- result+videoOverlayRectangleGetFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_overlay_rectangle_get_flags _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data VideoOverlayRectangleGetFlagsMethodInfo+instance (signature ~ (m VideoOverlayFormatFlags), MonadIO m) => MethodInfo VideoOverlayRectangleGetFlagsMethodInfo VideoOverlayRectangle signature where+    overloadedMethod _ = videoOverlayRectangleGetFlags++-- method VideoOverlayRectangle::get_global_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TFloat+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_get_global_alpha" gst_video_overlay_rectangle_get_global_alpha :: +    Ptr VideoOverlayRectangle ->            -- _obj : TInterface "GstVideo" "VideoOverlayRectangle"+    IO CFloat+++videoOverlayRectangleGetGlobalAlpha ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- _obj+    -> m Float                              -- result+videoOverlayRectangleGetGlobalAlpha _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_overlay_rectangle_get_global_alpha _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++data VideoOverlayRectangleGetGlobalAlphaMethodInfo+instance (signature ~ (m Float), MonadIO m) => MethodInfo VideoOverlayRectangleGetGlobalAlphaMethodInfo VideoOverlayRectangle signature where+    overloadedMethod _ = videoOverlayRectangleGetGlobalAlpha++-- method VideoOverlayRectangle::get_pixels_argb+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "GstVideo" "VideoOverlayFormatFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_get_pixels_argb" gst_video_overlay_rectangle_get_pixels_argb :: +    Ptr VideoOverlayRectangle ->            -- _obj : TInterface "GstVideo" "VideoOverlayRectangle"+    CUInt ->                                -- flags : TInterface "GstVideo" "VideoOverlayFormatFlags"+    IO (Ptr Gst.Buffer)+++videoOverlayRectangleGetPixelsArgb ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- _obj+    -> VideoOverlayFormatFlags              -- flags+    -> m Gst.Buffer                         -- result+videoOverlayRectangleGetPixelsArgb _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let flags' = (fromIntegral . fromEnum) flags+    result <- gst_video_overlay_rectangle_get_pixels_argb _obj' flags'+    checkUnexpectedReturnNULL "gst_video_overlay_rectangle_get_pixels_argb" result+    result' <- (newBoxed Gst.Buffer) result+    touchManagedPtr _obj+    return result'++data VideoOverlayRectangleGetPixelsArgbMethodInfo+instance (signature ~ (VideoOverlayFormatFlags -> m Gst.Buffer), MonadIO m) => MethodInfo VideoOverlayRectangleGetPixelsArgbMethodInfo VideoOverlayRectangle signature where+    overloadedMethod _ = videoOverlayRectangleGetPixelsArgb++-- method VideoOverlayRectangle::get_pixels_ayuv+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "GstVideo" "VideoOverlayFormatFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_get_pixels_ayuv" gst_video_overlay_rectangle_get_pixels_ayuv :: +    Ptr VideoOverlayRectangle ->            -- _obj : TInterface "GstVideo" "VideoOverlayRectangle"+    CUInt ->                                -- flags : TInterface "GstVideo" "VideoOverlayFormatFlags"+    IO (Ptr Gst.Buffer)+++videoOverlayRectangleGetPixelsAyuv ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- _obj+    -> VideoOverlayFormatFlags              -- flags+    -> m Gst.Buffer                         -- result+videoOverlayRectangleGetPixelsAyuv _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let flags' = (fromIntegral . fromEnum) flags+    result <- gst_video_overlay_rectangle_get_pixels_ayuv _obj' flags'+    checkUnexpectedReturnNULL "gst_video_overlay_rectangle_get_pixels_ayuv" result+    result' <- (newBoxed Gst.Buffer) result+    touchManagedPtr _obj+    return result'++data VideoOverlayRectangleGetPixelsAyuvMethodInfo+instance (signature ~ (VideoOverlayFormatFlags -> m Gst.Buffer), MonadIO m) => MethodInfo VideoOverlayRectangleGetPixelsAyuvMethodInfo VideoOverlayRectangle signature where+    overloadedMethod _ = videoOverlayRectangleGetPixelsAyuv++-- method VideoOverlayRectangle::get_pixels_raw+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "GstVideo" "VideoOverlayFormatFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_get_pixels_raw" gst_video_overlay_rectangle_get_pixels_raw :: +    Ptr VideoOverlayRectangle ->            -- _obj : TInterface "GstVideo" "VideoOverlayRectangle"+    CUInt ->                                -- flags : TInterface "GstVideo" "VideoOverlayFormatFlags"+    IO (Ptr Gst.Buffer)+++videoOverlayRectangleGetPixelsRaw ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- _obj+    -> VideoOverlayFormatFlags              -- flags+    -> m Gst.Buffer                         -- result+videoOverlayRectangleGetPixelsRaw _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let flags' = (fromIntegral . fromEnum) flags+    result <- gst_video_overlay_rectangle_get_pixels_raw _obj' flags'+    checkUnexpectedReturnNULL "gst_video_overlay_rectangle_get_pixels_raw" result+    result' <- (newBoxed Gst.Buffer) result+    touchManagedPtr _obj+    return result'++data VideoOverlayRectangleGetPixelsRawMethodInfo+instance (signature ~ (VideoOverlayFormatFlags -> m Gst.Buffer), MonadIO m) => MethodInfo VideoOverlayRectangleGetPixelsRawMethodInfo VideoOverlayRectangle signature where+    overloadedMethod _ = videoOverlayRectangleGetPixelsRaw++-- method VideoOverlayRectangle::get_pixels_unscaled_argb+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "GstVideo" "VideoOverlayFormatFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_get_pixels_unscaled_argb" gst_video_overlay_rectangle_get_pixels_unscaled_argb :: +    Ptr VideoOverlayRectangle ->            -- _obj : TInterface "GstVideo" "VideoOverlayRectangle"+    CUInt ->                                -- flags : TInterface "GstVideo" "VideoOverlayFormatFlags"+    IO (Ptr Gst.Buffer)+++videoOverlayRectangleGetPixelsUnscaledArgb ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- _obj+    -> VideoOverlayFormatFlags              -- flags+    -> m Gst.Buffer                         -- result+videoOverlayRectangleGetPixelsUnscaledArgb _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let flags' = (fromIntegral . fromEnum) flags+    result <- gst_video_overlay_rectangle_get_pixels_unscaled_argb _obj' flags'+    checkUnexpectedReturnNULL "gst_video_overlay_rectangle_get_pixels_unscaled_argb" result+    result' <- (newBoxed Gst.Buffer) result+    touchManagedPtr _obj+    return result'++data VideoOverlayRectangleGetPixelsUnscaledArgbMethodInfo+instance (signature ~ (VideoOverlayFormatFlags -> m Gst.Buffer), MonadIO m) => MethodInfo VideoOverlayRectangleGetPixelsUnscaledArgbMethodInfo VideoOverlayRectangle signature where+    overloadedMethod _ = videoOverlayRectangleGetPixelsUnscaledArgb++-- method VideoOverlayRectangle::get_pixels_unscaled_ayuv+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "GstVideo" "VideoOverlayFormatFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_get_pixels_unscaled_ayuv" gst_video_overlay_rectangle_get_pixels_unscaled_ayuv :: +    Ptr VideoOverlayRectangle ->            -- _obj : TInterface "GstVideo" "VideoOverlayRectangle"+    CUInt ->                                -- flags : TInterface "GstVideo" "VideoOverlayFormatFlags"+    IO (Ptr Gst.Buffer)+++videoOverlayRectangleGetPixelsUnscaledAyuv ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- _obj+    -> VideoOverlayFormatFlags              -- flags+    -> m Gst.Buffer                         -- result+videoOverlayRectangleGetPixelsUnscaledAyuv _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let flags' = (fromIntegral . fromEnum) flags+    result <- gst_video_overlay_rectangle_get_pixels_unscaled_ayuv _obj' flags'+    checkUnexpectedReturnNULL "gst_video_overlay_rectangle_get_pixels_unscaled_ayuv" result+    result' <- (newBoxed Gst.Buffer) result+    touchManagedPtr _obj+    return result'++data VideoOverlayRectangleGetPixelsUnscaledAyuvMethodInfo+instance (signature ~ (VideoOverlayFormatFlags -> m Gst.Buffer), MonadIO m) => MethodInfo VideoOverlayRectangleGetPixelsUnscaledAyuvMethodInfo VideoOverlayRectangle signature where+    overloadedMethod _ = videoOverlayRectangleGetPixelsUnscaledAyuv++-- method VideoOverlayRectangle::get_pixels_unscaled_raw+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "GstVideo" "VideoOverlayFormatFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_get_pixels_unscaled_raw" gst_video_overlay_rectangle_get_pixels_unscaled_raw :: +    Ptr VideoOverlayRectangle ->            -- _obj : TInterface "GstVideo" "VideoOverlayRectangle"+    CUInt ->                                -- flags : TInterface "GstVideo" "VideoOverlayFormatFlags"+    IO (Ptr Gst.Buffer)+++videoOverlayRectangleGetPixelsUnscaledRaw ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- _obj+    -> VideoOverlayFormatFlags              -- flags+    -> m Gst.Buffer                         -- result+videoOverlayRectangleGetPixelsUnscaledRaw _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let flags' = (fromIntegral . fromEnum) flags+    result <- gst_video_overlay_rectangle_get_pixels_unscaled_raw _obj' flags'+    checkUnexpectedReturnNULL "gst_video_overlay_rectangle_get_pixels_unscaled_raw" result+    result' <- (newBoxed Gst.Buffer) result+    touchManagedPtr _obj+    return result'++data VideoOverlayRectangleGetPixelsUnscaledRawMethodInfo+instance (signature ~ (VideoOverlayFormatFlags -> m Gst.Buffer), MonadIO m) => MethodInfo VideoOverlayRectangleGetPixelsUnscaledRawMethodInfo VideoOverlayRectangle signature where+    overloadedMethod _ = videoOverlayRectangleGetPixelsUnscaledRaw++-- method VideoOverlayRectangle::get_render_rectangle+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_x", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "render_y", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "render_width", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "render_height", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_get_render_rectangle" gst_video_overlay_rectangle_get_render_rectangle :: +    Ptr VideoOverlayRectangle ->            -- _obj : TInterface "GstVideo" "VideoOverlayRectangle"+    Ptr Int32 ->                            -- render_x : TBasicType TInt32+    Ptr Int32 ->                            -- render_y : TBasicType TInt32+    Ptr Word32 ->                           -- render_width : TBasicType TUInt32+    Ptr Word32 ->                           -- render_height : TBasicType TUInt32+    IO CInt+++videoOverlayRectangleGetRenderRectangle ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- _obj+    -> m (Bool,Int32,Int32,Word32,Word32)   -- result+videoOverlayRectangleGetRenderRectangle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    renderX <- allocMem :: IO (Ptr Int32)+    renderY <- allocMem :: IO (Ptr Int32)+    renderWidth <- allocMem :: IO (Ptr Word32)+    renderHeight <- allocMem :: IO (Ptr Word32)+    result <- gst_video_overlay_rectangle_get_render_rectangle _obj' renderX renderY renderWidth renderHeight+    let result' = (/= 0) result+    renderX' <- peek renderX+    renderY' <- peek renderY+    renderWidth' <- peek renderWidth+    renderHeight' <- peek renderHeight+    touchManagedPtr _obj+    freeMem renderX+    freeMem renderY+    freeMem renderWidth+    freeMem renderHeight+    return (result', renderX', renderY', renderWidth', renderHeight')++data VideoOverlayRectangleGetRenderRectangleMethodInfo+instance (signature ~ (m (Bool,Int32,Int32,Word32,Word32)), MonadIO m) => MethodInfo VideoOverlayRectangleGetRenderRectangleMethodInfo VideoOverlayRectangle signature where+    overloadedMethod _ = videoOverlayRectangleGetRenderRectangle++-- method VideoOverlayRectangle::get_seqnum+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_get_seqnum" gst_video_overlay_rectangle_get_seqnum :: +    Ptr VideoOverlayRectangle ->            -- _obj : TInterface "GstVideo" "VideoOverlayRectangle"+    IO Word32+++videoOverlayRectangleGetSeqnum ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- _obj+    -> m Word32                             -- result+videoOverlayRectangleGetSeqnum _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_overlay_rectangle_get_seqnum _obj'+    touchManagedPtr _obj+    return result++data VideoOverlayRectangleGetSeqnumMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo VideoOverlayRectangleGetSeqnumMethodInfo VideoOverlayRectangle signature where+    overloadedMethod _ = videoOverlayRectangleGetSeqnum++-- method VideoOverlayRectangle::set_global_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "global_alpha", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_set_global_alpha" gst_video_overlay_rectangle_set_global_alpha :: +    Ptr VideoOverlayRectangle ->            -- _obj : TInterface "GstVideo" "VideoOverlayRectangle"+    CFloat ->                               -- global_alpha : TBasicType TFloat+    IO ()+++videoOverlayRectangleSetGlobalAlpha ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- _obj+    -> Float                                -- globalAlpha+    -> m ()                                 -- result+videoOverlayRectangleSetGlobalAlpha _obj globalAlpha = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let globalAlpha' = realToFrac globalAlpha+    gst_video_overlay_rectangle_set_global_alpha _obj' globalAlpha'+    touchManagedPtr _obj+    return ()++data VideoOverlayRectangleSetGlobalAlphaMethodInfo+instance (signature ~ (Float -> m ()), MonadIO m) => MethodInfo VideoOverlayRectangleSetGlobalAlphaMethodInfo VideoOverlayRectangle signature where+    overloadedMethod _ = videoOverlayRectangleSetGlobalAlpha++-- method VideoOverlayRectangle::set_render_rectangle+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoOverlayRectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_height", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_overlay_rectangle_set_render_rectangle" gst_video_overlay_rectangle_set_render_rectangle :: +    Ptr VideoOverlayRectangle ->            -- _obj : TInterface "GstVideo" "VideoOverlayRectangle"+    Int32 ->                                -- render_x : TBasicType TInt32+    Int32 ->                                -- render_y : TBasicType TInt32+    Word32 ->                               -- render_width : TBasicType TUInt32+    Word32 ->                               -- render_height : TBasicType TUInt32+    IO ()+++videoOverlayRectangleSetRenderRectangle ::+    (MonadIO m) =>+    VideoOverlayRectangle                   -- _obj+    -> Int32                                -- renderX+    -> Int32                                -- renderY+    -> Word32                               -- renderWidth+    -> Word32                               -- renderHeight+    -> m ()                                 -- result+videoOverlayRectangleSetRenderRectangle _obj renderX renderY renderWidth renderHeight = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_overlay_rectangle_set_render_rectangle _obj' renderX renderY renderWidth renderHeight+    touchManagedPtr _obj+    return ()++data VideoOverlayRectangleSetRenderRectangleMethodInfo+instance (signature ~ (Int32 -> Int32 -> Word32 -> Word32 -> m ()), MonadIO m) => MethodInfo VideoOverlayRectangleSetRenderRectangleMethodInfo VideoOverlayRectangle signature where+    overloadedMethod _ = videoOverlayRectangleSetRenderRectangle++type family ResolveVideoOverlayRectangleMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoOverlayRectangleMethod "copy" o = VideoOverlayRectangleCopyMethodInfo+    ResolveVideoOverlayRectangleMethod "getFlags" o = VideoOverlayRectangleGetFlagsMethodInfo+    ResolveVideoOverlayRectangleMethod "getGlobalAlpha" o = VideoOverlayRectangleGetGlobalAlphaMethodInfo+    ResolveVideoOverlayRectangleMethod "getPixelsArgb" o = VideoOverlayRectangleGetPixelsArgbMethodInfo+    ResolveVideoOverlayRectangleMethod "getPixelsAyuv" o = VideoOverlayRectangleGetPixelsAyuvMethodInfo+    ResolveVideoOverlayRectangleMethod "getPixelsRaw" o = VideoOverlayRectangleGetPixelsRawMethodInfo+    ResolveVideoOverlayRectangleMethod "getPixelsUnscaledArgb" o = VideoOverlayRectangleGetPixelsUnscaledArgbMethodInfo+    ResolveVideoOverlayRectangleMethod "getPixelsUnscaledAyuv" o = VideoOverlayRectangleGetPixelsUnscaledAyuvMethodInfo+    ResolveVideoOverlayRectangleMethod "getPixelsUnscaledRaw" o = VideoOverlayRectangleGetPixelsUnscaledRawMethodInfo+    ResolveVideoOverlayRectangleMethod "getRenderRectangle" o = VideoOverlayRectangleGetRenderRectangleMethodInfo+    ResolveVideoOverlayRectangleMethod "getSeqnum" o = VideoOverlayRectangleGetSeqnumMethodInfo+    ResolveVideoOverlayRectangleMethod "setGlobalAlpha" o = VideoOverlayRectangleSetGlobalAlphaMethodInfo+    ResolveVideoOverlayRectangleMethod "setRenderRectangle" o = VideoOverlayRectangleSetRenderRectangleMethodInfo+    ResolveVideoOverlayRectangleMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoOverlayRectangleMethod t VideoOverlayRectangle, MethodInfo info VideoOverlayRectangle p) => IsLabelProxy t (VideoOverlayRectangle -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoOverlayRectangleMethod t VideoOverlayRectangle, MethodInfo info VideoOverlayRectangle p) => IsLabel t (VideoOverlayRectangle -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoOverlayRectangle.hs-boot view
@@ -0,0 +1,24 @@+module GI.GstVideo.Structs.VideoOverlayRectangle where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoOverlayRectangle = VideoOverlayRectangle (ForeignPtr VideoOverlayRectangle)+instance BoxedObject VideoOverlayRectangle where+data VideoOverlayRectangleCopyMethodInfo+data VideoOverlayRectangleGetFlagsMethodInfo+data VideoOverlayRectangleGetGlobalAlphaMethodInfo+data VideoOverlayRectangleGetPixelsArgbMethodInfo+data VideoOverlayRectangleGetPixelsAyuvMethodInfo+data VideoOverlayRectangleGetPixelsRawMethodInfo+data VideoOverlayRectangleGetPixelsUnscaledArgbMethodInfo+data VideoOverlayRectangleGetPixelsUnscaledAyuvMethodInfo+data VideoOverlayRectangleGetPixelsUnscaledRawMethodInfo+data VideoOverlayRectangleGetRenderRectangleMethodInfo+data VideoOverlayRectangleGetSeqnumMethodInfo+data VideoOverlayRectangleSetGlobalAlphaMethodInfo+data VideoOverlayRectangleSetRenderRectangleMethodInfo
+ GI/GstVideo/Structs/VideoRectangle.hs view
@@ -0,0 +1,90 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Helper structure representing a rectangular area.+-}++module GI.GstVideo.Structs.VideoRectangle+    ( ++-- * Exported types+    VideoRectangle(..)                      ,+    newZeroVideoRectangle                   ,+    noVideoRectangle                        ,+++ -- * Properties+-- ** H+    videoRectangleReadH                     ,+++-- ** W+    videoRectangleReadW                     ,+++-- ** X+    videoRectangleReadX                     ,+++-- ** Y+    videoRectangleReadY                     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++newtype VideoRectangle = VideoRectangle (ForeignPtr VideoRectangle)+-- | Construct a `VideoRectangle` struct initialized to zero.+newZeroVideoRectangle :: MonadIO m => m VideoRectangle+newZeroVideoRectangle = liftIO $ callocBytes 16 >>= wrapPtr VideoRectangle++noVideoRectangle :: Maybe VideoRectangle+noVideoRectangle = Nothing++videoRectangleReadX :: VideoRectangle -> IO Int32+videoRectangleReadX s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Int32+    return val++videoRectangleReadY :: VideoRectangle -> IO Int32+videoRectangleReadY s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 4) :: IO Int32+    return val++videoRectangleReadW :: VideoRectangle -> IO Int32+videoRectangleReadW s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO Int32+    return val++videoRectangleReadH :: VideoRectangle -> IO Int32+videoRectangleReadH s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 12) :: IO Int32+    return val++type family ResolveVideoRectangleMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoRectangleMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoRectangleMethod t VideoRectangle, MethodInfo info VideoRectangle p) => IsLabelProxy t (VideoRectangle -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoRectangleMethod t VideoRectangle, MethodInfo info VideoRectangle p) => IsLabel t (VideoRectangle -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoRectangle.hs-boot view
@@ -0,0 +1,10 @@+module GI.GstVideo.Structs.VideoRectangle where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoRectangle = VideoRectangle (ForeignPtr VideoRectangle)
+ GI/GstVideo/Structs/VideoRegionOfInterestMeta.hs view
@@ -0,0 +1,156 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Extra buffer metadata describing an image region of interest+-}++module GI.GstVideo.Structs.VideoRegionOfInterestMeta+    ( ++-- * Exported types+    VideoRegionOfInterestMeta(..)           ,+    newZeroVideoRegionOfInterestMeta        ,+    noVideoRegionOfInterestMeta             ,+++ -- * Methods+-- ** videoRegionOfInterestMetaGetInfo+    videoRegionOfInterestMetaGetInfo        ,+++++ -- * Properties+-- ** H+    videoRegionOfInterestMetaReadH          ,+++-- ** Id+    videoRegionOfInterestMetaReadId         ,+++-- ** Meta+    videoRegionOfInterestMetaReadMeta       ,+++-- ** ParentId+    videoRegionOfInterestMetaReadParentId   ,+++-- ** RoiType+    videoRegionOfInterestMetaReadRoiType    ,+++-- ** W+    videoRegionOfInterestMetaReadW          ,+++-- ** X+    videoRegionOfInterestMetaReadX          ,+++-- ** Y+    videoRegionOfInterestMetaReadY          ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.Gst as Gst++newtype VideoRegionOfInterestMeta = VideoRegionOfInterestMeta (ForeignPtr VideoRegionOfInterestMeta)+-- | Construct a `VideoRegionOfInterestMeta` struct initialized to zero.+newZeroVideoRegionOfInterestMeta :: MonadIO m => m VideoRegionOfInterestMeta+newZeroVideoRegionOfInterestMeta = liftIO $ callocBytes 48 >>= wrapPtr VideoRegionOfInterestMeta++noVideoRegionOfInterestMeta :: Maybe VideoRegionOfInterestMeta+noVideoRegionOfInterestMeta = Nothing++videoRegionOfInterestMetaReadMeta :: VideoRegionOfInterestMeta -> IO Gst.Meta+videoRegionOfInterestMetaReadMeta s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Gst.Meta)+    val' <- (newPtr 16 Gst.Meta) val+    return val'++videoRegionOfInterestMetaReadRoiType :: VideoRegionOfInterestMeta -> IO Word32+videoRegionOfInterestMetaReadRoiType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO Word32+    return val++videoRegionOfInterestMetaReadId :: VideoRegionOfInterestMeta -> IO Int32+videoRegionOfInterestMetaReadId s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 20) :: IO Int32+    return val++videoRegionOfInterestMetaReadParentId :: VideoRegionOfInterestMeta -> IO Int32+videoRegionOfInterestMetaReadParentId s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO Int32+    return val++videoRegionOfInterestMetaReadX :: VideoRegionOfInterestMeta -> IO Word32+videoRegionOfInterestMetaReadX s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 28) :: IO Word32+    return val++videoRegionOfInterestMetaReadY :: VideoRegionOfInterestMeta -> IO Word32+videoRegionOfInterestMetaReadY s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO Word32+    return val++videoRegionOfInterestMetaReadW :: VideoRegionOfInterestMeta -> IO Word32+videoRegionOfInterestMetaReadW s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 36) :: IO Word32+    return val++videoRegionOfInterestMetaReadH :: VideoRegionOfInterestMeta -> IO Word32+videoRegionOfInterestMetaReadH s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 40) :: IO Word32+    return val++-- method VideoRegionOfInterestMeta::get_info+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "MetaInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_region_of_interest_meta_get_info" gst_video_region_of_interest_meta_get_info :: +    IO (Ptr Gst.MetaInfo)+++videoRegionOfInterestMetaGetInfo ::+    (MonadIO m) =>+    m Gst.MetaInfo                          -- result+videoRegionOfInterestMetaGetInfo  = liftIO $ do+    result <- gst_video_region_of_interest_meta_get_info+    checkUnexpectedReturnNULL "gst_video_region_of_interest_meta_get_info" result+    result' <- (newPtr 80 Gst.MetaInfo) result+    return result'++type family ResolveVideoRegionOfInterestMetaMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoRegionOfInterestMetaMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoRegionOfInterestMetaMethod t VideoRegionOfInterestMeta, MethodInfo info VideoRegionOfInterestMeta p) => IsLabelProxy t (VideoRegionOfInterestMeta -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoRegionOfInterestMetaMethod t VideoRegionOfInterestMeta, MethodInfo info VideoRegionOfInterestMeta p) => IsLabel t (VideoRegionOfInterestMeta -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoRegionOfInterestMeta.hs-boot view
@@ -0,0 +1,10 @@+module GI.GstVideo.Structs.VideoRegionOfInterestMeta where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoRegionOfInterestMeta = VideoRegionOfInterestMeta (ForeignPtr VideoRegionOfInterestMeta)
+ GI/GstVideo/Structs/VideoResampler.hs view
@@ -0,0 +1,220 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++#GstVideoResampler is a structure which holds the information+required to perform various kinds of resampling filtering.+-}++module GI.GstVideo.Structs.VideoResampler+    ( ++-- * Exported types+    VideoResampler(..)                      ,+    newZeroVideoResampler                   ,+    noVideoResampler                        ,+++ -- * Methods+-- ** videoResamplerClear+    VideoResamplerClearMethodInfo           ,+    videoResamplerClear                     ,+++-- ** videoResamplerInit+    VideoResamplerInitMethodInfo            ,+    videoResamplerInit                      ,+++++ -- * Properties+-- ** InSize+    videoResamplerReadInSize                ,+++-- ** MaxTaps+    videoResamplerReadMaxTaps               ,+++-- ** NPhases+    videoResamplerReadNPhases               ,+++-- ** NTaps+    videoResamplerReadNTaps                 ,+++-- ** Offset+    videoResamplerReadOffset                ,+++-- ** OutSize+    videoResamplerReadOutSize               ,+++-- ** Phase+    videoResamplerReadPhase                 ,+++-- ** Taps+    videoResamplerReadTaps                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks+import qualified GI.Gst as Gst++newtype VideoResampler = VideoResampler (ForeignPtr VideoResampler)+-- | Construct a `VideoResampler` struct initialized to zero.+newZeroVideoResampler :: MonadIO m => m VideoResampler+newZeroVideoResampler = liftIO $ callocBytes 80 >>= wrapPtr VideoResampler++noVideoResampler :: Maybe VideoResampler+noVideoResampler = Nothing++videoResamplerReadInSize :: VideoResampler -> IO Int32+videoResamplerReadInSize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Int32+    return val++videoResamplerReadOutSize :: VideoResampler -> IO Int32+videoResamplerReadOutSize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 4) :: IO Int32+    return val++videoResamplerReadMaxTaps :: VideoResampler -> IO Word32+videoResamplerReadMaxTaps s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO Word32+    return val++videoResamplerReadNPhases :: VideoResampler -> IO Word32+videoResamplerReadNPhases s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 12) :: IO Word32+    return val++videoResamplerReadOffset :: VideoResampler -> IO Word32+videoResamplerReadOffset s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO Word32+    return val++videoResamplerReadPhase :: VideoResampler -> IO Word32+videoResamplerReadPhase s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO Word32+    return val++videoResamplerReadNTaps :: VideoResampler -> IO Word32+videoResamplerReadNTaps s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO Word32+    return val++videoResamplerReadTaps :: VideoResampler -> IO Double+videoResamplerReadTaps s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 40) :: IO CDouble+    let val' = realToFrac val+    return val'++-- method VideoResampler::clear+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoResampler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_resampler_clear" gst_video_resampler_clear :: +    Ptr VideoResampler ->                   -- _obj : TInterface "GstVideo" "VideoResampler"+    IO ()+++videoResamplerClear ::+    (MonadIO m) =>+    VideoResampler                          -- _obj+    -> m ()                                 -- result+videoResamplerClear _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_resampler_clear _obj'+    touchManagedPtr _obj+    return ()++data VideoResamplerClearMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoResamplerClearMethodInfo VideoResampler signature where+    overloadedMethod _ = videoResamplerClear++-- method VideoResampler::init+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoResampler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "method", argType = TInterface "GstVideo" "VideoResamplerMethod", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "GstVideo" "VideoResamplerFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_phases", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_taps", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shift", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "in_size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_resampler_init" gst_video_resampler_init :: +    Ptr VideoResampler ->                   -- _obj : TInterface "GstVideo" "VideoResampler"+    CUInt ->                                -- method : TInterface "GstVideo" "VideoResamplerMethod"+    CUInt ->                                -- flags : TInterface "GstVideo" "VideoResamplerFlags"+    Word32 ->                               -- n_phases : TBasicType TUInt32+    Word32 ->                               -- n_taps : TBasicType TUInt32+    CDouble ->                              -- shift : TBasicType TDouble+    Word32 ->                               -- in_size : TBasicType TUInt32+    Word32 ->                               -- out_size : TBasicType TUInt32+    Ptr Gst.Structure ->                    -- options : TInterface "Gst" "Structure"+    IO CInt+++videoResamplerInit ::+    (MonadIO m) =>+    VideoResampler                          -- _obj+    -> VideoResamplerMethod                 -- method+    -> VideoResamplerFlags                  -- flags+    -> Word32                               -- nPhases+    -> Word32                               -- nTaps+    -> Double                               -- shift+    -> Word32                               -- inSize+    -> Word32                               -- outSize+    -> Gst.Structure                        -- options+    -> m Bool                               -- result+videoResamplerInit _obj method flags nPhases nTaps shift inSize outSize options = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let method' = (fromIntegral . fromEnum) method+    let flags' = (fromIntegral . fromEnum) flags+    let shift' = realToFrac shift+    let options' = unsafeManagedPtrGetPtr options+    result <- gst_video_resampler_init _obj' method' flags' nPhases nTaps shift' inSize outSize options'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr options+    return result'++data VideoResamplerInitMethodInfo+instance (signature ~ (VideoResamplerMethod -> VideoResamplerFlags -> Word32 -> Word32 -> Double -> Word32 -> Word32 -> Gst.Structure -> m Bool), MonadIO m) => MethodInfo VideoResamplerInitMethodInfo VideoResampler signature where+    overloadedMethod _ = videoResamplerInit++type family ResolveVideoResamplerMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoResamplerMethod "clear" o = VideoResamplerClearMethodInfo+    ResolveVideoResamplerMethod "init" o = VideoResamplerInitMethodInfo+    ResolveVideoResamplerMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoResamplerMethod t VideoResampler, MethodInfo info VideoResampler p) => IsLabelProxy t (VideoResampler -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoResamplerMethod t VideoResampler, MethodInfo info VideoResampler p) => IsLabel t (VideoResampler -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoResampler.hs-boot view
@@ -0,0 +1,12 @@+module GI.GstVideo.Structs.VideoResampler where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoResampler = VideoResampler (ForeignPtr VideoResampler)+data VideoResamplerClearMethodInfo+data VideoResamplerInitMethodInfo
+ GI/GstVideo/Structs/VideoScaler.hs view
@@ -0,0 +1,300 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++#GstVideoScaler is a utility object for rescaling and resampling+video frames using various interpolation / sampling methods.+-}++module GI.GstVideo.Structs.VideoScaler+    ( ++-- * Exported types+    VideoScaler(..)                         ,+    noVideoScaler                           ,+++ -- * Methods+-- ** videoScaler2d+    VideoScaler2dMethodInfo                 ,+    videoScaler2d                           ,+++-- ** videoScalerFree+    VideoScalerFreeMethodInfo               ,+    videoScalerFree                         ,+++-- ** videoScalerGetCoeff+    VideoScalerGetCoeffMethodInfo           ,+    videoScalerGetCoeff                     ,+++-- ** videoScalerGetMaxTaps+    VideoScalerGetMaxTapsMethodInfo         ,+    videoScalerGetMaxTaps                   ,+++-- ** videoScalerHorizontal+    VideoScalerHorizontalMethodInfo         ,+    videoScalerHorizontal                   ,+++-- ** videoScalerVertical+    VideoScalerVerticalMethodInfo           ,+    videoScalerVertical                     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.GstVideo.Types+import GI.GstVideo.Callbacks++newtype VideoScaler = VideoScaler (ForeignPtr VideoScaler)+noVideoScaler :: Maybe VideoScaler+noVideoScaler = Nothing++-- method VideoScaler::2d+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoScaler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vscale", argType = TInterface "GstVideo" "VideoScaler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "GstVideo" "VideoFormat", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_stride", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_stride", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_scaler_2d" gst_video_scaler_2d :: +    Ptr VideoScaler ->                      -- _obj : TInterface "GstVideo" "VideoScaler"+    Ptr VideoScaler ->                      -- vscale : TInterface "GstVideo" "VideoScaler"+    CUInt ->                                -- format : TInterface "GstVideo" "VideoFormat"+    Ptr () ->                               -- src : TBasicType TVoid+    Int32 ->                                -- src_stride : TBasicType TInt32+    Ptr () ->                               -- dest : TBasicType TVoid+    Int32 ->                                -- dest_stride : TBasicType TInt32+    Word32 ->                               -- x : TBasicType TUInt32+    Word32 ->                               -- y : TBasicType TUInt32+    Word32 ->                               -- width : TBasicType TUInt32+    Word32 ->                               -- height : TBasicType TUInt32+    IO ()+++videoScaler2d ::+    (MonadIO m) =>+    VideoScaler                             -- _obj+    -> VideoScaler                          -- vscale+    -> VideoFormat                          -- format+    -> Ptr ()                               -- src+    -> Int32                                -- srcStride+    -> Ptr ()                               -- dest+    -> Int32                                -- destStride+    -> Word32                               -- x+    -> Word32                               -- y+    -> Word32                               -- width+    -> Word32                               -- height+    -> m ()                                 -- result+videoScaler2d _obj vscale format src srcStride dest destStride x y width height = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let vscale' = unsafeManagedPtrGetPtr vscale+    let format' = (fromIntegral . fromEnum) format+    gst_video_scaler_2d _obj' vscale' format' src srcStride dest destStride x y width height+    touchManagedPtr _obj+    touchManagedPtr vscale+    return ()++data VideoScaler2dMethodInfo+instance (signature ~ (VideoScaler -> VideoFormat -> Ptr () -> Int32 -> Ptr () -> Int32 -> Word32 -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m) => MethodInfo VideoScaler2dMethodInfo VideoScaler signature where+    overloadedMethod _ = videoScaler2d++-- method VideoScaler::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoScaler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_scaler_free" gst_video_scaler_free :: +    Ptr VideoScaler ->                      -- _obj : TInterface "GstVideo" "VideoScaler"+    IO ()+++videoScalerFree ::+    (MonadIO m) =>+    VideoScaler                             -- _obj+    -> m ()                                 -- result+videoScalerFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_video_scaler_free _obj'+    touchManagedPtr _obj+    return ()++data VideoScalerFreeMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo VideoScalerFreeMethodInfo VideoScaler signature where+    overloadedMethod _ = videoScalerFree++-- method VideoScaler::get_coeff+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoScaler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_offset", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "in_offset", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_taps", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_scaler_get_coeff" gst_video_scaler_get_coeff :: +    Ptr VideoScaler ->                      -- _obj : TInterface "GstVideo" "VideoScaler"+    Word32 ->                               -- out_offset : TBasicType TUInt32+    Word32 ->                               -- in_offset : TBasicType TUInt32+    Word32 ->                               -- n_taps : TBasicType TUInt32+    IO CDouble+++videoScalerGetCoeff ::+    (MonadIO m) =>+    VideoScaler                             -- _obj+    -> Word32                               -- outOffset+    -> Word32                               -- inOffset+    -> Word32                               -- nTaps+    -> m Double                             -- result+videoScalerGetCoeff _obj outOffset inOffset nTaps = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_scaler_get_coeff _obj' outOffset inOffset nTaps+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++data VideoScalerGetCoeffMethodInfo+instance (signature ~ (Word32 -> Word32 -> Word32 -> m Double), MonadIO m) => MethodInfo VideoScalerGetCoeffMethodInfo VideoScaler signature where+    overloadedMethod _ = videoScalerGetCoeff++-- method VideoScaler::get_max_taps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoScaler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_scaler_get_max_taps" gst_video_scaler_get_max_taps :: +    Ptr VideoScaler ->                      -- _obj : TInterface "GstVideo" "VideoScaler"+    IO Word32+++videoScalerGetMaxTaps ::+    (MonadIO m) =>+    VideoScaler                             -- _obj+    -> m Word32                             -- result+videoScalerGetMaxTaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_video_scaler_get_max_taps _obj'+    touchManagedPtr _obj+    return result++data VideoScalerGetMaxTapsMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo VideoScalerGetMaxTapsMethodInfo VideoScaler signature where+    overloadedMethod _ = videoScalerGetMaxTaps++-- method VideoScaler::horizontal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoScaler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "GstVideo" "VideoFormat", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_offset", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_scaler_horizontal" gst_video_scaler_horizontal :: +    Ptr VideoScaler ->                      -- _obj : TInterface "GstVideo" "VideoScaler"+    CUInt ->                                -- format : TInterface "GstVideo" "VideoFormat"+    Ptr () ->                               -- src : TBasicType TVoid+    Ptr () ->                               -- dest : TBasicType TVoid+    Word32 ->                               -- dest_offset : TBasicType TUInt32+    Word32 ->                               -- width : TBasicType TUInt32+    IO ()+++videoScalerHorizontal ::+    (MonadIO m) =>+    VideoScaler                             -- _obj+    -> VideoFormat                          -- format+    -> Ptr ()                               -- src+    -> Ptr ()                               -- dest+    -> Word32                               -- destOffset+    -> Word32                               -- width+    -> m ()                                 -- result+videoScalerHorizontal _obj format src dest destOffset width = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    gst_video_scaler_horizontal _obj' format' src dest destOffset width+    touchManagedPtr _obj+    return ()++data VideoScalerHorizontalMethodInfo+instance (signature ~ (VideoFormat -> Ptr () -> Ptr () -> Word32 -> Word32 -> m ()), MonadIO m) => MethodInfo VideoScalerHorizontalMethodInfo VideoScaler signature where+    overloadedMethod _ = videoScalerHorizontal++-- method VideoScaler::vertical+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "GstVideo" "VideoScaler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "GstVideo" "VideoFormat", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_lines", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_offset", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_video_scaler_vertical" gst_video_scaler_vertical :: +    Ptr VideoScaler ->                      -- _obj : TInterface "GstVideo" "VideoScaler"+    CUInt ->                                -- format : TInterface "GstVideo" "VideoFormat"+    Ptr () ->                               -- src_lines : TBasicType TVoid+    Ptr () ->                               -- dest : TBasicType TVoid+    Word32 ->                               -- dest_offset : TBasicType TUInt32+    Word32 ->                               -- width : TBasicType TUInt32+    IO ()+++videoScalerVertical ::+    (MonadIO m) =>+    VideoScaler                             -- _obj+    -> VideoFormat                          -- format+    -> Ptr ()                               -- srcLines+    -> Ptr ()                               -- dest+    -> Word32                               -- destOffset+    -> Word32                               -- width+    -> m ()                                 -- result+videoScalerVertical _obj format srcLines dest destOffset width = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    gst_video_scaler_vertical _obj' format' srcLines dest destOffset width+    touchManagedPtr _obj+    return ()++data VideoScalerVerticalMethodInfo+instance (signature ~ (VideoFormat -> Ptr () -> Ptr () -> Word32 -> Word32 -> m ()), MonadIO m) => MethodInfo VideoScalerVerticalMethodInfo VideoScaler signature where+    overloadedMethod _ = videoScalerVertical++type family ResolveVideoScalerMethod (t :: Symbol) (o :: *) :: * where+    ResolveVideoScalerMethod "2d" o = VideoScaler2dMethodInfo+    ResolveVideoScalerMethod "free" o = VideoScalerFreeMethodInfo+    ResolveVideoScalerMethod "horizontal" o = VideoScalerHorizontalMethodInfo+    ResolveVideoScalerMethod "vertical" o = VideoScalerVerticalMethodInfo+    ResolveVideoScalerMethod "getCoeff" o = VideoScalerGetCoeffMethodInfo+    ResolveVideoScalerMethod "getMaxTaps" o = VideoScalerGetMaxTapsMethodInfo+    ResolveVideoScalerMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveVideoScalerMethod t VideoScaler, MethodInfo info VideoScaler p) => IsLabelProxy t (VideoScaler -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveVideoScalerMethod t VideoScaler, MethodInfo info VideoScaler p) => IsLabel t (VideoScaler -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/GstVideo/Structs/VideoScaler.hs-boot view
@@ -0,0 +1,16 @@+module GI.GstVideo.Structs.VideoScaler where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VideoScaler = VideoScaler (ForeignPtr VideoScaler)+data VideoScaler2dMethodInfo+data VideoScalerFreeMethodInfo+data VideoScalerGetCoeffMethodInfo+data VideoScalerGetMaxTapsMethodInfo+data VideoScalerHorizontalMethodInfo+data VideoScalerVerticalMethodInfo
+ GI/GstVideo/Types.hs view
@@ -0,0 +1,76 @@+module GI.GstVideo.Types+    (     module GI.GstVideo.Interfaces.ColorBalance,+    module GI.GstVideo.Interfaces.Navigation,+    module GI.GstVideo.Interfaces.VideoOrientation,+    module GI.GstVideo.Interfaces.VideoOverlay,+    module GI.GstVideo.Objects.ColorBalanceChannel,+    module GI.GstVideo.Objects.VideoBufferPool,+    module GI.GstVideo.Objects.VideoDecoder ,+    module GI.GstVideo.Objects.VideoEncoder ,+    module GI.GstVideo.Objects.VideoFilter  ,+    module GI.GstVideo.Objects.VideoSink    ,+    module GI.GstVideo.Structs.VideoAlignment,+    module GI.GstVideo.Structs.VideoChromaResample,+    module GI.GstVideo.Structs.VideoCodecFrame,+    module GI.GstVideo.Structs.VideoCodecState,+    module GI.GstVideo.Structs.VideoColorPrimariesInfo,+    module GI.GstVideo.Structs.VideoColorimetry,+    module GI.GstVideo.Structs.VideoConverter,+    module GI.GstVideo.Structs.VideoCropMeta,+    module GI.GstVideo.Structs.VideoDither  ,+    module GI.GstVideo.Structs.VideoFormatInfo,+    module GI.GstVideo.Structs.VideoFrame   ,+    module GI.GstVideo.Structs.VideoGLTextureUploadMeta,+    module GI.GstVideo.Structs.VideoInfo    ,+    module GI.GstVideo.Structs.VideoMeta    ,+    module GI.GstVideo.Structs.VideoMetaTransform,+    module GI.GstVideo.Structs.VideoOverlayComposition,+    module GI.GstVideo.Structs.VideoOverlayCompositionMeta,+    module GI.GstVideo.Structs.VideoOverlayRectangle,+    module GI.GstVideo.Structs.VideoRectangle,+    module GI.GstVideo.Structs.VideoRegionOfInterestMeta,+    module GI.GstVideo.Structs.VideoResampler,+    module GI.GstVideo.Structs.VideoScaler  ,+    module GI.GstVideo.Enums                ,+    module GI.GstVideo.Flags                ,+++    ) where+++import {-# SOURCE #-} GI.GstVideo.Interfaces.ColorBalance+import {-# SOURCE #-} GI.GstVideo.Interfaces.Navigation+import {-# SOURCE #-} GI.GstVideo.Interfaces.VideoOrientation+import {-# SOURCE #-} GI.GstVideo.Interfaces.VideoOverlay+import {-# SOURCE #-} GI.GstVideo.Objects.ColorBalanceChannel+import {-# SOURCE #-} GI.GstVideo.Objects.VideoBufferPool+import {-# SOURCE #-} GI.GstVideo.Objects.VideoDecoder+import {-# SOURCE #-} GI.GstVideo.Objects.VideoEncoder+import {-# SOURCE #-} GI.GstVideo.Objects.VideoFilter+import {-# SOURCE #-} GI.GstVideo.Objects.VideoSink+import {-# SOURCE #-} GI.GstVideo.Structs.VideoAlignment+import {-# SOURCE #-} GI.GstVideo.Structs.VideoChromaResample+import {-# SOURCE #-} GI.GstVideo.Structs.VideoCodecFrame+import {-# SOURCE #-} GI.GstVideo.Structs.VideoCodecState+import {-# SOURCE #-} GI.GstVideo.Structs.VideoColorPrimariesInfo+import {-# SOURCE #-} GI.GstVideo.Structs.VideoColorimetry+import {-# SOURCE #-} GI.GstVideo.Structs.VideoConverter+import {-# SOURCE #-} GI.GstVideo.Structs.VideoCropMeta+import {-# SOURCE #-} GI.GstVideo.Structs.VideoDither+import {-# SOURCE #-} GI.GstVideo.Structs.VideoFormatInfo+import {-# SOURCE #-} GI.GstVideo.Structs.VideoFrame+import {-# SOURCE #-} GI.GstVideo.Structs.VideoGLTextureUploadMeta+import {-# SOURCE #-} GI.GstVideo.Structs.VideoInfo+import {-# SOURCE #-} GI.GstVideo.Structs.VideoMeta+import {-# SOURCE #-} GI.GstVideo.Structs.VideoMetaTransform+import {-# SOURCE #-} GI.GstVideo.Structs.VideoOverlayComposition+import {-# SOURCE #-} GI.GstVideo.Structs.VideoOverlayCompositionMeta+import {-# SOURCE #-} GI.GstVideo.Structs.VideoOverlayRectangle+import {-# SOURCE #-} GI.GstVideo.Structs.VideoRectangle+import {-# SOURCE #-} GI.GstVideo.Structs.VideoRegionOfInterestMeta+import {-# SOURCE #-} GI.GstVideo.Structs.VideoResampler+import {-# SOURCE #-} GI.GstVideo.Structs.VideoScaler++import GI.GstVideo.Enums+import GI.GstVideo.Flags+
+ LICENSE view
@@ -0,0 +1,456 @@+                  GNU LESSER GENERAL PUBLIC LICENSE+                       Version 2.1, February 1999++ Copyright (C) 1991, 1999 Free Software Foundation, Inc.+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++[This is the first released version of the Lesser GPL.  It also counts+ as the successor of the GNU Library Public License, version 2, hence+ the version number 2.1.]++                            Preamble++  The licenses for most software are designed to take away your+freedom to share and change it.  By contrast, the GNU General Public+Licenses are intended to guarantee your freedom to share and change+free software--to make sure the software is free for all its users.++  This license, the Lesser General Public License, applies to some+specially designated software packages--typically libraries--of the+Free Software Foundation and other authors who decide to use it.  You+can use it too, but we suggest you first think carefully about whether+this license or the ordinary General Public License is the better+strategy to use in any particular case, based on the explanations below.++  When we speak of free software, we are referring to freedom of use,+not price.  Our General Public Licenses are designed to make sure that+you have the freedom to distribute copies of free software (and charge+for this service if you wish); that you receive source code or can get+it if you want it; that you can change the software and use pieces of+it in new free programs; and that you are informed that you can do+these things.++  To protect your rights, we need to make restrictions that forbid+distributors to deny you these rights or to ask you to surrender these+rights.  These restrictions translate to certain responsibilities for+you if you distribute copies of the library or if you modify it.++  For example, if you distribute copies of the library, whether gratis+or for a fee, you must give the recipients all the rights that we gave+you.  You must make sure that they, too, receive or can get the source+code.  If you link other code with the library, you must provide+complete object files to the recipients, so that they can relink them+with the library after making changes to the library and recompiling+it.  And you must show them these terms so they know their rights.++  We protect your rights with a two-step method: (1) we copyright the+library, and (2) we offer you this license, which gives you legal+permission to copy, distribute and/or modify the library.++  To protect each distributor, we want to make it very clear that+there is no warranty for the free library.  Also, if the library is+modified by someone else and passed on, the recipients should know+that what they have is not the original version, so that the original+author's reputation will not be affected by problems that might be+introduced by others.++  Finally, software patents pose a constant threat to the existence of+any free program.  We wish to make sure that a company cannot+effectively restrict the users of a free program by obtaining a+restrictive license from a patent holder.  Therefore, we insist that+any patent license obtained for a version of the library must be+consistent with the full freedom of use specified in this license.++  Most GNU software, including some libraries, is covered by the+ordinary GNU General Public License.  This license, the GNU Lesser+General Public License, applies to certain designated libraries, and+is quite different from the ordinary General Public License.  We use+this license for certain libraries in order to permit linking those+libraries into non-free programs.++  When a program is linked with a library, whether statically or using+a shared library, the combination of the two is legally speaking a+combined work, a derivative of the original library.  The ordinary+General Public License therefore permits such linking only if the+entire combination fits its criteria of freedom.  The Lesser General+Public License permits more lax criteria for linking other code with+the library.++  We call this license the "Lesser" General Public License because it+does Less to protect the user's freedom than the ordinary General+Public License.  It also provides other free software developers Less+of an advantage over competing non-free programs.  These disadvantages+are the reason we use the ordinary General Public License for many+libraries.  However, the Lesser license provides advantages in certain+special circumstances.++  For example, on rare occasions, there may be a special need to+encourage the widest possible use of a certain library, so that it becomes+a de-facto standard.  To achieve this, non-free programs must be+allowed to use the library.  A more frequent case is that a free+library does the same job as widely used non-free libraries.  In this+case, there is little to gain by limiting the free library to free+software only, so we use the Lesser General Public License.++  In other cases, permission to use a particular library in non-free+programs enables a greater number of people to use a large body of+free software.  For example, permission to use the GNU C Library in+non-free programs enables many more people to use the whole GNU+operating system, as well as its variant, the GNU/Linux operating+system.++  Although the Lesser General Public License is Less protective of the+users' freedom, it does ensure that the user of a program that is+linked with the Library has the freedom and the wherewithal to run+that program using a modified version of the Library.++  The precise terms and conditions for copying, distribution and+modification follow.  Pay close attention to the difference between a+"work based on the library" and a "work that uses the library".  The+former contains code derived from the library, whereas the latter must+be combined with the library in order to run.++                  GNU LESSER GENERAL PUBLIC LICENSE+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION++  0. This License Agreement applies to any software library or other+program which contains a notice placed by the copyright holder or+other authorized party saying it may be distributed under the terms of+this Lesser General Public License (also called "this License").+Each licensee is addressed as "you".++  A "library" means a collection of software functions and/or data+prepared so as to be conveniently linked with application programs+(which use some of those functions and data) to form executables.++  The "Library", below, refers to any such software library or work+which has been distributed under these terms.  A "work based on the+Library" means either the Library or any derivative work under+copyright law: that is to say, a work containing the Library or a+portion of it, either verbatim or with modifications and/or translated+straightforwardly into another language.  (Hereinafter, translation is+included without limitation in the term "modification".)++  "Source code" for a work means the preferred form of the work for+making modifications to it.  For a library, complete source code means+all the source code for all modules it contains, plus any associated+interface definition files, plus the scripts used to control compilation+and installation of the library.++  Activities other than copying, distribution and modification are not+covered by this License; they are outside its scope.  The act of+running a program using the Library is not restricted, and output from+such a program is covered only if its contents constitute a work based+on the Library (independent of the use of the Library in a tool for+writing it).  Whether that is true depends on what the Library does+and what the program that uses the Library does.++  1. You may copy and distribute verbatim copies of the Library's+complete source code as you receive it, in any medium, provided that+you conspicuously and appropriately publish on each copy an+appropriate copyright notice and disclaimer of warranty; keep intact+all the notices that refer to this License and to the absence of any+warranty; and distribute a copy of this License along with the+Library.++  You may charge a fee for the physical act of transferring a copy,+and you may at your option offer warranty protection in exchange for a+fee.++  2. You may modify your copy or copies of the Library or any portion+of it, thus forming a work based on the Library, and copy and+distribute such modifications or work under the terms of Section 1+above, provided that you also meet all of these conditions:++    a) The modified work must itself be a software library.++    b) You must cause the files modified to carry prominent notices+    stating that you changed the files and the date of any change.++    c) You must cause the whole of the work to be licensed at no+    charge to all third parties under the terms of this License.++    d) If a facility in the modified Library refers to a function or a+    table of data to be supplied by an application program that uses+    the facility, other than as an argument passed when the facility+    is invoked, then you must make a good faith effort to ensure that,+    in the event an application does not supply such function or+    table, the facility still operates, and performs whatever part of+    its purpose remains meaningful.++    (For example, a function in a library to compute square roots has+    a purpose that is entirely well-defined independent of the+    application.  Therefore, Subsection 2d requires that any+    application-supplied function or table used by this function must+    be optional: if the application does not supply it, the square+    root function must still compute square roots.)++These requirements apply to the modified work as a whole.  If+identifiable sections of that work are not derived from the Library,+and can be reasonably considered independent and separate works in+themselves, then this License, and its terms, do not apply to those+sections when you distribute them as separate works.  But when you+distribute the same sections as part of a whole which is a work based+on the Library, the distribution of the whole must be on the terms of+this License, whose permissions for other licensees extend to the+entire whole, and thus to each and every part regardless of who wrote+it.++Thus, it is not the intent of this section to claim rights or contest+your rights to work written entirely by you; rather, the intent is to+exercise the right to control the distribution of derivative or+collective works based on the Library.++In addition, mere aggregation of another work not based on the Library+with the Library (or with a work based on the Library) on a volume of+a storage or distribution medium does not bring the other work under+the scope of this License.++  3. You may opt to apply the terms of the ordinary GNU General Public+License instead of this License to a given copy of the Library.  To do+this, you must alter all the notices that refer to this License, so+that they refer to the ordinary GNU General Public License, version 2,+instead of to this License.  (If a newer version than version 2 of the+ordinary GNU General Public License has appeared, then you can specify+that version instead if you wish.)  Do not make any other change in+these notices.++  Once this change is made in a given copy, it is irreversible for+that copy, so the ordinary GNU General Public License applies to all+subsequent copies and derivative works made from that copy.++  This option is useful when you wish to copy part of the code of+the Library into a program that is not a library.++  4. You may copy and distribute the Library (or a portion or+derivative of it, under Section 2) in object code or executable form+under the terms of Sections 1 and 2 above provided that you accompany+it with the complete corresponding machine-readable source code, which+must be distributed under the terms of Sections 1 and 2 above on a+medium customarily used for software interchange.++  If distribution of object code is made by offering access to copy+from a designated place, then offering equivalent access to copy the+source code from the same place satisfies the requirement to+distribute the source code, even though third parties are not+compelled to copy the source along with the object code.++  5. A program that contains no derivative of any portion of the+Library, but is designed to work with the Library by being compiled or+linked with it, is called a "work that uses the Library".  Such a+work, in isolation, is not a derivative work of the Library, and+therefore falls outside the scope of this License.++  However, linking a "work that uses the Library" with the Library+creates an executable that is a derivative of the Library (because it+contains portions of the Library), rather than a "work that uses the+library".  The executable is therefore covered by this License.+Section 6 states terms for distribution of such executables.++  When a "work that uses the Library" uses material from a header file+that is part of the Library, the object code for the work may be a+derivative work of the Library even though the source code is not.+Whether this is true is especially significant if the work can be+linked without the Library, or if the work is itself a library.  The+threshold for this to be true is not precisely defined by law.++  If such an object file uses only numerical parameters, data+structure layouts and accessors, and small macros and small inline+functions (ten lines or less in length), then the use of the object+file is unrestricted, regardless of whether it is legally a derivative+work.  (Executables containing this object code plus portions of the+Library will still fall under Section 6.)++  Otherwise, if the work is a derivative of the Library, you may+distribute the object code for the work under the terms of Section 6.+Any executables containing that work also fall under Section 6,+whether or not they are linked directly with the Library itself.++  6. As an exception to the Sections above, you may also combine or+link a "work that uses the Library" with the Library to produce a+work containing portions of the Library, and distribute that work+under terms of your choice, provided that the terms permit+modification of the work for the customer's own use and reverse+engineering for debugging such modifications.++  You must give prominent notice with each copy of the work that the+Library is used in it and that the Library and its use are covered by+this License.  You must supply a copy of this License.  If the work+during execution displays copyright notices, you must include the+copyright notice for the Library among them, as well as a reference+directing the user to the copy of this License.  Also, you must do one+of these things:++    a) Accompany the work with the complete corresponding+    machine-readable source code for the Library including whatever+    changes were used in the work (which must be distributed under+    Sections 1 and 2 above); and, if the work is an executable linked+    with the Library, with the complete machine-readable "work that+    uses the Library", as object code and/or source code, so that the+    user can modify the Library and then relink to produce a modified+    executable containing the modified Library.  (It is understood+    that the user who changes the contents of definitions files in the+    Library will not necessarily be able to recompile the application+    to use the modified definitions.)++    b) Use a suitable shared library mechanism for linking with the+    Library.  A suitable mechanism is one that (1) uses at run time a+    copy of the library already present on the user's computer system,+    rather than copying library functions into the executable, and (2)+    will operate properly with a modified version of the library, if+    the user installs one, as long as the modified version is+    interface-compatible with the version that the work was made with.++    c) Accompany the work with a written offer, valid for at+    least three years, to give the same user the materials+    specified in Subsection 6a, above, for a charge no more+    than the cost of performing this distribution.++    d) If distribution of the work is made by offering access to copy+    from a designated place, offer equivalent access to copy the above+    specified materials from the same place.++    e) Verify that the user has already received a copy of these+    materials or that you have already sent this user a copy.++  For an executable, the required form of the "work that uses the+Library" must include any data and utility programs needed for+reproducing the executable from it.  However, as a special exception,+the materials to be distributed need not include anything that is+normally distributed (in either source or binary form) with the major+components (compiler, kernel, and so on) of the operating system on+which the executable runs, unless that component itself accompanies+the executable.++  It may happen that this requirement contradicts the license+restrictions of other proprietary libraries that do not normally+accompany the operating system.  Such a contradiction means you cannot+use both them and the Library together in an executable that you+distribute.++  7. You may place library facilities that are a work based on the+Library side-by-side in a single library together with other library+facilities not covered by this License, and distribute such a combined+library, provided that the separate distribution of the work based on+the Library and of the other library facilities is otherwise+permitted, and provided that you do these two things:++    a) Accompany the combined library with a copy of the same work+    based on the Library, uncombined with any other library+    facilities.  This must be distributed under the terms of the+    Sections above.++    b) Give prominent notice with the combined library of the fact+    that part of it is a work based on the Library, and explaining+    where to find the accompanying uncombined form of the same work.++  8. You may not copy, modify, sublicense, link with, or distribute+the Library except as expressly provided under this License.  Any+attempt otherwise to copy, modify, sublicense, link with, or+distribute the Library is void, and will automatically terminate your+rights under this License.  However, parties who have received copies,+or rights, from you under this License will not have their licenses+terminated so long as such parties remain in full compliance.++  9. You are not required to accept this License, since you have not+signed it.  However, nothing else grants you permission to modify or+distribute the Library or its derivative works.  These actions are+prohibited by law if you do not accept this License.  Therefore, by+modifying or distributing the Library (or any work based on the+Library), you indicate your acceptance of this License to do so, and+all its terms and conditions for copying, distributing or modifying+the Library or works based on it.++  10. Each time you redistribute the Library (or any work based on the+Library), the recipient automatically receives a license from the+original licensor to copy, distribute, link with or modify the Library+subject to these terms and conditions.  You may not impose any further+restrictions on the recipients' exercise of the rights granted herein.+You are not responsible for enforcing compliance by third parties with+this License.++  11. If, as a consequence of a court judgment or allegation of patent+infringement or for any other reason (not limited to patent issues),+conditions are imposed on you (whether by court order, agreement or+otherwise) that contradict the conditions of this License, they do not+excuse you from the conditions of this License.  If you cannot+distribute so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you+may not distribute the Library at all.  For example, if a patent+license would not permit royalty-free redistribution of the Library by+all those who receive copies directly or indirectly through you, then+the only way you could satisfy both it and this License would be to+refrain entirely from distribution of the Library.++If any portion of this section is held invalid or unenforceable under any+particular circumstance, the balance of the section is intended to apply,+and the section as a whole is intended to apply in other circumstances.++It is not the purpose of this section to induce you to infringe any+patents or other property right claims or to contest validity of any+such claims; this section has the sole purpose of protecting the+integrity of the free software distribution system which is+implemented by public license practices.  Many people have made+generous contributions to the wide range of software distributed+through that system in reliance on consistent application of that+system; it is up to the author/donor to decide if he or she is willing+to distribute software through any other system and a licensee cannot+impose that choice.++This section is intended to make thoroughly clear what is believed to+be a consequence of the rest of this License.++  12. If the distribution and/or use of the Library is restricted in+certain countries either by patents or by copyrighted interfaces, the+original copyright holder who places the Library under this License may add+an explicit geographical distribution limitation excluding those countries,+so that distribution is permitted only in or among countries not thus+excluded.  In such case, this License incorporates the limitation as if+written in the body of this License.++  13. The Free Software Foundation may publish revised and/or new+versions of the Lesser General Public License from time to time.+Such new versions will be similar in spirit to the present version,+but may differ in detail to address new problems or concerns.++Each version is given a distinguishing version number.  If the Library+specifies a version number of this License which applies to it and+"any later version", you have the option of following the terms and+conditions either of that version or of any later version published by+the Free Software Foundation.  If the Library does not specify a+license version number, you may choose any version ever published by+the Free Software Foundation.++  14. If you wish to incorporate parts of the Library into other free+programs whose distribution conditions are incompatible with these,+write to the author to ask for permission.  For software which is+copyrighted by the Free Software Foundation, write to the Free+Software Foundation; we sometimes make exceptions for this.  Our+decision will be guided by the two goals of preserving the free status+of all derivatives of our free software and of promoting the sharing+and reuse of software generally.++                            NO WARRANTY++  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.++  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH+DAMAGES.
+ Setup.hs view
@@ -0,0 +1,3 @@+#!/usr/bin/env runhaskell+import Distribution.Simple+main = defaultMain
+ gi-gstvideo.cabal view
@@ -0,0 +1,72 @@+-- Autogenerated, do not edit.+name:               gi-gstvideo+version:            0.1.6.13+synopsis:           GstVideo bindings+description:        Bindings for GstVideo, autogenerated by haskell-gi.+homepage:           https://github.com/haskell-gi/haskell-gi+license:            LGPL-2.1+license-file:       LICENSE+author:             Will Thompson, Iñaki García Etxebarria and Jonas Platte+maintainer:         Iñaki García Etxebarria (garetxe@gmail.com)+category:           Bindings+build-type:         Simple+cabal-version:      >=1.10++library+    default-language:   Haskell2010+    default-extensions: ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts+    other-extensions:   PatternSynonyms ViewPatterns+    ghc-options:        -fno-warn-unused-imports -fno-warn-warnings-deprecations+    exposed-modules:    GI.GstVideo.Types+                        GI.GstVideo+                        GI.GstVideo.Callbacks+                        GI.GstVideo.Constants+                        GI.GstVideo.Enums+                        GI.GstVideo.Flags+                        GI.GstVideo.Functions+                        GI.GstVideo.Interfaces+                        GI.GstVideo.Interfaces.ColorBalance+                        GI.GstVideo.Interfaces.Navigation+                        GI.GstVideo.Interfaces.VideoOrientation+                        GI.GstVideo.Interfaces.VideoOverlay+                        GI.GstVideo.Objects+                        GI.GstVideo.Objects.ColorBalanceChannel+                        GI.GstVideo.Objects.VideoBufferPool+                        GI.GstVideo.Objects.VideoDecoder+                        GI.GstVideo.Objects.VideoEncoder+                        GI.GstVideo.Objects.VideoFilter+                        GI.GstVideo.Objects.VideoSink+                        GI.GstVideo.Structs+                        GI.GstVideo.Structs.VideoAlignment+                        GI.GstVideo.Structs.VideoChromaResample+                        GI.GstVideo.Structs.VideoCodecFrame+                        GI.GstVideo.Structs.VideoCodecState+                        GI.GstVideo.Structs.VideoColorPrimariesInfo+                        GI.GstVideo.Structs.VideoColorimetry+                        GI.GstVideo.Structs.VideoConverter+                        GI.GstVideo.Structs.VideoCropMeta+                        GI.GstVideo.Structs.VideoDither+                        GI.GstVideo.Structs.VideoFormatInfo+                        GI.GstVideo.Structs.VideoFrame+                        GI.GstVideo.Structs.VideoGLTextureUploadMeta+                        GI.GstVideo.Structs.VideoInfo+                        GI.GstVideo.Structs.VideoMeta+                        GI.GstVideo.Structs.VideoMetaTransform+                        GI.GstVideo.Structs.VideoOverlayComposition+                        GI.GstVideo.Structs.VideoOverlayCompositionMeta+                        GI.GstVideo.Structs.VideoOverlayRectangle+                        GI.GstVideo.Structs.VideoRectangle+                        GI.GstVideo.Structs.VideoRegionOfInterestMeta+                        GI.GstVideo.Structs.VideoResampler+                        GI.GstVideo.Structs.VideoScaler+    pkgconfig-depends:  gstreamer-video-1.0 >= 1.6+    build-depends: base >= 4.7 && <5,+        haskell-gi-base >= 0.13 && < 1,+        gi-glib >= 0.2.46.13 && < 0.2.47,+        gi-gobject >= 0.2.46.13 && < 0.2.47,+        gi-gst >= 0.1.6.13 && < 0.1.7,+        gi-gstbase >= 0.1.6.13 && < 0.1.7,+        bytestring >= 0.10,+        containers >= 0.5,+        text >= 1.0,+        transformers >= 0.3