diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,3 +1,11 @@ +### 1.0.18 + ++ Update to haskell-gi(-base) 0.22 + +### 1.0.17 + ++ Update stack version to 12.10 + ### 1.0.16 + Do not generate bindings for `VideoOverlay.installProperties`, since we don't support class structures yet. diff --git a/GI/GstVideo.hs b/GI/GstVideo.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo.hs @@ -0,0 +1,60 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo + ( module GI.GstVideo.Callbacks , + module GI.GstVideo.Constants , + module GI.GstVideo.Enums , + module GI.GstVideo.Flags , + module GI.GstVideo.Functions , + module GI.GstVideo.Interfaces , + module GI.GstVideo.Objects , + module GI.GstVideo.Structs , + + + + module Data.GI.Base , + + + ) where + +import GI.GstVideo.Callbacks +import GI.GstVideo.Constants +import GI.GstVideo.Enums +import GI.GstVideo.Flags +import GI.GstVideo.Functions +import GI.GstVideo.Interfaces +import GI.GstVideo.Objects +import GI.GstVideo.Structs + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +import Data.GI.Base + diff --git a/GI/GstVideo/Callbacks.hs b/GI/GstVideo/Callbacks.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Callbacks.hs @@ -0,0 +1,736 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Callbacks + ( + + -- * Signals +-- ** VideoAffineTransformationGetMatrix #signal:VideoAffineTransformationGetMatrix# + + C_VideoAffineTransformationGetMatrix , + VideoAffineTransformationGetMatrix , + dynamic_VideoAffineTransformationGetMatrix, + genClosure_VideoAffineTransformationGetMatrix, + mk_VideoAffineTransformationGetMatrix , + noVideoAffineTransformationGetMatrix , + wrap_VideoAffineTransformationGetMatrix , + + +-- ** VideoConvertSampleCallback #signal:VideoConvertSampleCallback# + + C_VideoConvertSampleCallback , + VideoConvertSampleCallback , + VideoConvertSampleCallback_WithClosures , + drop_closures_VideoConvertSampleCallback, + dynamic_VideoConvertSampleCallback , + genClosure_VideoConvertSampleCallback , + mk_VideoConvertSampleCallback , + noVideoConvertSampleCallback , + noVideoConvertSampleCallback_WithClosures, + wrap_VideoConvertSampleCallback , + + +-- ** VideoFormatPack #signal:VideoFormatPack# + + C_VideoFormatPack , + VideoFormatPack , + dynamic_VideoFormatPack , + genClosure_VideoFormatPack , + mk_VideoFormatPack , + noVideoFormatPack , + wrap_VideoFormatPack , + + +-- ** VideoFormatUnpack #signal:VideoFormatUnpack# + + C_VideoFormatUnpack , + VideoFormatUnpack , + dynamic_VideoFormatUnpack , + genClosure_VideoFormatUnpack , + mk_VideoFormatUnpack , + noVideoFormatUnpack , + wrap_VideoFormatUnpack , + + +-- ** VideoGLTextureUpload #signal:VideoGLTextureUpload# + + C_VideoGLTextureUpload , + VideoGLTextureUpload , + dynamic_VideoGLTextureUpload , + genClosure_VideoGLTextureUpload , + mk_VideoGLTextureUpload , + noVideoGLTextureUpload , + wrap_VideoGLTextureUpload , + + +-- ** VideoMetaMapFieldCallback #signal:VideoMetaMapFieldCallback# + + C_VideoMetaMapFieldCallback , + VideoMetaMapFieldCallback , + dynamic_VideoMetaMapFieldCallback , + genClosure_VideoMetaMapFieldCallback , + mk_VideoMetaMapFieldCallback , + noVideoMetaMapFieldCallback , + wrap_VideoMetaMapFieldCallback , + + +-- ** VideoMetaUnmapFieldCallback #signal:VideoMetaUnmapFieldCallback# + + C_VideoMetaUnmapFieldCallback , + VideoMetaUnmapFieldCallback , + dynamic_VideoMetaUnmapFieldCallback , + genClosure_VideoMetaUnmapFieldCallback , + mk_VideoMetaUnmapFieldCallback , + noVideoMetaUnmapFieldCallback , + wrap_VideoMetaUnmapFieldCallback , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Flags as Gst.Flags +import qualified GI.Gst.Structs.MapInfo as Gst.MapInfo +import qualified GI.Gst.Structs.Sample as Gst.Sample +import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoAffineTransformationMeta as GstVideo.VideoAffineTransformationMeta +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoFormatInfo as GstVideo.VideoFormatInfo +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoGLTextureUploadMeta as GstVideo.VideoGLTextureUploadMeta +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoMeta as GstVideo.VideoMeta + +-- callback VideoMetaUnmapFieldCallback +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gst", name = "MapInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_VideoMetaUnmapFieldCallback = + Ptr GstVideo.VideoMeta.VideoMeta -> + Word32 -> + Ptr Gst.MapInfo.MapInfo -> + IO CInt + +-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gst", name = "MapInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_VideoMetaUnmapFieldCallback :: FunPtr C_VideoMetaUnmapFieldCallback -> C_VideoMetaUnmapFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_VideoMetaUnmapFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_VideoMetaUnmapFieldCallback + -> GstVideo.VideoMeta.VideoMeta + -> Word32 + -> Gst.MapInfo.MapInfo + -> m Bool +dynamic_VideoMetaUnmapFieldCallback __funPtr meta plane info = liftIO $ do + meta' <- unsafeManagedPtrGetPtr meta + info' <- unsafeManagedPtrGetPtr info + result <- (__dynamic_C_VideoMetaUnmapFieldCallback __funPtr) meta' plane info' + let result' = (/= 0) result + touchManagedPtr meta + touchManagedPtr info + return result' + +-- | Generate a function pointer callable from C code, from a `C_VideoMetaUnmapFieldCallback`. +foreign import ccall "wrapper" + mk_VideoMetaUnmapFieldCallback :: C_VideoMetaUnmapFieldCallback -> IO (FunPtr C_VideoMetaUnmapFieldCallback) + +{- | +/No description available in the introspection data./ +-} +type VideoMetaUnmapFieldCallback = + GstVideo.VideoMeta.VideoMeta + -> Word32 + -> Gst.MapInfo.MapInfo + -> IO Bool + +-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoMetaUnmapFieldCallback`@. +noVideoMetaUnmapFieldCallback :: Maybe VideoMetaUnmapFieldCallback +noVideoMetaUnmapFieldCallback = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_VideoMetaUnmapFieldCallback :: MonadIO m => VideoMetaUnmapFieldCallback -> m (GClosure C_VideoMetaUnmapFieldCallback) +genClosure_VideoMetaUnmapFieldCallback cb = liftIO $ do + let cb' = wrap_VideoMetaUnmapFieldCallback Nothing cb + mk_VideoMetaUnmapFieldCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `VideoMetaUnmapFieldCallback` into a `C_VideoMetaUnmapFieldCallback`. +wrap_VideoMetaUnmapFieldCallback :: + Maybe (Ptr (FunPtr C_VideoMetaUnmapFieldCallback)) -> + VideoMetaUnmapFieldCallback -> + C_VideoMetaUnmapFieldCallback +wrap_VideoMetaUnmapFieldCallback funptrptr _cb meta plane info = do + meta' <- (newPtr GstVideo.VideoMeta.VideoMeta) meta + info' <- (newPtr Gst.MapInfo.MapInfo) info + result <- _cb meta' plane info' + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + + +-- callback VideoMetaMapFieldCallback +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gst", name = "MapInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "MapFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_VideoMetaMapFieldCallback = + Ptr GstVideo.VideoMeta.VideoMeta -> + Word32 -> + Ptr Gst.MapInfo.MapInfo -> + Ptr () -> + Int32 -> + CUInt -> + IO CInt + +-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gst", name = "MapInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "MapFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_VideoMetaMapFieldCallback :: FunPtr C_VideoMetaMapFieldCallback -> C_VideoMetaMapFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_VideoMetaMapFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_VideoMetaMapFieldCallback + -> GstVideo.VideoMeta.VideoMeta + -> Word32 + -> Gst.MapInfo.MapInfo + -> Ptr () + -> Int32 + -> [Gst.Flags.MapFlags] + -> m Bool +dynamic_VideoMetaMapFieldCallback __funPtr meta plane info data_ stride flags = liftIO $ do + meta' <- unsafeManagedPtrGetPtr meta + info' <- unsafeManagedPtrGetPtr info + let flags' = gflagsToWord flags + result <- (__dynamic_C_VideoMetaMapFieldCallback __funPtr) meta' plane info' data_ stride flags' + let result' = (/= 0) result + touchManagedPtr meta + touchManagedPtr info + return result' + +-- | Generate a function pointer callable from C code, from a `C_VideoMetaMapFieldCallback`. +foreign import ccall "wrapper" + mk_VideoMetaMapFieldCallback :: C_VideoMetaMapFieldCallback -> IO (FunPtr C_VideoMetaMapFieldCallback) + +{- | +/No description available in the introspection data./ +-} +type VideoMetaMapFieldCallback = + GstVideo.VideoMeta.VideoMeta + -> Word32 + -> Gst.MapInfo.MapInfo + -> Ptr () + -> Int32 + -> [Gst.Flags.MapFlags] + -> IO Bool + +-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoMetaMapFieldCallback`@. +noVideoMetaMapFieldCallback :: Maybe VideoMetaMapFieldCallback +noVideoMetaMapFieldCallback = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_VideoMetaMapFieldCallback :: MonadIO m => VideoMetaMapFieldCallback -> m (GClosure C_VideoMetaMapFieldCallback) +genClosure_VideoMetaMapFieldCallback cb = liftIO $ do + let cb' = wrap_VideoMetaMapFieldCallback Nothing cb + mk_VideoMetaMapFieldCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `VideoMetaMapFieldCallback` into a `C_VideoMetaMapFieldCallback`. +wrap_VideoMetaMapFieldCallback :: + Maybe (Ptr (FunPtr C_VideoMetaMapFieldCallback)) -> + VideoMetaMapFieldCallback -> + C_VideoMetaMapFieldCallback +wrap_VideoMetaMapFieldCallback funptrptr _cb meta plane info data_ stride flags = do + meta' <- (newPtr GstVideo.VideoMeta.VideoMeta) meta + info' <- (newPtr Gst.MapInfo.MapInfo) info + let flags' = wordToGFlags flags + result <- _cb meta' plane info' data_ stride flags' + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + + +-- callback VideoGLTextureUpload +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureUploadMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "texture_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_VideoGLTextureUpload = + Ptr GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta -> + Word32 -> + IO CInt + +-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureUploadMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "texture_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_VideoGLTextureUpload :: FunPtr C_VideoGLTextureUpload -> C_VideoGLTextureUpload + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_VideoGLTextureUpload :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_VideoGLTextureUpload + -> GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta + -> Word32 + -> m Bool +dynamic_VideoGLTextureUpload __funPtr meta textureId = liftIO $ do + meta' <- unsafeManagedPtrGetPtr meta + result <- (__dynamic_C_VideoGLTextureUpload __funPtr) meta' textureId + let result' = (/= 0) result + touchManagedPtr meta + return result' + +-- | Generate a function pointer callable from C code, from a `C_VideoGLTextureUpload`. +foreign import ccall "wrapper" + mk_VideoGLTextureUpload :: C_VideoGLTextureUpload -> IO (FunPtr C_VideoGLTextureUpload) + +{- | +/No description available in the introspection data./ +-} +type VideoGLTextureUpload = + GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta + -> Word32 + -> IO Bool + +-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoGLTextureUpload`@. +noVideoGLTextureUpload :: Maybe VideoGLTextureUpload +noVideoGLTextureUpload = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_VideoGLTextureUpload :: MonadIO m => VideoGLTextureUpload -> m (GClosure C_VideoGLTextureUpload) +genClosure_VideoGLTextureUpload cb = liftIO $ do + let cb' = wrap_VideoGLTextureUpload Nothing cb + mk_VideoGLTextureUpload cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `VideoGLTextureUpload` into a `C_VideoGLTextureUpload`. +wrap_VideoGLTextureUpload :: + Maybe (Ptr (FunPtr C_VideoGLTextureUpload)) -> + VideoGLTextureUpload -> + C_VideoGLTextureUpload +wrap_VideoGLTextureUpload funptrptr _cb meta textureId = do + meta' <- (newPtr GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta) meta + result <- _cb meta' textureId + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + + +-- callback VideoFormatUnpack +-- -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormatInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormatInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoPackFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags to control the unpacking", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a destination array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "pointers to the data planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "strides of the planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x position in the image to start from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y position in the image to start from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the amount of pixels to unpack.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Unpacks @width pixels from the given planes and strides containing data of\nformat @info. The pixels will be unpacked into @dest with each component\ninterleaved as per @info's unpack_format, which will usually be one of\n#GST_VIDEO_FORMAT_ARGB, #GST_VIDEO_FORMAT_AYUV, #GST_VIDEO_FORMAT_ARGB64 or\n#GST_VIDEO_FORMAT_AYUV64 depending on the format to unpack.\n@dest should at least be big enough to hold @width * bytes_per_pixel bytes\nwhere bytes_per_pixel relates to the unpack format and will usually be\neither 4 or 8 depending on the unpack format. bytes_per_pixel will be\nthe same as the pixel stride for plane 0 for the above formats.\n\nFor subsampled formats, the components will be duplicated in the destination\narray. Reconstruction of the missing components can be performed in a\nseparate step after unpacking.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_VideoFormatUnpack = + Ptr GstVideo.VideoFormatInfo.VideoFormatInfo -> + CUInt -> + Ptr () -> + Ptr () -> + Int32 -> + Int32 -> + Int32 -> + Int32 -> + IO () + +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormatInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormatInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoPackFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags to control the unpacking", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a destination array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "pointers to the data planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "strides of the planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x position in the image to start from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y position in the image to start from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the amount of pixels to unpack.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_VideoFormatUnpack :: FunPtr C_VideoFormatUnpack -> C_VideoFormatUnpack + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_VideoFormatUnpack :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_VideoFormatUnpack + -> GstVideo.VideoFormatInfo.VideoFormatInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoFormatInfo.VideoFormatInfo' -} + -> [GstVideo.Flags.VideoPackFlags] + {- ^ /@flags@/: flags to control the unpacking -} + -> Ptr () + {- ^ /@dest@/: a destination array -} + -> Ptr () + {- ^ /@data@/: pointers to the data planes -} + -> Int32 + {- ^ /@stride@/: strides of the planes -} + -> Int32 + {- ^ /@x@/: the x position in the image to start from -} + -> Int32 + {- ^ /@y@/: the y position in the image to start from -} + -> Int32 + {- ^ /@width@/: the amount of pixels to unpack. -} + -> m () +dynamic_VideoFormatUnpack __funPtr info flags dest data_ stride x y width = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + let flags' = gflagsToWord flags + (__dynamic_C_VideoFormatUnpack __funPtr) info' flags' dest data_ stride x y width + touchManagedPtr info + return () + +-- | Generate a function pointer callable from C code, from a `C_VideoFormatUnpack`. +foreign import ccall "wrapper" + mk_VideoFormatUnpack :: C_VideoFormatUnpack -> IO (FunPtr C_VideoFormatUnpack) + +{- | +Unpacks /@width@/ pixels from the given planes and strides containing data of +format /@info@/. The pixels will be unpacked into /@dest@/ with each component +interleaved as per /@info@/\'s unpack_format, which will usually be one of +@/GST_VIDEO_FORMAT_ARGB/@, @/GST_VIDEO_FORMAT_AYUV/@, @/GST_VIDEO_FORMAT_ARGB64/@ or +@/GST_VIDEO_FORMAT_AYUV64/@ depending on the format to unpack. +/@dest@/ should at least be big enough to hold /@width@/ * bytes_per_pixel bytes +where bytes_per_pixel relates to the unpack format and will usually be +either 4 or 8 depending on the unpack format. bytes_per_pixel will be +the same as the pixel stride for plane 0 for the above formats. + +For subsampled formats, the components will be duplicated in the destination +array. Reconstruction of the missing components can be performed in a +separate step after unpacking. +-} +type VideoFormatUnpack = + GstVideo.VideoFormatInfo.VideoFormatInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoFormatInfo.VideoFormatInfo' -} + -> [GstVideo.Flags.VideoPackFlags] + {- ^ /@flags@/: flags to control the unpacking -} + -> Ptr () + {- ^ /@dest@/: a destination array -} + -> Ptr () + {- ^ /@data@/: pointers to the data planes -} + -> Int32 + {- ^ /@stride@/: strides of the planes -} + -> Int32 + {- ^ /@x@/: the x position in the image to start from -} + -> Int32 + {- ^ /@y@/: the y position in the image to start from -} + -> Int32 + {- ^ /@width@/: the amount of pixels to unpack. -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoFormatUnpack`@. +noVideoFormatUnpack :: Maybe VideoFormatUnpack +noVideoFormatUnpack = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_VideoFormatUnpack :: MonadIO m => VideoFormatUnpack -> m (GClosure C_VideoFormatUnpack) +genClosure_VideoFormatUnpack cb = liftIO $ do + let cb' = wrap_VideoFormatUnpack Nothing cb + mk_VideoFormatUnpack cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `VideoFormatUnpack` into a `C_VideoFormatUnpack`. +wrap_VideoFormatUnpack :: + Maybe (Ptr (FunPtr C_VideoFormatUnpack)) -> + VideoFormatUnpack -> + C_VideoFormatUnpack +wrap_VideoFormatUnpack funptrptr _cb info flags dest data_ stride x y width = do + info' <- (newPtr GstVideo.VideoFormatInfo.VideoFormatInfo) info + let flags' = wordToGFlags flags + _cb info' flags' dest data_ stride x y width + maybeReleaseFunPtr funptrptr + + +-- callback VideoFormatPack +-- -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormatInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormatInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoPackFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags to control the packing", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a source array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sstride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source array stride", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "pointers to the destination data planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "strides of the destination planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chroma_site", argType = TInterface (Name {namespace = "GstVideo", name = "VideoChromaSite"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the chroma siting of the target when subsampled (not used)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y position in the image to pack to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the amount of pixels to pack.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Packs @width pixels from @src to the given planes and strides in the\nformat @info. The pixels from source have each component interleaved\nand will be packed into the planes in @data.\n\nThis function operates on pack_lines lines, meaning that @src should\ncontain at least pack_lines lines with a stride of @sstride and @y\nshould be a multiple of pack_lines.\n\nSubsampled formats will use the horizontally and vertically cosited\ncomponent from the source. Subsampling should be performed before\npacking.\n\nBecause this function does not have a x coordinate, it is not possible to\npack pixels starting from an unaligned position. For tiled images this\nmeans that packing should start from a tile coordinate. For subsampled\nformats this means that a complete pixel needs to be packed.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_VideoFormatPack = + Ptr GstVideo.VideoFormatInfo.VideoFormatInfo -> + CUInt -> + Ptr () -> + Int32 -> + Ptr () -> + Int32 -> + CUInt -> + Int32 -> + Int32 -> + IO () + +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormatInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormatInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoPackFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags to control the packing", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a source array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sstride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source array stride", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "pointers to the destination data planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "strides of the destination planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chroma_site", argType = TInterface (Name {namespace = "GstVideo", name = "VideoChromaSite"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the chroma siting of the target when subsampled (not used)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y position in the image to pack to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the amount of pixels to pack.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_VideoFormatPack :: FunPtr C_VideoFormatPack -> C_VideoFormatPack + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_VideoFormatPack :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_VideoFormatPack + -> GstVideo.VideoFormatInfo.VideoFormatInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoFormatInfo.VideoFormatInfo' -} + -> [GstVideo.Flags.VideoPackFlags] + {- ^ /@flags@/: flags to control the packing -} + -> Ptr () + {- ^ /@src@/: a source array -} + -> Int32 + {- ^ /@sstride@/: the source array stride -} + -> Ptr () + {- ^ /@data@/: pointers to the destination data planes -} + -> Int32 + {- ^ /@stride@/: strides of the destination planes -} + -> [GstVideo.Flags.VideoChromaSite] + {- ^ /@chromaSite@/: the chroma siting of the target when subsampled (not used) -} + -> Int32 + {- ^ /@y@/: the y position in the image to pack to -} + -> Int32 + {- ^ /@width@/: the amount of pixels to pack. -} + -> m () +dynamic_VideoFormatPack __funPtr info flags src sstride data_ stride chromaSite y width = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + let flags' = gflagsToWord flags + let chromaSite' = gflagsToWord chromaSite + (__dynamic_C_VideoFormatPack __funPtr) info' flags' src sstride data_ stride chromaSite' y width + touchManagedPtr info + return () + +-- | Generate a function pointer callable from C code, from a `C_VideoFormatPack`. +foreign import ccall "wrapper" + mk_VideoFormatPack :: C_VideoFormatPack -> IO (FunPtr C_VideoFormatPack) + +{- | +Packs /@width@/ pixels from /@src@/ to the given planes and strides in the +format /@info@/. The pixels from source have each component interleaved +and will be packed into the planes in /@data@/. + +This function operates on pack_lines lines, meaning that /@src@/ should +contain at least pack_lines lines with a stride of /@sstride@/ and /@y@/ +should be a multiple of pack_lines. + +Subsampled formats will use the horizontally and vertically cosited +component from the source. Subsampling should be performed before +packing. + +Because this function does not have a x coordinate, it is not possible to +pack pixels starting from an unaligned position. For tiled images this +means that packing should start from a tile coordinate. For subsampled +formats this means that a complete pixel needs to be packed. +-} +type VideoFormatPack = + GstVideo.VideoFormatInfo.VideoFormatInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoFormatInfo.VideoFormatInfo' -} + -> [GstVideo.Flags.VideoPackFlags] + {- ^ /@flags@/: flags to control the packing -} + -> Ptr () + {- ^ /@src@/: a source array -} + -> Int32 + {- ^ /@sstride@/: the source array stride -} + -> Ptr () + {- ^ /@data@/: pointers to the destination data planes -} + -> Int32 + {- ^ /@stride@/: strides of the destination planes -} + -> [GstVideo.Flags.VideoChromaSite] + {- ^ /@chromaSite@/: the chroma siting of the target when subsampled (not used) -} + -> Int32 + {- ^ /@y@/: the y position in the image to pack to -} + -> Int32 + {- ^ /@width@/: the amount of pixels to pack. -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoFormatPack`@. +noVideoFormatPack :: Maybe VideoFormatPack +noVideoFormatPack = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_VideoFormatPack :: MonadIO m => VideoFormatPack -> m (GClosure C_VideoFormatPack) +genClosure_VideoFormatPack cb = liftIO $ do + let cb' = wrap_VideoFormatPack Nothing cb + mk_VideoFormatPack cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `VideoFormatPack` into a `C_VideoFormatPack`. +wrap_VideoFormatPack :: + Maybe (Ptr (FunPtr C_VideoFormatPack)) -> + VideoFormatPack -> + C_VideoFormatPack +wrap_VideoFormatPack funptrptr _cb info flags src sstride data_ stride chromaSite y width = do + info' <- (newPtr GstVideo.VideoFormatInfo.VideoFormatInfo) info + let flags' = wordToGFlags flags + let chromaSite' = wordToGFlags chromaSite + _cb info' flags' src sstride data_ stride chromaSite' y width + maybeReleaseFunPtr funptrptr + + +-- callback VideoConvertSampleCallback +-- -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "sample", argType = TInterface (Name {namespace = "Gst", name = "Sample"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_VideoConvertSampleCallback = + Ptr Gst.Sample.Sample -> + Ptr GError -> + Ptr () -> + IO () + +-- Args : [Arg {argCName = "sample", argType = TInterface (Name {namespace = "Gst", name = "Sample"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_VideoConvertSampleCallback :: FunPtr C_VideoConvertSampleCallback -> C_VideoConvertSampleCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_VideoConvertSampleCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_VideoConvertSampleCallback + -> Gst.Sample.Sample + -> GError + -> Ptr () + -> m () +dynamic_VideoConvertSampleCallback __funPtr sample error_ userData = liftIO $ do + sample' <- unsafeManagedPtrGetPtr sample + error_' <- unsafeManagedPtrGetPtr error_ + (__dynamic_C_VideoConvertSampleCallback __funPtr) sample' error_' userData + touchManagedPtr sample + touchManagedPtr error_ + return () + +-- | Generate a function pointer callable from C code, from a `C_VideoConvertSampleCallback`. +foreign import ccall "wrapper" + mk_VideoConvertSampleCallback :: C_VideoConvertSampleCallback -> IO (FunPtr C_VideoConvertSampleCallback) + +{- | +/No description available in the introspection data./ +-} +type VideoConvertSampleCallback = + Gst.Sample.Sample + -> GError + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoConvertSampleCallback`@. +noVideoConvertSampleCallback :: Maybe VideoConvertSampleCallback +noVideoConvertSampleCallback = Nothing + +{- | +/No description available in the introspection data./ +-} +type VideoConvertSampleCallback_WithClosures = + Gst.Sample.Sample + -> GError + -> Ptr () + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoConvertSampleCallback_WithClosures`@. +noVideoConvertSampleCallback_WithClosures :: Maybe VideoConvertSampleCallback_WithClosures +noVideoConvertSampleCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_VideoConvertSampleCallback :: VideoConvertSampleCallback -> VideoConvertSampleCallback_WithClosures +drop_closures_VideoConvertSampleCallback _f sample error_ _ = _f sample error_ + +-- | Wrap the callback into a `GClosure`. +genClosure_VideoConvertSampleCallback :: MonadIO m => VideoConvertSampleCallback -> m (GClosure C_VideoConvertSampleCallback) +genClosure_VideoConvertSampleCallback cb = liftIO $ do + let cb' = drop_closures_VideoConvertSampleCallback cb + let cb'' = wrap_VideoConvertSampleCallback Nothing cb' + mk_VideoConvertSampleCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `VideoConvertSampleCallback` into a `C_VideoConvertSampleCallback`. +wrap_VideoConvertSampleCallback :: + Maybe (Ptr (FunPtr C_VideoConvertSampleCallback)) -> + VideoConvertSampleCallback_WithClosures -> + C_VideoConvertSampleCallback +wrap_VideoConvertSampleCallback funptrptr _cb sample error_ userData = do + B.ManagedPtr.withTransient Gst.Sample.Sample sample $ \sample' -> do + error_' <- (newBoxed GError) error_ + _cb sample' error_' userData + maybeReleaseFunPtr funptrptr + + +-- callback VideoAffineTransformationGetMatrix +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAffineTransformationMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "matrix", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_VideoAffineTransformationGetMatrix = + Ptr GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta -> + CFloat -> + IO CInt + +-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAffineTransformationMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "matrix", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_VideoAffineTransformationGetMatrix :: FunPtr C_VideoAffineTransformationGetMatrix -> C_VideoAffineTransformationGetMatrix + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_VideoAffineTransformationGetMatrix :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_VideoAffineTransformationGetMatrix + -> GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta + -> Float + -> m Bool +dynamic_VideoAffineTransformationGetMatrix __funPtr meta matrix = liftIO $ do + meta' <- unsafeManagedPtrGetPtr meta + let matrix' = realToFrac matrix + result <- (__dynamic_C_VideoAffineTransformationGetMatrix __funPtr) meta' matrix' + let result' = (/= 0) result + touchManagedPtr meta + return result' + +-- | Generate a function pointer callable from C code, from a `C_VideoAffineTransformationGetMatrix`. +foreign import ccall "wrapper" + mk_VideoAffineTransformationGetMatrix :: C_VideoAffineTransformationGetMatrix -> IO (FunPtr C_VideoAffineTransformationGetMatrix) + +{- | +/No description available in the introspection data./ +-} +type VideoAffineTransformationGetMatrix = + GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta + -> Float + -> IO Bool + +-- | A convenience synonym for @`Nothing` :: `Maybe` `VideoAffineTransformationGetMatrix`@. +noVideoAffineTransformationGetMatrix :: Maybe VideoAffineTransformationGetMatrix +noVideoAffineTransformationGetMatrix = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_VideoAffineTransformationGetMatrix :: MonadIO m => VideoAffineTransformationGetMatrix -> m (GClosure C_VideoAffineTransformationGetMatrix) +genClosure_VideoAffineTransformationGetMatrix cb = liftIO $ do + let cb' = wrap_VideoAffineTransformationGetMatrix Nothing cb + mk_VideoAffineTransformationGetMatrix cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `VideoAffineTransformationGetMatrix` into a `C_VideoAffineTransformationGetMatrix`. +wrap_VideoAffineTransformationGetMatrix :: + Maybe (Ptr (FunPtr C_VideoAffineTransformationGetMatrix)) -> + VideoAffineTransformationGetMatrix -> + C_VideoAffineTransformationGetMatrix +wrap_VideoAffineTransformationGetMatrix funptrptr _cb meta matrix = do + meta' <- (newPtr GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta) meta + let matrix' = realToFrac matrix + result <- _cb meta' matrix' + maybeReleaseFunPtr funptrptr + let result' = (fromIntegral . fromEnum) result + return result' + + + diff --git a/GI/GstVideo/Constants.hs b/GI/GstVideo/Constants.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Constants.hs @@ -0,0 +1,538 @@ +{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-} + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Constants + ( + pattern VIDEO_TILE_Y_TILES_SHIFT , + pattern VIDEO_TILE_X_TILES_MASK , + pattern VIDEO_TILE_TYPE_SHIFT , + pattern VIDEO_TILE_TYPE_MASK , + pattern VIDEO_SIZE_RANGE , + pattern VIDEO_SCALER_OPT_DITHER_METHOD , + pattern VIDEO_RESAMPLER_OPT_SHARPNESS , + pattern VIDEO_RESAMPLER_OPT_SHARPEN , + pattern VIDEO_RESAMPLER_OPT_MAX_TAPS , + pattern VIDEO_RESAMPLER_OPT_ENVELOPE , + pattern VIDEO_RESAMPLER_OPT_CUBIC_C , + pattern VIDEO_RESAMPLER_OPT_CUBIC_B , + pattern VIDEO_OVERLAY_COMPOSITION_BLEND_FORMATS, + pattern VIDEO_MAX_PLANES , + pattern VIDEO_MAX_COMPONENTS , + pattern VIDEO_FPS_RANGE , + pattern VIDEO_FORMATS_ALL , + pattern VIDEO_ENCODER_SRC_NAME , + pattern VIDEO_ENCODER_SINK_NAME , + pattern VIDEO_DECODER_SRC_NAME , + pattern VIDEO_DECODER_SINK_NAME , + pattern VIDEO_DECODER_MAX_ERRORS , + pattern VIDEO_CONVERTER_OPT_THREADS , + pattern VIDEO_CONVERTER_OPT_SRC_Y , + pattern VIDEO_CONVERTER_OPT_SRC_X , + pattern VIDEO_CONVERTER_OPT_SRC_WIDTH , + pattern VIDEO_CONVERTER_OPT_SRC_HEIGHT , + pattern VIDEO_CONVERTER_OPT_RESAMPLER_TAPS, + pattern VIDEO_CONVERTER_OPT_RESAMPLER_METHOD, + pattern VIDEO_CONVERTER_OPT_PRIMARIES_MODE, + pattern VIDEO_CONVERTER_OPT_MATRIX_MODE , + pattern VIDEO_CONVERTER_OPT_GAMMA_MODE , + pattern VIDEO_CONVERTER_OPT_FILL_BORDER , + pattern VIDEO_CONVERTER_OPT_DITHER_QUANTIZATION, + pattern VIDEO_CONVERTER_OPT_DITHER_METHOD, + pattern VIDEO_CONVERTER_OPT_DEST_Y , + pattern VIDEO_CONVERTER_OPT_DEST_X , + pattern VIDEO_CONVERTER_OPT_DEST_WIDTH , + pattern VIDEO_CONVERTER_OPT_DEST_HEIGHT , + pattern VIDEO_CONVERTER_OPT_CHROMA_RESAMPLER_METHOD, + pattern VIDEO_CONVERTER_OPT_CHROMA_MODE , + pattern VIDEO_CONVERTER_OPT_BORDER_ARGB , + pattern VIDEO_CONVERTER_OPT_ALPHA_VALUE , + pattern VIDEO_CONVERTER_OPT_ALPHA_MODE , + pattern VIDEO_COMP_Y , + pattern VIDEO_COMP_V , + pattern VIDEO_COMP_U , + pattern VIDEO_COMP_R , + pattern VIDEO_COMP_PALETTE , + pattern VIDEO_COMP_INDEX , + pattern VIDEO_COMP_G , + pattern VIDEO_COMP_B , + pattern VIDEO_COMP_A , + pattern VIDEO_COLORIMETRY_SRGB , + pattern VIDEO_COLORIMETRY_SMPTE240M , + pattern VIDEO_COLORIMETRY_BT709 , + pattern VIDEO_COLORIMETRY_BT601 , + pattern VIDEO_COLORIMETRY_BT2020 , + pattern META_TAG_VIDEO_STR , + pattern META_TAG_VIDEO_SIZE_STR , + pattern META_TAG_VIDEO_ORIENTATION_STR , + pattern META_TAG_VIDEO_COLORSPACE_STR , + pattern CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION, + pattern CAPS_FEATURE_META_GST_VIDEO_META, + pattern CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META, + pattern CAPS_FEATURE_META_GST_VIDEO_AFFINE_TRANSFORMATION_META, + pattern CAPS_FEATURE_FORMAT_INTERLACED , + pattern BUFFER_POOL_OPTION_VIDEO_META , + pattern BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META, + pattern BUFFER_POOL_OPTION_VIDEO_ALIGNMENT, + pattern BUFFER_POOL_OPTION_VIDEO_AFFINE_TRANSFORMATION_META, + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_TILE_Y_TILES_SHIFT = 16 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_TILE_X_TILES_MASK = 65535 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_TILE_TYPE_SHIFT = 16 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_TILE_TYPE_MASK = 65535 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_SIZE_RANGE = "(int) [ 1, max ]" :: T.Text + +{- | +@/GST_TYPE_VIDEO_DITHER_METHOD/@, The dither method to use for propagating +quatization errors. +-} +pattern VIDEO_SCALER_OPT_DITHER_METHOD = "GstVideoScaler.dither-method" :: T.Text + +{- | +G_TYPE_DOUBLE, specifies sharpness of the filter for +/@gSTVIDEORESAMPLERMETHODLANCZOS@/. values are clamped between +0.5 and 1.5. 1.0 is the default. +-} +pattern VIDEO_RESAMPLER_OPT_SHARPNESS = "GstVideoResampler.sharpness" :: T.Text + +{- | +G_TYPE_DOUBLE, specifies sharpening of the filter for +/@gSTVIDEORESAMPLERMETHODLANCZOS@/. values are clamped between +0.0 and 1.0. 0.0 is the default. +-} +pattern VIDEO_RESAMPLER_OPT_SHARPEN = "GstVideoResampler.sharpen" :: T.Text + +{- | +G_TYPE_INT, limits the maximum number of taps to use. +16 is the default. +-} +pattern VIDEO_RESAMPLER_OPT_MAX_TAPS = "GstVideoResampler.max-taps" :: T.Text + +{- | +G_TYPE_DOUBLE, specifies the size of filter envelope for +/@gSTVIDEORESAMPLERMETHODLANCZOS@/. values are clamped between +1.0 and 5.0. 2.0 is the default. +-} +pattern VIDEO_RESAMPLER_OPT_ENVELOPE = "GstVideoResampler.envelope" :: T.Text + +{- | +G_TYPE_DOUBLE, C parameter of the cubic filter. The C +parameter controls the Keys alpha value. Values between 0.0 and +2.0 are accepted. 1\/3 is the default. + +See 'GI.GstVideo.Constants.VIDEO_RESAMPLER_OPT_CUBIC_B' for some more common values +-} +pattern VIDEO_RESAMPLER_OPT_CUBIC_C = "GstVideoResampler.cubic-c" :: T.Text + +{- | +G_TYPE_DOUBLE, B parameter of the cubic filter. The B +parameter controls the bluriness. Values between 0.0 and +2.0 are accepted. 1\/3 is the default. + +Below are some values of popular filters: + B C +Hermite 0.0 0.0 +Spline 1.0 0.0 +Catmull-Rom 0.0 1\/2 +Mitchell 1\/3 1\/3 +Robidoux 0.3782 0.3109 +Robidoux + Sharp 0.2620 0.3690 +Robidoux + Soft 0.6796 0.1602 +-} +pattern VIDEO_RESAMPLER_OPT_CUBIC_B = "GstVideoResampler.cubic-b" :: T.Text + +{- | +Video formats supported by 'GI.GstVideo.Structs.VideoOverlayComposition.videoOverlayCompositionBlend', for +use in overlay elements\' pad template caps. + +/Since: 1.2/ +-} +pattern VIDEO_OVERLAY_COMPOSITION_BLEND_FORMATS = "{ BGRx, RGBx, xRGB, xBGR, RGBA, BGRA, ARGB, ABGR, RGB, BGR, I420, YV12, AYUV, YUY2, UYVY, v308, Y41B, Y42B, Y444, NV12, NV21, A420, YUV9, YVU9, IYU1, GRAY8 }" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_MAX_PLANES = 4 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_MAX_COMPONENTS = 4 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_FPS_RANGE = "(fraction) [ 0, max ]" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_FORMATS_ALL = "{ I420, YV12, YUY2, UYVY, AYUV, VUYA, RGBx, BGRx, xRGB, xBGR, RGBA, BGRA, ARGB, ABGR, RGB, BGR, Y41B, Y42B, YVYU, Y444, v210, v216, Y210, Y410, NV12, NV21, GRAY8, GRAY16_BE, GRAY16_LE, v308, RGB16, BGR16, RGB15, BGR15, UYVP, A420, RGB8P, YUV9, YVU9, IYU1, ARGB64, AYUV64, r210, I420_10BE, I420_10LE, I422_10BE, I422_10LE, Y444_10BE, Y444_10LE, GBR, GBR_10BE, GBR_10LE, NV16, NV24, NV12_64Z32, A420_10BE, A420_10LE, A422_10BE, A422_10LE, A444_10BE, A444_10LE, NV61, P010_10BE, P010_10LE, IYU2, VYUY, GBRA, GBRA_10BE, GBRA_10LE, BGR10A2_LE, GBR_12BE, GBR_12LE, GBRA_12BE, GBRA_12LE, I420_12BE, I420_12LE, I422_12BE, I422_12LE, Y444_12BE, Y444_12LE, GRAY10_LE32, NV12_10LE32, NV16_10LE32, NV12_10LE40 }" :: T.Text + +{- | +The name of the templates for the source pad. +-} +pattern VIDEO_ENCODER_SRC_NAME = "src" :: T.Text + +{- | +The name of the templates for the sink pad. +-} +pattern VIDEO_ENCODER_SINK_NAME = "sink" :: T.Text + +{- | +The name of the templates for the source pad. +-} +pattern VIDEO_DECODER_SRC_NAME = "src" :: T.Text + +{- | +The name of the templates for the sink pad. +-} +pattern VIDEO_DECODER_SINK_NAME = "sink" :: T.Text + +{- | +Default maximum number of errors tolerated before signaling error. +-} +pattern VIDEO_DECODER_MAX_ERRORS = 10 :: Int32 + +{- | +@/G_TYPE_UINT/@, maximum number of threads to use. Default 1, 0 for the number +of cores. +-} +pattern VIDEO_CONVERTER_OPT_THREADS = "GstVideoConverter.threads" :: T.Text + +{- | +@/G_TYPE_INT/@, source y position to start conversion, default 0 +-} +pattern VIDEO_CONVERTER_OPT_SRC_Y = "GstVideoConverter.src-y" :: T.Text + +{- | +@/G_TYPE_INT/@, source x position to start conversion, default 0 +-} +pattern VIDEO_CONVERTER_OPT_SRC_X = "GstVideoConverter.src-x" :: T.Text + +{- | +@/G_TYPE_INT/@, source width to convert, default source width +-} +pattern VIDEO_CONVERTER_OPT_SRC_WIDTH = "GstVideoConverter.src-width" :: T.Text + +{- | +@/G_TYPE_INT/@, source height to convert, default source height +-} +pattern VIDEO_CONVERTER_OPT_SRC_HEIGHT = "GstVideoConverter.src-height" :: T.Text + +{- | +@/G_TYPE_UINT/@, The number of taps for the resampler. +Default is 0: let the resampler choose a good value. +-} +pattern VIDEO_CONVERTER_OPT_RESAMPLER_TAPS = "GstVideoConverter.resampler-taps" :: T.Text + +{- | +@/GST_TYPE_VIDEO_RESAMPLER_METHOD/@, The resampler method to use for +resampling. Other options for the resampler can be used, see +the 'GI.GstVideo.Structs.VideoResampler.VideoResampler'. Default is @/GST_VIDEO_RESAMPLER_METHOD_CUBIC/@ +-} +pattern VIDEO_CONVERTER_OPT_RESAMPLER_METHOD = "GstVideoConverter.resampler-method" :: T.Text + +{- | +@/GST_TYPE_VIDEO_PRIMARIES_MODE/@, set the primaries conversion mode. +Default is @/GST_VIDEO_PRIMARIES_MODE_NONE/@. +-} +pattern VIDEO_CONVERTER_OPT_PRIMARIES_MODE = "GstVideoConverter.primaries-mode" :: T.Text + +{- | +@/GST_TYPE_VIDEO_MATRIX_MODE/@, set the color matrix conversion mode for +converting between Y\'PbPr and non-linear RGB (R\'G\'B\'). +Default is @/GST_VIDEO_MATRIX_MODE_FULL/@. +-} +pattern VIDEO_CONVERTER_OPT_MATRIX_MODE = "GstVideoConverter.matrix-mode" :: T.Text + +{- | +@/GST_TYPE_VIDEO_GAMMA_MODE/@, set the gamma mode. +Default is @/GST_VIDEO_GAMMA_MODE_NONE/@. +-} +pattern VIDEO_CONVERTER_OPT_GAMMA_MODE = "GstVideoConverter.gamma-mode" :: T.Text + +{- | +@/G_TYPE_BOOLEAN/@, if the destination rectangle does not fill the complete +destination image, render a border with +'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_BORDER_ARGB'. Otherwise the unusded pixels in the +destination are untouched. Default 'True'. +-} +pattern VIDEO_CONVERTER_OPT_FILL_BORDER = "GstVideoConverter.fill-border" :: T.Text + +{- | +@/G_TYPE_UINT/@, The quantization amount to dither to. Components will be +quantized to multiples of this value. +Default is 1 +-} +pattern VIDEO_CONVERTER_OPT_DITHER_QUANTIZATION = "GstVideoConverter.dither-quantization" :: T.Text + +{- | +@/GST_TYPE_VIDEO_DITHER_METHOD/@, The dither method to use when +changing bit depth. +Default is @/GST_VIDEO_DITHER_BAYER/@. +-} +pattern VIDEO_CONVERTER_OPT_DITHER_METHOD = "GstVideoConverter.dither-method" :: T.Text + +{- | +@/G_TYPE_INT/@, y position in the destination frame, default 0 +-} +pattern VIDEO_CONVERTER_OPT_DEST_Y = "GstVideoConverter.dest-y" :: T.Text + +{- | +@/G_TYPE_INT/@, x position in the destination frame, default 0 +-} +pattern VIDEO_CONVERTER_OPT_DEST_X = "GstVideoConverter.dest-x" :: T.Text + +{- | +@/G_TYPE_INT/@, width in the destination frame, default destination width +-} +pattern VIDEO_CONVERTER_OPT_DEST_WIDTH = "GstVideoConverter.dest-width" :: T.Text + +{- | +@/G_TYPE_INT/@, height in the destination frame, default destination height +-} +pattern VIDEO_CONVERTER_OPT_DEST_HEIGHT = "GstVideoConverter.dest-height" :: T.Text + +{- | +@/GST_TYPE_VIDEO_RESAMPLER_METHOD/@, The resampler method to use for +chroma resampling. Other options for the resampler can be used, see +the 'GI.GstVideo.Structs.VideoResampler.VideoResampler'. Default is @/GST_VIDEO_RESAMPLER_METHOD_LINEAR/@ +-} +pattern VIDEO_CONVERTER_OPT_CHROMA_RESAMPLER_METHOD = "GstVideoConverter.chroma-resampler-method" :: T.Text + +{- | +@/GST_TYPE_VIDEO_CHROMA_MODE/@, set the chroma resample mode subsampled +formats. Default is @/GST_VIDEO_CHROMA_MODE_FULL/@. +-} +pattern VIDEO_CONVERTER_OPT_CHROMA_MODE = "GstVideoConverter.chroma-mode" :: T.Text + +{- | +@/G_TYPE_UINT/@, the border color to use if 'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_FILL_BORDER' +is set to 'True'. The color is in ARGB format. +Default 0xff000000 +-} +pattern VIDEO_CONVERTER_OPT_BORDER_ARGB = "GstVideoConverter.border-argb" :: T.Text + +{- | +@/G_TYPE_DOUBLE/@, the alpha color value to use. +Default to 1.0 +-} +pattern VIDEO_CONVERTER_OPT_ALPHA_VALUE = "GstVideoConverter.alpha-value" :: T.Text + +{- | +@/GST_TYPE_VIDEO_ALPHA_MODE/@, the alpha mode to use. +Default is @/GST_VIDEO_ALPHA_MODE_COPY/@. +-} +pattern VIDEO_CONVERTER_OPT_ALPHA_MODE = "GstVideoConverter.alpha-mode" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COMP_Y = 0 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COMP_V = 2 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COMP_U = 1 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COMP_R = 0 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COMP_PALETTE = 1 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COMP_INDEX = 0 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COMP_G = 1 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COMP_B = 2 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COMP_A = 3 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COLORIMETRY_SRGB = "sRGB" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COLORIMETRY_SMPTE240M = "smpte240m" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COLORIMETRY_BT709 = "bt709" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COLORIMETRY_BT601 = "bt601" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern VIDEO_COLORIMETRY_BT2020 = "bt2020" :: T.Text + +{- | +This metadata is relevant for video streams. + +/Since: 1.2/ +-} +pattern META_TAG_VIDEO_STR = "video" :: T.Text + +{- | +This metadata stays relevant as long as video size is unchanged. + +/Since: 1.2/ +-} +pattern META_TAG_VIDEO_SIZE_STR = "size" :: T.Text + +{- | +This metadata stays relevant as long as video orientation is unchanged. + +/Since: 1.2/ +-} +pattern META_TAG_VIDEO_ORIENTATION_STR = "orientation" :: T.Text + +{- | +This metadata stays relevant as long as video colorspace is unchanged. + +/Since: 1.2/ +-} +pattern META_TAG_VIDEO_COLORSPACE_STR = "colorspace" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION = "meta:GstVideoOverlayComposition" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern CAPS_FEATURE_META_GST_VIDEO_META = "meta:GstVideoMeta" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META = "meta:GstVideoGLTextureUploadMeta" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern CAPS_FEATURE_META_GST_VIDEO_AFFINE_TRANSFORMATION_META = "meta:GstVideoAffineTransformation" :: T.Text + +{- | +Name of the caps feature indicating that the stream is interlaced. Currently +it is only used for video. + +/Since: 1.16./ +-} +pattern CAPS_FEATURE_FORMAT_INTERLACED = "format:Interlaced" :: T.Text + +{- | +An option that can be activated on bufferpool to request video metadata +on buffers from the pool. +-} +pattern BUFFER_POOL_OPTION_VIDEO_META = "GstBufferPoolOptionVideoMeta" :: T.Text + +{- | +An option that can be activated on a bufferpool to request gl texture upload +meta on buffers from the pool. + +When this option is enabled on the bufferpool, +/@gSTBUFFERPOOLOPTIONVIDEOMETA@/ should also be enabled. + +/Since: 1.2.2/ +-} +pattern BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META = "GstBufferPoolOptionVideoGLTextureUploadMeta" :: T.Text + +{- | +A bufferpool option to enable extra padding. When a bufferpool supports this +option, 'GI.GstVideo.Functions.bufferPoolConfigSetVideoAlignment' can be called. + +When this option is enabled on the bufferpool, +'GI.GstVideo.Constants.BUFFER_POOL_OPTION_VIDEO_META' should also be enabled. +-} +pattern BUFFER_POOL_OPTION_VIDEO_ALIGNMENT = "GstBufferPoolOptionVideoAlignment" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern BUFFER_POOL_OPTION_VIDEO_AFFINE_TRANSFORMATION_META = "GstBufferPoolOptionVideoAffineTransformation" :: T.Text + + diff --git a/GI/GstVideo/Enums.hs b/GI/GstVideo/Enums.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Enums.hs @@ -0,0 +1,2633 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Enums + ( + + -- * Enumerations +-- ** ColorBalanceType #enum:ColorBalanceType# + + ColorBalanceType(..) , + + +-- ** NavigationCommand #enum:NavigationCommand# + + NavigationCommand(..) , + + +-- ** NavigationEventType #enum:NavigationEventType# + + NavigationEventType(..) , + + +-- ** NavigationMessageType #enum:NavigationMessageType# + + NavigationMessageType(..) , + + +-- ** NavigationQueryType #enum:NavigationQueryType# + + NavigationQueryType(..) , + + +-- ** VideoAlphaMode #enum:VideoAlphaMode# + + VideoAlphaMode(..) , + + +-- ** VideoAncillaryDID #enum:VideoAncillaryDID# + + VideoAncillaryDID(..) , + + +-- ** VideoAncillaryDID16 #enum:VideoAncillaryDID16# + + VideoAncillaryDID16(..) , + + +-- ** VideoCaptionType #enum:VideoCaptionType# + + VideoCaptionType(..) , + + +-- ** VideoChromaMethod #enum:VideoChromaMethod# + + VideoChromaMethod(..) , + + +-- ** VideoChromaMode #enum:VideoChromaMode# + + VideoChromaMode(..) , + + +-- ** VideoColorMatrix #enum:VideoColorMatrix# + + VideoColorMatrix(..) , + + +-- ** VideoColorPrimaries #enum:VideoColorPrimaries# + + VideoColorPrimaries(..) , + + +-- ** VideoColorRange #enum:VideoColorRange# + + VideoColorRange(..) , + + +-- ** VideoDitherMethod #enum:VideoDitherMethod# + + VideoDitherMethod(..) , + + +-- ** VideoFieldOrder #enum:VideoFieldOrder# + + VideoFieldOrder(..) , + + +-- ** VideoFormat #enum:VideoFormat# + + VideoFormat(..) , + + +-- ** VideoGLTextureOrientation #enum:VideoGLTextureOrientation# + + VideoGLTextureOrientation(..) , + + +-- ** VideoGLTextureType #enum:VideoGLTextureType# + + VideoGLTextureType(..) , + + +-- ** VideoGammaMode #enum:VideoGammaMode# + + VideoGammaMode(..) , + + +-- ** VideoInterlaceMode #enum:VideoInterlaceMode# + + VideoInterlaceMode(..) , + + +-- ** VideoMatrixMode #enum:VideoMatrixMode# + + VideoMatrixMode(..) , + + +-- ** VideoMultiviewFramePacking #enum:VideoMultiviewFramePacking# + + VideoMultiviewFramePacking(..) , + + +-- ** VideoMultiviewMode #enum:VideoMultiviewMode# + + VideoMultiviewMode(..) , + + +-- ** VideoOrientationMethod #enum:VideoOrientationMethod# + + VideoOrientationMethod(..) , + + +-- ** VideoPrimariesMode #enum:VideoPrimariesMode# + + VideoPrimariesMode(..) , + + +-- ** VideoResamplerMethod #enum:VideoResamplerMethod# + + VideoResamplerMethod(..) , + + +-- ** VideoTileMode #enum:VideoTileMode# + + VideoTileMode(..) , + + +-- ** VideoTileType #enum:VideoTileType# + + VideoTileType(..) , + + +-- ** VideoTransferFunction #enum:VideoTransferFunction# + + VideoTransferFunction(..) , + + +-- ** VideoVBIParserResult #enum:VideoVBIParserResult# + + VideoVBIParserResult(..) , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- Enum VideoVBIParserResult +{- | +Return values for 'GI.GstVideo.Structs.VideoVBIParser.VideoVBIParser' + +/Since: 1.16/ +-} +data VideoVBIParserResult = + VideoVBIParserResultDone + {- ^ + No line were provided, or no more Ancillary data was found. + -} + | VideoVBIParserResultOk + {- ^ + A 'GI.GstVideo.Structs.VideoAncillary.VideoAncillary' was found. + -} + | VideoVBIParserResultError + {- ^ + An error occured + -} + | AnotherVideoVBIParserResult Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoVBIParserResult where + fromEnum VideoVBIParserResultDone = 0 + fromEnum VideoVBIParserResultOk = 1 + fromEnum VideoVBIParserResultError = 2 + fromEnum (AnotherVideoVBIParserResult k) = k + + toEnum 0 = VideoVBIParserResultDone + toEnum 1 = VideoVBIParserResultOk + toEnum 2 = VideoVBIParserResultError + toEnum k = AnotherVideoVBIParserResult k + +instance P.Ord VideoVBIParserResult where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_vbi_parser_result_get_type" c_gst_video_vbi_parser_result_get_type :: + IO GType + +instance BoxedEnum VideoVBIParserResult where + boxedEnumType _ = c_gst_video_vbi_parser_result_get_type + +-- Enum VideoTransferFunction +{- | +The video transfer function defines the formula for converting between +non-linear RGB (R\'G\'B\') and linear RGB +-} +data VideoTransferFunction = + VideoTransferFunctionUnknown + {- ^ + unknown transfer function + -} + | VideoTransferFunctionGamma10 + {- ^ + linear RGB, gamma 1.0 curve + -} + | VideoTransferFunctionGamma18 + {- ^ + Gamma 1.8 curve + -} + | VideoTransferFunctionGamma20 + {- ^ + Gamma 2.0 curve + -} + | VideoTransferFunctionGamma22 + {- ^ + Gamma 2.2 curve + -} + | VideoTransferFunctionBt709 + {- ^ + Gamma 2.2 curve with a linear segment in the lower + range + -} + | VideoTransferFunctionSmpte240m + {- ^ + Gamma 2.2 curve with a linear segment in the + lower range + -} + | VideoTransferFunctionSrgb + {- ^ + Gamma 2.4 curve with a linear segment in the lower + range + -} + | VideoTransferFunctionGamma28 + {- ^ + Gamma 2.8 curve + -} + | VideoTransferFunctionLog100 + {- ^ + Logarithmic transfer characteristic + 100:1 range + -} + | VideoTransferFunctionLog316 + {- ^ + Logarithmic transfer characteristic + 316.22777:1 range + -} + | VideoTransferFunctionBt202012 + {- ^ + Gamma 2.2 curve with a linear segment in the lower + range. Used for BT.2020 with 12 bits per + component. Since: 1.6 + -} + | VideoTransferFunctionAdobergb + {- ^ + Gamma 2.19921875. Since: 1.8 + -} + | AnotherVideoTransferFunction Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoTransferFunction where + fromEnum VideoTransferFunctionUnknown = 0 + fromEnum VideoTransferFunctionGamma10 = 1 + fromEnum VideoTransferFunctionGamma18 = 2 + fromEnum VideoTransferFunctionGamma20 = 3 + fromEnum VideoTransferFunctionGamma22 = 4 + fromEnum VideoTransferFunctionBt709 = 5 + fromEnum VideoTransferFunctionSmpte240m = 6 + fromEnum VideoTransferFunctionSrgb = 7 + fromEnum VideoTransferFunctionGamma28 = 8 + fromEnum VideoTransferFunctionLog100 = 9 + fromEnum VideoTransferFunctionLog316 = 10 + fromEnum VideoTransferFunctionBt202012 = 11 + fromEnum VideoTransferFunctionAdobergb = 12 + fromEnum (AnotherVideoTransferFunction k) = k + + toEnum 0 = VideoTransferFunctionUnknown + toEnum 1 = VideoTransferFunctionGamma10 + toEnum 2 = VideoTransferFunctionGamma18 + toEnum 3 = VideoTransferFunctionGamma20 + toEnum 4 = VideoTransferFunctionGamma22 + toEnum 5 = VideoTransferFunctionBt709 + toEnum 6 = VideoTransferFunctionSmpte240m + toEnum 7 = VideoTransferFunctionSrgb + toEnum 8 = VideoTransferFunctionGamma28 + toEnum 9 = VideoTransferFunctionLog100 + toEnum 10 = VideoTransferFunctionLog316 + toEnum 11 = VideoTransferFunctionBt202012 + toEnum 12 = VideoTransferFunctionAdobergb + toEnum k = AnotherVideoTransferFunction k + +instance P.Ord VideoTransferFunction where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_transfer_function_get_type" c_gst_video_transfer_function_get_type :: + IO GType + +instance BoxedEnum VideoTransferFunction where + boxedEnumType _ = c_gst_video_transfer_function_get_type + +-- Enum VideoTileType +{- | +Enum value describing the most common tiling types. +-} +data VideoTileType = + VideoTileTypeIndexed + {- ^ + Tiles are indexed. Use + gst_video_tile_get_index () to retrieve the tile at the requested + coordinates. + -} + | AnotherVideoTileType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoTileType where + fromEnum VideoTileTypeIndexed = 0 + fromEnum (AnotherVideoTileType k) = k + + toEnum 0 = VideoTileTypeIndexed + toEnum k = AnotherVideoTileType k + +instance P.Ord VideoTileType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_tile_type_get_type" c_gst_video_tile_type_get_type :: + IO GType + +instance BoxedEnum VideoTileType where + boxedEnumType _ = c_gst_video_tile_type_get_type + +-- Enum VideoTileMode +{- | +Enum value describing the available tiling modes. +-} +data VideoTileMode = + VideoTileModeUnknown + {- ^ + Unknown or unset tile mode + -} + | VideoTileModeZflipz2x2 + {- ^ + Every four adjacent blocks - two + horizontally and two vertically are grouped together and are located + in memory in Z or flipped Z order. In case of odd rows, the last row + of blocks is arranged in linear order. + -} + | AnotherVideoTileMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoTileMode where + fromEnum VideoTileModeUnknown = 0 + fromEnum VideoTileModeZflipz2x2 = 65536 + fromEnum (AnotherVideoTileMode k) = k + + toEnum 0 = VideoTileModeUnknown + toEnum 65536 = VideoTileModeZflipz2x2 + toEnum k = AnotherVideoTileMode k + +instance P.Ord VideoTileMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_tile_mode_get_type" c_gst_video_tile_mode_get_type :: + IO GType + +instance BoxedEnum VideoTileMode where + boxedEnumType _ = c_gst_video_tile_mode_get_type + +-- Enum VideoResamplerMethod +{- | +Different subsampling and upsampling methods + +/Since: 1.6/ +-} +data VideoResamplerMethod = + VideoResamplerMethodNearest + {- ^ + Duplicates the samples when + upsampling and drops when downsampling + -} + | VideoResamplerMethodLinear + {- ^ + Uses linear interpolation to reconstruct + missing samples and averaging to downsample + -} + | VideoResamplerMethodCubic + {- ^ + Uses cubic interpolation + -} + | VideoResamplerMethodSinc + {- ^ + Uses sinc interpolation + -} + | VideoResamplerMethodLanczos + {- ^ + Uses lanczos interpolation + -} + | AnotherVideoResamplerMethod Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoResamplerMethod where + fromEnum VideoResamplerMethodNearest = 0 + fromEnum VideoResamplerMethodLinear = 1 + fromEnum VideoResamplerMethodCubic = 2 + fromEnum VideoResamplerMethodSinc = 3 + fromEnum VideoResamplerMethodLanczos = 4 + fromEnum (AnotherVideoResamplerMethod k) = k + + toEnum 0 = VideoResamplerMethodNearest + toEnum 1 = VideoResamplerMethodLinear + toEnum 2 = VideoResamplerMethodCubic + toEnum 3 = VideoResamplerMethodSinc + toEnum 4 = VideoResamplerMethodLanczos + toEnum k = AnotherVideoResamplerMethod k + +instance P.Ord VideoResamplerMethod where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_resampler_method_get_type" c_gst_video_resampler_method_get_type :: + IO GType + +instance BoxedEnum VideoResamplerMethod where + boxedEnumType _ = c_gst_video_resampler_method_get_type + +-- Enum VideoPrimariesMode +{- | +Different primaries conversion modes + +/Since: 1.6/ +-} +data VideoPrimariesMode = + VideoPrimariesModeNone + {- ^ + disable conversion between primaries + -} + | VideoPrimariesModeMergeOnly + {- ^ + do conversion between primaries only + when it can be merged with color matrix conversion. + -} + | VideoPrimariesModeFast + {- ^ + fast conversion between primaries + -} + | AnotherVideoPrimariesMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoPrimariesMode where + fromEnum VideoPrimariesModeNone = 0 + fromEnum VideoPrimariesModeMergeOnly = 1 + fromEnum VideoPrimariesModeFast = 2 + fromEnum (AnotherVideoPrimariesMode k) = k + + toEnum 0 = VideoPrimariesModeNone + toEnum 1 = VideoPrimariesModeMergeOnly + toEnum 2 = VideoPrimariesModeFast + toEnum k = AnotherVideoPrimariesMode k + +instance P.Ord VideoPrimariesMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_primaries_mode_get_type" c_gst_video_primaries_mode_get_type :: + IO GType + +instance BoxedEnum VideoPrimariesMode where + boxedEnumType _ = c_gst_video_primaries_mode_get_type + +-- Enum VideoOrientationMethod +{- | +The different video orientation methods. + +/Since: 1.10/ +-} +data VideoOrientationMethod = + VideoOrientationMethodIdentity + {- ^ + Identity (no rotation) + -} + | VideoOrientationMethod90r + {- ^ + Rotate clockwise 90 degrees + -} + | VideoOrientationMethod180 + {- ^ + Rotate 180 degrees + -} + | VideoOrientationMethod90l + {- ^ + Rotate counter-clockwise 90 degrees + -} + | VideoOrientationMethodHoriz + {- ^ + Flip horizontally + -} + | VideoOrientationMethodVert + {- ^ + Flip vertically + -} + | VideoOrientationMethodUlLr + {- ^ + Flip across upper left\/lower right diagonal + -} + | VideoOrientationMethodUrLl + {- ^ + Flip across upper right\/lower left diagonal + -} + | VideoOrientationMethodAuto + {- ^ + Select flip method based on image-orientation tag + -} + | VideoOrientationMethodCustom + {- ^ + Current status depends on plugin internal setup + -} + | AnotherVideoOrientationMethod Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoOrientationMethod where + fromEnum VideoOrientationMethodIdentity = 0 + fromEnum VideoOrientationMethod90r = 1 + fromEnum VideoOrientationMethod180 = 2 + fromEnum VideoOrientationMethod90l = 3 + fromEnum VideoOrientationMethodHoriz = 4 + fromEnum VideoOrientationMethodVert = 5 + fromEnum VideoOrientationMethodUlLr = 6 + fromEnum VideoOrientationMethodUrLl = 7 + fromEnum VideoOrientationMethodAuto = 8 + fromEnum VideoOrientationMethodCustom = 9 + fromEnum (AnotherVideoOrientationMethod k) = k + + toEnum 0 = VideoOrientationMethodIdentity + toEnum 1 = VideoOrientationMethod90r + toEnum 2 = VideoOrientationMethod180 + toEnum 3 = VideoOrientationMethod90l + toEnum 4 = VideoOrientationMethodHoriz + toEnum 5 = VideoOrientationMethodVert + toEnum 6 = VideoOrientationMethodUlLr + toEnum 7 = VideoOrientationMethodUrLl + toEnum 8 = VideoOrientationMethodAuto + toEnum 9 = VideoOrientationMethodCustom + toEnum k = AnotherVideoOrientationMethod k + +instance P.Ord VideoOrientationMethod where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_orientation_method_get_type" c_gst_video_orientation_method_get_type :: + IO GType + +instance BoxedEnum VideoOrientationMethod where + boxedEnumType _ = c_gst_video_orientation_method_get_type + +-- Enum VideoMultiviewMode +{- | +All possible stereoscopic 3D and multiview representations. +In conjunction with 'GI.GstVideo.Flags.VideoMultiviewFlags', describes how +multiview content is being transported in the stream. +-} +data VideoMultiviewMode = + VideoMultiviewModeNone + {- ^ + A special value indicating + no multiview information. Used in GstVideoInfo and other places to + indicate that no specific multiview handling has been requested or + provided. This value is never carried on caps. + -} + | VideoMultiviewModeMono + {- ^ + All frames are monoscopic. + -} + | VideoMultiviewModeLeft + {- ^ + All frames represent a left-eye view. + -} + | VideoMultiviewModeRight + {- ^ + All frames represent a right-eye view. + -} + | VideoMultiviewModeSideBySide + {- ^ + Left and right eye views are + provided in the left and right half of the frame respectively. + -} + | VideoMultiviewModeSideBySideQuincunx + {- ^ + Left and right eye + views are provided in the left and right half of the frame, but + have been sampled using quincunx method, with half-pixel offset + between the 2 views. + -} + | VideoMultiviewModeColumnInterleaved + {- ^ + Alternating vertical + columns of pixels represent the left and right eye view respectively. + -} + | VideoMultiviewModeRowInterleaved + {- ^ + Alternating horizontal + rows of pixels represent the left and right eye view respectively. + -} + | VideoMultiviewModeTopBottom + {- ^ + The top half of the frame + contains the left eye, and the bottom half the right eye. + -} + | VideoMultiviewModeCheckerboard + {- ^ + Pixels are arranged with + alternating pixels representing left and right eye views in a + checkerboard fashion. + -} + | VideoMultiviewModeFrameByFrame + {- ^ + Left and right eye views + are provided in separate frames alternately. + -} + | VideoMultiviewModeMultiviewFrameByFrame + {- ^ + Multiple + independent views are provided in separate frames in sequence. + This method only applies to raw video buffers at the moment. + Specific view identification is via the @/GstVideoMultiviewMeta/@ + and 'GI.GstVideo.Structs.VideoMeta.VideoMeta'(s) on raw video buffers. + -} + | VideoMultiviewModeSeparated + {- ^ + Multiple views are + provided as separate 'GI.Gst.Structs.Memory.Memory' framebuffers attached to each + 'GI.Gst.Structs.Buffer.Buffer', described by the @/GstVideoMultiviewMeta/@ + and 'GI.GstVideo.Structs.VideoMeta.VideoMeta'(s) + -} + | AnotherVideoMultiviewMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoMultiviewMode where + fromEnum VideoMultiviewModeNone = -1 + fromEnum VideoMultiviewModeMono = 0 + fromEnum VideoMultiviewModeLeft = 1 + fromEnum VideoMultiviewModeRight = 2 + fromEnum VideoMultiviewModeSideBySide = 3 + fromEnum VideoMultiviewModeSideBySideQuincunx = 4 + fromEnum VideoMultiviewModeColumnInterleaved = 5 + fromEnum VideoMultiviewModeRowInterleaved = 6 + fromEnum VideoMultiviewModeTopBottom = 7 + fromEnum VideoMultiviewModeCheckerboard = 8 + fromEnum VideoMultiviewModeFrameByFrame = 32 + fromEnum VideoMultiviewModeMultiviewFrameByFrame = 33 + fromEnum VideoMultiviewModeSeparated = 34 + fromEnum (AnotherVideoMultiviewMode k) = k + + toEnum -1 = VideoMultiviewModeNone + toEnum 0 = VideoMultiviewModeMono + toEnum 1 = VideoMultiviewModeLeft + toEnum 2 = VideoMultiviewModeRight + toEnum 3 = VideoMultiviewModeSideBySide + toEnum 4 = VideoMultiviewModeSideBySideQuincunx + toEnum 5 = VideoMultiviewModeColumnInterleaved + toEnum 6 = VideoMultiviewModeRowInterleaved + toEnum 7 = VideoMultiviewModeTopBottom + toEnum 8 = VideoMultiviewModeCheckerboard + toEnum 32 = VideoMultiviewModeFrameByFrame + toEnum 33 = VideoMultiviewModeMultiviewFrameByFrame + toEnum 34 = VideoMultiviewModeSeparated + toEnum k = AnotherVideoMultiviewMode k + +instance P.Ord VideoMultiviewMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_multiview_mode_get_type" c_gst_video_multiview_mode_get_type :: + IO GType + +instance BoxedEnum VideoMultiviewMode where + boxedEnumType _ = c_gst_video_multiview_mode_get_type + +-- Enum VideoMultiviewFramePacking +{- | +'GI.GstVideo.Enums.VideoMultiviewFramePacking' represents the subset of 'GI.GstVideo.Enums.VideoMultiviewMode' +values that can be applied to any video frame without needing extra metadata. +It can be used by elements that provide a property to override the +multiview interpretation of a video stream when the video doesn\'t contain +any markers. + +This enum is used (for example) on playbin, to re-interpret a played +video stream as a stereoscopic video. The individual enum values are +equivalent to and have the same value as the matching 'GI.GstVideo.Enums.VideoMultiviewMode'. +-} +data VideoMultiviewFramePacking = + VideoMultiviewFramePackingNone + {- ^ + A special value indicating + no frame packing info. + -} + | VideoMultiviewFramePackingMono + {- ^ + All frames are monoscopic. + -} + | VideoMultiviewFramePackingLeft + {- ^ + All frames represent a left-eye view. + -} + | VideoMultiviewFramePackingRight + {- ^ + All frames represent a right-eye view. + -} + | VideoMultiviewFramePackingSideBySide + {- ^ + Left and right eye views are + provided in the left and right half of the frame respectively. + -} + | VideoMultiviewFramePackingSideBySideQuincunx + {- ^ + Left and right eye + views are provided in the left and right half of the frame, but + have been sampled using quincunx method, with half-pixel offset + between the 2 views. + -} + | VideoMultiviewFramePackingColumnInterleaved + {- ^ + Alternating vertical + columns of pixels represent the left and right eye view respectively. + -} + | VideoMultiviewFramePackingRowInterleaved + {- ^ + Alternating horizontal + rows of pixels represent the left and right eye view respectively. + -} + | VideoMultiviewFramePackingTopBottom + {- ^ + The top half of the frame + contains the left eye, and the bottom half the right eye. + -} + | VideoMultiviewFramePackingCheckerboard + {- ^ + Pixels are arranged with + alternating pixels representing left and right eye views in a + checkerboard fashion. + -} + | AnotherVideoMultiviewFramePacking Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoMultiviewFramePacking where + fromEnum VideoMultiviewFramePackingNone = -1 + fromEnum VideoMultiviewFramePackingMono = 0 + fromEnum VideoMultiviewFramePackingLeft = 1 + fromEnum VideoMultiviewFramePackingRight = 2 + fromEnum VideoMultiviewFramePackingSideBySide = 3 + fromEnum VideoMultiviewFramePackingSideBySideQuincunx = 4 + fromEnum VideoMultiviewFramePackingColumnInterleaved = 5 + fromEnum VideoMultiviewFramePackingRowInterleaved = 6 + fromEnum VideoMultiviewFramePackingTopBottom = 7 + fromEnum VideoMultiviewFramePackingCheckerboard = 8 + fromEnum (AnotherVideoMultiviewFramePacking k) = k + + toEnum -1 = VideoMultiviewFramePackingNone + toEnum 0 = VideoMultiviewFramePackingMono + toEnum 1 = VideoMultiviewFramePackingLeft + toEnum 2 = VideoMultiviewFramePackingRight + toEnum 3 = VideoMultiviewFramePackingSideBySide + toEnum 4 = VideoMultiviewFramePackingSideBySideQuincunx + toEnum 5 = VideoMultiviewFramePackingColumnInterleaved + toEnum 6 = VideoMultiviewFramePackingRowInterleaved + toEnum 7 = VideoMultiviewFramePackingTopBottom + toEnum 8 = VideoMultiviewFramePackingCheckerboard + toEnum k = AnotherVideoMultiviewFramePacking k + +instance P.Ord VideoMultiviewFramePacking where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_multiview_frame_packing_get_type" c_gst_video_multiview_frame_packing_get_type :: + IO GType + +instance BoxedEnum VideoMultiviewFramePacking where + boxedEnumType _ = c_gst_video_multiview_frame_packing_get_type + +-- Enum VideoMatrixMode +{- | +Different color matrix conversion modes + +/Since: 1.6/ +-} +data VideoMatrixMode = + VideoMatrixModeFull + {- ^ + do conversion between color matrices + -} + | VideoMatrixModeInputOnly + {- ^ + use the input color matrix to convert + to and from R\'G\'B + -} + | VideoMatrixModeOutputOnly + {- ^ + use the output color matrix to convert + to and from R\'G\'B + -} + | VideoMatrixModeNone + {- ^ + disable color matrix conversion. + -} + | AnotherVideoMatrixMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoMatrixMode where + fromEnum VideoMatrixModeFull = 0 + fromEnum VideoMatrixModeInputOnly = 1 + fromEnum VideoMatrixModeOutputOnly = 2 + fromEnum VideoMatrixModeNone = 3 + fromEnum (AnotherVideoMatrixMode k) = k + + toEnum 0 = VideoMatrixModeFull + toEnum 1 = VideoMatrixModeInputOnly + toEnum 2 = VideoMatrixModeOutputOnly + toEnum 3 = VideoMatrixModeNone + toEnum k = AnotherVideoMatrixMode k + +instance P.Ord VideoMatrixMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_matrix_mode_get_type" c_gst_video_matrix_mode_get_type :: + IO GType + +instance BoxedEnum VideoMatrixMode where + boxedEnumType _ = c_gst_video_matrix_mode_get_type + +-- Enum VideoInterlaceMode +{- | +The possible values of the 'GI.GstVideo.Enums.VideoInterlaceMode' describing the interlace +mode of the stream. +-} +data VideoInterlaceMode = + VideoInterlaceModeProgressive + {- ^ + all frames are progressive + -} + | VideoInterlaceModeInterleaved + {- ^ + 2 fields are interleaved in one video + frame. Extra buffer flags describe the field order. + -} + | VideoInterlaceModeMixed + {- ^ + frames contains both interlaced and + progressive video, the buffer flags describe the frame and fields. + -} + | VideoInterlaceModeFields + {- ^ + 2 fields are stored in one buffer, use the + frame ID to get access to the required field. For multiview (the + \'views\' property > 1) the fields of view N can be found at frame ID + (N * 2) and (N * 2) + 1. + Each field has only half the amount of lines as noted in the + height property. This mode requires multiple GstVideoMeta metadata + to describe the fields. + -} + | VideoInterlaceModeAlternate + {- ^ + 1 field is stored in one buffer, + /@gSTVIDEOBUFFERFLAGTF@/ or /@gSTVIDEOBUFFERFLAGBF@/ indicates if + the buffer is carrying the top or bottom field, respectively. The top and + bottom buffers are expected to alternate in the pipeline, with this mode + (Since: 1.16). + -} + | AnotherVideoInterlaceMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoInterlaceMode where + fromEnum VideoInterlaceModeProgressive = 0 + fromEnum VideoInterlaceModeInterleaved = 1 + fromEnum VideoInterlaceModeMixed = 2 + fromEnum VideoInterlaceModeFields = 3 + fromEnum VideoInterlaceModeAlternate = 4 + fromEnum (AnotherVideoInterlaceMode k) = k + + toEnum 0 = VideoInterlaceModeProgressive + toEnum 1 = VideoInterlaceModeInterleaved + toEnum 2 = VideoInterlaceModeMixed + toEnum 3 = VideoInterlaceModeFields + toEnum 4 = VideoInterlaceModeAlternate + toEnum k = AnotherVideoInterlaceMode k + +instance P.Ord VideoInterlaceMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_interlace_mode_get_type" c_gst_video_interlace_mode_get_type :: + IO GType + +instance BoxedEnum VideoInterlaceMode where + boxedEnumType _ = c_gst_video_interlace_mode_get_type + +-- Enum VideoGammaMode +{- | +/No description available in the introspection data./ + +/Since: 1.6/ +-} +data VideoGammaMode = + VideoGammaModeNone + {- ^ + disable gamma handling + -} + | VideoGammaModeRemap + {- ^ + convert between input and output gamma + Different gamma conversion modes + -} + | AnotherVideoGammaMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoGammaMode where + fromEnum VideoGammaModeNone = 0 + fromEnum VideoGammaModeRemap = 1 + fromEnum (AnotherVideoGammaMode k) = k + + toEnum 0 = VideoGammaModeNone + toEnum 1 = VideoGammaModeRemap + toEnum k = AnotherVideoGammaMode k + +instance P.Ord VideoGammaMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_gamma_mode_get_type" c_gst_video_gamma_mode_get_type :: + IO GType + +instance BoxedEnum VideoGammaMode where + boxedEnumType _ = c_gst_video_gamma_mode_get_type + +-- Enum VideoGLTextureType +{- | +The GL texture type. +-} +data VideoGLTextureType = + VideoGLTextureTypeLuminance + {- ^ + Luminance texture, GL_LUMINANCE + -} + | VideoGLTextureTypeLuminanceAlpha + {- ^ + Luminance-alpha texture, GL_LUMINANCE_ALPHA + -} + | VideoGLTextureTypeRgb16 + {- ^ + RGB 565 texture, GL_RGB + -} + | VideoGLTextureTypeRgb + {- ^ + RGB texture, GL_RGB + -} + | VideoGLTextureTypeRgba + {- ^ + RGBA texture, GL_RGBA + -} + | VideoGLTextureTypeR + {- ^ + R texture, GL_RED_EXT + -} + | VideoGLTextureTypeRg + {- ^ + RG texture, GL_RG_EXT + -} + | AnotherVideoGLTextureType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoGLTextureType where + fromEnum VideoGLTextureTypeLuminance = 0 + fromEnum VideoGLTextureTypeLuminanceAlpha = 1 + fromEnum VideoGLTextureTypeRgb16 = 2 + fromEnum VideoGLTextureTypeRgb = 3 + fromEnum VideoGLTextureTypeRgba = 4 + fromEnum VideoGLTextureTypeR = 5 + fromEnum VideoGLTextureTypeRg = 6 + fromEnum (AnotherVideoGLTextureType k) = k + + toEnum 0 = VideoGLTextureTypeLuminance + toEnum 1 = VideoGLTextureTypeLuminanceAlpha + toEnum 2 = VideoGLTextureTypeRgb16 + toEnum 3 = VideoGLTextureTypeRgb + toEnum 4 = VideoGLTextureTypeRgba + toEnum 5 = VideoGLTextureTypeR + toEnum 6 = VideoGLTextureTypeRg + toEnum k = AnotherVideoGLTextureType k + +instance P.Ord VideoGLTextureType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum VideoGLTextureOrientation +{- | +The orientation of the GL texture. +-} +data VideoGLTextureOrientation = + VideoGLTextureOrientationNormalYNormal + {- ^ + Top line first in memory, left row first + -} + | VideoGLTextureOrientationNormalYFlip + {- ^ + Bottom line first in memory, left row first + -} + | VideoGLTextureOrientationFlipYNormal + {- ^ + Top line first in memory, right row first + -} + | VideoGLTextureOrientationFlipYFlip + {- ^ + Bottom line first in memory, right row first + -} + | AnotherVideoGLTextureOrientation Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoGLTextureOrientation where + fromEnum VideoGLTextureOrientationNormalYNormal = 0 + fromEnum VideoGLTextureOrientationNormalYFlip = 1 + fromEnum VideoGLTextureOrientationFlipYNormal = 2 + fromEnum VideoGLTextureOrientationFlipYFlip = 3 + fromEnum (AnotherVideoGLTextureOrientation k) = k + + toEnum 0 = VideoGLTextureOrientationNormalYNormal + toEnum 1 = VideoGLTextureOrientationNormalYFlip + toEnum 2 = VideoGLTextureOrientationFlipYNormal + toEnum 3 = VideoGLTextureOrientationFlipYFlip + toEnum k = AnotherVideoGLTextureOrientation k + +instance P.Ord VideoGLTextureOrientation where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum VideoFormat +{- | +Enum value describing the most common video formats. + +See the +for details about the layout and packing of these formats in memory. +-} +data VideoFormat = + VideoFormatUnknown + {- ^ + Unknown or unset video format id + -} + | VideoFormatEncoded + {- ^ + Encoded video format. Only ever use that in caps for + special video formats in combination with non-system + memory GstCapsFeatures where it does not make sense + to specify a real video format. + -} + | VideoFormatI420 + {- ^ + planar 4:2:0 YUV + -} + | VideoFormatYv12 + {- ^ + planar 4:2:0 YVU (like I420 but UV planes swapped) + -} + | VideoFormatYuy2 + {- ^ + packed 4:2:2 YUV (Y0-U0-Y1-V0 Y2-U2-Y3-V2 Y4 ...) + -} + | VideoFormatUyvy + {- ^ + packed 4:2:2 YUV (U0-Y0-V0-Y1 U2-Y2-V2-Y3 U4 ...) + -} + | VideoFormatAyuv + {- ^ + packed 4:4:4 YUV with alpha channel (A0-Y0-U0-V0 ...) + -} + | VideoFormatRgbx + {- ^ + sparse rgb packed into 32 bit, space last + -} + | VideoFormatBgrx + {- ^ + sparse reverse rgb packed into 32 bit, space last + -} + | VideoFormatXrgb + {- ^ + sparse rgb packed into 32 bit, space first + -} + | VideoFormatXbgr + {- ^ + sparse reverse rgb packed into 32 bit, space first + -} + | VideoFormatRgba + {- ^ + rgb with alpha channel last + -} + | VideoFormatBgra + {- ^ + reverse rgb with alpha channel last + -} + | VideoFormatArgb + {- ^ + rgb with alpha channel first + -} + | VideoFormatAbgr + {- ^ + reverse rgb with alpha channel first + -} + | VideoFormatRgb + {- ^ + RGB packed into 24 bits without padding (@R-G-B-R-G-B@) + -} + | VideoFormatBgr + {- ^ + reverse RGB packed into 24 bits without padding (@B-G-R-B-G-R@) + -} + | VideoFormatY41b + {- ^ + planar 4:1:1 YUV + -} + | VideoFormatY42b + {- ^ + planar 4:2:2 YUV + -} + | VideoFormatYvyu + {- ^ + packed 4:2:2 YUV (Y0-V0-Y1-U0 Y2-V2-Y3-U2 Y4 ...) + -} + | VideoFormatY444 + {- ^ + planar 4:4:4 YUV + -} + | VideoFormatV210 + {- ^ + packed 4:2:2 10-bit YUV, complex format + -} + | VideoFormatV216 + {- ^ + packed 4:2:2 16-bit YUV, Y0-U0-Y1-V1 order + -} + | VideoFormatNv12 + {- ^ + planar 4:2:0 YUV with interleaved UV plane + -} + | VideoFormatNv21 + {- ^ + planar 4:2:0 YUV with interleaved VU plane + -} + | VideoFormatGray8 + {- ^ + 8-bit grayscale + -} + | VideoFormatGray16Be + {- ^ + 16-bit grayscale, most significant byte first + -} + | VideoFormatGray16Le + {- ^ + 16-bit grayscale, least significant byte first + -} + | VideoFormatV308 + {- ^ + packed 4:4:4 YUV (Y-U-V ...) + -} + | VideoFormatRgb16 + {- ^ + rgb 5-6-5 bits per component + -} + | VideoFormatBgr16 + {- ^ + reverse rgb 5-6-5 bits per component + -} + | VideoFormatRgb15 + {- ^ + rgb 5-5-5 bits per component + -} + | VideoFormatBgr15 + {- ^ + reverse rgb 5-5-5 bits per component + -} + | VideoFormatUyvp + {- ^ + packed 10-bit 4:2:2 YUV (U0-Y0-V0-Y1 U2-Y2-V2-Y3 U4 ...) + -} + | VideoFormatA420 + {- ^ + planar 4:4:2:0 AYUV + -} + | VideoFormatRgb8p + {- ^ + 8-bit paletted RGB + -} + | VideoFormatYuv9 + {- ^ + planar 4:1:0 YUV + -} + | VideoFormatYvu9 + {- ^ + planar 4:1:0 YUV (like YUV9 but UV planes swapped) + -} + | VideoFormatIyu1 + {- ^ + packed 4:1:1 YUV (Cb-Y0-Y1-Cr-Y2-Y3 ...) + -} + | VideoFormatArgb64 + {- ^ + rgb with alpha channel first, 16 bits per channel + -} + | VideoFormatAyuv64 + {- ^ + packed 4:4:4 YUV with alpha channel, 16 bits per channel (A0-Y0-U0-V0 ...) + -} + | VideoFormatR210 + {- ^ + packed 4:4:4 RGB, 10 bits per channel + -} + | VideoFormatI42010be + {- ^ + planar 4:2:0 YUV, 10 bits per channel + -} + | VideoFormatI42010le + {- ^ + planar 4:2:0 YUV, 10 bits per channel + -} + | VideoFormatI42210be + {- ^ + planar 4:2:2 YUV, 10 bits per channel + -} + | VideoFormatI42210le + {- ^ + planar 4:2:2 YUV, 10 bits per channel + -} + | VideoFormatY44410be + {- ^ + planar 4:4:4 YUV, 10 bits per channel (Since: 1.2) + -} + | VideoFormatY44410le + {- ^ + planar 4:4:4 YUV, 10 bits per channel (Since: 1.2) + -} + | VideoFormatGbr + {- ^ + planar 4:4:4 RGB, 8 bits per channel (Since: 1.2) + -} + | VideoFormatGbr10be + {- ^ + planar 4:4:4 RGB, 10 bits per channel (Since: 1.2) + -} + | VideoFormatGbr10le + {- ^ + planar 4:4:4 RGB, 10 bits per channel (Since: 1.2) + -} + | VideoFormatNv16 + {- ^ + planar 4:2:2 YUV with interleaved UV plane (Since: 1.2) + -} + | VideoFormatNv24 + {- ^ + planar 4:4:4 YUV with interleaved UV plane (Since: 1.2) + -} + | VideoFormatNv1264z32 + {- ^ + NV12 with 64x32 tiling in zigzag pattern (Since: 1.4) + -} + | VideoFormatA42010be + {- ^ + planar 4:4:2:0 YUV, 10 bits per channel (Since: 1.6) + -} + | VideoFormatA42010le + {- ^ + planar 4:4:2:0 YUV, 10 bits per channel (Since: 1.6) + -} + | VideoFormatA42210be + {- ^ + planar 4:4:2:2 YUV, 10 bits per channel (Since: 1.6) + -} + | VideoFormatA42210le + {- ^ + planar 4:4:2:2 YUV, 10 bits per channel (Since: 1.6) + -} + | VideoFormatA44410be + {- ^ + planar 4:4:4:4 YUV, 10 bits per channel (Since: 1.6) + -} + | VideoFormatA44410le + {- ^ + planar 4:4:4:4 YUV, 10 bits per channel (Since: 1.6) + -} + | VideoFormatNv61 + {- ^ + planar 4:2:2 YUV with interleaved VU plane (Since: 1.6) + -} + | VideoFormatP01010be + {- ^ + planar 4:2:0 YUV with interleaved UV plane, 10 bits per channel (Since: 1.10) + -} + | VideoFormatP01010le + {- ^ + planar 4:2:0 YUV with interleaved UV plane, 10 bits per channel (Since: 1.10) + -} + | VideoFormatIyu2 + {- ^ + packed 4:4:4 YUV (U-Y-V ...) (Since 1.10) + -} + | VideoFormatVyuy + {- ^ + packed 4:2:2 YUV (V0-Y0-U0-Y1 V2-Y2-U2-Y3 V4 ...) + -} + | VideoFormatGbra + {- ^ + planar 4:4:4:4 ARGB, 8 bits per channel (Since: 1.12) + -} + | VideoFormatGbra10be + {- ^ + planar 4:4:4:4 ARGB, 10 bits per channel (Since: 1.12) + -} + | VideoFormatGbra10le + {- ^ + planar 4:4:4:4 ARGB, 10 bits per channel (Since: 1.12) + -} + | VideoFormatGbr12be + {- ^ + planar 4:4:4 RGB, 12 bits per channel (Since: 1.12) + -} + | VideoFormatGbr12le + {- ^ + planar 4:4:4 RGB, 12 bits per channel (Since: 1.12) + -} + | VideoFormatGbra12be + {- ^ + planar 4:4:4:4 ARGB, 12 bits per channel (Since: 1.12) + -} + | VideoFormatGbra12le + {- ^ + planar 4:4:4:4 ARGB, 12 bits per channel (Since: 1.12) + -} + | VideoFormatI42012be + {- ^ + planar 4:2:0 YUV, 12 bits per channel (Since: 1.12) + -} + | VideoFormatI42012le + {- ^ + planar 4:2:0 YUV, 12 bits per channel (Since: 1.12) + -} + | VideoFormatI42212be + {- ^ + planar 4:2:2 YUV, 12 bits per channel (Since: 1.12) + -} + | VideoFormatI42212le + {- ^ + planar 4:2:2 YUV, 12 bits per channel (Since: 1.12) + -} + | VideoFormatY44412be + {- ^ + planar 4:4:4 YUV, 12 bits per channel (Since: 1.12) + -} + | VideoFormatY44412le + {- ^ + planar 4:4:4 YUV, 12 bits per channel (Since: 1.12) + -} + | VideoFormatGray10Le32 + {- ^ + 10-bit grayscale, packed into 32bit words (2 bits padding) (Since: 1.14) + -} + | VideoFormatNv1210le32 + {- ^ + 10-bit variant of /@gSTVIDEOFORMATNV12@/, packed into 32bit words (MSB 2 bits padding) (Since: 1.14) + -} + | VideoFormatNv1610le32 + {- ^ + 10-bit variant of /@gSTVIDEOFORMATNV16@/, packed into 32bit words (MSB 2 bits padding) (Since: 1.14) + -} + | VideoFormatNv1210le40 + {- ^ + Fully packed variant of NV12_10LE32 (Since: 1.16) + -} + | VideoFormatY210 + {- ^ + packed 4:2:2 YUV, 10 bits per channel (Since: 1.16) + -} + | VideoFormatY410 + {- ^ + packed 4:4:4 YUV, 10 bits per channel(A-V-Y-U...) (Since: 1.16) + -} + | VideoFormatVuya + {- ^ + packed 4:4:4 YUV with alpha channel (V0-U0-Y0-A0...) (Since: 1.16) + -} + | VideoFormatBgr10a2Le + {- ^ + packed 4:4:4 RGB with alpha channel(B-G-R-A), 10 bits for R\/G\/B channel and MSB 2 bits for alpha channel (Since: 1.16) + -} + | AnotherVideoFormat Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoFormat where + fromEnum VideoFormatUnknown = 0 + fromEnum VideoFormatEncoded = 1 + fromEnum VideoFormatI420 = 2 + fromEnum VideoFormatYv12 = 3 + fromEnum VideoFormatYuy2 = 4 + fromEnum VideoFormatUyvy = 5 + fromEnum VideoFormatAyuv = 6 + fromEnum VideoFormatRgbx = 7 + fromEnum VideoFormatBgrx = 8 + fromEnum VideoFormatXrgb = 9 + fromEnum VideoFormatXbgr = 10 + fromEnum VideoFormatRgba = 11 + fromEnum VideoFormatBgra = 12 + fromEnum VideoFormatArgb = 13 + fromEnum VideoFormatAbgr = 14 + fromEnum VideoFormatRgb = 15 + fromEnum VideoFormatBgr = 16 + fromEnum VideoFormatY41b = 17 + fromEnum VideoFormatY42b = 18 + fromEnum VideoFormatYvyu = 19 + fromEnum VideoFormatY444 = 20 + fromEnum VideoFormatV210 = 21 + fromEnum VideoFormatV216 = 22 + fromEnum VideoFormatNv12 = 23 + fromEnum VideoFormatNv21 = 24 + fromEnum VideoFormatGray8 = 25 + fromEnum VideoFormatGray16Be = 26 + fromEnum VideoFormatGray16Le = 27 + fromEnum VideoFormatV308 = 28 + fromEnum VideoFormatRgb16 = 29 + fromEnum VideoFormatBgr16 = 30 + fromEnum VideoFormatRgb15 = 31 + fromEnum VideoFormatBgr15 = 32 + fromEnum VideoFormatUyvp = 33 + fromEnum VideoFormatA420 = 34 + fromEnum VideoFormatRgb8p = 35 + fromEnum VideoFormatYuv9 = 36 + fromEnum VideoFormatYvu9 = 37 + fromEnum VideoFormatIyu1 = 38 + fromEnum VideoFormatArgb64 = 39 + fromEnum VideoFormatAyuv64 = 40 + fromEnum VideoFormatR210 = 41 + fromEnum VideoFormatI42010be = 42 + fromEnum VideoFormatI42010le = 43 + fromEnum VideoFormatI42210be = 44 + fromEnum VideoFormatI42210le = 45 + fromEnum VideoFormatY44410be = 46 + fromEnum VideoFormatY44410le = 47 + fromEnum VideoFormatGbr = 48 + fromEnum VideoFormatGbr10be = 49 + fromEnum VideoFormatGbr10le = 50 + fromEnum VideoFormatNv16 = 51 + fromEnum VideoFormatNv24 = 52 + fromEnum VideoFormatNv1264z32 = 53 + fromEnum VideoFormatA42010be = 54 + fromEnum VideoFormatA42010le = 55 + fromEnum VideoFormatA42210be = 56 + fromEnum VideoFormatA42210le = 57 + fromEnum VideoFormatA44410be = 58 + fromEnum VideoFormatA44410le = 59 + fromEnum VideoFormatNv61 = 60 + fromEnum VideoFormatP01010be = 61 + fromEnum VideoFormatP01010le = 62 + fromEnum VideoFormatIyu2 = 63 + fromEnum VideoFormatVyuy = 64 + fromEnum VideoFormatGbra = 65 + fromEnum VideoFormatGbra10be = 66 + fromEnum VideoFormatGbra10le = 67 + fromEnum VideoFormatGbr12be = 68 + fromEnum VideoFormatGbr12le = 69 + fromEnum VideoFormatGbra12be = 70 + fromEnum VideoFormatGbra12le = 71 + fromEnum VideoFormatI42012be = 72 + fromEnum VideoFormatI42012le = 73 + fromEnum VideoFormatI42212be = 74 + fromEnum VideoFormatI42212le = 75 + fromEnum VideoFormatY44412be = 76 + fromEnum VideoFormatY44412le = 77 + fromEnum VideoFormatGray10Le32 = 78 + fromEnum VideoFormatNv1210le32 = 79 + fromEnum VideoFormatNv1610le32 = 80 + fromEnum VideoFormatNv1210le40 = 81 + fromEnum VideoFormatY210 = 82 + fromEnum VideoFormatY410 = 83 + fromEnum VideoFormatVuya = 84 + fromEnum VideoFormatBgr10a2Le = 85 + fromEnum (AnotherVideoFormat k) = k + + toEnum 0 = VideoFormatUnknown + toEnum 1 = VideoFormatEncoded + toEnum 2 = VideoFormatI420 + toEnum 3 = VideoFormatYv12 + toEnum 4 = VideoFormatYuy2 + toEnum 5 = VideoFormatUyvy + toEnum 6 = VideoFormatAyuv + toEnum 7 = VideoFormatRgbx + toEnum 8 = VideoFormatBgrx + toEnum 9 = VideoFormatXrgb + toEnum 10 = VideoFormatXbgr + toEnum 11 = VideoFormatRgba + toEnum 12 = VideoFormatBgra + toEnum 13 = VideoFormatArgb + toEnum 14 = VideoFormatAbgr + toEnum 15 = VideoFormatRgb + toEnum 16 = VideoFormatBgr + toEnum 17 = VideoFormatY41b + toEnum 18 = VideoFormatY42b + toEnum 19 = VideoFormatYvyu + toEnum 20 = VideoFormatY444 + toEnum 21 = VideoFormatV210 + toEnum 22 = VideoFormatV216 + toEnum 23 = VideoFormatNv12 + toEnum 24 = VideoFormatNv21 + toEnum 25 = VideoFormatGray8 + toEnum 26 = VideoFormatGray16Be + toEnum 27 = VideoFormatGray16Le + toEnum 28 = VideoFormatV308 + toEnum 29 = VideoFormatRgb16 + toEnum 30 = VideoFormatBgr16 + toEnum 31 = VideoFormatRgb15 + toEnum 32 = VideoFormatBgr15 + toEnum 33 = VideoFormatUyvp + toEnum 34 = VideoFormatA420 + toEnum 35 = VideoFormatRgb8p + toEnum 36 = VideoFormatYuv9 + toEnum 37 = VideoFormatYvu9 + toEnum 38 = VideoFormatIyu1 + toEnum 39 = VideoFormatArgb64 + toEnum 40 = VideoFormatAyuv64 + toEnum 41 = VideoFormatR210 + toEnum 42 = VideoFormatI42010be + toEnum 43 = VideoFormatI42010le + toEnum 44 = VideoFormatI42210be + toEnum 45 = VideoFormatI42210le + toEnum 46 = VideoFormatY44410be + toEnum 47 = VideoFormatY44410le + toEnum 48 = VideoFormatGbr + toEnum 49 = VideoFormatGbr10be + toEnum 50 = VideoFormatGbr10le + toEnum 51 = VideoFormatNv16 + toEnum 52 = VideoFormatNv24 + toEnum 53 = VideoFormatNv1264z32 + toEnum 54 = VideoFormatA42010be + toEnum 55 = VideoFormatA42010le + toEnum 56 = VideoFormatA42210be + toEnum 57 = VideoFormatA42210le + toEnum 58 = VideoFormatA44410be + toEnum 59 = VideoFormatA44410le + toEnum 60 = VideoFormatNv61 + toEnum 61 = VideoFormatP01010be + toEnum 62 = VideoFormatP01010le + toEnum 63 = VideoFormatIyu2 + toEnum 64 = VideoFormatVyuy + toEnum 65 = VideoFormatGbra + toEnum 66 = VideoFormatGbra10be + toEnum 67 = VideoFormatGbra10le + toEnum 68 = VideoFormatGbr12be + toEnum 69 = VideoFormatGbr12le + toEnum 70 = VideoFormatGbra12be + toEnum 71 = VideoFormatGbra12le + toEnum 72 = VideoFormatI42012be + toEnum 73 = VideoFormatI42012le + toEnum 74 = VideoFormatI42212be + toEnum 75 = VideoFormatI42212le + toEnum 76 = VideoFormatY44412be + toEnum 77 = VideoFormatY44412le + toEnum 78 = VideoFormatGray10Le32 + toEnum 79 = VideoFormatNv1210le32 + toEnum 80 = VideoFormatNv1610le32 + toEnum 81 = VideoFormatNv1210le40 + toEnum 82 = VideoFormatY210 + toEnum 83 = VideoFormatY410 + toEnum 84 = VideoFormatVuya + toEnum 85 = VideoFormatBgr10a2Le + toEnum k = AnotherVideoFormat k + +instance P.Ord VideoFormat where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_format_get_type" c_gst_video_format_get_type :: + IO GType + +instance BoxedEnum VideoFormat where + boxedEnumType _ = c_gst_video_format_get_type + +-- Enum VideoFieldOrder +{- | +Field order of interlaced content. This is only valid for +interlace-mode=interleaved and not interlace-mode=mixed. In the case of +mixed or GST_VIDEO_FIELD_ORDER_UNKOWN, the field order is signalled via +buffer flags. + +/Since: 1.12/ +-} +data VideoFieldOrder = + VideoFieldOrderUnknown + {- ^ + unknown field order for interlaced content. + The actual field order is signalled via buffer flags. + -} + | VideoFieldOrderTopFieldFirst + {- ^ + top field is first + -} + | VideoFieldOrderBottomFieldFirst + {- ^ + bottom field is first + -} + | AnotherVideoFieldOrder Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoFieldOrder where + fromEnum VideoFieldOrderUnknown = 0 + fromEnum VideoFieldOrderTopFieldFirst = 1 + fromEnum VideoFieldOrderBottomFieldFirst = 2 + fromEnum (AnotherVideoFieldOrder k) = k + + toEnum 0 = VideoFieldOrderUnknown + toEnum 1 = VideoFieldOrderTopFieldFirst + toEnum 2 = VideoFieldOrderBottomFieldFirst + toEnum k = AnotherVideoFieldOrder k + +instance P.Ord VideoFieldOrder where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_field_order_get_type" c_gst_video_field_order_get_type :: + IO GType + +instance BoxedEnum VideoFieldOrder where + boxedEnumType _ = c_gst_video_field_order_get_type + +-- Enum VideoDitherMethod +{- | +Different dithering methods to use. +-} +data VideoDitherMethod = + VideoDitherMethodNone + {- ^ + no dithering + -} + | VideoDitherMethodVerterr + {- ^ + propagate rounding errors downwards + -} + | VideoDitherMethodFloydSteinberg + {- ^ + Dither with floyd-steinberg error diffusion + -} + | VideoDitherMethodSierraLite + {- ^ + Dither with Sierra Lite error diffusion + -} + | VideoDitherMethodBayer + {- ^ + ordered dither using a bayer pattern + -} + | AnotherVideoDitherMethod Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoDitherMethod where + fromEnum VideoDitherMethodNone = 0 + fromEnum VideoDitherMethodVerterr = 1 + fromEnum VideoDitherMethodFloydSteinberg = 2 + fromEnum VideoDitherMethodSierraLite = 3 + fromEnum VideoDitherMethodBayer = 4 + fromEnum (AnotherVideoDitherMethod k) = k + + toEnum 0 = VideoDitherMethodNone + toEnum 1 = VideoDitherMethodVerterr + toEnum 2 = VideoDitherMethodFloydSteinberg + toEnum 3 = VideoDitherMethodSierraLite + toEnum 4 = VideoDitherMethodBayer + toEnum k = AnotherVideoDitherMethod k + +instance P.Ord VideoDitherMethod where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_dither_method_get_type" c_gst_video_dither_method_get_type :: + IO GType + +instance BoxedEnum VideoDitherMethod where + boxedEnumType _ = c_gst_video_dither_method_get_type + +-- Enum VideoColorRange +{- | +Possible color range values. These constants are defined for 8 bit color +values and can be scaled for other bit depths. +-} +data VideoColorRange = + VideoColorRangeUnknown + {- ^ + unknown range + -} + | VideoColorRange0255 + {- ^ + [0..255] for 8 bit components + -} + | VideoColorRange16235 + {- ^ + [16..235] for 8 bit components. Chroma has + [16..240] range. + -} + | AnotherVideoColorRange Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoColorRange where + fromEnum VideoColorRangeUnknown = 0 + fromEnum VideoColorRange0255 = 1 + fromEnum VideoColorRange16235 = 2 + fromEnum (AnotherVideoColorRange k) = k + + toEnum 0 = VideoColorRangeUnknown + toEnum 1 = VideoColorRange0255 + toEnum 2 = VideoColorRange16235 + toEnum k = AnotherVideoColorRange k + +instance P.Ord VideoColorRange where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_color_range_get_type" c_gst_video_color_range_get_type :: + IO GType + +instance BoxedEnum VideoColorRange where + boxedEnumType _ = c_gst_video_color_range_get_type + +-- Enum VideoColorPrimaries +{- | +The color primaries define the how to transform linear RGB values to and from +the CIE XYZ colorspace. +-} +data VideoColorPrimaries = + VideoColorPrimariesUnknown + {- ^ + unknown color primaries + -} + | VideoColorPrimariesBt709 + {- ^ + BT709 primaries + -} + | VideoColorPrimariesBt470m + {- ^ + BT470M primaries + -} + | VideoColorPrimariesBt470bg + {- ^ + BT470BG primaries + -} + | VideoColorPrimariesSmpte170m + {- ^ + SMPTE170M primaries + -} + | VideoColorPrimariesSmpte240m + {- ^ + SMPTE240M primaries + -} + | VideoColorPrimariesFilm + {- ^ + Generic film + -} + | VideoColorPrimariesBt2020 + {- ^ + BT2020 primaries. Since: 1.6 + -} + | VideoColorPrimariesAdobergb + {- ^ + Adobe RGB primaries. Since: 1.8 + -} + | VideoColorPrimariesSmptest428 + {- ^ + SMPTE ST 428 primaries. Since: 1.16 + -} + | VideoColorPrimariesSmpterp431 + {- ^ + SMPTE RP 431 primaries. Since: 1.16 + -} + | VideoColorPrimariesSmpteeg432 + {- ^ + SMPTE EG 432 primaries. Since: 1.16 + -} + | VideoColorPrimariesEbu3213 + {- ^ + EBU 3213 primaries. Since: 1.16 + -} + | AnotherVideoColorPrimaries Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoColorPrimaries where + fromEnum VideoColorPrimariesUnknown = 0 + fromEnum VideoColorPrimariesBt709 = 1 + fromEnum VideoColorPrimariesBt470m = 2 + fromEnum VideoColorPrimariesBt470bg = 3 + fromEnum VideoColorPrimariesSmpte170m = 4 + fromEnum VideoColorPrimariesSmpte240m = 5 + fromEnum VideoColorPrimariesFilm = 6 + fromEnum VideoColorPrimariesBt2020 = 7 + fromEnum VideoColorPrimariesAdobergb = 8 + fromEnum VideoColorPrimariesSmptest428 = 9 + fromEnum VideoColorPrimariesSmpterp431 = 10 + fromEnum VideoColorPrimariesSmpteeg432 = 11 + fromEnum VideoColorPrimariesEbu3213 = 12 + fromEnum (AnotherVideoColorPrimaries k) = k + + toEnum 0 = VideoColorPrimariesUnknown + toEnum 1 = VideoColorPrimariesBt709 + toEnum 2 = VideoColorPrimariesBt470m + toEnum 3 = VideoColorPrimariesBt470bg + toEnum 4 = VideoColorPrimariesSmpte170m + toEnum 5 = VideoColorPrimariesSmpte240m + toEnum 6 = VideoColorPrimariesFilm + toEnum 7 = VideoColorPrimariesBt2020 + toEnum 8 = VideoColorPrimariesAdobergb + toEnum 9 = VideoColorPrimariesSmptest428 + toEnum 10 = VideoColorPrimariesSmpterp431 + toEnum 11 = VideoColorPrimariesSmpteeg432 + toEnum 12 = VideoColorPrimariesEbu3213 + toEnum k = AnotherVideoColorPrimaries k + +instance P.Ord VideoColorPrimaries where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_color_primaries_get_type" c_gst_video_color_primaries_get_type :: + IO GType + +instance BoxedEnum VideoColorPrimaries where + boxedEnumType _ = c_gst_video_color_primaries_get_type + +-- Enum VideoColorMatrix +{- | +The color matrix is used to convert between Y\'PbPr and +non-linear RGB (R\'G\'B\') +-} +data VideoColorMatrix = + VideoColorMatrixUnknown + {- ^ + unknown matrix + -} + | VideoColorMatrixRgb + {- ^ + identity matrix + -} + | VideoColorMatrixFcc + {- ^ + FCC color matrix + -} + | VideoColorMatrixBt709 + {- ^ + ITU-R BT.709 color matrix + -} + | VideoColorMatrixBt601 + {- ^ + ITU-R BT.601 color matrix + -} + | VideoColorMatrixSmpte240m + {- ^ + SMPTE 240M color matrix + -} + | VideoColorMatrixBt2020 + {- ^ + ITU-R BT.2020 color matrix. Since: 1.6 + -} + | AnotherVideoColorMatrix Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoColorMatrix where + fromEnum VideoColorMatrixUnknown = 0 + fromEnum VideoColorMatrixRgb = 1 + fromEnum VideoColorMatrixFcc = 2 + fromEnum VideoColorMatrixBt709 = 3 + fromEnum VideoColorMatrixBt601 = 4 + fromEnum VideoColorMatrixSmpte240m = 5 + fromEnum VideoColorMatrixBt2020 = 6 + fromEnum (AnotherVideoColorMatrix k) = k + + toEnum 0 = VideoColorMatrixUnknown + toEnum 1 = VideoColorMatrixRgb + toEnum 2 = VideoColorMatrixFcc + toEnum 3 = VideoColorMatrixBt709 + toEnum 4 = VideoColorMatrixBt601 + toEnum 5 = VideoColorMatrixSmpte240m + toEnum 6 = VideoColorMatrixBt2020 + toEnum k = AnotherVideoColorMatrix k + +instance P.Ord VideoColorMatrix where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_color_matrix_get_type" c_gst_video_color_matrix_get_type :: + IO GType + +instance BoxedEnum VideoColorMatrix where + boxedEnumType _ = c_gst_video_color_matrix_get_type + +-- Enum VideoChromaMode +{- | +Different chroma downsampling and upsampling modes + +/Since: 1.6/ +-} +data VideoChromaMode = + VideoChromaModeFull + {- ^ + do full chroma up and down sampling + -} + | VideoChromaModeUpsampleOnly + {- ^ + only perform chroma upsampling + -} + | VideoChromaModeDownsampleOnly + {- ^ + only perform chroma downsampling + -} + | VideoChromaModeNone + {- ^ + disable chroma resampling + -} + | AnotherVideoChromaMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoChromaMode where + fromEnum VideoChromaModeFull = 0 + fromEnum VideoChromaModeUpsampleOnly = 1 + fromEnum VideoChromaModeDownsampleOnly = 2 + fromEnum VideoChromaModeNone = 3 + fromEnum (AnotherVideoChromaMode k) = k + + toEnum 0 = VideoChromaModeFull + toEnum 1 = VideoChromaModeUpsampleOnly + toEnum 2 = VideoChromaModeDownsampleOnly + toEnum 3 = VideoChromaModeNone + toEnum k = AnotherVideoChromaMode k + +instance P.Ord VideoChromaMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_chroma_mode_get_type" c_gst_video_chroma_mode_get_type :: + IO GType + +instance BoxedEnum VideoChromaMode where + boxedEnumType _ = c_gst_video_chroma_mode_get_type + +-- Enum VideoChromaMethod +{- | +Different subsampling and upsampling methods +-} +data VideoChromaMethod = + VideoChromaMethodNearest + {- ^ + Duplicates the chroma samples when + upsampling and drops when subsampling + -} + | VideoChromaMethodLinear + {- ^ + Uses linear interpolation to reconstruct + missing chroma and averaging to subsample + -} + | AnotherVideoChromaMethod Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoChromaMethod where + fromEnum VideoChromaMethodNearest = 0 + fromEnum VideoChromaMethodLinear = 1 + fromEnum (AnotherVideoChromaMethod k) = k + + toEnum 0 = VideoChromaMethodNearest + toEnum 1 = VideoChromaMethodLinear + toEnum k = AnotherVideoChromaMethod k + +instance P.Ord VideoChromaMethod where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_chroma_method_get_type" c_gst_video_chroma_method_get_type :: + IO GType + +instance BoxedEnum VideoChromaMethod where + boxedEnumType _ = c_gst_video_chroma_method_get_type + +-- Enum VideoCaptionType +{- | +The various known types of Closed Caption (CC). + +/Since: 1.16/ +-} +data VideoCaptionType = + VideoCaptionTypeUnknown + {- ^ + Unknown type of CC + -} + | VideoCaptionTypeCea608Raw + {- ^ + CEA-608 as byte pairs. Note that + this format is not recommended since is does not specify to + which field the caption comes from and therefore assumes + it comes from the first field (and that there is no information + on the second field). Use /@gSTVIDEOCAPTIONTYPECEA708RAW@/ + if you wish to store CEA-608 from two fields and prefix each byte pair + with 0xFC for the first field and 0xFD for the second field. + -} + | VideoCaptionTypeCea608S3341a + {- ^ + CEA-608 as byte triplets as defined + in SMPTE S334-1 Annex A. The second and third byte of the byte triplet + is the raw CEA608 data, the first byte is a bitfield: The top\/7th bit is + 0 for the second field, 1 for the first field, bit 6 and 5 are 0 and + bits 4 to 0 are a 5 bit unsigned integer that represents the line + offset relative to the base-line of the original image format (line 9 + for 525-line field 1, line 272 for 525-line field 2, line 5 for + 625-line field 1 and line 318 for 625-line field 2). + -} + | VideoCaptionTypeCea708Raw + {- ^ + CEA-708 as cc_data byte triplets. They + can also contain 608-in-708 and the first byte of each triplet has to + be inspected for detecting the type. + -} + | VideoCaptionTypeCea708Cdp + {- ^ + CEA-708 (and optionally CEA-608) in + a CDP (Caption Distribution Packet) defined by SMPTE S-334-2. + Contains the whole CDP (starting with 0x9669). + -} + | AnotherVideoCaptionType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoCaptionType where + fromEnum VideoCaptionTypeUnknown = 0 + fromEnum VideoCaptionTypeCea608Raw = 1 + fromEnum VideoCaptionTypeCea608S3341a = 2 + fromEnum VideoCaptionTypeCea708Raw = 3 + fromEnum VideoCaptionTypeCea708Cdp = 4 + fromEnum (AnotherVideoCaptionType k) = k + + toEnum 0 = VideoCaptionTypeUnknown + toEnum 1 = VideoCaptionTypeCea608Raw + toEnum 2 = VideoCaptionTypeCea608S3341a + toEnum 3 = VideoCaptionTypeCea708Raw + toEnum 4 = VideoCaptionTypeCea708Cdp + toEnum k = AnotherVideoCaptionType k + +instance P.Ord VideoCaptionType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_caption_type_get_type" c_gst_video_caption_type_get_type :: + IO GType + +instance BoxedEnum VideoCaptionType where + boxedEnumType _ = c_gst_video_caption_type_get_type + +-- Enum VideoAncillaryDID16 +{- | +Some know types of Ancillary Data identifiers. + +/Since: 1.16/ +-} +data VideoAncillaryDID16 = + VideoAncillaryDID16708 + {- ^ + CEA 708 Ancillary data according to SMPTE 334 + -} + | VideoAncillaryDID16608 + {- ^ + CEA 608 Ancillary data according to SMPTE 334 + -} + | AnotherVideoAncillaryDID16 Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoAncillaryDID16 where + fromEnum VideoAncillaryDID16708 = 24833 + fromEnum VideoAncillaryDID16608 = 24834 + fromEnum (AnotherVideoAncillaryDID16 k) = k + + toEnum 24833 = VideoAncillaryDID16708 + toEnum 24834 = VideoAncillaryDID16608 + toEnum k = AnotherVideoAncillaryDID16 k + +instance P.Ord VideoAncillaryDID16 where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_ancillary_di_d16_get_type" c_gst_video_ancillary_di_d16_get_type :: + IO GType + +instance BoxedEnum VideoAncillaryDID16 where + boxedEnumType _ = c_gst_video_ancillary_di_d16_get_type + +-- Enum VideoAncillaryDID +{- | +/No description available in the introspection data./ +-} +data VideoAncillaryDID = + VideoAncillaryDIDUndefined + {- ^ + /No description available in the introspection data./ + -} + | VideoAncillaryDIDDeletion + {- ^ + /No description available in the introspection data./ + -} + | VideoAncillaryDIDHanc3gAudioDataFirst + {- ^ + /No description available in the introspection data./ + -} + | VideoAncillaryDIDHanc3gAudioDataLast + {- ^ + /No description available in the introspection data./ + -} + | VideoAncillaryDIDHancHdtvAudioDataFirst + {- ^ + /No description available in the introspection data./ + -} + | VideoAncillaryDIDHancHdtvAudioDataLast + {- ^ + /No description available in the introspection data./ + -} + | VideoAncillaryDIDHancSdtvAudioData1First + {- ^ + /No description available in the introspection data./ + -} + | VideoAncillaryDIDHancSdtvAudioData1Last + {- ^ + /No description available in the introspection data./ + -} + | VideoAncillaryDIDCameraPosition + {- ^ + /No description available in the introspection data./ + -} + | VideoAncillaryDIDHancErrorDetection + {- ^ + /No description available in the introspection data./ + -} + | VideoAncillaryDIDHancSdtvAudioData2First + {- ^ + /No description available in the introspection data./ + -} + | VideoAncillaryDIDHancSdtvAudioData2Last + {- ^ + /No description available in the introspection data./ + -} + | AnotherVideoAncillaryDID Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoAncillaryDID where + fromEnum VideoAncillaryDIDUndefined = 0 + fromEnum VideoAncillaryDIDDeletion = 128 + fromEnum VideoAncillaryDIDHanc3gAudioDataFirst = 160 + fromEnum VideoAncillaryDIDHanc3gAudioDataLast = 167 + fromEnum VideoAncillaryDIDHancHdtvAudioDataFirst = 224 + fromEnum VideoAncillaryDIDHancHdtvAudioDataLast = 231 + fromEnum VideoAncillaryDIDHancSdtvAudioData1First = 236 + fromEnum VideoAncillaryDIDHancSdtvAudioData1Last = 239 + fromEnum VideoAncillaryDIDCameraPosition = 240 + fromEnum VideoAncillaryDIDHancErrorDetection = 244 + fromEnum VideoAncillaryDIDHancSdtvAudioData2First = 248 + fromEnum VideoAncillaryDIDHancSdtvAudioData2Last = 255 + fromEnum (AnotherVideoAncillaryDID k) = k + + toEnum 0 = VideoAncillaryDIDUndefined + toEnum 128 = VideoAncillaryDIDDeletion + toEnum 160 = VideoAncillaryDIDHanc3gAudioDataFirst + toEnum 167 = VideoAncillaryDIDHanc3gAudioDataLast + toEnum 224 = VideoAncillaryDIDHancHdtvAudioDataFirst + toEnum 231 = VideoAncillaryDIDHancHdtvAudioDataLast + toEnum 236 = VideoAncillaryDIDHancSdtvAudioData1First + toEnum 239 = VideoAncillaryDIDHancSdtvAudioData1Last + toEnum 240 = VideoAncillaryDIDCameraPosition + toEnum 244 = VideoAncillaryDIDHancErrorDetection + toEnum 248 = VideoAncillaryDIDHancSdtvAudioData2First + toEnum 255 = VideoAncillaryDIDHancSdtvAudioData2Last + toEnum k = AnotherVideoAncillaryDID k + +instance P.Ord VideoAncillaryDID where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_ancillary_did_get_type" c_gst_video_ancillary_did_get_type :: + IO GType + +instance BoxedEnum VideoAncillaryDID where + boxedEnumType _ = c_gst_video_ancillary_did_get_type + +-- Enum VideoAlphaMode +{- | +Different alpha modes. + +/Since: 1.6/ +-} +data VideoAlphaMode = + VideoAlphaModeCopy + {- ^ + When input and output have alpha, it will be copied. + When the input has no alpha, alpha will be set to + 'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_ALPHA_VALUE' + -} + | VideoAlphaModeSet + {- ^ + set all alpha to + 'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_ALPHA_VALUE' + -} + | VideoAlphaModeMult + {- ^ + multiply all alpha with + 'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_ALPHA_VALUE'. + When the input format has no alpha but the output format has, the + alpha value will be set to 'GI.GstVideo.Constants.VIDEO_CONVERTER_OPT_ALPHA_VALUE' + -} + | AnotherVideoAlphaMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoAlphaMode where + fromEnum VideoAlphaModeCopy = 0 + fromEnum VideoAlphaModeSet = 1 + fromEnum VideoAlphaModeMult = 2 + fromEnum (AnotherVideoAlphaMode k) = k + + toEnum 0 = VideoAlphaModeCopy + toEnum 1 = VideoAlphaModeSet + toEnum 2 = VideoAlphaModeMult + toEnum k = AnotherVideoAlphaMode k + +instance P.Ord VideoAlphaMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_alpha_mode_get_type" c_gst_video_alpha_mode_get_type :: + IO GType + +instance BoxedEnum VideoAlphaMode where + boxedEnumType _ = c_gst_video_alpha_mode_get_type + +-- Enum NavigationQueryType +{- | +Tyoes of navigation interface queries. +-} +data NavigationQueryType = + NavigationQueryTypeInvalid + {- ^ + invalid query + -} + | NavigationQueryTypeCommands + {- ^ + command query + -} + | NavigationQueryTypeAngles + {- ^ + viewing angle query + -} + | AnotherNavigationQueryType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum NavigationQueryType where + fromEnum NavigationQueryTypeInvalid = 0 + fromEnum NavigationQueryTypeCommands = 1 + fromEnum NavigationQueryTypeAngles = 2 + fromEnum (AnotherNavigationQueryType k) = k + + toEnum 0 = NavigationQueryTypeInvalid + toEnum 1 = NavigationQueryTypeCommands + toEnum 2 = NavigationQueryTypeAngles + toEnum k = AnotherNavigationQueryType k + +instance P.Ord NavigationQueryType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_navigation_query_type_get_type" c_gst_navigation_query_type_get_type :: + IO GType + +instance BoxedEnum NavigationQueryType where + boxedEnumType _ = c_gst_navigation_query_type_get_type + +-- Enum NavigationMessageType +{- | +A set of notifications that may be received on the bus when navigation +related status changes. +-} +data NavigationMessageType = + NavigationMessageTypeInvalid + {- ^ + Returned from + 'GI.GstVideo.Functions.navigationMessageGetType' when the passed message is not a + navigation message. + -} + | NavigationMessageTypeMouseOver + {- ^ + Sent when the mouse moves over or leaves a + clickable region of the output, such as a DVD menu button. + -} + | NavigationMessageTypeCommandsChanged + {- ^ + Sent when the set of available commands + changes and should re-queried by interested applications. + -} + | NavigationMessageTypeAnglesChanged + {- ^ + Sent when display angles in a multi-angle + feature (such as a multiangle DVD) change - either angles have appeared or + disappeared. + -} + | NavigationMessageTypeEvent + {- ^ + Sent when a navigation event was not handled + by any element in the pipeline (Since 1.6) + -} + | AnotherNavigationMessageType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum NavigationMessageType where + fromEnum NavigationMessageTypeInvalid = 0 + fromEnum NavigationMessageTypeMouseOver = 1 + fromEnum NavigationMessageTypeCommandsChanged = 2 + fromEnum NavigationMessageTypeAnglesChanged = 3 + fromEnum NavigationMessageTypeEvent = 4 + fromEnum (AnotherNavigationMessageType k) = k + + toEnum 0 = NavigationMessageTypeInvalid + toEnum 1 = NavigationMessageTypeMouseOver + toEnum 2 = NavigationMessageTypeCommandsChanged + toEnum 3 = NavigationMessageTypeAnglesChanged + toEnum 4 = NavigationMessageTypeEvent + toEnum k = AnotherNavigationMessageType k + +instance P.Ord NavigationMessageType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_navigation_message_type_get_type" c_gst_navigation_message_type_get_type :: + IO GType + +instance BoxedEnum NavigationMessageType where + boxedEnumType _ = c_gst_navigation_message_type_get_type + +-- Enum NavigationEventType +{- | +Enum values for the various events that an element implementing the +GstNavigation interface might send up the pipeline. +-} +data NavigationEventType = + NavigationEventTypeInvalid + {- ^ + Returned from + 'GI.GstVideo.Functions.navigationEventGetType' when the passed event is not a navigation event. + -} + | NavigationEventTypeKeyPress + {- ^ + A key press event. Use + 'GI.GstVideo.Functions.navigationEventParseKeyEvent' to extract the details from the event. + -} + | NavigationEventTypeKeyRelease + {- ^ + A key release event. Use + 'GI.GstVideo.Functions.navigationEventParseKeyEvent' to extract the details from the event. + -} + | NavigationEventTypeMouseButtonPress + {- ^ + A mouse button press event. Use + 'GI.GstVideo.Functions.navigationEventParseMouseButtonEvent' to extract the details from the + event. + -} + | NavigationEventTypeMouseButtonRelease + {- ^ + A mouse button release event. Use + 'GI.GstVideo.Functions.navigationEventParseMouseButtonEvent' to extract the details from the + event. + -} + | NavigationEventTypeMouseMove + {- ^ + A mouse movement event. Use + 'GI.GstVideo.Functions.navigationEventParseMouseMoveEvent' to extract the details from the + event. + -} + | NavigationEventTypeCommand + {- ^ + A navigation command event. Use + 'GI.GstVideo.Functions.navigationEventParseCommand' to extract the details from the event. + -} + | AnotherNavigationEventType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum NavigationEventType where + fromEnum NavigationEventTypeInvalid = 0 + fromEnum NavigationEventTypeKeyPress = 1 + fromEnum NavigationEventTypeKeyRelease = 2 + fromEnum NavigationEventTypeMouseButtonPress = 3 + fromEnum NavigationEventTypeMouseButtonRelease = 4 + fromEnum NavigationEventTypeMouseMove = 5 + fromEnum NavigationEventTypeCommand = 6 + fromEnum (AnotherNavigationEventType k) = k + + toEnum 0 = NavigationEventTypeInvalid + toEnum 1 = NavigationEventTypeKeyPress + toEnum 2 = NavigationEventTypeKeyRelease + toEnum 3 = NavigationEventTypeMouseButtonPress + toEnum 4 = NavigationEventTypeMouseButtonRelease + toEnum 5 = NavigationEventTypeMouseMove + toEnum 6 = NavigationEventTypeCommand + toEnum k = AnotherNavigationEventType k + +instance P.Ord NavigationEventType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_navigation_event_type_get_type" c_gst_navigation_event_type_get_type :: + IO GType + +instance BoxedEnum NavigationEventType where + boxedEnumType _ = c_gst_navigation_event_type_get_type + +-- Enum NavigationCommand +{- | +A set of commands that may be issued to an element providing the +'GI.GstVideo.Interfaces.Navigation.Navigation' interface. The available commands can be queried via +the 'GI.GstVideo.Functions.navigationQueryNewCommands' query. + +For convenience in handling DVD navigation, the MENU commands are aliased as: + GST_NAVIGATION_COMMAND_DVD_MENU = /@gSTNAVIGATIONCOMMANDMENU1@/ + GST_NAVIGATION_COMMAND_DVD_TITLE_MENU = /@gSTNAVIGATIONCOMMANDMENU2@/ + GST_NAVIGATION_COMMAND_DVD_ROOT_MENU = /@gSTNAVIGATIONCOMMANDMENU3@/ + GST_NAVIGATION_COMMAND_DVD_SUBPICTURE_MENU = /@gSTNAVIGATIONCOMMANDMENU4@/ + GST_NAVIGATION_COMMAND_DVD_AUDIO_MENU = /@gSTNAVIGATIONCOMMANDMENU5@/ + GST_NAVIGATION_COMMAND_DVD_ANGLE_MENU = /@gSTNAVIGATIONCOMMANDMENU6@/ + GST_NAVIGATION_COMMAND_DVD_CHAPTER_MENU = /@gSTNAVIGATIONCOMMANDMENU7@/ +-} +data NavigationCommand = + NavigationCommandInvalid + {- ^ + An invalid command entry + -} + | NavigationCommandMenu1 + {- ^ + Execute navigation menu command 1. For DVD, + this enters the DVD root menu, or exits back to the title from the menu. + -} + | NavigationCommandMenu2 + {- ^ + Execute navigation menu command 2. For DVD, + this jumps to the DVD title menu. + -} + | NavigationCommandMenu3 + {- ^ + Execute navigation menu command 3. For DVD, + this jumps into the DVD root menu. + -} + | NavigationCommandMenu4 + {- ^ + Execute navigation menu command 4. For DVD, + this jumps to the Subpicture menu. + -} + | NavigationCommandMenu5 + {- ^ + Execute navigation menu command 5. For DVD, + the jumps to the audio menu. + -} + | NavigationCommandMenu6 + {- ^ + Execute navigation menu command 6. For DVD, + this jumps to the angles menu. + -} + | NavigationCommandMenu7 + {- ^ + Execute navigation menu command 7. For DVD, + this jumps to the chapter menu. + -} + | NavigationCommandLeft + {- ^ + Select the next button to the left in a menu, + if such a button exists. + -} + | NavigationCommandRight + {- ^ + Select the next button to the right in a menu, + if such a button exists. + -} + | NavigationCommandUp + {- ^ + Select the button above the current one in a + menu, if such a button exists. + -} + | NavigationCommandDown + {- ^ + Select the button below the current one in a + menu, if such a button exists. + -} + | NavigationCommandActivate + {- ^ + Activate (click) the currently selected + button in a menu, if such a button exists. + -} + | NavigationCommandPrevAngle + {- ^ + Switch to the previous angle in a + multiangle feature. + -} + | NavigationCommandNextAngle + {- ^ + Switch to the next angle in a multiangle + feature. + -} + | AnotherNavigationCommand Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum NavigationCommand where + fromEnum NavigationCommandInvalid = 0 + fromEnum NavigationCommandMenu1 = 1 + fromEnum NavigationCommandMenu2 = 2 + fromEnum NavigationCommandMenu3 = 3 + fromEnum NavigationCommandMenu4 = 4 + fromEnum NavigationCommandMenu5 = 5 + fromEnum NavigationCommandMenu6 = 6 + fromEnum NavigationCommandMenu7 = 7 + fromEnum NavigationCommandLeft = 20 + fromEnum NavigationCommandRight = 21 + fromEnum NavigationCommandUp = 22 + fromEnum NavigationCommandDown = 23 + fromEnum NavigationCommandActivate = 24 + fromEnum NavigationCommandPrevAngle = 30 + fromEnum NavigationCommandNextAngle = 31 + fromEnum (AnotherNavigationCommand k) = k + + toEnum 0 = NavigationCommandInvalid + toEnum 1 = NavigationCommandMenu1 + toEnum 2 = NavigationCommandMenu2 + toEnum 3 = NavigationCommandMenu3 + toEnum 4 = NavigationCommandMenu4 + toEnum 5 = NavigationCommandMenu5 + toEnum 6 = NavigationCommandMenu6 + toEnum 7 = NavigationCommandMenu7 + toEnum 20 = NavigationCommandLeft + toEnum 21 = NavigationCommandRight + toEnum 22 = NavigationCommandUp + toEnum 23 = NavigationCommandDown + toEnum 24 = NavigationCommandActivate + toEnum 30 = NavigationCommandPrevAngle + toEnum 31 = NavigationCommandNextAngle + toEnum k = AnotherNavigationCommand k + +instance P.Ord NavigationCommand where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_navigation_command_get_type" c_gst_navigation_command_get_type :: + IO GType + +instance BoxedEnum NavigationCommand where + boxedEnumType _ = c_gst_navigation_command_get_type + +-- Enum ColorBalanceType +{- | +An enumeration indicating whether an element implements color balancing +operations in software or in dedicated hardware. In general, dedicated +hardware implementations (such as those provided by xvimagesink) are +preferred. +-} +data ColorBalanceType = + ColorBalanceTypeHardware + {- ^ + Color balance is implemented with dedicated + hardware. + -} + | ColorBalanceTypeSoftware + {- ^ + Color balance is implemented via software + processing. + -} + | AnotherColorBalanceType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ColorBalanceType where + fromEnum ColorBalanceTypeHardware = 0 + fromEnum ColorBalanceTypeSoftware = 1 + fromEnum (AnotherColorBalanceType k) = k + + toEnum 0 = ColorBalanceTypeHardware + toEnum 1 = ColorBalanceTypeSoftware + toEnum k = AnotherColorBalanceType k + +instance P.Ord ColorBalanceType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_color_balance_type_get_type" c_gst_color_balance_type_get_type :: + IO GType + +instance BoxedEnum ColorBalanceType where + boxedEnumType _ = c_gst_color_balance_type_get_type + + diff --git a/GI/GstVideo/Enums.hs-boot b/GI/GstVideo/Enums.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Enums.hs-boot @@ -0,0 +1,115 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Enums where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +data VideoVBIParserResult +instance P.Enum VideoVBIParserResult where +instance BoxedEnum VideoVBIParserResult where +data VideoTransferFunction +instance P.Enum VideoTransferFunction where +instance BoxedEnum VideoTransferFunction where +data VideoTileType +instance P.Enum VideoTileType where +instance BoxedEnum VideoTileType where +data VideoTileMode +instance P.Enum VideoTileMode where +instance BoxedEnum VideoTileMode where +data VideoResamplerMethod +instance P.Enum VideoResamplerMethod where +instance BoxedEnum VideoResamplerMethod where +data VideoPrimariesMode +instance P.Enum VideoPrimariesMode where +instance BoxedEnum VideoPrimariesMode where +data VideoOrientationMethod +instance P.Enum VideoOrientationMethod where +instance BoxedEnum VideoOrientationMethod where +data VideoMultiviewMode +instance P.Enum VideoMultiviewMode where +instance BoxedEnum VideoMultiviewMode where +data VideoMultiviewFramePacking +instance P.Enum VideoMultiviewFramePacking where +instance BoxedEnum VideoMultiviewFramePacking where +data VideoMatrixMode +instance P.Enum VideoMatrixMode where +instance BoxedEnum VideoMatrixMode where +data VideoInterlaceMode +instance P.Enum VideoInterlaceMode where +instance BoxedEnum VideoInterlaceMode where +data VideoGammaMode +instance P.Enum VideoGammaMode where +instance BoxedEnum VideoGammaMode where +data VideoGLTextureType +instance P.Enum VideoGLTextureType where +data VideoGLTextureOrientation +instance P.Enum VideoGLTextureOrientation where +data VideoFormat +instance P.Enum VideoFormat where +instance BoxedEnum VideoFormat where +data VideoFieldOrder +instance P.Enum VideoFieldOrder where +instance BoxedEnum VideoFieldOrder where +data VideoDitherMethod +instance P.Enum VideoDitherMethod where +instance BoxedEnum VideoDitherMethod where +data VideoColorRange +instance P.Enum VideoColorRange where +instance BoxedEnum VideoColorRange where +data VideoColorPrimaries +instance P.Enum VideoColorPrimaries where +instance BoxedEnum VideoColorPrimaries where +data VideoColorMatrix +instance P.Enum VideoColorMatrix where +instance BoxedEnum VideoColorMatrix where +data VideoChromaMode +instance P.Enum VideoChromaMode where +instance BoxedEnum VideoChromaMode where +data VideoChromaMethod +instance P.Enum VideoChromaMethod where +instance BoxedEnum VideoChromaMethod where +data VideoCaptionType +instance P.Enum VideoCaptionType where +instance BoxedEnum VideoCaptionType where +data VideoAncillaryDID16 +instance P.Enum VideoAncillaryDID16 where +instance BoxedEnum VideoAncillaryDID16 where +data VideoAncillaryDID +instance P.Enum VideoAncillaryDID where +instance BoxedEnum VideoAncillaryDID where +data VideoAlphaMode +instance P.Enum VideoAlphaMode where +instance BoxedEnum VideoAlphaMode where +data NavigationQueryType +instance P.Enum NavigationQueryType where +instance BoxedEnum NavigationQueryType where +data NavigationMessageType +instance P.Enum NavigationMessageType where +instance BoxedEnum NavigationMessageType where +data NavigationEventType +instance P.Enum NavigationEventType where +instance BoxedEnum NavigationEventType where +data NavigationCommand +instance P.Enum NavigationCommand where +instance BoxedEnum NavigationCommand where +data ColorBalanceType +instance P.Enum ColorBalanceType where +instance BoxedEnum ColorBalanceType where diff --git a/GI/GstVideo/Flags.hs b/GI/GstVideo/Flags.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Flags.hs @@ -0,0 +1,983 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Flags + ( + + -- * Flags +-- ** VideoBufferFlags #flag:VideoBufferFlags# + + VideoBufferFlags(..) , + + +-- ** VideoChromaFlags #flag:VideoChromaFlags# + + VideoChromaFlags(..) , + + +-- ** VideoChromaSite #flag:VideoChromaSite# + + VideoChromaSite(..) , + + +-- ** VideoCodecFrameFlags #flag:VideoCodecFrameFlags# + + VideoCodecFrameFlags(..) , + + +-- ** VideoDitherFlags #flag:VideoDitherFlags# + + VideoDitherFlags(..) , + + +-- ** VideoFlags #flag:VideoFlags# + + VideoFlags(..) , + + +-- ** VideoFormatFlags #flag:VideoFormatFlags# + + VideoFormatFlags(..) , + + +-- ** VideoFrameFlags #flag:VideoFrameFlags# + + VideoFrameFlags(..) , + + +-- ** VideoFrameMapFlags #flag:VideoFrameMapFlags# + + VideoFrameMapFlags(..) , + + +-- ** VideoMultiviewFlags #flag:VideoMultiviewFlags# + + VideoMultiviewFlags(..) , + + +-- ** VideoOverlayFormatFlags #flag:VideoOverlayFormatFlags# + + VideoOverlayFormatFlags(..) , + + +-- ** VideoPackFlags #flag:VideoPackFlags# + + VideoPackFlags(..) , + + +-- ** VideoResamplerFlags #flag:VideoResamplerFlags# + + VideoResamplerFlags(..) , + + +-- ** VideoScalerFlags #flag:VideoScalerFlags# + + VideoScalerFlags(..) , + + +-- ** VideoTimeCodeFlags #flag:VideoTimeCodeFlags# + + VideoTimeCodeFlags(..) , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- Flags VideoTimeCodeFlags +{- | +Flags related to the time code information. +For drop frame, only 30000\/1001 and 60000\/1001 frame rates are supported. + +/Since: 1.10/ +-} +data VideoTimeCodeFlags = + VideoTimeCodeFlagsNone + {- ^ + No flags + -} + | VideoTimeCodeFlagsDropFrame + {- ^ + Whether we have drop frame rate + -} + | VideoTimeCodeFlagsInterlaced + {- ^ + Whether we have interlaced video + -} + | AnotherVideoTimeCodeFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoTimeCodeFlags where + fromEnum VideoTimeCodeFlagsNone = 0 + fromEnum VideoTimeCodeFlagsDropFrame = 1 + fromEnum VideoTimeCodeFlagsInterlaced = 2 + fromEnum (AnotherVideoTimeCodeFlags k) = k + + toEnum 0 = VideoTimeCodeFlagsNone + toEnum 1 = VideoTimeCodeFlagsDropFrame + toEnum 2 = VideoTimeCodeFlagsInterlaced + toEnum k = AnotherVideoTimeCodeFlags k + +instance P.Ord VideoTimeCodeFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag VideoTimeCodeFlags + +-- Flags VideoScalerFlags +{- | +Different scale flags. +-} +data VideoScalerFlags = + VideoScalerFlagsNone + {- ^ + no flags + -} + | VideoScalerFlagsInterlaced + {- ^ + Set up a scaler for interlaced content + -} + | AnotherVideoScalerFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoScalerFlags where + fromEnum VideoScalerFlagsNone = 0 + fromEnum VideoScalerFlagsInterlaced = 1 + fromEnum (AnotherVideoScalerFlags k) = k + + toEnum 0 = VideoScalerFlagsNone + toEnum 1 = VideoScalerFlagsInterlaced + toEnum k = AnotherVideoScalerFlags k + +instance P.Ord VideoScalerFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_scaler_flags_get_type" c_gst_video_scaler_flags_get_type :: + IO GType + +instance BoxedFlags VideoScalerFlags where + boxedFlagsType _ = c_gst_video_scaler_flags_get_type + +instance IsGFlag VideoScalerFlags + +-- Flags VideoResamplerFlags +{- | +Different resampler flags. + +/Since: 1.6/ +-} +data VideoResamplerFlags = + VideoResamplerFlagsNone + {- ^ + no flags + -} + | VideoResamplerFlagsHalfTaps + {- ^ + when no taps are given, half the + number of calculated taps. This can be used when making scalers + for the different fields of an interlaced picture. Since 1.10 + -} + | AnotherVideoResamplerFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoResamplerFlags where + fromEnum VideoResamplerFlagsNone = 0 + fromEnum VideoResamplerFlagsHalfTaps = 1 + fromEnum (AnotherVideoResamplerFlags k) = k + + toEnum 0 = VideoResamplerFlagsNone + toEnum 1 = VideoResamplerFlagsHalfTaps + toEnum k = AnotherVideoResamplerFlags k + +instance P.Ord VideoResamplerFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_resampler_flags_get_type" c_gst_video_resampler_flags_get_type :: + IO GType + +instance BoxedFlags VideoResamplerFlags where + boxedFlagsType _ = c_gst_video_resampler_flags_get_type + +instance IsGFlag VideoResamplerFlags + +-- Flags VideoPackFlags +{- | +The different flags that can be used when packing and unpacking. +-} +data VideoPackFlags = + VideoPackFlagsNone + {- ^ + No flag + -} + | VideoPackFlagsTruncateRange + {- ^ + When the source has a smaller depth + than the target format, set the least significant bits of the target + to 0. This is likely sightly faster but less accurate. When this flag + is not specified, the most significant bits of the source are duplicated + in the least significant bits of the destination. + -} + | VideoPackFlagsInterlaced + {- ^ + The source is interlaced. The unpacked + format will be interlaced as well with each line containing + information from alternating fields. (Since 1.2) + -} + | AnotherVideoPackFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoPackFlags where + fromEnum VideoPackFlagsNone = 0 + fromEnum VideoPackFlagsTruncateRange = 1 + fromEnum VideoPackFlagsInterlaced = 2 + fromEnum (AnotherVideoPackFlags k) = k + + toEnum 0 = VideoPackFlagsNone + toEnum 1 = VideoPackFlagsTruncateRange + toEnum 2 = VideoPackFlagsInterlaced + toEnum k = AnotherVideoPackFlags k + +instance P.Ord VideoPackFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_pack_flags_get_type" c_gst_video_pack_flags_get_type :: + IO GType + +instance BoxedFlags VideoPackFlags where + boxedFlagsType _ = c_gst_video_pack_flags_get_type + +instance IsGFlag VideoPackFlags + +-- Flags VideoOverlayFormatFlags +{- | +Overlay format flags. +-} +data VideoOverlayFormatFlags = + VideoOverlayFormatFlagsNone + {- ^ + no flags + -} + | VideoOverlayFormatFlagsPremultipliedAlpha + {- ^ + RGB are premultiplied by A\/255. + -} + | VideoOverlayFormatFlagsGlobalAlpha + {- ^ + a global-alpha value != 1 is set. + -} + | AnotherVideoOverlayFormatFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoOverlayFormatFlags where + fromEnum VideoOverlayFormatFlagsNone = 0 + fromEnum VideoOverlayFormatFlagsPremultipliedAlpha = 1 + fromEnum VideoOverlayFormatFlagsGlobalAlpha = 2 + fromEnum (AnotherVideoOverlayFormatFlags k) = k + + toEnum 0 = VideoOverlayFormatFlagsNone + toEnum 1 = VideoOverlayFormatFlagsPremultipliedAlpha + toEnum 2 = VideoOverlayFormatFlagsGlobalAlpha + toEnum k = AnotherVideoOverlayFormatFlags k + +instance P.Ord VideoOverlayFormatFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_overlay_format_flags_get_type" c_gst_video_overlay_format_flags_get_type :: + IO GType + +instance BoxedFlags VideoOverlayFormatFlags where + boxedFlagsType _ = c_gst_video_overlay_format_flags_get_type + +instance IsGFlag VideoOverlayFormatFlags + +-- Flags VideoMultiviewFlags +{- | +GstVideoMultiviewFlags are used to indicate extra properties of a +stereo\/multiview stream beyond the frame layout and buffer mapping +that is conveyed in the 'GI.GstVideo.Enums.VideoMultiviewMode'. +-} +data VideoMultiviewFlags = + VideoMultiviewFlagsNone + {- ^ + No flags + -} + | VideoMultiviewFlagsRightViewFirst + {- ^ + For stereo streams, the + normal arrangement of left and right views is reversed. + -} + | VideoMultiviewFlagsLeftFlipped + {- ^ + The left view is vertically + mirrored. + -} + | VideoMultiviewFlagsLeftFlopped + {- ^ + The left view is horizontally + mirrored. + -} + | VideoMultiviewFlagsRightFlipped + {- ^ + The right view is + vertically mirrored. + -} + | VideoMultiviewFlagsRightFlopped + {- ^ + The right view is + horizontally mirrored. + -} + | VideoMultiviewFlagsHalfAspect + {- ^ + For frame-packed + multiview modes, indicates that the individual + views have been encoded with half the true width or height + and should be scaled back up for display. This flag + is used for overriding input layout interpretation + by adjusting pixel-aspect-ratio. + For side-by-side, column interleaved or checkerboard packings, the + pixel width will be doubled. For row interleaved and top-bottom + encodings, pixel height will be doubled. + -} + | VideoMultiviewFlagsMixedMono + {- ^ + The video stream contains both + mono and multiview portions, signalled on each buffer by the + absence or presence of the /@gSTVIDEOBUFFERFLAGMULTIPLEVIEW@/ + buffer flag. + -} + | AnotherVideoMultiviewFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoMultiviewFlags where + fromEnum VideoMultiviewFlagsNone = 0 + fromEnum VideoMultiviewFlagsRightViewFirst = 1 + fromEnum VideoMultiviewFlagsLeftFlipped = 2 + fromEnum VideoMultiviewFlagsLeftFlopped = 4 + fromEnum VideoMultiviewFlagsRightFlipped = 8 + fromEnum VideoMultiviewFlagsRightFlopped = 16 + fromEnum VideoMultiviewFlagsHalfAspect = 16384 + fromEnum VideoMultiviewFlagsMixedMono = 32768 + fromEnum (AnotherVideoMultiviewFlags k) = k + + toEnum 0 = VideoMultiviewFlagsNone + toEnum 1 = VideoMultiviewFlagsRightViewFirst + toEnum 2 = VideoMultiviewFlagsLeftFlipped + toEnum 4 = VideoMultiviewFlagsLeftFlopped + toEnum 8 = VideoMultiviewFlagsRightFlipped + toEnum 16 = VideoMultiviewFlagsRightFlopped + toEnum 16384 = VideoMultiviewFlagsHalfAspect + toEnum 32768 = VideoMultiviewFlagsMixedMono + toEnum k = AnotherVideoMultiviewFlags k + +instance P.Ord VideoMultiviewFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_multiview_flags_get_type" c_gst_video_multiview_flags_get_type :: + IO GType + +instance BoxedFlags VideoMultiviewFlags where + boxedFlagsType _ = c_gst_video_multiview_flags_get_type + +instance IsGFlag VideoMultiviewFlags + +-- Flags VideoFrameMapFlags +{- | +Additional mapping flags for 'GI.GstVideo.Structs.VideoFrame.videoFrameMap'. + +/Since: 1.6/ +-} +data VideoFrameMapFlags = + VideoFrameMapFlagsNoRef + {- ^ + Don\'t take another reference of the buffer and store it in + the GstVideoFrame. This makes sure that the buffer stays + writable while the frame is mapped, but requires that the + buffer reference stays valid until the frame is unmapped again. + -} + | VideoFrameMapFlagsLast + {- ^ + Offset to define more flags + -} + | AnotherVideoFrameMapFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoFrameMapFlags where + fromEnum VideoFrameMapFlagsNoRef = 65536 + fromEnum VideoFrameMapFlagsLast = 16777216 + fromEnum (AnotherVideoFrameMapFlags k) = k + + toEnum 65536 = VideoFrameMapFlagsNoRef + toEnum 16777216 = VideoFrameMapFlagsLast + toEnum k = AnotherVideoFrameMapFlags k + +instance P.Ord VideoFrameMapFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_frame_map_flags_get_type" c_gst_video_frame_map_flags_get_type :: + IO GType + +instance BoxedFlags VideoFrameMapFlags where + boxedFlagsType _ = c_gst_video_frame_map_flags_get_type + +instance IsGFlag VideoFrameMapFlags + +-- Flags VideoFrameFlags +{- | +Extra video frame flags +-} +data VideoFrameFlags = + VideoFrameFlagsNone + {- ^ + no flags + -} + | VideoFrameFlagsInterlaced + {- ^ + The video frame is interlaced. In mixed + interlace-mode, this flag specifies if the frame is interlaced or + progressive. + -} + | VideoFrameFlagsTff + {- ^ + The video frame has the top field first + -} + | VideoFrameFlagsRff + {- ^ + The video frame has the repeat flag + -} + | VideoFrameFlagsOnefield + {- ^ + The video frame has one field + -} + | VideoFrameFlagsMultipleView + {- ^ + The video contains one or + more non-mono views + -} + | VideoFrameFlagsFirstInBundle + {- ^ + The video frame is the first + in a set of corresponding views provided as sequential frames. + -} + | VideoFrameFlagsTopField + {- ^ + The video frame has the top field only. This + is the same as GST_VIDEO_FRAME_FLAG_TFF | GST_VIDEO_FRAME_FLAG_ONEFIELD + (Since: 1.16). + -} + | VideoFrameFlagsBottomField + {- ^ + The video frame has the bottom field + only. This is the same as GST_VIDEO_FRAME_FLAG_ONEFIELD + (GST_VIDEO_FRAME_FLAG_TFF flag unset) (Since: 1.16). + -} + | AnotherVideoFrameFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoFrameFlags where + fromEnum VideoFrameFlagsNone = 0 + fromEnum VideoFrameFlagsInterlaced = 1 + fromEnum VideoFrameFlagsTff = 2 + fromEnum VideoFrameFlagsRff = 4 + fromEnum VideoFrameFlagsOnefield = 8 + fromEnum VideoFrameFlagsMultipleView = 16 + fromEnum VideoFrameFlagsFirstInBundle = 32 + fromEnum VideoFrameFlagsTopField = 10 + fromEnum VideoFrameFlagsBottomField = 8 + fromEnum (AnotherVideoFrameFlags k) = k + + toEnum 0 = VideoFrameFlagsNone + toEnum 1 = VideoFrameFlagsInterlaced + toEnum 2 = VideoFrameFlagsTff + toEnum 4 = VideoFrameFlagsRff + toEnum 8 = VideoFrameFlagsOnefield + toEnum 16 = VideoFrameFlagsMultipleView + toEnum 32 = VideoFrameFlagsFirstInBundle + toEnum 10 = VideoFrameFlagsTopField + toEnum 8 = VideoFrameFlagsBottomField + toEnum k = AnotherVideoFrameFlags k + +instance P.Ord VideoFrameFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_frame_flags_get_type" c_gst_video_frame_flags_get_type :: + IO GType + +instance BoxedFlags VideoFrameFlags where + boxedFlagsType _ = c_gst_video_frame_flags_get_type + +instance IsGFlag VideoFrameFlags + +-- Flags VideoFormatFlags +{- | +The different video flags that a format info can have. +-} +data VideoFormatFlags = + VideoFormatFlagsYuv + {- ^ + The video format is YUV, components are numbered + 0=Y, 1=U, 2=V. + -} + | VideoFormatFlagsRgb + {- ^ + The video format is RGB, components are numbered + 0=R, 1=G, 2=B. + -} + | VideoFormatFlagsGray + {- ^ + The video is gray, there is one gray component + with index 0. + -} + | VideoFormatFlagsAlpha + {- ^ + The video format has an alpha components with + the number 3. + -} + | VideoFormatFlagsLe + {- ^ + The video format has data stored in little + endianness. + -} + | VideoFormatFlagsPalette + {- ^ + The video format has a palette. The palette + is stored in the second plane and indexes are stored in the first plane. + -} + | VideoFormatFlagsComplex + {- ^ + The video format has a complex layout that + can\'t be described with the usual information in the 'GI.GstVideo.Structs.VideoFormatInfo.VideoFormatInfo'. + -} + | VideoFormatFlagsUnpack + {- ^ + This format can be used in a + 'GI.GstVideo.Callbacks.VideoFormatUnpack' and 'GI.GstVideo.Callbacks.VideoFormatPack' function. + -} + | VideoFormatFlagsTiled + {- ^ + The format is tiled, there is tiling information + in the last plane. + -} + | AnotherVideoFormatFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoFormatFlags where + fromEnum VideoFormatFlagsYuv = 1 + fromEnum VideoFormatFlagsRgb = 2 + fromEnum VideoFormatFlagsGray = 4 + fromEnum VideoFormatFlagsAlpha = 8 + fromEnum VideoFormatFlagsLe = 16 + fromEnum VideoFormatFlagsPalette = 32 + fromEnum VideoFormatFlagsComplex = 64 + fromEnum VideoFormatFlagsUnpack = 128 + fromEnum VideoFormatFlagsTiled = 256 + fromEnum (AnotherVideoFormatFlags k) = k + + toEnum 1 = VideoFormatFlagsYuv + toEnum 2 = VideoFormatFlagsRgb + toEnum 4 = VideoFormatFlagsGray + toEnum 8 = VideoFormatFlagsAlpha + toEnum 16 = VideoFormatFlagsLe + toEnum 32 = VideoFormatFlagsPalette + toEnum 64 = VideoFormatFlagsComplex + toEnum 128 = VideoFormatFlagsUnpack + toEnum 256 = VideoFormatFlagsTiled + toEnum k = AnotherVideoFormatFlags k + +instance P.Ord VideoFormatFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_format_flags_get_type" c_gst_video_format_flags_get_type :: + IO GType + +instance BoxedFlags VideoFormatFlags where + boxedFlagsType _ = c_gst_video_format_flags_get_type + +instance IsGFlag VideoFormatFlags + +-- Flags VideoFlags +{- | +Extra video flags +-} +data VideoFlags = + VideoFlagsNone + {- ^ + no flags + -} + | VideoFlagsVariableFps + {- ^ + a variable fps is selected, fps_n and fps_d + denote the maximum fps of the video + -} + | VideoFlagsPremultipliedAlpha + {- ^ + Each color has been scaled by the alpha + value. + -} + | AnotherVideoFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoFlags where + fromEnum VideoFlagsNone = 0 + fromEnum VideoFlagsVariableFps = 1 + fromEnum VideoFlagsPremultipliedAlpha = 2 + fromEnum (AnotherVideoFlags k) = k + + toEnum 0 = VideoFlagsNone + toEnum 1 = VideoFlagsVariableFps + toEnum 2 = VideoFlagsPremultipliedAlpha + toEnum k = AnotherVideoFlags k + +instance P.Ord VideoFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_flags_get_type" c_gst_video_flags_get_type :: + IO GType + +instance BoxedFlags VideoFlags where + boxedFlagsType _ = c_gst_video_flags_get_type + +instance IsGFlag VideoFlags + +-- Flags VideoDitherFlags +{- | +Extra flags that influence the result from @/gst_video_chroma_resample_new()/@. +-} +data VideoDitherFlags = + VideoDitherFlagsNone + {- ^ + no flags + -} + | VideoDitherFlagsInterlaced + {- ^ + the input is interlaced + -} + | VideoDitherFlagsQuantize + {- ^ + quantize values in addition to adding dither. + -} + | AnotherVideoDitherFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoDitherFlags where + fromEnum VideoDitherFlagsNone = 0 + fromEnum VideoDitherFlagsInterlaced = 1 + fromEnum VideoDitherFlagsQuantize = 2 + fromEnum (AnotherVideoDitherFlags k) = k + + toEnum 0 = VideoDitherFlagsNone + toEnum 1 = VideoDitherFlagsInterlaced + toEnum 2 = VideoDitherFlagsQuantize + toEnum k = AnotherVideoDitherFlags k + +instance P.Ord VideoDitherFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_dither_flags_get_type" c_gst_video_dither_flags_get_type :: + IO GType + +instance BoxedFlags VideoDitherFlags where + boxedFlagsType _ = c_gst_video_dither_flags_get_type + +instance IsGFlag VideoDitherFlags + +-- Flags VideoCodecFrameFlags +{- | +Flags for 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' +-} +data VideoCodecFrameFlags = + VideoCodecFrameFlagsDecodeOnly + {- ^ + is the frame only meant to be decoded + -} + | VideoCodecFrameFlagsSyncPoint + {- ^ + is the frame a synchronization point (keyframe) + -} + | VideoCodecFrameFlagsForceKeyframe + {- ^ + should the output frame be made a keyframe + -} + | VideoCodecFrameFlagsForceKeyframeHeaders + {- ^ + should the encoder output stream headers + -} + | AnotherVideoCodecFrameFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoCodecFrameFlags where + fromEnum VideoCodecFrameFlagsDecodeOnly = 1 + fromEnum VideoCodecFrameFlagsSyncPoint = 2 + fromEnum VideoCodecFrameFlagsForceKeyframe = 4 + fromEnum VideoCodecFrameFlagsForceKeyframeHeaders = 8 + fromEnum (AnotherVideoCodecFrameFlags k) = k + + toEnum 1 = VideoCodecFrameFlagsDecodeOnly + toEnum 2 = VideoCodecFrameFlagsSyncPoint + toEnum 4 = VideoCodecFrameFlagsForceKeyframe + toEnum 8 = VideoCodecFrameFlagsForceKeyframeHeaders + toEnum k = AnotherVideoCodecFrameFlags k + +instance P.Ord VideoCodecFrameFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag VideoCodecFrameFlags + +-- Flags VideoChromaSite +{- | +Various Chroma sitings. +-} +data VideoChromaSite = + VideoChromaSiteUnknown + {- ^ + unknown cositing + -} + | VideoChromaSiteNone + {- ^ + no cositing + -} + | VideoChromaSiteHCosited + {- ^ + chroma is horizontally cosited + -} + | VideoChromaSiteVCosited + {- ^ + chroma is vertically cosited + -} + | VideoChromaSiteAltLine + {- ^ + choma samples are sited on alternate lines + -} + | VideoChromaSiteCosited + {- ^ + chroma samples cosited with luma samples + -} + | VideoChromaSiteJpeg + {- ^ + jpeg style cositing, also for mpeg1 and mjpeg + -} + | VideoChromaSiteMpeg2 + {- ^ + mpeg2 style cositing + -} + | VideoChromaSiteDv + {- ^ + DV style cositing + -} + | AnotherVideoChromaSite Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoChromaSite where + fromEnum VideoChromaSiteUnknown = 0 + fromEnum VideoChromaSiteNone = 1 + fromEnum VideoChromaSiteHCosited = 2 + fromEnum VideoChromaSiteVCosited = 4 + fromEnum VideoChromaSiteAltLine = 8 + fromEnum VideoChromaSiteCosited = 6 + fromEnum VideoChromaSiteJpeg = 1 + fromEnum VideoChromaSiteMpeg2 = 2 + fromEnum VideoChromaSiteDv = 14 + fromEnum (AnotherVideoChromaSite k) = k + + toEnum 0 = VideoChromaSiteUnknown + toEnum 1 = VideoChromaSiteNone + toEnum 2 = VideoChromaSiteHCosited + toEnum 4 = VideoChromaSiteVCosited + toEnum 8 = VideoChromaSiteAltLine + toEnum 6 = VideoChromaSiteCosited + toEnum 1 = VideoChromaSiteJpeg + toEnum 2 = VideoChromaSiteMpeg2 + toEnum 14 = VideoChromaSiteDv + toEnum k = AnotherVideoChromaSite k + +instance P.Ord VideoChromaSite where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_chroma_site_get_type" c_gst_video_chroma_site_get_type :: + IO GType + +instance BoxedFlags VideoChromaSite where + boxedFlagsType _ = c_gst_video_chroma_site_get_type + +instance IsGFlag VideoChromaSite + +-- Flags VideoChromaFlags +{- | +Extra flags that influence the result from @/gst_video_chroma_resample_new()/@. +-} +data VideoChromaFlags = + VideoChromaFlagsNone + {- ^ + no flags + -} + | VideoChromaFlagsInterlaced + {- ^ + the input is interlaced + -} + | AnotherVideoChromaFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoChromaFlags where + fromEnum VideoChromaFlagsNone = 0 + fromEnum VideoChromaFlagsInterlaced = 1 + fromEnum (AnotherVideoChromaFlags k) = k + + toEnum 0 = VideoChromaFlagsNone + toEnum 1 = VideoChromaFlagsInterlaced + toEnum k = AnotherVideoChromaFlags k + +instance P.Ord VideoChromaFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_chroma_flags_get_type" c_gst_video_chroma_flags_get_type :: + IO GType + +instance BoxedFlags VideoChromaFlags where + boxedFlagsType _ = c_gst_video_chroma_flags_get_type + +instance IsGFlag VideoChromaFlags + +-- Flags VideoBufferFlags +{- | +Additional video buffer flags. These flags can potentially be used on any +buffers carrying video data - even encoded data. + +Note that these are only valid for 'GI.Gst.Structs.Caps.Caps' of type: video\/... +They can conflict with other extended buffer flags. +-} +data VideoBufferFlags = + VideoBufferFlagsInterlaced + {- ^ + If the 'GI.Gst.Structs.Buffer.Buffer' is interlaced. In mixed + interlace-mode, this flags specifies if the frame is + interlaced or progressive. + -} + | VideoBufferFlagsTff + {- ^ + If the 'GI.Gst.Structs.Buffer.Buffer' is interlaced, then the first field + in the video frame is the top field. If unset, the + bottom field is first. + -} + | VideoBufferFlagsRff + {- ^ + If the 'GI.Gst.Structs.Buffer.Buffer' is interlaced, then the first field + (as defined by the 'GI.GstVideo.Flags.VideoBufferFlagsTff' flag setting) + is repeated. + -} + | VideoBufferFlagsOnefield + {- ^ + If the 'GI.Gst.Structs.Buffer.Buffer' is interlaced, then only the + first field (as defined by the 'GI.GstVideo.Flags.VideoBufferFlagsTff' + flag setting) is to be displayed (Since: 1.16). + -} + | VideoBufferFlagsMultipleView + {- ^ + The 'GI.Gst.Structs.Buffer.Buffer' contains one or more specific views, + such as left or right eye view. This flags is set on + any buffer that contains non-mono content - even for + streams that contain only a single viewpoint. In mixed + mono \/ non-mono streams, the absense of the flag marks + mono buffers. + -} + | VideoBufferFlagsFirstInBundle + {- ^ + When conveying stereo\/multiview content with + frame-by-frame methods, this flag marks the first buffer + in a bundle of frames that belong together. + -} + | VideoBufferFlagsTopField + {- ^ + The video frame has the top field only. This is the + same as GST_VIDEO_BUFFER_FLAG_TFF | + GST_VIDEO_BUFFER_FLAG_ONEFIELD (Since: 1.16). + -} + | VideoBufferFlagsBottomField + {- ^ + The video frame has the bottom field only. This is + the same as GST_VIDEO_BUFFER_FLAG_ONEFIELD + (GST_VIDEO_BUFFER_FLAG_TFF flag unset) (Since: 1.16). + -} + | VideoBufferFlagsLast + {- ^ + Offset to define more flags + -} + | AnotherVideoBufferFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VideoBufferFlags where + fromEnum VideoBufferFlagsInterlaced = 1048576 + fromEnum VideoBufferFlagsTff = 2097152 + fromEnum VideoBufferFlagsRff = 4194304 + fromEnum VideoBufferFlagsOnefield = 8388608 + fromEnum VideoBufferFlagsMultipleView = 16777216 + fromEnum VideoBufferFlagsFirstInBundle = 33554432 + fromEnum VideoBufferFlagsTopField = 10485760 + fromEnum VideoBufferFlagsBottomField = 8388608 + fromEnum VideoBufferFlagsLast = 268435456 + fromEnum (AnotherVideoBufferFlags k) = k + + toEnum 1048576 = VideoBufferFlagsInterlaced + toEnum 2097152 = VideoBufferFlagsTff + toEnum 4194304 = VideoBufferFlagsRff + toEnum 8388608 = VideoBufferFlagsOnefield + toEnum 16777216 = VideoBufferFlagsMultipleView + toEnum 33554432 = VideoBufferFlagsFirstInBundle + toEnum 10485760 = VideoBufferFlagsTopField + toEnum 8388608 = VideoBufferFlagsBottomField + toEnum 268435456 = VideoBufferFlagsLast + toEnum k = AnotherVideoBufferFlags k + +instance P.Ord VideoBufferFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "gst_video_buffer_flags_get_type" c_gst_video_buffer_flags_get_type :: + IO GType + +instance BoxedFlags VideoBufferFlags where + boxedFlagsType _ = c_gst_video_buffer_flags_get_type + +instance IsGFlag VideoBufferFlags + + diff --git a/GI/GstVideo/Flags.hs-boot b/GI/GstVideo/Flags.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Flags.hs-boot @@ -0,0 +1,82 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Flags where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +data VideoTimeCodeFlags +instance P.Enum VideoTimeCodeFlags where +instance IsGFlag VideoTimeCodeFlags +data VideoScalerFlags +instance P.Enum VideoScalerFlags where +instance BoxedFlags VideoScalerFlags where +instance IsGFlag VideoScalerFlags +data VideoResamplerFlags +instance P.Enum VideoResamplerFlags where +instance BoxedFlags VideoResamplerFlags where +instance IsGFlag VideoResamplerFlags +data VideoPackFlags +instance P.Enum VideoPackFlags where +instance BoxedFlags VideoPackFlags where +instance IsGFlag VideoPackFlags +data VideoOverlayFormatFlags +instance P.Enum VideoOverlayFormatFlags where +instance BoxedFlags VideoOverlayFormatFlags where +instance IsGFlag VideoOverlayFormatFlags +data VideoMultiviewFlags +instance P.Enum VideoMultiviewFlags where +instance BoxedFlags VideoMultiviewFlags where +instance IsGFlag VideoMultiviewFlags +data VideoFrameMapFlags +instance P.Enum VideoFrameMapFlags where +instance BoxedFlags VideoFrameMapFlags where +instance IsGFlag VideoFrameMapFlags +data VideoFrameFlags +instance P.Enum VideoFrameFlags where +instance BoxedFlags VideoFrameFlags where +instance IsGFlag VideoFrameFlags +data VideoFormatFlags +instance P.Enum VideoFormatFlags where +instance BoxedFlags VideoFormatFlags where +instance IsGFlag VideoFormatFlags +data VideoFlags +instance P.Enum VideoFlags where +instance BoxedFlags VideoFlags where +instance IsGFlag VideoFlags +data VideoDitherFlags +instance P.Enum VideoDitherFlags where +instance BoxedFlags VideoDitherFlags where +instance IsGFlag VideoDitherFlags +data VideoCodecFrameFlags +instance P.Enum VideoCodecFrameFlags where +instance IsGFlag VideoCodecFrameFlags +data VideoChromaSite +instance P.Enum VideoChromaSite where +instance BoxedFlags VideoChromaSite where +instance IsGFlag VideoChromaSite +data VideoChromaFlags +instance P.Enum VideoChromaFlags where +instance BoxedFlags VideoChromaFlags where +instance IsGFlag VideoChromaFlags +data VideoBufferFlags +instance P.Enum VideoBufferFlags where +instance BoxedFlags VideoBufferFlags where +instance IsGFlag VideoBufferFlags diff --git a/GI/GstVideo/Functions.hs b/GI/GstVideo/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Functions.hs @@ -0,0 +1,2198 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Functions + ( + + -- * Methods +-- ** bufferAddVideoAffineTransformationMeta #method:bufferAddVideoAffineTransformationMeta# + + bufferAddVideoAffineTransformationMeta , + + +-- ** bufferAddVideoCaptionMeta #method:bufferAddVideoCaptionMeta# + + bufferAddVideoCaptionMeta , + + +-- ** bufferAddVideoGlTextureUploadMeta #method:bufferAddVideoGlTextureUploadMeta# + + bufferAddVideoGlTextureUploadMeta , + + +-- ** bufferAddVideoMeta #method:bufferAddVideoMeta# + + bufferAddVideoMeta , + + +-- ** bufferAddVideoMetaFull #method:bufferAddVideoMetaFull# + + bufferAddVideoMetaFull , + + +-- ** bufferAddVideoOverlayCompositionMeta #method:bufferAddVideoOverlayCompositionMeta# + + bufferAddVideoOverlayCompositionMeta , + + +-- ** bufferAddVideoRegionOfInterestMeta #method:bufferAddVideoRegionOfInterestMeta# + + bufferAddVideoRegionOfInterestMeta , + + +-- ** bufferAddVideoRegionOfInterestMetaId #method:bufferAddVideoRegionOfInterestMetaId# + + bufferAddVideoRegionOfInterestMetaId , + + +-- ** bufferAddVideoTimeCodeMeta #method:bufferAddVideoTimeCodeMeta# + + bufferAddVideoTimeCodeMeta , + + +-- ** bufferAddVideoTimeCodeMetaFull #method:bufferAddVideoTimeCodeMetaFull# + + bufferAddVideoTimeCodeMetaFull , + + +-- ** bufferGetVideoMeta #method:bufferGetVideoMeta# + + bufferGetVideoMeta , + + +-- ** bufferGetVideoMetaId #method:bufferGetVideoMetaId# + + bufferGetVideoMetaId , + + +-- ** bufferGetVideoRegionOfInterestMetaId #method:bufferGetVideoRegionOfInterestMetaId# + + bufferGetVideoRegionOfInterestMetaId , + + +-- ** bufferPoolConfigGetVideoAlignment #method:bufferPoolConfigGetVideoAlignment# + + bufferPoolConfigGetVideoAlignment , + + +-- ** bufferPoolConfigSetVideoAlignment #method:bufferPoolConfigSetVideoAlignment# + + bufferPoolConfigSetVideoAlignment , + + +-- ** isVideoOverlayPrepareWindowHandleMessage #method:isVideoOverlayPrepareWindowHandleMessage# + + isVideoOverlayPrepareWindowHandleMessage, + + +-- ** videoAffineTransformationMetaApiGetType #method:videoAffineTransformationMetaApiGetType# + + videoAffineTransformationMetaApiGetType , + + +-- ** videoBlend #method:videoBlend# + + videoBlend , + + +-- ** videoBlendScaleLinearRGBA #method:videoBlendScaleLinearRGBA# + + videoBlendScaleLinearRGBA , + + +-- ** videoCalculateDisplayRatio #method:videoCalculateDisplayRatio# + + videoCalculateDisplayRatio , + + +-- ** videoCaptionMetaApiGetType #method:videoCaptionMetaApiGetType# + + videoCaptionMetaApiGetType , + + +-- ** videoChromaFromString #method:videoChromaFromString# + + videoChromaFromString , + + +-- ** videoChromaResample #method:videoChromaResample# + + videoChromaResample , + + +-- ** videoChromaToString #method:videoChromaToString# + + videoChromaToString , + + +-- ** videoColorTransferDecode #method:videoColorTransferDecode# + + videoColorTransferDecode , + + +-- ** videoColorTransferEncode #method:videoColorTransferEncode# + + videoColorTransferEncode , + + +-- ** videoConvertSample #method:videoConvertSample# + + videoConvertSample , + + +-- ** videoConvertSampleAsync #method:videoConvertSampleAsync# + + videoConvertSampleAsync , + + +-- ** videoCropMetaApiGetType #method:videoCropMetaApiGetType# + + videoCropMetaApiGetType , + + +-- ** videoEventIsForceKeyUnit #method:videoEventIsForceKeyUnit# + + videoEventIsForceKeyUnit , + + +-- ** videoEventNewDownstreamForceKeyUnit #method:videoEventNewDownstreamForceKeyUnit# + + videoEventNewDownstreamForceKeyUnit , + + +-- ** videoEventNewStillFrame #method:videoEventNewStillFrame# + + videoEventNewStillFrame , + + +-- ** videoEventNewUpstreamForceKeyUnit #method:videoEventNewUpstreamForceKeyUnit# + + videoEventNewUpstreamForceKeyUnit , + + +-- ** videoEventParseDownstreamForceKeyUnit #method:videoEventParseDownstreamForceKeyUnit# + + videoEventParseDownstreamForceKeyUnit , + + +-- ** videoEventParseStillFrame #method:videoEventParseStillFrame# + + videoEventParseStillFrame , + + +-- ** videoEventParseUpstreamForceKeyUnit #method:videoEventParseUpstreamForceKeyUnit# + + videoEventParseUpstreamForceKeyUnit , + + +-- ** videoGlTextureUploadMetaApiGetType #method:videoGlTextureUploadMetaApiGetType# + + videoGlTextureUploadMetaApiGetType , + + +-- ** videoGuessFramerate #method:videoGuessFramerate# + + videoGuessFramerate , + + +-- ** videoMetaApiGetType #method:videoMetaApiGetType# + + videoMetaApiGetType , + + +-- ** videoMultiviewGetDoubledHeightModes #method:videoMultiviewGetDoubledHeightModes# + + videoMultiviewGetDoubledHeightModes , + + +-- ** videoMultiviewGetDoubledSizeModes #method:videoMultiviewGetDoubledSizeModes# + + videoMultiviewGetDoubledSizeModes , + + +-- ** videoMultiviewGetDoubledWidthModes #method:videoMultiviewGetDoubledWidthModes# + + videoMultiviewGetDoubledWidthModes , + + +-- ** videoMultiviewGetMonoModes #method:videoMultiviewGetMonoModes# + + videoMultiviewGetMonoModes , + + +-- ** videoMultiviewGetUnpackedModes #method:videoMultiviewGetUnpackedModes# + + videoMultiviewGetUnpackedModes , + + +-- ** videoMultiviewGuessHalfAspect #method:videoMultiviewGuessHalfAspect# + + videoMultiviewGuessHalfAspect , + + +-- ** videoMultiviewVideoInfoChangeMode #method:videoMultiviewVideoInfoChangeMode# + + videoMultiviewVideoInfoChangeMode , + + +-- ** videoOverlayCompositionMetaApiGetType #method:videoOverlayCompositionMetaApiGetType# + + videoOverlayCompositionMetaApiGetType , + + +-- ** videoRegionOfInterestMetaApiGetType #method:videoRegionOfInterestMetaApiGetType# + + videoRegionOfInterestMetaApiGetType , + + +-- ** videoTileGetIndex #method:videoTileGetIndex# + + videoTileGetIndex , + + +-- ** videoTimeCodeMetaApiGetType #method:videoTimeCodeMetaApiGetType# + + videoTimeCodeMetaApiGetType , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.DateTime as GLib.DateTime +import qualified GI.GObject.Callbacks as GObject.Callbacks +import qualified GI.Gst.Structs.Buffer as Gst.Buffer +import qualified GI.Gst.Structs.Caps as Gst.Caps +import qualified GI.Gst.Structs.Event as Gst.Event +import qualified GI.Gst.Structs.Message as Gst.Message +import qualified GI.Gst.Structs.Sample as Gst.Sample +import qualified GI.Gst.Structs.Structure as Gst.Structure +import qualified GI.GstVideo.Callbacks as GstVideo.Callbacks +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums +import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoAffineTransformationMeta as GstVideo.VideoAffineTransformationMeta +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoAlignment as GstVideo.VideoAlignment +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoCaptionMeta as GstVideo.VideoCaptionMeta +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoChromaResample as GstVideo.VideoChromaResample +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoFrame as GstVideo.VideoFrame +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoGLTextureUploadMeta as GstVideo.VideoGLTextureUploadMeta +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoInfo as GstVideo.VideoInfo +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoMeta as GstVideo.VideoMeta +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoOverlayComposition as GstVideo.VideoOverlayComposition +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoOverlayCompositionMeta as GstVideo.VideoOverlayCompositionMeta +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoRegionOfInterestMeta as GstVideo.VideoRegionOfInterestMeta +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoTimeCode as GstVideo.VideoTimeCode +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoTimeCodeMeta as GstVideo.VideoTimeCodeMeta + +-- function gst_video_time_code_meta_api_get_type +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TGType) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_meta_api_get_type" gst_video_time_code_meta_api_get_type :: + IO CGType + +{- | +/No description available in the introspection data./ +-} +videoTimeCodeMetaApiGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + m GType +videoTimeCodeMetaApiGetType = liftIO $ do + result <- gst_video_time_code_meta_api_get_type + let result' = GType result + return result' + + +-- function gst_video_tile_get_index +-- Args : [Arg {argCName = "mode", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTileMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTileMode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "x coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "y coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x_tiles", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of horizintal tiles", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y_tiles", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of vertical tiles", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_tile_get_index" gst_video_tile_get_index :: + CUInt -> -- mode : TInterface (Name {namespace = "GstVideo", name = "VideoTileMode"}) + Int32 -> -- x : TBasicType TInt + Int32 -> -- y : TBasicType TInt + Int32 -> -- x_tiles : TBasicType TInt + Int32 -> -- y_tiles : TBasicType TInt + IO Word32 + +{- | +Get the tile index of the tile at coordinates /@x@/ and /@y@/ in the tiled +image of /@xTiles@/ by /@yTiles@/. + +Use this method when /@mode@/ is of type 'GI.GstVideo.Enums.VideoTileTypeIndexed'. + +/Since: 1.4/ +-} +videoTileGetIndex :: + (B.CallStack.HasCallStack, MonadIO m) => + GstVideo.Enums.VideoTileMode + {- ^ /@mode@/: a 'GI.GstVideo.Enums.VideoTileMode' -} + -> Int32 + {- ^ /@x@/: x coordinate -} + -> Int32 + {- ^ /@y@/: y coordinate -} + -> Int32 + {- ^ /@xTiles@/: number of horizintal tiles -} + -> Int32 + {- ^ /@yTiles@/: number of vertical tiles -} + -> m Word32 + {- ^ __Returns:__ the index of the tile at /@x@/ and /@y@/ in the tiled image of + /@xTiles@/ by /@yTiles@/. -} +videoTileGetIndex mode x y xTiles yTiles = liftIO $ do + let mode' = (fromIntegral . fromEnum) mode + result <- gst_video_tile_get_index mode' x y xTiles yTiles + return result + + +-- function gst_video_region_of_interest_meta_api_get_type +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TGType) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_region_of_interest_meta_api_get_type" gst_video_region_of_interest_meta_api_get_type :: + IO CGType + +{- | +/No description available in the introspection data./ +-} +videoRegionOfInterestMetaApiGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + m GType +videoRegionOfInterestMetaApiGetType = liftIO $ do + result <- gst_video_region_of_interest_meta_api_get_type + let result' = GType result + return result' + + +-- function gst_video_overlay_composition_meta_api_get_type +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TGType) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_composition_meta_api_get_type" gst_video_overlay_composition_meta_api_get_type :: + IO CGType + +{- | +/No description available in the introspection data./ +-} +videoOverlayCompositionMetaApiGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + m GType +videoOverlayCompositionMetaApiGetType = liftIO $ do + result <- gst_video_overlay_composition_meta_api_get_type + let result' = GType result + return result' + + +-- function gst_video_multiview_video_info_change_mode +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstVideoInfo structure to operate on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_mview_mode", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMultiviewMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstVideoMultiviewMode value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_mview_flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMultiviewFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A set of #GstVideoMultiviewFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_multiview_video_info_change_mode" gst_video_multiview_video_info_change_mode :: + Ptr GstVideo.VideoInfo.VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + CInt -> -- out_mview_mode : TInterface (Name {namespace = "GstVideo", name = "VideoMultiviewMode"}) + CUInt -> -- out_mview_flags : TInterface (Name {namespace = "GstVideo", name = "VideoMultiviewFlags"}) + IO () + +{- | +Utility function that transforms the width\/height\/PAR +and multiview mode and flags of a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' into +the requested mode. + +/Since: 1.6/ +-} +videoMultiviewVideoInfoChangeMode :: + (B.CallStack.HasCallStack, MonadIO m) => + GstVideo.VideoInfo.VideoInfo + {- ^ /@info@/: A 'GI.GstVideo.Structs.VideoInfo.VideoInfo' structure to operate on -} + -> GstVideo.Enums.VideoMultiviewMode + {- ^ /@outMviewMode@/: A 'GI.GstVideo.Enums.VideoMultiviewMode' value -} + -> [GstVideo.Flags.VideoMultiviewFlags] + {- ^ /@outMviewFlags@/: A set of 'GI.GstVideo.Flags.VideoMultiviewFlags' -} + -> m () +videoMultiviewVideoInfoChangeMode info outMviewMode outMviewFlags = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + let outMviewMode' = (fromIntegral . fromEnum) outMviewMode + let outMviewFlags' = gflagsToWord outMviewFlags + gst_video_multiview_video_info_change_mode info' outMviewMode' outMviewFlags' + touchManagedPtr info + return () + + +-- function gst_video_multiview_guess_half_aspect +-- Args : [Arg {argCName = "mv_mode", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMultiviewMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstVideoMultiviewMode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Video frame width in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Video frame height in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "par_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the video pixel-aspect-ratio", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "par_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the video pixel-aspect-ratio", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_multiview_guess_half_aspect" gst_video_multiview_guess_half_aspect :: + CInt -> -- mv_mode : TInterface (Name {namespace = "GstVideo", name = "VideoMultiviewMode"}) + Word32 -> -- width : TBasicType TUInt + Word32 -> -- height : TBasicType TUInt + Word32 -> -- par_n : TBasicType TUInt + Word32 -> -- par_d : TBasicType TUInt + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 1.6/ +-} +videoMultiviewGuessHalfAspect :: + (B.CallStack.HasCallStack, MonadIO m) => + GstVideo.Enums.VideoMultiviewMode + {- ^ /@mvMode@/: A 'GI.GstVideo.Enums.VideoMultiviewMode' -} + -> Word32 + {- ^ /@width@/: Video frame width in pixels -} + -> Word32 + {- ^ /@height@/: Video frame height in pixels -} + -> Word32 + {- ^ /@parN@/: Numerator of the video pixel-aspect-ratio -} + -> Word32 + {- ^ /@parD@/: Denominator of the video pixel-aspect-ratio -} + -> m Bool + {- ^ __Returns:__ A boolean indicating whether the + @/GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT/@ flag should be set. + +Utility function that heuristically guess whether a +frame-packed stereoscopic video contains half width\/height +encoded views, or full-frame views by looking at the +overall display aspect ratio. -} +videoMultiviewGuessHalfAspect mvMode width height parN parD = liftIO $ do + let mvMode' = (fromIntegral . fromEnum) mvMode + result <- gst_video_multiview_guess_half_aspect mvMode' width height parN parD + let result' = (/= 0) result + return result' + + +-- function gst_video_multiview_get_unpacked_modes +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_multiview_get_unpacked_modes" gst_video_multiview_get_unpacked_modes :: + IO (Ptr GValue) + +{- | +/No description available in the introspection data./ + +/Since: 1.6/ +-} +videoMultiviewGetUnpackedModes :: + (B.CallStack.HasCallStack, MonadIO m) => + m GValue + {- ^ __Returns:__ A const 'GI.GObject.Structs.Value.Value' containing a list of \'unpacked\' stereo video modes + +Utility function that returns a 'GI.GObject.Structs.Value.Value' with a GstList of unpacked +stereo video modes (separated\/frame-by-frame\/frame-by-frame-multiview) +for use in caps negotiations. -} +videoMultiviewGetUnpackedModes = liftIO $ do + result <- gst_video_multiview_get_unpacked_modes + checkUnexpectedReturnNULL "videoMultiviewGetUnpackedModes" result + result' <- (newBoxed GValue) result + return result' + + +-- function gst_video_multiview_get_mono_modes +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_multiview_get_mono_modes" gst_video_multiview_get_mono_modes :: + IO (Ptr GValue) + +{- | +/No description available in the introspection data./ + +/Since: 1.6/ +-} +videoMultiviewGetMonoModes :: + (B.CallStack.HasCallStack, MonadIO m) => + m GValue + {- ^ __Returns:__ A const 'GI.GObject.Structs.Value.Value' containing a list of mono video modes + +Utility function that returns a 'GI.GObject.Structs.Value.Value' with a GstList of mono video +modes (mono\/left\/right) for use in caps negotiations. -} +videoMultiviewGetMonoModes = liftIO $ do + result <- gst_video_multiview_get_mono_modes + checkUnexpectedReturnNULL "videoMultiviewGetMonoModes" result + result' <- (newBoxed GValue) result + return result' + + +-- function gst_video_multiview_get_doubled_width_modes +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_multiview_get_doubled_width_modes" gst_video_multiview_get_doubled_width_modes :: + IO (Ptr GValue) + +{- | +/No description available in the introspection data./ + +/Since: 1.6/ +-} +videoMultiviewGetDoubledWidthModes :: + (B.CallStack.HasCallStack, MonadIO m) => + m GValue + {- ^ __Returns:__ A const 'GI.GObject.Structs.Value.Value' containing a list of stereo video modes + +Utility function that returns a 'GI.GObject.Structs.Value.Value' with a GstList of packed stereo +video modes with double the width of a single view for use in +caps negotiations. Currently this is side-by-side, side-by-side-quincunx +and column-interleaved. -} +videoMultiviewGetDoubledWidthModes = liftIO $ do + result <- gst_video_multiview_get_doubled_width_modes + checkUnexpectedReturnNULL "videoMultiviewGetDoubledWidthModes" result + result' <- (newBoxed GValue) result + return result' + + +-- function gst_video_multiview_get_doubled_size_modes +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_multiview_get_doubled_size_modes" gst_video_multiview_get_doubled_size_modes :: + IO (Ptr GValue) + +{- | +/No description available in the introspection data./ + +/Since: 1.6/ +-} +videoMultiviewGetDoubledSizeModes :: + (B.CallStack.HasCallStack, MonadIO m) => + m GValue + {- ^ __Returns:__ A const 'GI.GObject.Structs.Value.Value' containing a list of stereo video modes + +Utility function that returns a 'GI.GObject.Structs.Value.Value' with a GstList of packed +stereo video modes that have double the width\/height of a single +view for use in caps negotiation. Currently this is just +\'checkerboard\' layout. -} +videoMultiviewGetDoubledSizeModes = liftIO $ do + result <- gst_video_multiview_get_doubled_size_modes + checkUnexpectedReturnNULL "videoMultiviewGetDoubledSizeModes" result + result' <- (newBoxed GValue) result + return result' + + +-- function gst_video_multiview_get_doubled_height_modes +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_multiview_get_doubled_height_modes" gst_video_multiview_get_doubled_height_modes :: + IO (Ptr GValue) + +{- | +/No description available in the introspection data./ + +/Since: 1.6/ +-} +videoMultiviewGetDoubledHeightModes :: + (B.CallStack.HasCallStack, MonadIO m) => + m GValue + {- ^ __Returns:__ A const 'GI.GObject.Structs.Value.Value' containing a list of stereo video modes + +Utility function that returns a 'GI.GObject.Structs.Value.Value' with a GstList of packed stereo +video modes with double the height of a single view for use in +caps negotiations. Currently this is top-bottom and row-interleaved. -} +videoMultiviewGetDoubledHeightModes = liftIO $ do + result <- gst_video_multiview_get_doubled_height_modes + checkUnexpectedReturnNULL "videoMultiviewGetDoubledHeightModes" result + result' <- (newBoxed GValue) result + return result' + + +-- function gst_video_meta_api_get_type +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TGType) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_meta_api_get_type" gst_video_meta_api_get_type :: + IO CGType + +{- | +/No description available in the introspection data./ +-} +videoMetaApiGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + m GType +videoMetaApiGetType = liftIO $ do + result <- gst_video_meta_api_get_type + let result' = GType result + return result' + + +-- function gst_video_guess_framerate +-- Args : [Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Nominal duration of one frame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_n", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the calculated framerate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_d", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the calculated framerate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_guess_framerate" gst_video_guess_framerate :: + Word64 -> -- duration : TBasicType TUInt64 + Ptr Int32 -> -- dest_n : TBasicType TInt + Ptr Int32 -> -- dest_d : TBasicType TInt + IO CInt + +{- | +Given the nominal duration of one video frame, +this function will check some standard framerates for +a close match (within 0.1%) and return one if possible, + +It will calculate an arbitrary framerate if no close +match was found, and return 'False'. + +It returns 'False' if a duration of 0 is passed. + +/Since: 1.6/ +-} +videoGuessFramerate :: + (B.CallStack.HasCallStack, MonadIO m) => + Word64 + {- ^ /@duration@/: Nominal duration of one frame -} + -> m ((Bool, Int32, Int32)) + {- ^ __Returns:__ 'True' if a close \"standard\" framerate was +recognised, and 'False' otherwise. -} +videoGuessFramerate duration = liftIO $ do + destN <- allocMem :: IO (Ptr Int32) + destD <- allocMem :: IO (Ptr Int32) + result <- gst_video_guess_framerate duration destN destD + let result' = (/= 0) result + destN' <- peek destN + destD' <- peek destD + freeMem destN + freeMem destD + return (result', destN', destD') + + +-- function gst_video_gl_texture_upload_meta_api_get_type +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TGType) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_gl_texture_upload_meta_api_get_type" gst_video_gl_texture_upload_meta_api_get_type :: + IO CGType + +{- | +/No description available in the introspection data./ +-} +videoGlTextureUploadMetaApiGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + m GType +videoGlTextureUploadMetaApiGetType = liftIO $ do + result <- gst_video_gl_texture_upload_meta_api_get_type + let result' = GType result + return result' + + +-- function gst_video_event_parse_upstream_force_key_unit +-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstEvent to parse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the running_time in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "all_headers", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the all_headers flag in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "count", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the count field in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_event_parse_upstream_force_key_unit" gst_video_event_parse_upstream_force_key_unit :: + Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) + Ptr Word64 -> -- running_time : TBasicType TUInt64 + Ptr CInt -> -- all_headers : TBasicType TBoolean + Ptr Word32 -> -- count : TBasicType TUInt + IO CInt + +{- | +Get running-time, all-headers and count in the force key unit event. See +'GI.GstVideo.Functions.videoEventNewUpstreamForceKeyUnit' for a full description of the +upstream force key unit event. + +Create an upstream force key unit event using 'GI.GstVideo.Functions.videoEventNewUpstreamForceKeyUnit' + +/@runningTime@/ will be adjusted for any pad offsets of pads it was passing through. +-} +videoEventParseUpstreamForceKeyUnit :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Event.Event + {- ^ /@event@/: A 'GI.Gst.Structs.Event.Event' to parse -} + -> m ((Bool, Word64, Bool, Word32)) + {- ^ __Returns:__ 'True' if the event is a valid upstream force-key-unit event. 'False' if not -} +videoEventParseUpstreamForceKeyUnit event = liftIO $ do + event' <- unsafeManagedPtrGetPtr event + runningTime <- allocMem :: IO (Ptr Word64) + allHeaders <- allocMem :: IO (Ptr CInt) + count <- allocMem :: IO (Ptr Word32) + result <- gst_video_event_parse_upstream_force_key_unit event' runningTime allHeaders count + let result' = (/= 0) result + runningTime' <- peek runningTime + allHeaders' <- peek allHeaders + let allHeaders'' = (/= 0) allHeaders' + count' <- peek count + touchManagedPtr event + freeMem runningTime + freeMem allHeaders + freeMem count + return (result', runningTime', allHeaders'', count') + + +-- function gst_video_event_parse_still_frame +-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstEvent to parse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "in_still", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n A boolean to receive the still-frame status from the event, or NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_event_parse_still_frame" gst_video_event_parse_still_frame :: + Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) + Ptr CInt -> -- in_still : TBasicType TBoolean + IO CInt + +{- | +Parse a 'GI.Gst.Structs.Event.Event', identify if it is a Still Frame event, and +return the still-frame state from the event if it is. +If the event represents the start of a still frame, the in_still +variable will be set to TRUE, otherwise FALSE. It is OK to pass NULL for the +in_still variable order to just check whether the event is a valid still-frame +event. + +Create a still frame event using 'GI.GstVideo.Functions.videoEventNewStillFrame' +-} +videoEventParseStillFrame :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Event.Event + {- ^ /@event@/: A 'GI.Gst.Structs.Event.Event' to parse -} + -> m ((Bool, Bool)) + {- ^ __Returns:__ 'True' if the event is a valid still-frame event. 'False' if not -} +videoEventParseStillFrame event = liftIO $ do + event' <- unsafeManagedPtrGetPtr event + inStill <- allocMem :: IO (Ptr CInt) + result <- gst_video_event_parse_still_frame event' inStill + let result' = (/= 0) result + inStill' <- peek inStill + let inStill'' = (/= 0) inStill' + touchManagedPtr event + freeMem inStill + return (result', inStill'') + + +-- function gst_video_event_parse_downstream_force_key_unit +-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstEvent to parse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the timestamp in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stream_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the stream-time in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the running-time in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "all_headers", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the all_headers flag in the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "count", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the count field of the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_event_parse_downstream_force_key_unit" gst_video_event_parse_downstream_force_key_unit :: + Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) + Ptr Word64 -> -- timestamp : TBasicType TUInt64 + Ptr Word64 -> -- stream_time : TBasicType TUInt64 + Ptr Word64 -> -- running_time : TBasicType TUInt64 + Ptr CInt -> -- all_headers : TBasicType TBoolean + Ptr Word32 -> -- count : TBasicType TUInt + IO CInt + +{- | +Get timestamp, stream-time, running-time, all-headers and count in the force +key unit event. See 'GI.GstVideo.Functions.videoEventNewDownstreamForceKeyUnit' for a +full description of the downstream force key unit event. + +/@runningTime@/ will be adjusted for any pad offsets of pads it was passing through. +-} +videoEventParseDownstreamForceKeyUnit :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Event.Event + {- ^ /@event@/: A 'GI.Gst.Structs.Event.Event' to parse -} + -> m ((Bool, Word64, Word64, Word64, Bool, Word32)) + {- ^ __Returns:__ 'True' if the event is a valid downstream force key unit event. -} +videoEventParseDownstreamForceKeyUnit event = liftIO $ do + event' <- unsafeManagedPtrGetPtr event + timestamp <- allocMem :: IO (Ptr Word64) + streamTime <- allocMem :: IO (Ptr Word64) + runningTime <- allocMem :: IO (Ptr Word64) + allHeaders <- allocMem :: IO (Ptr CInt) + count <- allocMem :: IO (Ptr Word32) + result <- gst_video_event_parse_downstream_force_key_unit event' timestamp streamTime runningTime allHeaders count + let result' = (/= 0) result + timestamp' <- peek timestamp + streamTime' <- peek streamTime + runningTime' <- peek runningTime + allHeaders' <- peek allHeaders + let allHeaders'' = (/= 0) allHeaders' + count' <- peek count + touchManagedPtr event + freeMem timestamp + freeMem streamTime + freeMem runningTime + freeMem allHeaders + freeMem count + return (result', timestamp', streamTime', runningTime', allHeaders'', count') + + +-- function gst_video_event_new_upstream_force_key_unit +-- Args : [Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the running_time at which a new key unit should be produced", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "all_headers", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to produce headers when starting a new key unit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "integer that can be used to number key units", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Event"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_event_new_upstream_force_key_unit" gst_video_event_new_upstream_force_key_unit :: + Word64 -> -- running_time : TBasicType TUInt64 + CInt -> -- all_headers : TBasicType TBoolean + Word32 -> -- count : TBasicType TUInt + IO (Ptr Gst.Event.Event) + +{- | +Creates a new upstream force key unit event. An upstream force key unit event +can be sent to request upstream elements to produce a key unit. + +/@runningTime@/ can be set to request a new key unit at a specific +running_time. If set to GST_CLOCK_TIME_NONE, upstream elements will produce a +new key unit as soon as possible. + +To parse an event created by 'GI.GstVideo.Functions.videoEventNewDownstreamForceKeyUnit' use +'GI.GstVideo.Functions.videoEventParseDownstreamForceKeyUnit'. +-} +videoEventNewUpstreamForceKeyUnit :: + (B.CallStack.HasCallStack, MonadIO m) => + Word64 + {- ^ /@runningTime@/: the running_time at which a new key unit should be produced -} + -> Bool + {- ^ /@allHeaders@/: 'True' to produce headers when starting a new key unit -} + -> Word32 + {- ^ /@count@/: integer that can be used to number key units -} + -> m Gst.Event.Event + {- ^ __Returns:__ The new GstEvent -} +videoEventNewUpstreamForceKeyUnit runningTime allHeaders count = liftIO $ do + let allHeaders' = (fromIntegral . fromEnum) allHeaders + result <- gst_video_event_new_upstream_force_key_unit runningTime allHeaders' count + checkUnexpectedReturnNULL "videoEventNewUpstreamForceKeyUnit" result + result' <- (wrapBoxed Gst.Event.Event) result + return result' + + +-- function gst_video_event_new_still_frame +-- Args : [Arg {argCName = "in_still", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "boolean value for the still-frame state of the event.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Event"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_event_new_still_frame" gst_video_event_new_still_frame :: + CInt -> -- in_still : TBasicType TBoolean + IO (Ptr Gst.Event.Event) + +{- | +Creates a new Still Frame event. If /@inStill@/ is 'True', then the event +represents the start of a still frame sequence. If it is 'False', then +the event ends a still frame sequence. + +To parse an event created by 'GI.GstVideo.Functions.videoEventNewStillFrame' use +'GI.GstVideo.Functions.videoEventParseStillFrame'. +-} +videoEventNewStillFrame :: + (B.CallStack.HasCallStack, MonadIO m) => + Bool + {- ^ /@inStill@/: boolean value for the still-frame state of the event. -} + -> m Gst.Event.Event + {- ^ __Returns:__ The new GstEvent -} +videoEventNewStillFrame inStill = liftIO $ do + let inStill' = (fromIntegral . fromEnum) inStill + result <- gst_video_event_new_still_frame inStill' + checkUnexpectedReturnNULL "videoEventNewStillFrame" result + result' <- (wrapBoxed Gst.Event.Event) result + return result' + + +-- function gst_video_event_new_downstream_force_key_unit +-- Args : [Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the timestamp of the buffer that starts a new key unit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stream_time of the buffer that starts a new key unit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the running_time of the buffer that starts a new key unit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "all_headers", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to produce headers when starting a new key unit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "integer that can be used to number key units", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Event"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_event_new_downstream_force_key_unit" gst_video_event_new_downstream_force_key_unit :: + Word64 -> -- timestamp : TBasicType TUInt64 + Word64 -> -- stream_time : TBasicType TUInt64 + Word64 -> -- running_time : TBasicType TUInt64 + CInt -> -- all_headers : TBasicType TBoolean + Word32 -> -- count : TBasicType TUInt + IO (Ptr Gst.Event.Event) + +{- | +Creates a new downstream force key unit event. A downstream force key unit +event can be sent down the pipeline to request downstream elements to produce +a key unit. A downstream force key unit event must also be sent when handling +an upstream force key unit event to notify downstream that the latter has been +handled. + +To parse an event created by 'GI.GstVideo.Functions.videoEventNewDownstreamForceKeyUnit' use +'GI.GstVideo.Functions.videoEventParseDownstreamForceKeyUnit'. +-} +videoEventNewDownstreamForceKeyUnit :: + (B.CallStack.HasCallStack, MonadIO m) => + Word64 + {- ^ /@timestamp@/: the timestamp of the buffer that starts a new key unit -} + -> Word64 + {- ^ /@streamTime@/: the stream_time of the buffer that starts a new key unit -} + -> Word64 + {- ^ /@runningTime@/: the running_time of the buffer that starts a new key unit -} + -> Bool + {- ^ /@allHeaders@/: 'True' to produce headers when starting a new key unit -} + -> Word32 + {- ^ /@count@/: integer that can be used to number key units -} + -> m Gst.Event.Event + {- ^ __Returns:__ The new GstEvent -} +videoEventNewDownstreamForceKeyUnit timestamp streamTime runningTime allHeaders count = liftIO $ do + let allHeaders' = (fromIntegral . fromEnum) allHeaders + result <- gst_video_event_new_downstream_force_key_unit timestamp streamTime runningTime allHeaders' count + checkUnexpectedReturnNULL "videoEventNewDownstreamForceKeyUnit" result + result' <- (wrapBoxed Gst.Event.Event) result + return result' + + +-- function gst_video_event_is_force_key_unit +-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstEvent to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_event_is_force_key_unit" gst_video_event_is_force_key_unit :: + Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) + IO CInt + +{- | +Checks if an event is a force key unit event. Returns true for both upstream +and downstream force key unit events. +-} +videoEventIsForceKeyUnit :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Event.Event + {- ^ /@event@/: A 'GI.Gst.Structs.Event.Event' to check -} + -> m Bool + {- ^ __Returns:__ 'True' if the event is a valid force key unit event -} +videoEventIsForceKeyUnit event = liftIO $ do + event' <- unsafeManagedPtrGetPtr event + result <- gst_video_event_is_force_key_unit event' + let result' = (/= 0) result + touchManagedPtr event + return result' + + +-- function gst_video_crop_meta_api_get_type +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TGType) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_crop_meta_api_get_type" gst_video_crop_meta_api_get_type :: + IO CGType + +{- | +/No description available in the introspection data./ +-} +videoCropMetaApiGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + m GType +videoCropMetaApiGetType = liftIO $ do + result <- gst_video_crop_meta_api_get_type + let result' = GType result + return result' + + +-- function gst_video_convert_sample_async +-- Args : [Arg {argCName = "sample", argType = TInterface (Name {namespace = "Gst", name = "Sample"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstSample", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "to_caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstCaps to convert to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum amount of time allowed for the processing.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GstVideo", name = "VideoConvertSampleCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%GstVideoConvertSampleCallback that will be called after conversion.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 4, argDestroy = 5, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "extra data that will be passed to the @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%GDestroyNotify to be called after @user_data is not needed anymore", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_convert_sample_async" gst_video_convert_sample_async :: + Ptr Gst.Sample.Sample -> -- sample : TInterface (Name {namespace = "Gst", name = "Sample"}) + Ptr Gst.Caps.Caps -> -- to_caps : TInterface (Name {namespace = "Gst", name = "Caps"}) + Word64 -> -- timeout : TBasicType TUInt64 + FunPtr GstVideo.Callbacks.C_VideoConvertSampleCallback -> -- callback : TInterface (Name {namespace = "GstVideo", name = "VideoConvertSampleCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + IO () + +{- | +Converts a raw video buffer into the specified output caps. + +The output caps can be any raw video formats or any image formats (jpeg, png, ...). + +The width, height and pixel-aspect-ratio can also be specified in the output caps. + +/@callback@/ will be called after conversion, when an error occured or if conversion didn\'t +finish after /@timeout@/. /@callback@/ will always be called from the thread default +@/GMainContext/@, see 'GI.GLib.Functions.mainContextGetThreadDefault'. If GLib before 2.22 is used, +this will always be the global default main context. + +/@destroyNotify@/ will be called after the callback was called and /@userData@/ is not needed +anymore. +-} +videoConvertSampleAsync :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Sample.Sample + {- ^ /@sample@/: a 'GI.Gst.Structs.Sample.Sample' -} + -> Gst.Caps.Caps + {- ^ /@toCaps@/: the 'GI.Gst.Structs.Caps.Caps' to convert to -} + -> Word64 + {- ^ /@timeout@/: the maximum amount of time allowed for the processing. -} + -> GstVideo.Callbacks.VideoConvertSampleCallback + {- ^ /@callback@/: @/GstVideoConvertSampleCallback/@ that will be called after conversion. -} + -> m () +videoConvertSampleAsync sample toCaps timeout callback = liftIO $ do + sample' <- unsafeManagedPtrGetPtr sample + toCaps' <- unsafeManagedPtrGetPtr toCaps + callback' <- GstVideo.Callbacks.mk_VideoConvertSampleCallback (GstVideo.Callbacks.wrap_VideoConvertSampleCallback Nothing (GstVideo.Callbacks.drop_closures_VideoConvertSampleCallback callback)) + let userData = castFunPtrToPtr callback' + let destroyNotify = safeFreeFunPtrPtr + gst_video_convert_sample_async sample' toCaps' timeout callback' userData destroyNotify + touchManagedPtr sample + touchManagedPtr toCaps + return () + + +-- function gst_video_convert_sample +-- Args : [Arg {argCName = "sample", argType = TInterface (Name {namespace = "Gst", name = "Sample"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstSample", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "to_caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstCaps to convert to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum amount of time allowed for the processing.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Sample"})) +-- throws : True +-- Skip return : False + +foreign import ccall "gst_video_convert_sample" gst_video_convert_sample :: + Ptr Gst.Sample.Sample -> -- sample : TInterface (Name {namespace = "Gst", name = "Sample"}) + Ptr Gst.Caps.Caps -> -- to_caps : TInterface (Name {namespace = "Gst", name = "Caps"}) + Word64 -> -- timeout : TBasicType TUInt64 + Ptr (Ptr GError) -> -- error + IO (Ptr Gst.Sample.Sample) + +{- | +Converts a raw video buffer into the specified output caps. + +The output caps can be any raw video formats or any image formats (jpeg, png, ...). + +The width, height and pixel-aspect-ratio can also be specified in the output caps. +-} +videoConvertSample :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Sample.Sample + {- ^ /@sample@/: a 'GI.Gst.Structs.Sample.Sample' -} + -> Gst.Caps.Caps + {- ^ /@toCaps@/: the 'GI.Gst.Structs.Caps.Caps' to convert to -} + -> Word64 + {- ^ /@timeout@/: the maximum amount of time allowed for the processing. -} + -> m Gst.Sample.Sample + {- ^ __Returns:__ The converted 'GI.Gst.Structs.Sample.Sample', or 'Nothing' if an error happened (in which case /@err@/ +will point to the 'GError'). /(Can throw 'Data.GI.Base.GError.GError')/ -} +videoConvertSample sample toCaps timeout = liftIO $ do + sample' <- unsafeManagedPtrGetPtr sample + toCaps' <- unsafeManagedPtrGetPtr toCaps + onException (do + result <- propagateGError $ gst_video_convert_sample sample' toCaps' timeout + checkUnexpectedReturnNULL "videoConvertSample" result + result' <- (wrapBoxed Gst.Sample.Sample) result + touchManagedPtr sample + touchManagedPtr toCaps + return result' + ) (do + return () + ) + + +-- function gst_video_color_transfer_encode +-- Args : [Arg {argCName = "func", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTransferFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTransferFunction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_color_transfer_encode" gst_video_color_transfer_encode :: + CUInt -> -- func : TInterface (Name {namespace = "GstVideo", name = "VideoTransferFunction"}) + CDouble -> -- val : TBasicType TDouble + IO CDouble + +{- | +Convert /@val@/ to its gamma encoded value. + +For a linear value L in the range [0..1], conversion to the non-linear +(gamma encoded) L\' is in general performed with a power function like: + +> +> L' = L ^ (1 / gamma) + + +Depending on /@func@/, different formulas might be applied. Some formulas +encode a linear segment in the lower range. + +/Since: 1.6/ +-} +videoColorTransferEncode :: + (B.CallStack.HasCallStack, MonadIO m) => + GstVideo.Enums.VideoTransferFunction + {- ^ /@func@/: a 'GI.GstVideo.Enums.VideoTransferFunction' -} + -> Double + {- ^ /@val@/: a value -} + -> m Double + {- ^ __Returns:__ the gamme encoded value of /@val@/ -} +videoColorTransferEncode func val = liftIO $ do + let func' = (fromIntegral . fromEnum) func + let val' = realToFrac val + result <- gst_video_color_transfer_encode func' val' + let result' = realToFrac result + return result' + + +-- function gst_video_color_transfer_decode +-- Args : [Arg {argCName = "func", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTransferFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTransferFunction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_color_transfer_decode" gst_video_color_transfer_decode :: + CUInt -> -- func : TInterface (Name {namespace = "GstVideo", name = "VideoTransferFunction"}) + CDouble -> -- val : TBasicType TDouble + IO CDouble + +{- | +Convert /@val@/ to its gamma decoded value. This is the inverse operation of +/@gstVideoColorTransferEncode@/(). + +For a non-linear value L\' in the range [0..1], conversion to the linear +L is in general performed with a power function like: + +> +> L = L' ^ gamma + + +Depending on /@func@/, different formulas might be applied. Some formulas +encode a linear segment in the lower range. + +/Since: 1.6/ +-} +videoColorTransferDecode :: + (B.CallStack.HasCallStack, MonadIO m) => + GstVideo.Enums.VideoTransferFunction + {- ^ /@func@/: a 'GI.GstVideo.Enums.VideoTransferFunction' -} + -> Double + {- ^ /@val@/: a value -} + -> m Double + {- ^ __Returns:__ the gamme decoded value of /@val@/ -} +videoColorTransferDecode func val = liftIO $ do + let func' = (fromIntegral . fromEnum) func + let val' = realToFrac val + result <- gst_video_color_transfer_decode func' val' + let result' = realToFrac result + return result' + + +-- function gst_video_chroma_to_string +-- Args : [Arg {argCName = "site", argType = TInterface (Name {namespace = "GstVideo", name = "VideoChromaSite"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoChromaSite", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_chroma_to_string" gst_video_chroma_to_string :: + CUInt -> -- site : TInterface (Name {namespace = "GstVideo", name = "VideoChromaSite"}) + IO CString + +{- | +Converts /@site@/ to its string representation. +-} +videoChromaToString :: + (B.CallStack.HasCallStack, MonadIO m) => + [GstVideo.Flags.VideoChromaSite] + {- ^ /@site@/: a 'GI.GstVideo.Flags.VideoChromaSite' -} + -> m T.Text + {- ^ __Returns:__ a string describing /@site@/. -} +videoChromaToString site = liftIO $ do + let site' = gflagsToWord site + result <- gst_video_chroma_to_string site' + checkUnexpectedReturnNULL "videoChromaToString" result + result' <- cstringToText result + return result' + + +-- function gst_video_chroma_resample +-- Args : [Arg {argCName = "resample", argType = TInterface (Name {namespace = "GstVideo", name = "VideoChromaResample"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoChromaResample", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "lines", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "pixel lines", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of pixels on one line", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_chroma_resample" gst_video_chroma_resample :: + Ptr GstVideo.VideoChromaResample.VideoChromaResample -> -- resample : TInterface (Name {namespace = "GstVideo", name = "VideoChromaResample"}) + Ptr () -> -- lines : TBasicType TPtr + Int32 -> -- width : TBasicType TInt + IO () + +{- | +Perform resampling of /@width@/ chroma pixels in /@lines@/. +-} +videoChromaResample :: + (B.CallStack.HasCallStack, MonadIO m) => + GstVideo.VideoChromaResample.VideoChromaResample + {- ^ /@resample@/: a 'GI.GstVideo.Structs.VideoChromaResample.VideoChromaResample' -} + -> Ptr () + {- ^ /@lines@/: pixel lines -} + -> Int32 + {- ^ /@width@/: the number of pixels on one line -} + -> m () +videoChromaResample resample lines width = liftIO $ do + resample' <- unsafeManagedPtrGetPtr resample + gst_video_chroma_resample resample' lines width + touchManagedPtr resample + return () + + +-- function gst_video_chroma_from_string +-- Args : [Arg {argCName = "s", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a chromasite string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoChromaSite"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_chroma_from_string" gst_video_chroma_from_string :: + CString -> -- s : TBasicType TUTF8 + IO CUInt + +{- | +Convert /@s@/ to a 'GI.GstVideo.Flags.VideoChromaSite' +-} +videoChromaFromString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@s@/: a chromasite string -} + -> m [GstVideo.Flags.VideoChromaSite] + {- ^ __Returns:__ a 'GI.GstVideo.Flags.VideoChromaSite' or 'GI.GstVideo.Flags.VideoChromaSiteUnknown' when /@s@/ does +not contain a valid chroma description. -} +videoChromaFromString s = liftIO $ do + s' <- textToCString s + result <- gst_video_chroma_from_string s' + let result' = wordToGFlags result + freeMem s' + return result' + + +-- function gst_video_caption_meta_api_get_type +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TGType) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_caption_meta_api_get_type" gst_video_caption_meta_api_get_type :: + IO CGType + +{- | +/No description available in the introspection data./ +-} +videoCaptionMetaApiGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + m GType +videoCaptionMetaApiGetType = liftIO $ do + result <- gst_video_caption_meta_api_get_type + let result' = GType result + return result' + + +-- function gst_video_calculate_display_ratio +-- Args : [Arg {argCName = "dar_n", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the calculated display_ratio", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dar_d", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the calculated display_ratio", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "video_width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Width of the video frame in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "video_height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Height of the video frame in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "video_par_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the pixel aspect ratio of the input video.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "video_par_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the pixel aspect ratio of the input video.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "display_par_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the pixel aspect ratio of the display device", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "display_par_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the pixel aspect ratio of the display device", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_calculate_display_ratio" gst_video_calculate_display_ratio :: + Ptr Word32 -> -- dar_n : TBasicType TUInt + Ptr Word32 -> -- dar_d : TBasicType TUInt + Word32 -> -- video_width : TBasicType TUInt + Word32 -> -- video_height : TBasicType TUInt + Word32 -> -- video_par_n : TBasicType TUInt + Word32 -> -- video_par_d : TBasicType TUInt + Word32 -> -- display_par_n : TBasicType TUInt + Word32 -> -- display_par_d : TBasicType TUInt + IO CInt + +{- | +Given the Pixel Aspect Ratio and size of an input video frame, and the +pixel aspect ratio of the intended display device, calculates the actual +display ratio the video will be rendered with. +-} +videoCalculateDisplayRatio :: + (B.CallStack.HasCallStack, MonadIO m) => + Word32 + {- ^ /@videoWidth@/: Width of the video frame in pixels -} + -> Word32 + {- ^ /@videoHeight@/: Height of the video frame in pixels -} + -> Word32 + {- ^ /@videoParN@/: Numerator of the pixel aspect ratio of the input video. -} + -> Word32 + {- ^ /@videoParD@/: Denominator of the pixel aspect ratio of the input video. -} + -> Word32 + {- ^ /@displayParN@/: Numerator of the pixel aspect ratio of the display device -} + -> Word32 + {- ^ /@displayParD@/: Denominator of the pixel aspect ratio of the display device -} + -> m ((Bool, Word32, Word32)) + {- ^ __Returns:__ A boolean indicating success and a calculated Display Ratio in the +dar_n and dar_d parameters. +The return value is FALSE in the case of integer overflow or other error. -} +videoCalculateDisplayRatio videoWidth videoHeight videoParN videoParD displayParN displayParD = liftIO $ do + darN <- allocMem :: IO (Ptr Word32) + darD <- allocMem :: IO (Ptr Word32) + result <- gst_video_calculate_display_ratio darN darD videoWidth videoHeight videoParN videoParD displayParN displayParD + let result' = (/= 0) result + darN' <- peek darN + darD' <- peek darD + freeMem darN + freeMem darD + return (result', darN', darD') + + +-- function gst_video_blend_scale_linear_RGBA +-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstVideoInfo describing the video data in @src_buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source buffer containing video pixels to scale", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height in pixels to scale the video data in @src_buffer to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width in pixels to scale the video data in @src_buffer to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer to a #GstVideoInfo structure that will be filled in\n with the details for @dest_buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "dest_buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GstBuffer variable, which will be\n set to a newly-allocated buffer containing the scaled pixels.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_blend_scale_linear_RGBA" gst_video_blend_scale_linear_RGBA :: + Ptr GstVideo.VideoInfo.VideoInfo -> -- src : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + Ptr Gst.Buffer.Buffer -> -- src_buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + Int32 -> -- dest_height : TBasicType TInt + Int32 -> -- dest_width : TBasicType TInt + Ptr GstVideo.VideoInfo.VideoInfo -> -- dest : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + Ptr (Ptr Gst.Buffer.Buffer) -> -- dest_buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + IO () + +{- | +Scales a buffer containing RGBA (or AYUV) video. This is an internal +helper function which is used to scale subtitle overlays, and may be +deprecated in the near future. Use 'GI.GstVideo.Structs.VideoScaler.VideoScaler' to scale video buffers +instead. +-} +videoBlendScaleLinearRGBA :: + (B.CallStack.HasCallStack, MonadIO m) => + GstVideo.VideoInfo.VideoInfo + {- ^ /@src@/: the 'GI.GstVideo.Structs.VideoInfo.VideoInfo' describing the video data in /@srcBuffer@/ -} + -> Gst.Buffer.Buffer + {- ^ /@srcBuffer@/: the source buffer containing video pixels to scale -} + -> Int32 + {- ^ /@destHeight@/: the height in pixels to scale the video data in /@srcBuffer@/ to -} + -> Int32 + {- ^ /@destWidth@/: the width in pixels to scale the video data in /@srcBuffer@/ to -} + -> m ((GstVideo.VideoInfo.VideoInfo, Gst.Buffer.Buffer)) +videoBlendScaleLinearRGBA src srcBuffer destHeight destWidth = liftIO $ do + src' <- unsafeManagedPtrGetPtr src + srcBuffer' <- unsafeManagedPtrGetPtr srcBuffer + dest <- callocBoxedBytes 120 :: IO (Ptr GstVideo.VideoInfo.VideoInfo) + destBuffer <- allocMem :: IO (Ptr (Ptr Gst.Buffer.Buffer)) + gst_video_blend_scale_linear_RGBA src' srcBuffer' destHeight destWidth dest destBuffer + dest' <- (wrapBoxed GstVideo.VideoInfo.VideoInfo) dest + destBuffer' <- peek destBuffer + destBuffer'' <- (wrapBoxed Gst.Buffer.Buffer) destBuffer' + touchManagedPtr src + touchManagedPtr srcBuffer + freeMem destBuffer + return (dest', destBuffer'') + + +-- function gst_video_blend +-- Args : [Arg {argCName = "dest", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GstVideoFrame where to blend @src in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstVideoFrame that we want to blend into", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The x offset in pixel where the @src image should be blended", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y offset in pixel where the @src image should be blended", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "global_alpha", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the global_alpha each per-pixel alpha value is multiplied\n with", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_blend" gst_video_blend :: + Ptr GstVideo.VideoFrame.VideoFrame -> -- dest : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) + Ptr GstVideo.VideoFrame.VideoFrame -> -- src : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) + Int32 -> -- x : TBasicType TInt + Int32 -> -- y : TBasicType TInt + CFloat -> -- global_alpha : TBasicType TFloat + IO CInt + +{- | +Lets you blend the /@src@/ image into the /@dest@/ image +-} +videoBlend :: + (B.CallStack.HasCallStack, MonadIO m) => + GstVideo.VideoFrame.VideoFrame + {- ^ /@dest@/: The 'GI.GstVideo.Structs.VideoFrame.VideoFrame' where to blend /@src@/ in -} + -> GstVideo.VideoFrame.VideoFrame + {- ^ /@src@/: the 'GI.GstVideo.Structs.VideoFrame.VideoFrame' that we want to blend into -} + -> Int32 + {- ^ /@x@/: The x offset in pixel where the /@src@/ image should be blended -} + -> Int32 + {- ^ /@y@/: the y offset in pixel where the /@src@/ image should be blended -} + -> Float + {- ^ /@globalAlpha@/: the global_alpha each per-pixel alpha value is multiplied + with -} + -> m Bool +videoBlend dest src x y globalAlpha = liftIO $ do + dest' <- unsafeManagedPtrGetPtr dest + src' <- unsafeManagedPtrGetPtr src + let globalAlpha' = realToFrac globalAlpha + result <- gst_video_blend dest' src' x y globalAlpha' + let result' = (/= 0) result + touchManagedPtr dest + touchManagedPtr src + return result' + + +-- function gst_video_affine_transformation_meta_api_get_type +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TGType) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_affine_transformation_meta_api_get_type" gst_video_affine_transformation_meta_api_get_type :: + IO CGType + +{- | +/No description available in the introspection data./ +-} +videoAffineTransformationMetaApiGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + m GType +videoAffineTransformationMetaApiGetType = liftIO $ do + result <- gst_video_affine_transformation_meta_api_get_type + let result' = GType result + return result' + + +-- function gst_is_video_overlay_prepare_window_handle_message +-- Args : [Arg {argCName = "msg", argType = TInterface (Name {namespace = "Gst", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMessage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_is_video_overlay_prepare_window_handle_message" gst_is_video_overlay_prepare_window_handle_message :: + Ptr Gst.Message.Message -> -- msg : TInterface (Name {namespace = "Gst", name = "Message"}) + IO CInt + +{- | +Convenience function to check if the given message is a +\"prepare-window-handle\" message from a 'GI.GstVideo.Interfaces.VideoOverlay.VideoOverlay'. +-} +isVideoOverlayPrepareWindowHandleMessage :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Message.Message + {- ^ /@msg@/: a 'GI.Gst.Structs.Message.Message' -} + -> m Bool + {- ^ __Returns:__ whether /@msg@/ is a \"prepare-window-handle\" message -} +isVideoOverlayPrepareWindowHandleMessage msg = liftIO $ do + msg' <- unsafeManagedPtrGetPtr msg + result <- gst_is_video_overlay_prepare_window_handle_message msg' + let result' = (/= 0) result + touchManagedPtr msg + return result' + + +-- function gst_buffer_pool_config_set_video_alignment +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoAlignment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_pool_config_set_video_alignment" gst_buffer_pool_config_set_video_alignment :: + Ptr Gst.Structure.Structure -> -- config : TInterface (Name {namespace = "Gst", name = "Structure"}) + Ptr GstVideo.VideoAlignment.VideoAlignment -> -- align : TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"}) + IO () + +{- | +Set the video alignment in /@align@/ to the bufferpool configuration +/@config@/ +-} +bufferPoolConfigSetVideoAlignment :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Structure.Structure + {- ^ /@config@/: a 'GI.Gst.Structs.Structure.Structure' -} + -> GstVideo.VideoAlignment.VideoAlignment + {- ^ /@align@/: a 'GI.GstVideo.Structs.VideoAlignment.VideoAlignment' -} + -> m () +bufferPoolConfigSetVideoAlignment config align = liftIO $ do + config' <- unsafeManagedPtrGetPtr config + align' <- unsafeManagedPtrGetPtr align + gst_buffer_pool_config_set_video_alignment config' align' + touchManagedPtr config + touchManagedPtr align + return () + + +-- function gst_buffer_pool_config_get_video_alignment +-- Args : [Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoAlignment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_pool_config_get_video_alignment" gst_buffer_pool_config_get_video_alignment :: + Ptr Gst.Structure.Structure -> -- config : TInterface (Name {namespace = "Gst", name = "Structure"}) + Ptr GstVideo.VideoAlignment.VideoAlignment -> -- align : TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"}) + IO CInt + +{- | +Get the video alignment from the bufferpool configuration /@config@/ in +in /@align@/ +-} +bufferPoolConfigGetVideoAlignment :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Structure.Structure + {- ^ /@config@/: a 'GI.Gst.Structs.Structure.Structure' -} + -> GstVideo.VideoAlignment.VideoAlignment + {- ^ /@align@/: a 'GI.GstVideo.Structs.VideoAlignment.VideoAlignment' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@config@/ could be parsed correctly. -} +bufferPoolConfigGetVideoAlignment config align = liftIO $ do + config' <- unsafeManagedPtrGetPtr config + align' <- unsafeManagedPtrGetPtr align + result <- gst_buffer_pool_config_get_video_alignment config' align' + let result' = (/= 0) result + touchManagedPtr config + touchManagedPtr align + return result' + + +-- function gst_buffer_get_video_region_of_interest_meta_id +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a metadata id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoRegionOfInterestMeta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_get_video_region_of_interest_meta_id" gst_buffer_get_video_region_of_interest_meta_id :: + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + Int32 -> -- id : TBasicType TInt + IO (Ptr GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta) + +{- | +Find the 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' on /@buffer@/ with the given /@id@/. + +Buffers can contain multiple 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' metadata items if +multiple regions of interests are marked on a frame. +-} +bufferGetVideoRegionOfInterestMetaId :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} + -> Int32 + {- ^ /@id@/: a metadata id -} + -> m GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' with /@id@/ or 'Nothing' when there is +no such metadata on /@buffer@/. -} +bufferGetVideoRegionOfInterestMetaId buffer id = liftIO $ do + buffer' <- unsafeManagedPtrGetPtr buffer + result <- gst_buffer_get_video_region_of_interest_meta_id buffer' id + checkUnexpectedReturnNULL "bufferGetVideoRegionOfInterestMetaId" result + result' <- (newPtr GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta) result + touchManagedPtr buffer + return result' + + +-- function gst_buffer_get_video_meta_id +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a metadata id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoMeta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_get_video_meta_id" gst_buffer_get_video_meta_id :: + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + Int32 -> -- id : TBasicType TInt + IO (Ptr GstVideo.VideoMeta.VideoMeta) + +{- | +Find the 'GI.GstVideo.Structs.VideoMeta.VideoMeta' on /@buffer@/ with the given /@id@/. + +Buffers can contain multiple 'GI.GstVideo.Structs.VideoMeta.VideoMeta' metadata items when dealing with +multiview buffers. +-} +bufferGetVideoMetaId :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} + -> Int32 + {- ^ /@id@/: a metadata id -} + -> m GstVideo.VideoMeta.VideoMeta + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoMeta.VideoMeta' with /@id@/ or 'Nothing' when there is no such metadata +on /@buffer@/. -} +bufferGetVideoMetaId buffer id = liftIO $ do + buffer' <- unsafeManagedPtrGetPtr buffer + result <- gst_buffer_get_video_meta_id buffer' id + checkUnexpectedReturnNULL "bufferGetVideoMetaId" result + result' <- (newPtr GstVideo.VideoMeta.VideoMeta) result + touchManagedPtr buffer + return result' + + +-- function gst_buffer_get_video_meta +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoMeta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_get_video_meta" gst_buffer_get_video_meta :: + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + IO (Ptr GstVideo.VideoMeta.VideoMeta) + +{- | +Find the 'GI.GstVideo.Structs.VideoMeta.VideoMeta' on /@buffer@/ with the lowest /@id@/. + +Buffers can contain multiple 'GI.GstVideo.Structs.VideoMeta.VideoMeta' metadata items when dealing with +multiview buffers. +-} +bufferGetVideoMeta :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} + -> m GstVideo.VideoMeta.VideoMeta + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoMeta.VideoMeta' with lowest id (usually 0) or 'Nothing' when there +is no such metadata on /@buffer@/. -} +bufferGetVideoMeta buffer = liftIO $ do + buffer' <- unsafeManagedPtrGetPtr buffer + result <- gst_buffer_get_video_meta buffer' + checkUnexpectedReturnNULL "bufferGetVideoMeta" result + result' <- (newPtr GstVideo.VideoMeta.VideoMeta) result + touchManagedPtr buffer + return result' + + +-- function gst_buffer_add_video_time_code_meta_full +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "framerate numerator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "framerate denominator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "latest_daily_jam", argType = TInterface (Name {namespace = "GLib", name = "DateTime"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDateTime for the latest daily jam", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCodeFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hours", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "hours since the daily jam", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minutes", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "minutes since the daily jam", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seconds", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "seconds since the daily jam", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frames", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "frames since the daily jam", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "fields since the daily jam", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeMeta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_add_video_time_code_meta_full" gst_buffer_add_video_time_code_meta_full :: + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + Word32 -> -- fps_n : TBasicType TUInt + Word32 -> -- fps_d : TBasicType TUInt + Ptr GLib.DateTime.DateTime -> -- latest_daily_jam : TInterface (Name {namespace = "GLib", name = "DateTime"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}) + Word32 -> -- hours : TBasicType TUInt + Word32 -> -- minutes : TBasicType TUInt + Word32 -> -- seconds : TBasicType TUInt + Word32 -> -- frames : TBasicType TUInt + Word32 -> -- field_count : TBasicType TUInt + IO (Ptr GstVideo.VideoTimeCodeMeta.VideoTimeCodeMeta) + +{- | +Attaches 'GI.GstVideo.Structs.VideoTimeCodeMeta.VideoTimeCodeMeta' metadata to /@buffer@/ with the given +parameters. + +/Since: 1.10/ +-} +bufferAddVideoTimeCodeMetaFull :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} + -> Word32 + {- ^ /@fpsN@/: framerate numerator -} + -> Word32 + {- ^ /@fpsD@/: framerate denominator -} + -> GLib.DateTime.DateTime + {- ^ /@latestDailyJam@/: a 'GI.GLib.Structs.DateTime.DateTime' for the latest daily jam -} + -> [GstVideo.Flags.VideoTimeCodeFlags] + {- ^ /@flags@/: a 'GI.GstVideo.Flags.VideoTimeCodeFlags' -} + -> Word32 + {- ^ /@hours@/: hours since the daily jam -} + -> Word32 + {- ^ /@minutes@/: minutes since the daily jam -} + -> Word32 + {- ^ /@seconds@/: seconds since the daily jam -} + -> Word32 + {- ^ /@frames@/: frames since the daily jam -} + -> Word32 + {- ^ /@fieldCount@/: fields since the daily jam -} + -> m GstVideo.VideoTimeCodeMeta.VideoTimeCodeMeta + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoTimeCodeMeta.VideoTimeCodeMeta' on /@buffer@/, or +(since 1.16) 'Nothing' if the timecode was invalid. -} +bufferAddVideoTimeCodeMetaFull buffer fpsN fpsD latestDailyJam flags hours minutes seconds frames fieldCount = liftIO $ do + buffer' <- unsafeManagedPtrGetPtr buffer + latestDailyJam' <- unsafeManagedPtrGetPtr latestDailyJam + let flags' = gflagsToWord flags + result <- gst_buffer_add_video_time_code_meta_full buffer' fpsN fpsD latestDailyJam' flags' hours minutes seconds frames fieldCount + checkUnexpectedReturnNULL "bufferAddVideoTimeCodeMetaFull" result + result' <- (newPtr GstVideo.VideoTimeCodeMeta.VideoTimeCodeMeta) result + touchManagedPtr buffer + touchManagedPtr latestDailyJam + return result' + + +-- function gst_buffer_add_video_time_code_meta +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeMeta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_add_video_time_code_meta" gst_buffer_add_video_time_code_meta :: + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + Ptr GstVideo.VideoTimeCode.VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + IO (Ptr GstVideo.VideoTimeCodeMeta.VideoTimeCodeMeta) + +{- | +Attaches 'GI.GstVideo.Structs.VideoTimeCodeMeta.VideoTimeCodeMeta' metadata to /@buffer@/ with the given +parameters. + +/Since: 1.10/ +-} +bufferAddVideoTimeCodeMeta :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} + -> GstVideo.VideoTimeCode.VideoTimeCode + {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> m (Maybe GstVideo.VideoTimeCodeMeta.VideoTimeCodeMeta) + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoTimeCodeMeta.VideoTimeCodeMeta' on /@buffer@/, or +(since 1.16) 'Nothing' if the timecode was invalid. -} +bufferAddVideoTimeCodeMeta buffer tc = liftIO $ do + buffer' <- unsafeManagedPtrGetPtr buffer + tc' <- unsafeManagedPtrGetPtr tc + result <- gst_buffer_add_video_time_code_meta buffer' tc' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newPtr GstVideo.VideoTimeCodeMeta.VideoTimeCodeMeta) result' + return result'' + touchManagedPtr buffer + touchManagedPtr tc + return maybeResult + + +-- function gst_buffer_add_video_region_of_interest_meta_id +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "roi_type", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Type of the region of interest (e.g. \"face\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "w", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "h", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoRegionOfInterestMeta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_add_video_region_of_interest_meta_id" gst_buffer_add_video_region_of_interest_meta_id :: + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + Word32 -> -- roi_type : TBasicType TUInt32 + Word32 -> -- x : TBasicType TUInt + Word32 -> -- y : TBasicType TUInt + Word32 -> -- w : TBasicType TUInt + Word32 -> -- h : TBasicType TUInt + IO (Ptr GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta) + +{- | +Attaches 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' metadata to /@buffer@/ with the given +parameters. +-} +bufferAddVideoRegionOfInterestMetaId :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} + -> Word32 + {- ^ /@roiType@/: Type of the region of interest (e.g. \"face\") -} + -> Word32 + {- ^ /@x@/: X position -} + -> Word32 + {- ^ /@y@/: Y position -} + -> Word32 + {- ^ /@w@/: width -} + -> Word32 + {- ^ /@h@/: height -} + -> m GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' on /@buffer@/. -} +bufferAddVideoRegionOfInterestMetaId buffer roiType x y w h = liftIO $ do + buffer' <- unsafeManagedPtrGetPtr buffer + result <- gst_buffer_add_video_region_of_interest_meta_id buffer' roiType x y w h + checkUnexpectedReturnNULL "bufferAddVideoRegionOfInterestMetaId" result + result' <- (newPtr GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta) result + touchManagedPtr buffer + return result' + + +-- function gst_buffer_add_video_region_of_interest_meta +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "roi_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Type of the region of interest (e.g. \"face\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "w", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "h", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoRegionOfInterestMeta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_add_video_region_of_interest_meta" gst_buffer_add_video_region_of_interest_meta :: + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + CString -> -- roi_type : TBasicType TUTF8 + Word32 -> -- x : TBasicType TUInt + Word32 -> -- y : TBasicType TUInt + Word32 -> -- w : TBasicType TUInt + Word32 -> -- h : TBasicType TUInt + IO (Ptr GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta) + +{- | +Attaches 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' metadata to /@buffer@/ with the given +parameters. +-} +bufferAddVideoRegionOfInterestMeta :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} + -> T.Text + {- ^ /@roiType@/: Type of the region of interest (e.g. \"face\") -} + -> Word32 + {- ^ /@x@/: X position -} + -> Word32 + {- ^ /@y@/: Y position -} + -> Word32 + {- ^ /@w@/: width -} + -> Word32 + {- ^ /@h@/: height -} + -> m GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' on /@buffer@/. -} +bufferAddVideoRegionOfInterestMeta buffer roiType x y w h = liftIO $ do + buffer' <- unsafeManagedPtrGetPtr buffer + roiType' <- textToCString roiType + result <- gst_buffer_add_video_region_of_interest_meta buffer' roiType' x y w h + checkUnexpectedReturnNULL "bufferAddVideoRegionOfInterestMeta" result + result' <- (newPtr GstVideo.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta) result + touchManagedPtr buffer + freeMem roiType' + return result' + + +-- function gst_buffer_add_video_overlay_composition_meta +-- Args : [Arg {argCName = "buf", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "comp", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayComposition", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoOverlayCompositionMeta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_add_video_overlay_composition_meta" gst_buffer_add_video_overlay_composition_meta :: + Ptr Gst.Buffer.Buffer -> -- buf : TInterface (Name {namespace = "Gst", name = "Buffer"}) + Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition -> -- comp : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}) + IO (Ptr GstVideo.VideoOverlayCompositionMeta.VideoOverlayCompositionMeta) + +{- | +Sets an overlay composition on a buffer. The buffer will obtain its own +reference to the composition, meaning this function does not take ownership +of /@comp@/. +-} +bufferAddVideoOverlayCompositionMeta :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@buf@/: a 'GI.Gst.Structs.Buffer.Buffer' -} + -> Maybe (GstVideo.VideoOverlayComposition.VideoOverlayComposition) + {- ^ /@comp@/: a 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' -} + -> m GstVideo.VideoOverlayCompositionMeta.VideoOverlayCompositionMeta + {- ^ __Returns:__ a 'GI.GstVideo.Structs.VideoOverlayCompositionMeta.VideoOverlayCompositionMeta' -} +bufferAddVideoOverlayCompositionMeta buf comp = liftIO $ do + buf' <- unsafeManagedPtrGetPtr buf + maybeComp <- case comp of + Nothing -> return nullPtr + Just jComp -> do + jComp' <- unsafeManagedPtrGetPtr jComp + return jComp' + result <- gst_buffer_add_video_overlay_composition_meta buf' maybeComp + checkUnexpectedReturnNULL "bufferAddVideoOverlayCompositionMeta" result + result' <- (newPtr GstVideo.VideoOverlayCompositionMeta.VideoOverlayCompositionMeta) result + touchManagedPtr buf + whenJust comp touchManagedPtr + return result' + + +-- function gst_buffer_add_video_meta_full +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrameFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoFrameFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_planes", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of planes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TCArray False 4 (-1) (TBasicType TUInt64), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "offset of each plane", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stride", argType = TCArray False 4 (-1) (TBasicType TInt), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "stride of each plane", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoMeta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_add_video_meta_full" gst_buffer_add_video_meta_full :: + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoFrameFlags"}) + CUInt -> -- format : TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}) + Word32 -> -- width : TBasicType TUInt + Word32 -> -- height : TBasicType TUInt + Word32 -> -- n_planes : TBasicType TUInt + Ptr Word64 -> -- offset : TCArray False 4 (-1) (TBasicType TUInt64) + Ptr Int32 -> -- stride : TCArray False 4 (-1) (TBasicType TInt) + IO (Ptr GstVideo.VideoMeta.VideoMeta) + +{- | +Attaches GstVideoMeta metadata to /@buffer@/ with the given parameters. +-} +bufferAddVideoMetaFull :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} + -> [GstVideo.Flags.VideoFrameFlags] + {- ^ /@flags@/: 'GI.GstVideo.Flags.VideoFrameFlags' -} + -> GstVideo.Enums.VideoFormat + {- ^ /@format@/: a 'GI.GstVideo.Enums.VideoFormat' -} + -> Word32 + {- ^ /@width@/: the width -} + -> Word32 + {- ^ /@height@/: the height -} + -> Word32 + {- ^ /@nPlanes@/: number of planes -} + -> [Word64] + {- ^ /@offset@/: offset of each plane -} + -> [Int32] + {- ^ /@stride@/: stride of each plane -} + -> m GstVideo.VideoMeta.VideoMeta + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoMeta.VideoMeta' on /@buffer@/. -} +bufferAddVideoMetaFull buffer flags format width height nPlanes offset stride = liftIO $ do + buffer' <- unsafeManagedPtrGetPtr buffer + let flags' = gflagsToWord flags + let format' = (fromIntegral . fromEnum) format + offset' <- packStorableArray offset + stride' <- packStorableArray stride + result <- gst_buffer_add_video_meta_full buffer' flags' format' width height nPlanes offset' stride' + checkUnexpectedReturnNULL "bufferAddVideoMetaFull" result + result' <- (newPtr GstVideo.VideoMeta.VideoMeta) result + touchManagedPtr buffer + freeMem offset' + freeMem stride' + return result' + + +-- function gst_buffer_add_video_meta +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrameFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoFrameFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoMeta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_add_video_meta" gst_buffer_add_video_meta :: + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoFrameFlags"}) + CUInt -> -- format : TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}) + Word32 -> -- width : TBasicType TUInt + Word32 -> -- height : TBasicType TUInt + IO (Ptr GstVideo.VideoMeta.VideoMeta) + +{- | +Attaches GstVideoMeta metadata to /@buffer@/ with the given parameters and the +default offsets and strides for /@format@/ and /@width@/ x /@height@/. + +This function calculates the default offsets and strides and then calls +'GI.GstVideo.Functions.bufferAddVideoMetaFull' with them. +-} +bufferAddVideoMeta :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} + -> [GstVideo.Flags.VideoFrameFlags] + {- ^ /@flags@/: 'GI.GstVideo.Flags.VideoFrameFlags' -} + -> GstVideo.Enums.VideoFormat + {- ^ /@format@/: a 'GI.GstVideo.Enums.VideoFormat' -} + -> Word32 + {- ^ /@width@/: the width -} + -> Word32 + {- ^ /@height@/: the height -} + -> m GstVideo.VideoMeta.VideoMeta + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoMeta.VideoMeta' on /@buffer@/. -} +bufferAddVideoMeta buffer flags format width height = liftIO $ do + buffer' <- unsafeManagedPtrGetPtr buffer + let flags' = gflagsToWord flags + let format' = (fromIntegral . fromEnum) format + result <- gst_buffer_add_video_meta buffer' flags' format' width height + checkUnexpectedReturnNULL "bufferAddVideoMeta" result + result' <- (newPtr GstVideo.VideoMeta.VideoMeta) result + touchManagedPtr buffer + return result' + + +-- function gst_buffer_add_video_gl_texture_upload_meta +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "texture_orientation", argType = TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureOrientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstVideoGLTextureOrientation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_textures", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of textures", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "texture_type", argType = TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "array of #GstVideoGLTextureType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "upload", argType = TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureUpload"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the function to upload the buffer to a specific texture ID", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data for the implementor of @upload", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data_copy", argType = TInterface (Name {namespace = "GObject", name = "BoxedCopyFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "function to copy @user_data", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data_free", argType = TInterface (Name {namespace = "GObject", name = "BoxedFreeFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "function to free @user_data", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureUploadMeta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_add_video_gl_texture_upload_meta" gst_buffer_add_video_gl_texture_upload_meta :: + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + CUInt -> -- texture_orientation : TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureOrientation"}) + Word32 -> -- n_textures : TBasicType TUInt + CUInt -> -- texture_type : TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureType"}) + FunPtr GstVideo.Callbacks.C_VideoGLTextureUpload -> -- upload : TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureUpload"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GObject.Callbacks.C_BoxedCopyFunc -> -- user_data_copy : TInterface (Name {namespace = "GObject", name = "BoxedCopyFunc"}) + FunPtr GObject.Callbacks.C_BoxedFreeFunc -> -- user_data_free : TInterface (Name {namespace = "GObject", name = "BoxedFreeFunc"}) + IO (Ptr GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta) + +{- | +Attaches GstVideoGLTextureUploadMeta metadata to /@buffer@/ with the given +parameters. +-} +bufferAddVideoGlTextureUploadMeta :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} + -> GstVideo.Enums.VideoGLTextureOrientation + {- ^ /@textureOrientation@/: the 'GI.GstVideo.Enums.VideoGLTextureOrientation' -} + -> Word32 + {- ^ /@nTextures@/: the number of textures -} + -> GstVideo.Enums.VideoGLTextureType + {- ^ /@textureType@/: array of 'GI.GstVideo.Enums.VideoGLTextureType' -} + -> GstVideo.Callbacks.VideoGLTextureUpload + {- ^ /@upload@/: the function to upload the buffer to a specific texture ID -} + -> GObject.Callbacks.BoxedCopyFunc + {- ^ /@userDataCopy@/: function to copy /@userData@/ -} + -> GObject.Callbacks.BoxedFreeFunc + {- ^ /@userDataFree@/: function to free /@userData@/ -} + -> m GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta' on /@buffer@/. -} +bufferAddVideoGlTextureUploadMeta buffer textureOrientation nTextures textureType upload userDataCopy userDataFree = liftIO $ do + buffer' <- unsafeManagedPtrGetPtr buffer + let textureOrientation' = (fromIntegral . fromEnum) textureOrientation + let textureType' = (fromIntegral . fromEnum) textureType + upload' <- GstVideo.Callbacks.mk_VideoGLTextureUpload (GstVideo.Callbacks.wrap_VideoGLTextureUpload Nothing upload) + userDataCopy' <- GObject.Callbacks.mk_BoxedCopyFunc (GObject.Callbacks.wrap_BoxedCopyFunc Nothing userDataCopy) + userDataFree' <- GObject.Callbacks.mk_BoxedFreeFunc (GObject.Callbacks.wrap_BoxedFreeFunc Nothing userDataFree) + let userData = nullPtr + result <- gst_buffer_add_video_gl_texture_upload_meta buffer' textureOrientation' nTextures textureType' upload' userData userDataCopy' userDataFree' + checkUnexpectedReturnNULL "bufferAddVideoGlTextureUploadMeta" result + result' <- (newPtr GstVideo.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta) result + safeFreeFunPtr $ castFunPtrToPtr upload' + safeFreeFunPtr $ castFunPtrToPtr userDataCopy' + safeFreeFunPtr $ castFunPtrToPtr userDataFree' + touchManagedPtr buffer + return result' + + +-- function gst_buffer_add_video_caption_meta +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caption_type", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCaptionType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The type of Closed Caption to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The Closed Caption data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The size of @data in bytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The size of @data in bytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCaptionMeta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_add_video_caption_meta" gst_buffer_add_video_caption_meta :: + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + CUInt -> -- caption_type : TInterface (Name {namespace = "GstVideo", name = "VideoCaptionType"}) + Ptr Word8 -> -- data : TCArray False (-1) 3 (TBasicType TUInt8) + Word64 -> -- size : TBasicType TUInt64 + IO (Ptr GstVideo.VideoCaptionMeta.VideoCaptionMeta) + +{- | +Attaches 'GI.GstVideo.Structs.VideoCaptionMeta.VideoCaptionMeta' metadata to /@buffer@/ with the given +parameters. + +/Since: 1.16/ +-} +bufferAddVideoCaptionMeta :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} + -> GstVideo.Enums.VideoCaptionType + {- ^ /@captionType@/: The type of Closed Caption to add -} + -> ByteString + {- ^ /@data@/: The Closed Caption data -} + -> m GstVideo.VideoCaptionMeta.VideoCaptionMeta + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoCaptionMeta.VideoCaptionMeta' on /@buffer@/. -} +bufferAddVideoCaptionMeta buffer captionType data_ = liftIO $ do + let size = fromIntegral $ B.length data_ + buffer' <- unsafeManagedPtrGetPtr buffer + let captionType' = (fromIntegral . fromEnum) captionType + data_' <- packByteString data_ + result <- gst_buffer_add_video_caption_meta buffer' captionType' data_' size + checkUnexpectedReturnNULL "bufferAddVideoCaptionMeta" result + result' <- (newPtr GstVideo.VideoCaptionMeta.VideoCaptionMeta) result + touchManagedPtr buffer + freeMem data_' + return result' + + +-- function gst_buffer_add_video_affine_transformation_meta +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoAffineTransformationMeta"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_buffer_add_video_affine_transformation_meta" gst_buffer_add_video_affine_transformation_meta :: + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + IO (Ptr GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta) + +{- | +Attaches GstVideoAffineTransformationMeta metadata to /@buffer@/ with +the given parameters. + +/Since: 1.8/ +-} +bufferAddVideoAffineTransformationMeta :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@buffer@/: a 'GI.Gst.Structs.Buffer.Buffer' -} + -> m GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoAffineTransformationMeta.VideoAffineTransformationMeta' on /@buffer@/. -} +bufferAddVideoAffineTransformationMeta buffer = liftIO $ do + buffer' <- unsafeManagedPtrGetPtr buffer + result <- gst_buffer_add_video_affine_transformation_meta buffer' + checkUnexpectedReturnNULL "bufferAddVideoAffineTransformationMeta" result + result' <- (newPtr GstVideo.VideoAffineTransformationMeta.VideoAffineTransformationMeta) result + touchManagedPtr buffer + return result' + + + diff --git a/GI/GstVideo/Interfaces.hs b/GI/GstVideo/Interfaces.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Interfaces.hs @@ -0,0 +1,49 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Interfaces + ( module GI.GstVideo.Interfaces.ColorBalance, + module GI.GstVideo.Interfaces.Navigation, + module GI.GstVideo.Interfaces.VideoDirection, + 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.VideoDirection +import GI.GstVideo.Interfaces.VideoOrientation +import GI.GstVideo.Interfaces.VideoOverlay + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + + diff --git a/GI/GstVideo/Interfaces/ColorBalance.hs b/GI/GstVideo/Interfaces/ColorBalance.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Interfaces/ColorBalance.hs @@ -0,0 +1,482 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +This interface is implemented by elements which can perform some color +balance operation on video frames they process. For example, modifying +the brightness, contrast, hue or saturation. + +Example elements are \'xvimagesink\' and \'colorbalance\' +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Interfaces.ColorBalance + ( + +-- * Exported types + ColorBalance(..) , + noColorBalance , + IsColorBalance , + toColorBalance , + + + -- * Methods +-- ** getBalanceType #method:getBalanceType# + +#if ENABLE_OVERLOADING + ColorBalanceGetBalanceTypeMethodInfo , +#endif + colorBalanceGetBalanceType , + + +-- ** getValue #method:getValue# + +#if ENABLE_OVERLOADING + ColorBalanceGetValueMethodInfo , +#endif + colorBalanceGetValue , + + +-- ** listChannels #method:listChannels# + +#if ENABLE_OVERLOADING + ColorBalanceListChannelsMethodInfo , +#endif + colorBalanceListChannels , + + +-- ** setValue #method:setValue# + +#if ENABLE_OVERLOADING + ColorBalanceSetValueMethodInfo , +#endif + colorBalanceSetValue , + + +-- ** valueChanged #method:valueChanged# + +#if ENABLE_OVERLOADING + ColorBalanceValueChangedMethodInfo , +#endif + colorBalanceValueChanged , + + + + + -- * Signals +-- ** valueChanged #signal:valueChanged# + + C_ColorBalanceValueChangedCallback , + ColorBalanceValueChangedCallback , +#if ENABLE_OVERLOADING + ColorBalanceValueChangedSignalInfo , +#endif + afterColorBalanceValueChanged , + genClosure_ColorBalanceValueChanged , + mk_ColorBalanceValueChangedCallback , + noColorBalanceValueChangedCallback , + onColorBalanceValueChanged , + wrap_ColorBalanceValueChangedCallback , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums +import {-# SOURCE #-} qualified GI.GstVideo.Objects.ColorBalanceChannel as GstVideo.ColorBalanceChannel + +-- interface ColorBalance +-- | Memory-managed wrapper type. +newtype ColorBalance = ColorBalance (ManagedPtr ColorBalance) +-- | A convenience alias for `Nothing` :: `Maybe` `ColorBalance`. +noColorBalance :: Maybe ColorBalance +noColorBalance = Nothing + +-- signal ColorBalance::value-changed +{- | +Fired when the value of the indicated channel has changed. +-} +type ColorBalanceValueChangedCallback = + GstVideo.ColorBalanceChannel.ColorBalanceChannel + {- ^ /@channel@/: The 'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' -} + -> Int32 + {- ^ /@value@/: The new value -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ColorBalanceValueChangedCallback`@. +noColorBalanceValueChangedCallback :: Maybe ColorBalanceValueChangedCallback +noColorBalanceValueChangedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ColorBalanceValueChangedCallback = + Ptr () -> -- object + Ptr GstVideo.ColorBalanceChannel.ColorBalanceChannel -> + Int32 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ColorBalanceValueChangedCallback`. +foreign import ccall "wrapper" + mk_ColorBalanceValueChangedCallback :: C_ColorBalanceValueChangedCallback -> IO (FunPtr C_ColorBalanceValueChangedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ColorBalanceValueChanged :: MonadIO m => ColorBalanceValueChangedCallback -> m (GClosure C_ColorBalanceValueChangedCallback) +genClosure_ColorBalanceValueChanged cb = liftIO $ do + let cb' = wrap_ColorBalanceValueChangedCallback cb + mk_ColorBalanceValueChangedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ColorBalanceValueChangedCallback` into a `C_ColorBalanceValueChangedCallback`. +wrap_ColorBalanceValueChangedCallback :: + ColorBalanceValueChangedCallback -> + C_ColorBalanceValueChangedCallback +wrap_ColorBalanceValueChangedCallback _cb _ channel value _ = do + channel' <- (newObject GstVideo.ColorBalanceChannel.ColorBalanceChannel) channel + _cb channel' value + + +{- | +Connect a signal handler for the “@value-changed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' colorBalance #valueChanged callback +@ +-} +onColorBalanceValueChanged :: (IsColorBalance a, MonadIO m) => a -> ColorBalanceValueChangedCallback -> m SignalHandlerId +onColorBalanceValueChanged obj cb = liftIO $ do + let cb' = wrap_ColorBalanceValueChangedCallback cb + cb'' <- mk_ColorBalanceValueChangedCallback cb' + connectSignalFunPtr obj "value-changed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@value-changed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' colorBalance #valueChanged callback +@ +-} +afterColorBalanceValueChanged :: (IsColorBalance a, MonadIO m) => a -> ColorBalanceValueChangedCallback -> m SignalHandlerId +afterColorBalanceValueChanged obj cb = liftIO $ do + let cb' = wrap_ColorBalanceValueChangedCallback cb + cb'' <- mk_ColorBalanceValueChangedCallback cb' + connectSignalFunPtr obj "value-changed" cb'' SignalConnectAfter + + +#if ENABLE_OVERLOADING +data ColorBalanceValueChangedSignalInfo +instance SignalInfo ColorBalanceValueChangedSignalInfo where + type HaskellCallbackType ColorBalanceValueChangedSignalInfo = ColorBalanceValueChangedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ColorBalanceValueChangedCallback cb + cb'' <- mk_ColorBalanceValueChangedCallback cb' + connectSignalFunPtr obj "value-changed" cb'' connectMode + +type instance O.SignalList ColorBalance = ColorBalanceSignalList +type ColorBalanceSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo), '("valueChanged", ColorBalanceValueChangedSignalInfo)] :: [(Symbol, *)]) + +#endif + +foreign import ccall "gst_color_balance_get_type" + c_gst_color_balance_get_type :: IO GType + +instance GObject ColorBalance where + gobjectType = c_gst_color_balance_get_type + + +-- | Type class for types which can be safely cast to `ColorBalance`, for instance with `toColorBalance`. +class (GObject o, O.IsDescendantOf ColorBalance o) => IsColorBalance o +instance (GObject o, O.IsDescendantOf ColorBalance o) => IsColorBalance o + +instance O.HasParentTypes ColorBalance +type instance O.ParentTypes ColorBalance = '[GObject.Object.Object] + +-- | Cast to `ColorBalance`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toColorBalance :: (MonadIO m, IsColorBalance o) => o -> m ColorBalance +toColorBalance = liftIO . unsafeCastTo ColorBalance + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ColorBalance +type instance O.AttributeList ColorBalance = ColorBalanceAttributeList +type ColorBalanceAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveColorBalanceMethod (t :: Symbol) (o :: *) :: * where + ResolveColorBalanceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveColorBalanceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveColorBalanceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveColorBalanceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveColorBalanceMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveColorBalanceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveColorBalanceMethod "listChannels" o = ColorBalanceListChannelsMethodInfo + ResolveColorBalanceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveColorBalanceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveColorBalanceMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveColorBalanceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveColorBalanceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveColorBalanceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveColorBalanceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveColorBalanceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveColorBalanceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveColorBalanceMethod "valueChanged" o = ColorBalanceValueChangedMethodInfo + ResolveColorBalanceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveColorBalanceMethod "getBalanceType" o = ColorBalanceGetBalanceTypeMethodInfo + ResolveColorBalanceMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveColorBalanceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveColorBalanceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveColorBalanceMethod "getValue" o = ColorBalanceGetValueMethodInfo + ResolveColorBalanceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveColorBalanceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveColorBalanceMethod "setValue" o = ColorBalanceSetValueMethodInfo + ResolveColorBalanceMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveColorBalanceMethod t ColorBalance, O.MethodInfo info ColorBalance p) => OL.IsLabel t (ColorBalance -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- method ColorBalance::get_balance_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "balance", argType = TInterface (Name {namespace = "GstVideo", name = "ColorBalance"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GstColorBalance implementation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "ColorBalanceType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_color_balance_get_balance_type" gst_color_balance_get_balance_type :: + Ptr ColorBalance -> -- balance : TInterface (Name {namespace = "GstVideo", name = "ColorBalance"}) + IO CUInt + +{- | +Get the 'GI.GstVideo.Enums.ColorBalanceType' of this implementation. +-} +colorBalanceGetBalanceType :: + (B.CallStack.HasCallStack, MonadIO m, IsColorBalance a) => + a + {- ^ /@balance@/: The 'GI.GstVideo.Interfaces.ColorBalance.ColorBalance' implementation -} + -> m GstVideo.Enums.ColorBalanceType + {- ^ __Returns:__ A the 'GI.GstVideo.Enums.ColorBalanceType'. -} +colorBalanceGetBalanceType balance = liftIO $ do + balance' <- unsafeManagedPtrCastPtr balance + result <- gst_color_balance_get_balance_type balance' + let result' = (toEnum . fromIntegral) result + touchManagedPtr balance + return result' + +#if ENABLE_OVERLOADING +data ColorBalanceGetBalanceTypeMethodInfo +instance (signature ~ (m GstVideo.Enums.ColorBalanceType), MonadIO m, IsColorBalance a) => O.MethodInfo ColorBalanceGetBalanceTypeMethodInfo a signature where + overloadedMethod _ = colorBalanceGetBalanceType + +#endif + +-- method ColorBalance::get_value +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "balance", argType = TInterface (Name {namespace = "GstVideo", name = "ColorBalance"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstColorBalance instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "channel", argType = TInterface (Name {namespace = "GstVideo", name = "ColorBalanceChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstColorBalanceChannel instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_color_balance_get_value" gst_color_balance_get_value :: + Ptr ColorBalance -> -- balance : TInterface (Name {namespace = "GstVideo", name = "ColorBalance"}) + Ptr GstVideo.ColorBalanceChannel.ColorBalanceChannel -> -- channel : TInterface (Name {namespace = "GstVideo", name = "ColorBalanceChannel"}) + IO Int32 + +{- | +Retrieve the current value of the indicated channel, between min_value +and max_value. + +See Also: The 'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel'.@/min_value/@ and + 'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel'.@/max_value/@ members of the + 'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' object. +-} +colorBalanceGetValue :: + (B.CallStack.HasCallStack, MonadIO m, IsColorBalance a, GstVideo.ColorBalanceChannel.IsColorBalanceChannel b) => + a + {- ^ /@balance@/: A 'GI.GstVideo.Interfaces.ColorBalance.ColorBalance' instance -} + -> b + {- ^ /@channel@/: A 'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' instance -} + -> m Int32 + {- ^ __Returns:__ The current value of the channel. -} +colorBalanceGetValue balance channel = liftIO $ do + balance' <- unsafeManagedPtrCastPtr balance + channel' <- unsafeManagedPtrCastPtr channel + result <- gst_color_balance_get_value balance' channel' + touchManagedPtr balance + touchManagedPtr channel + return result + +#if ENABLE_OVERLOADING +data ColorBalanceGetValueMethodInfo +instance (signature ~ (b -> m Int32), MonadIO m, IsColorBalance a, GstVideo.ColorBalanceChannel.IsColorBalanceChannel b) => O.MethodInfo ColorBalanceGetValueMethodInfo a signature where + overloadedMethod _ = colorBalanceGetValue + +#endif + +-- method ColorBalance::list_channels +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "balance", argType = TInterface (Name {namespace = "GstVideo", name = "ColorBalance"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstColorBalance instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "GstVideo", name = "ColorBalanceChannel"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_color_balance_list_channels" gst_color_balance_list_channels :: + Ptr ColorBalance -> -- balance : TInterface (Name {namespace = "GstVideo", name = "ColorBalance"}) + IO (Ptr (GList (Ptr GstVideo.ColorBalanceChannel.ColorBalanceChannel))) + +{- | +Retrieve a list of the available channels. +-} +colorBalanceListChannels :: + (B.CallStack.HasCallStack, MonadIO m, IsColorBalance a) => + a + {- ^ /@balance@/: A 'GI.GstVideo.Interfaces.ColorBalance.ColorBalance' instance -} + -> m [GstVideo.ColorBalanceChannel.ColorBalanceChannel] + {- ^ __Returns:__ A + GList containing pointers to 'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' + objects. The list is owned by the 'GI.GstVideo.Interfaces.ColorBalance.ColorBalance' + instance and must not be freed. -} +colorBalanceListChannels balance = liftIO $ do + balance' <- unsafeManagedPtrCastPtr balance + result <- gst_color_balance_list_channels balance' + result' <- unpackGList result + result'' <- mapM (newObject GstVideo.ColorBalanceChannel.ColorBalanceChannel) result' + touchManagedPtr balance + return result'' + +#if ENABLE_OVERLOADING +data ColorBalanceListChannelsMethodInfo +instance (signature ~ (m [GstVideo.ColorBalanceChannel.ColorBalanceChannel]), MonadIO m, IsColorBalance a) => O.MethodInfo ColorBalanceListChannelsMethodInfo a signature where + overloadedMethod _ = colorBalanceListChannels + +#endif + +-- method ColorBalance::set_value +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "balance", argType = TInterface (Name {namespace = "GstVideo", name = "ColorBalance"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstColorBalance instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "channel", argType = TInterface (Name {namespace = "GstVideo", name = "ColorBalanceChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstColorBalanceChannel instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The new value for the channel.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_color_balance_set_value" gst_color_balance_set_value :: + Ptr ColorBalance -> -- balance : TInterface (Name {namespace = "GstVideo", name = "ColorBalance"}) + Ptr GstVideo.ColorBalanceChannel.ColorBalanceChannel -> -- channel : TInterface (Name {namespace = "GstVideo", name = "ColorBalanceChannel"}) + Int32 -> -- value : TBasicType TInt + IO () + +{- | +Sets the current value of the channel to the passed value, which must +be between min_value and max_value. + +See Also: The 'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel'.@/min_value/@ and + 'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel'.@/max_value/@ members of the + 'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' object. +-} +colorBalanceSetValue :: + (B.CallStack.HasCallStack, MonadIO m, IsColorBalance a, GstVideo.ColorBalanceChannel.IsColorBalanceChannel b) => + a + {- ^ /@balance@/: A 'GI.GstVideo.Interfaces.ColorBalance.ColorBalance' instance -} + -> b + {- ^ /@channel@/: A 'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' instance -} + -> Int32 + {- ^ /@value@/: The new value for the channel. -} + -> m () +colorBalanceSetValue balance channel value = liftIO $ do + balance' <- unsafeManagedPtrCastPtr balance + channel' <- unsafeManagedPtrCastPtr channel + gst_color_balance_set_value balance' channel' value + touchManagedPtr balance + touchManagedPtr channel + return () + +#if ENABLE_OVERLOADING +data ColorBalanceSetValueMethodInfo +instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsColorBalance a, GstVideo.ColorBalanceChannel.IsColorBalanceChannel b) => O.MethodInfo ColorBalanceSetValueMethodInfo a signature where + overloadedMethod _ = colorBalanceSetValue + +#endif + +-- method ColorBalance::value_changed +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "balance", argType = TInterface (Name {namespace = "GstVideo", name = "ColorBalance"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstColorBalance instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "channel", argType = TInterface (Name {namespace = "GstVideo", name = "ColorBalanceChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstColorBalanceChannel whose value has changed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The new value of the channel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_color_balance_value_changed" gst_color_balance_value_changed :: + Ptr ColorBalance -> -- balance : TInterface (Name {namespace = "GstVideo", name = "ColorBalance"}) + Ptr GstVideo.ColorBalanceChannel.ColorBalanceChannel -> -- channel : TInterface (Name {namespace = "GstVideo", name = "ColorBalanceChannel"}) + Int32 -> -- value : TBasicType TInt + IO () + +{- | +A helper function called by implementations of the GstColorBalance +interface. It fires the 'GI.GstVideo.Interfaces.ColorBalance.ColorBalance'::@/value-changed/@ signal on the +instance, and the 'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel'::@/value-changed/@ signal on the +channel object. +-} +colorBalanceValueChanged :: + (B.CallStack.HasCallStack, MonadIO m, IsColorBalance a, GstVideo.ColorBalanceChannel.IsColorBalanceChannel b) => + a + {- ^ /@balance@/: A 'GI.GstVideo.Interfaces.ColorBalance.ColorBalance' instance -} + -> b + {- ^ /@channel@/: A 'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' whose value has changed -} + -> Int32 + {- ^ /@value@/: The new value of the channel -} + -> m () +colorBalanceValueChanged balance channel value = liftIO $ do + balance' <- unsafeManagedPtrCastPtr balance + channel' <- unsafeManagedPtrCastPtr channel + gst_color_balance_value_changed balance' channel' value + touchManagedPtr balance + touchManagedPtr channel + return () + +#if ENABLE_OVERLOADING +data ColorBalanceValueChangedMethodInfo +instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsColorBalance a, GstVideo.ColorBalanceChannel.IsColorBalanceChannel b) => O.MethodInfo ColorBalanceValueChangedMethodInfo a signature where + overloadedMethod _ = colorBalanceValueChanged + +#endif + + diff --git a/GI/GstVideo/Interfaces/ColorBalance.hs-boot b/GI/GstVideo/Interfaces/ColorBalance.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Interfaces/ColorBalance.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Interfaces.ColorBalance where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ColorBalance = ColorBalance (ManagedPtr ColorBalance) +#if ENABLE_OVERLOADING +data ColorBalanceValueChangedSignalInfo +#endif +instance GObject ColorBalance where +class (GObject o, O.IsDescendantOf ColorBalance o) => IsColorBalance o +instance (GObject o, O.IsDescendantOf ColorBalance o) => IsColorBalance o +instance O.HasParentTypes ColorBalance +#if ENABLE_OVERLOADING +data ColorBalanceGetBalanceTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data ColorBalanceGetValueMethodInfo +#endif +#if ENABLE_OVERLOADING +data ColorBalanceListChannelsMethodInfo +#endif +#if ENABLE_OVERLOADING +data ColorBalanceSetValueMethodInfo +#endif +#if ENABLE_OVERLOADING +data ColorBalanceValueChangedMethodInfo +#endif diff --git a/GI/GstVideo/Interfaces/Navigation.hs b/GI/GstVideo/Interfaces/Navigation.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Interfaces/Navigation.hs @@ -0,0 +1,1201 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +The Navigation interface is used for creating and injecting navigation related +events such as mouse button presses, cursor motion and key presses. The associated +library also provides methods for parsing received events, and for sending and +receiving navigation related bus events. One main usecase is DVD menu navigation. + +The main parts of the API are: + +* The GstNavigation interface, implemented by elements which provide an application + with the ability to create and inject navigation events into the pipeline. +* GstNavigation event handling API. GstNavigation events are created in response to + calls on a GstNavigation interface implementation, and sent in the pipeline. Upstream + elements can use the navigation event API functions to parse the contents of received + messages. + +* GstNavigation message handling API. GstNavigation messages may be sent on the message + bus to inform applications of navigation related changes in the pipeline, such as the + mouse moving over a clickable region, or the set of available angles changing. + +The GstNavigation message functions provide functions for creating and parsing +custom bus messages for signaling GstNavigation changes. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Interfaces.Navigation + ( + +-- * Exported types + Navigation(..) , + noNavigation , + IsNavigation , + + + -- * Methods +-- ** eventGetType #method:eventGetType# + + navigationEventGetType , + + +-- ** eventParseCommand #method:eventParseCommand# + + navigationEventParseCommand , + + +-- ** eventParseKeyEvent #method:eventParseKeyEvent# + + navigationEventParseKeyEvent , + + +-- ** eventParseMouseButtonEvent #method:eventParseMouseButtonEvent# + + navigationEventParseMouseButtonEvent , + + +-- ** eventParseMouseMoveEvent #method:eventParseMouseMoveEvent# + + navigationEventParseMouseMoveEvent , + + +-- ** messageGetType #method:messageGetType# + + navigationMessageGetType , + + +-- ** messageNewAnglesChanged #method:messageNewAnglesChanged# + + navigationMessageNewAnglesChanged , + + +-- ** messageNewCommandsChanged #method:messageNewCommandsChanged# + + navigationMessageNewCommandsChanged , + + +-- ** messageNewEvent #method:messageNewEvent# + + navigationMessageNewEvent , + + +-- ** messageNewMouseOver #method:messageNewMouseOver# + + navigationMessageNewMouseOver , + + +-- ** messageParseAnglesChanged #method:messageParseAnglesChanged# + + navigationMessageParseAnglesChanged , + + +-- ** messageParseEvent #method:messageParseEvent# + + navigationMessageParseEvent , + + +-- ** messageParseMouseOver #method:messageParseMouseOver# + + navigationMessageParseMouseOver , + + +-- ** queryGetType #method:queryGetType# + + navigationQueryGetType , + + +-- ** queryNewAngles #method:queryNewAngles# + + navigationQueryNewAngles , + + +-- ** queryNewCommands #method:queryNewCommands# + + navigationQueryNewCommands , + + +-- ** queryParseAngles #method:queryParseAngles# + + navigationQueryParseAngles , + + +-- ** queryParseCommandsLength #method:queryParseCommandsLength# + + navigationQueryParseCommandsLength , + + +-- ** queryParseCommandsNth #method:queryParseCommandsNth# + + navigationQueryParseCommandsNth , + + +-- ** querySetAngles #method:querySetAngles# + + navigationQuerySetAngles , + + +-- ** querySetCommandsv #method:querySetCommandsv# + + navigationQuerySetCommandsv , + + +-- ** sendCommand #method:sendCommand# + +#if ENABLE_OVERLOADING + NavigationSendCommandMethodInfo , +#endif + navigationSendCommand , + + +-- ** sendEvent #method:sendEvent# + +#if ENABLE_OVERLOADING + NavigationSendEventMethodInfo , +#endif + navigationSendEvent , + + +-- ** sendKeyEvent #method:sendKeyEvent# + +#if ENABLE_OVERLOADING + NavigationSendKeyEventMethodInfo , +#endif + navigationSendKeyEvent , + + +-- ** sendMouseEvent #method:sendMouseEvent# + +#if ENABLE_OVERLOADING + NavigationSendMouseEventMethodInfo , +#endif + navigationSendMouseEvent , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Objects.Object as Gst.Object +import qualified GI.Gst.Structs.Event as Gst.Event +import qualified GI.Gst.Structs.Message as Gst.Message +import qualified GI.Gst.Structs.Query as Gst.Query +import qualified GI.Gst.Structs.Structure as Gst.Structure +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums + +-- interface Navigation +-- | Memory-managed wrapper type. +newtype Navigation = Navigation (ManagedPtr Navigation) +-- | A convenience alias for `Nothing` :: `Maybe` `Navigation`. +noNavigation :: Maybe Navigation +noNavigation = Nothing + +#if ENABLE_OVERLOADING +type instance O.SignalList Navigation = NavigationSignalList +type NavigationSignalList = ('[ ] :: [(Symbol, *)]) + +#endif + +-- | Type class for types which implement `Navigation`. +class ManagedPtrNewtype a => IsNavigation a +instance IsNavigation Navigation +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr Navigation where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + + +#if ENABLE_OVERLOADING +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 = O.MethodResolutionFailed l o + +instance (info ~ ResolveNavigationMethod t Navigation, O.MethodInfo info Navigation p) => OL.IsLabel t (Navigation -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- method Navigation::send_command +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "navigation", argType = TInterface (Name {namespace = "GstVideo", name = "Navigation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The navigation interface instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TInterface (Name {namespace = "GstVideo", name = "NavigationCommand"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The command to issue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_send_command" gst_navigation_send_command :: + Ptr Navigation -> -- navigation : TInterface (Name {namespace = "GstVideo", name = "Navigation"}) + CUInt -> -- command : TInterface (Name {namespace = "GstVideo", name = "NavigationCommand"}) + IO () + +{- | +Sends the indicated command to the navigation interface. +-} +navigationSendCommand :: + (B.CallStack.HasCallStack, MonadIO m, IsNavigation a) => + a + {- ^ /@navigation@/: The navigation interface instance -} + -> GstVideo.Enums.NavigationCommand + {- ^ /@command@/: The command to issue -} + -> m () +navigationSendCommand navigation command = liftIO $ do + navigation' <- unsafeManagedPtrCastPtr navigation + let command' = (fromIntegral . fromEnum) command + gst_navigation_send_command navigation' command' + touchManagedPtr navigation + return () + +#if ENABLE_OVERLOADING +data NavigationSendCommandMethodInfo +instance (signature ~ (GstVideo.Enums.NavigationCommand -> m ()), MonadIO m, IsNavigation a) => O.MethodInfo NavigationSendCommandMethodInfo a signature where + overloadedMethod _ = navigationSendCommand + +#endif + +-- method Navigation::send_event +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "navigation", argType = TInterface (Name {namespace = "GstVideo", name = "Navigation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_send_event" gst_navigation_send_event :: + Ptr Navigation -> -- navigation : TInterface (Name {namespace = "GstVideo", name = "Navigation"}) + Ptr Gst.Structure.Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) + IO () + +{- | +/No description available in the introspection data./ +-} +navigationSendEvent :: + (B.CallStack.HasCallStack, MonadIO m, IsNavigation a) => + a + -> Gst.Structure.Structure + -> m () +navigationSendEvent navigation structure = liftIO $ do + navigation' <- unsafeManagedPtrCastPtr navigation + structure' <- unsafeManagedPtrGetPtr structure + gst_navigation_send_event navigation' structure' + touchManagedPtr navigation + touchManagedPtr structure + return () + +#if ENABLE_OVERLOADING +data NavigationSendEventMethodInfo +instance (signature ~ (Gst.Structure.Structure -> m ()), MonadIO m, IsNavigation a) => O.MethodInfo NavigationSendEventMethodInfo a signature where + overloadedMethod _ = navigationSendEvent + +#endif + +-- method Navigation::send_key_event +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "navigation", argType = TInterface (Name {namespace = "GstVideo", name = "Navigation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The navigation interface instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The type of the key event. Recognised values are \"key-press\" and\n\"key-release\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Character representation of the key. This is typically as produced\nby XKeysymToString.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_send_key_event" gst_navigation_send_key_event :: + Ptr Navigation -> -- navigation : TInterface (Name {namespace = "GstVideo", name = "Navigation"}) + CString -> -- event : TBasicType TUTF8 + CString -> -- key : TBasicType TUTF8 + IO () + +{- | +/No description available in the introspection data./ +-} +navigationSendKeyEvent :: + (B.CallStack.HasCallStack, MonadIO m, IsNavigation a) => + a + {- ^ /@navigation@/: The navigation interface instance -} + -> T.Text + {- ^ /@event@/: The type of the key event. Recognised values are \"key-press\" and +\"key-release\" -} + -> T.Text + {- ^ /@key@/: Character representation of the key. This is typically as produced +by XKeysymToString. -} + -> m () +navigationSendKeyEvent navigation event key = liftIO $ do + navigation' <- unsafeManagedPtrCastPtr navigation + event' <- textToCString event + key' <- textToCString key + gst_navigation_send_key_event navigation' event' key' + touchManagedPtr navigation + freeMem event' + freeMem key' + return () + +#if ENABLE_OVERLOADING +data NavigationSendKeyEventMethodInfo +instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsNavigation a) => O.MethodInfo NavigationSendKeyEventMethodInfo a signature where + overloadedMethod _ = navigationSendKeyEvent + +#endif + +-- method Navigation::send_mouse_event +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "navigation", argType = TInterface (Name {namespace = "GstVideo", name = "Navigation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The navigation interface instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The type of mouse event, as a text string. Recognised values are\n\"mouse-button-press\", \"mouse-button-release\" and \"mouse-move\".", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "button", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The button number of the button being pressed or released. Pass 0\nfor mouse-move events.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The x coordinate of the mouse event.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The y coordinate of the mouse event.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_send_mouse_event" gst_navigation_send_mouse_event :: + Ptr Navigation -> -- navigation : TInterface (Name {namespace = "GstVideo", name = "Navigation"}) + CString -> -- event : TBasicType TUTF8 + Int32 -> -- button : TBasicType TInt + CDouble -> -- x : TBasicType TDouble + CDouble -> -- y : TBasicType TDouble + IO () + +{- | +Sends a mouse event to the navigation interface. Mouse event coordinates +are sent relative to the display space of the related output area. This is +usually the size in pixels of the window associated with the element +implementing the 'GI.GstVideo.Interfaces.Navigation.Navigation' interface. +-} +navigationSendMouseEvent :: + (B.CallStack.HasCallStack, MonadIO m, IsNavigation a) => + a + {- ^ /@navigation@/: The navigation interface instance -} + -> T.Text + {- ^ /@event@/: The type of mouse event, as a text string. Recognised values are +\"mouse-button-press\", \"mouse-button-release\" and \"mouse-move\". -} + -> Int32 + {- ^ /@button@/: The button number of the button being pressed or released. Pass 0 +for mouse-move events. -} + -> Double + {- ^ /@x@/: The x coordinate of the mouse event. -} + -> Double + {- ^ /@y@/: The y coordinate of the mouse event. -} + -> m () +navigationSendMouseEvent navigation event button x y = liftIO $ do + navigation' <- unsafeManagedPtrCastPtr navigation + event' <- textToCString event + let x' = realToFrac x + let y' = realToFrac y + gst_navigation_send_mouse_event navigation' event' button x' y' + touchManagedPtr navigation + freeMem event' + return () + +#if ENABLE_OVERLOADING +data NavigationSendMouseEventMethodInfo +instance (signature ~ (T.Text -> Int32 -> Double -> Double -> m ()), MonadIO m, IsNavigation a) => O.MethodInfo NavigationSendMouseEventMethodInfo a signature where + overloadedMethod _ = navigationSendMouseEvent + +#endif + +-- method Navigation::event_get_type +-- method type : MemberFunction +-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstEvent to inspect.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "NavigationEventType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_event_get_type" gst_navigation_event_get_type :: + Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) + IO CUInt + +{- | +Inspect a 'GI.Gst.Structs.Event.Event' and return the 'GI.GstVideo.Enums.NavigationEventType' of the event, or +@/GST_NAVIGATION_EVENT_INVALID/@ if the event is not a 'GI.GstVideo.Interfaces.Navigation.Navigation' event. +-} +navigationEventGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Event.Event + {- ^ /@event@/: A 'GI.Gst.Structs.Event.Event' to inspect. -} + -> m GstVideo.Enums.NavigationEventType +navigationEventGetType event = liftIO $ do + event' <- unsafeManagedPtrGetPtr event + result <- gst_navigation_event_get_type event' + let result' = (toEnum . fromIntegral) result + touchManagedPtr event + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::event_parse_command +-- method type : MemberFunction +-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstEvent to inspect.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "command", argType = TInterface (Name {namespace = "GstVideo", name = "NavigationCommand"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to GstNavigationCommand to receive the\n type of the navigation event.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_event_parse_command" gst_navigation_event_parse_command :: + Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) + Ptr CUInt -> -- command : TInterface (Name {namespace = "GstVideo", name = "NavigationCommand"}) + IO CInt + +{- | +Inspect a 'GI.GstVideo.Interfaces.Navigation.Navigation' command event and retrieve the enum value of the +associated command. +-} +navigationEventParseCommand :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Event.Event + {- ^ /@event@/: A 'GI.Gst.Structs.Event.Event' to inspect. -} + -> m ((Bool, GstVideo.Enums.NavigationCommand)) + {- ^ __Returns:__ TRUE if the navigation command could be extracted, otherwise FALSE. -} +navigationEventParseCommand event = liftIO $ do + event' <- unsafeManagedPtrGetPtr event + command <- allocMem :: IO (Ptr CUInt) + result <- gst_navigation_event_parse_command event' command + let result' = (/= 0) result + command' <- peek command + let command'' = (toEnum . fromIntegral) command' + touchManagedPtr event + freeMem command + return (result', command'') + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::event_parse_key_event +-- method type : MemberFunction +-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstEvent to inspect.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to a location to receive\n the string identifying the key press. The returned string is owned by the\n event, and valid only until the event is unreffed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_event_parse_key_event" gst_navigation_event_parse_key_event :: + Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) + Ptr CString -> -- key : TBasicType TUTF8 + IO CInt + +{- | +/No description available in the introspection data./ +-} +navigationEventParseKeyEvent :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Event.Event + {- ^ /@event@/: A 'GI.Gst.Structs.Event.Event' to inspect. -} + -> m ((Bool, T.Text)) +navigationEventParseKeyEvent event = liftIO $ do + event' <- unsafeManagedPtrGetPtr event + key <- allocMem :: IO (Ptr CString) + result <- gst_navigation_event_parse_key_event event' key + let result' = (/= 0) result + key' <- peek key + key'' <- cstringToText key' + touchManagedPtr event + freeMem key + return (result', key'') + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::event_parse_mouse_button_event +-- method type : MemberFunction +-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstEvent to inspect.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "button", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a gint that will receive the button\n number associated with the event.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "x", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a gdouble to receive the x coordinate of the\n mouse button event.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a gdouble to receive the y coordinate of the\n mouse button event.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_event_parse_mouse_button_event" gst_navigation_event_parse_mouse_button_event :: + Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) + Ptr Int32 -> -- button : TBasicType TInt + Ptr CDouble -> -- x : TBasicType TDouble + Ptr CDouble -> -- y : TBasicType TDouble + IO CInt + +{- | +Retrieve the details of either a 'GI.GstVideo.Interfaces.Navigation.Navigation' mouse button press event or +a mouse button release event. Determine which type the event is using +'GI.GstVideo.Functions.navigationEventGetType' to retrieve the 'GI.GstVideo.Enums.NavigationEventType'. +-} +navigationEventParseMouseButtonEvent :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Event.Event + {- ^ /@event@/: A 'GI.Gst.Structs.Event.Event' to inspect. -} + -> m ((Bool, Int32, Double, Double)) + {- ^ __Returns:__ TRUE if the button number and both coordinates could be extracted, + otherwise FALSE. -} +navigationEventParseMouseButtonEvent event = liftIO $ do + event' <- unsafeManagedPtrGetPtr event + button <- allocMem :: IO (Ptr Int32) + x <- allocMem :: IO (Ptr CDouble) + y <- allocMem :: IO (Ptr CDouble) + result <- gst_navigation_event_parse_mouse_button_event event' button x y + let result' = (/= 0) result + button' <- peek button + x' <- peek x + let x'' = realToFrac x' + y' <- peek y + let y'' = realToFrac y' + touchManagedPtr event + freeMem button + freeMem x + freeMem y + return (result', button', x'', y'') + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::event_parse_mouse_move_event +-- method type : MemberFunction +-- Args : [Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstEvent to inspect.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a gdouble to receive the x coordinate of the\n mouse movement.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a gdouble to receive the y coordinate of the\n mouse movement.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_event_parse_mouse_move_event" gst_navigation_event_parse_mouse_move_event :: + Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) + Ptr CDouble -> -- x : TBasicType TDouble + Ptr CDouble -> -- y : TBasicType TDouble + IO CInt + +{- | +Inspect a 'GI.GstVideo.Interfaces.Navigation.Navigation' mouse movement event and extract the coordinates +of the event. +-} +navigationEventParseMouseMoveEvent :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Event.Event + {- ^ /@event@/: A 'GI.Gst.Structs.Event.Event' to inspect. -} + -> m ((Bool, Double, Double)) + {- ^ __Returns:__ TRUE if both coordinates could be extracted, otherwise FALSE. -} +navigationEventParseMouseMoveEvent event = liftIO $ do + event' <- unsafeManagedPtrGetPtr event + x <- allocMem :: IO (Ptr CDouble) + y <- allocMem :: IO (Ptr CDouble) + result <- gst_navigation_event_parse_mouse_move_event event' x y + let result' = (/= 0) result + x' <- peek x + let x'' = realToFrac x' + y' <- peek y + let y'' = realToFrac y' + touchManagedPtr event + freeMem x + freeMem y + return (result', x'', y'') + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::message_get_type +-- method type : MemberFunction +-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gst", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstMessage to inspect.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "NavigationMessageType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_message_get_type" gst_navigation_message_get_type :: + Ptr Gst.Message.Message -> -- message : TInterface (Name {namespace = "Gst", name = "Message"}) + IO CUInt + +{- | +Check a bus message to see if it is a 'GI.GstVideo.Interfaces.Navigation.Navigation' event, and return +the 'GI.GstVideo.Enums.NavigationMessageType' identifying the type of the message if so. +-} +navigationMessageGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Message.Message + {- ^ /@message@/: A 'GI.Gst.Structs.Message.Message' to inspect. -} + -> m GstVideo.Enums.NavigationMessageType + {- ^ __Returns:__ The type of the 'GI.Gst.Structs.Message.Message', or +@/GST_NAVIGATION_MESSAGE_INVALID/@ if the message is not a 'GI.GstVideo.Interfaces.Navigation.Navigation' +notification. -} +navigationMessageGetType message = liftIO $ do + message' <- unsafeManagedPtrGetPtr message + result <- gst_navigation_message_get_type message' + let result' = (toEnum . fromIntegral) result + touchManagedPtr message + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::message_new_angles_changed +-- method type : MemberFunction +-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstObject to set as source of the new message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur_angle", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The currently selected angle.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_angles", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The number of viewing angles now available.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Message"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_message_new_angles_changed" gst_navigation_message_new_angles_changed :: + Ptr Gst.Object.Object -> -- src : TInterface (Name {namespace = "Gst", name = "Object"}) + Word32 -> -- cur_angle : TBasicType TUInt + Word32 -> -- n_angles : TBasicType TUInt + IO (Ptr Gst.Message.Message) + +{- | +Creates a new 'GI.GstVideo.Interfaces.Navigation.Navigation' message with type +@/GST_NAVIGATION_MESSAGE_ANGLES_CHANGED/@ for notifying an application +that the current angle, or current number of angles available in a +multiangle video has changed. +-} +navigationMessageNewAnglesChanged :: + (B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) => + a + {- ^ /@src@/: A 'GI.Gst.Objects.Object.Object' to set as source of the new message. -} + -> Word32 + {- ^ /@curAngle@/: The currently selected angle. -} + -> Word32 + {- ^ /@nAngles@/: The number of viewing angles now available. -} + -> m Gst.Message.Message + {- ^ __Returns:__ The new 'GI.Gst.Structs.Message.Message'. -} +navigationMessageNewAnglesChanged src curAngle nAngles = liftIO $ do + src' <- unsafeManagedPtrCastPtr src + result <- gst_navigation_message_new_angles_changed src' curAngle nAngles + checkUnexpectedReturnNULL "navigationMessageNewAnglesChanged" result + result' <- (wrapBoxed Gst.Message.Message) result + touchManagedPtr src + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::message_new_commands_changed +-- method type : MemberFunction +-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstObject to set as source of the new message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Message"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_message_new_commands_changed" gst_navigation_message_new_commands_changed :: + Ptr Gst.Object.Object -> -- src : TInterface (Name {namespace = "Gst", name = "Object"}) + IO (Ptr Gst.Message.Message) + +{- | +Creates a new 'GI.GstVideo.Interfaces.Navigation.Navigation' message with type +@/GST_NAVIGATION_MESSAGE_COMMANDS_CHANGED/@ +-} +navigationMessageNewCommandsChanged :: + (B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) => + a + {- ^ /@src@/: A 'GI.Gst.Objects.Object.Object' to set as source of the new message. -} + -> m Gst.Message.Message + {- ^ __Returns:__ The new 'GI.Gst.Structs.Message.Message'. -} +navigationMessageNewCommandsChanged src = liftIO $ do + src' <- unsafeManagedPtrCastPtr src + result <- gst_navigation_message_new_commands_changed src' + checkUnexpectedReturnNULL "navigationMessageNewCommandsChanged" result + result' <- (wrapBoxed Gst.Message.Message) result + touchManagedPtr src + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::message_new_event +-- method type : MemberFunction +-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstObject to set as source of the new message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A navigation #GstEvent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Message"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_message_new_event" gst_navigation_message_new_event :: + Ptr Gst.Object.Object -> -- src : TInterface (Name {namespace = "Gst", name = "Object"}) + Ptr Gst.Event.Event -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) + IO (Ptr Gst.Message.Message) + +{- | +Creates a new 'GI.GstVideo.Interfaces.Navigation.Navigation' message with type +@/GST_NAVIGATION_MESSAGE_EVENT/@. + +/Since: 1.6/ +-} +navigationMessageNewEvent :: + (B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) => + a + {- ^ /@src@/: A 'GI.Gst.Objects.Object.Object' to set as source of the new message. -} + -> Gst.Event.Event + {- ^ /@event@/: A navigation 'GI.Gst.Structs.Event.Event' -} + -> m Gst.Message.Message + {- ^ __Returns:__ The new 'GI.Gst.Structs.Message.Message'. -} +navigationMessageNewEvent src event = liftIO $ do + src' <- unsafeManagedPtrCastPtr src + event' <- unsafeManagedPtrGetPtr event + result <- gst_navigation_message_new_event src' event' + checkUnexpectedReturnNULL "navigationMessageNewEvent" result + result' <- (wrapBoxed Gst.Message.Message) result + touchManagedPtr src + touchManagedPtr event + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::message_new_mouse_over +-- method type : MemberFunction +-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "Gst", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstObject to set as source of the new message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the mouse has entered a clickable area of the display.\n%FALSE if it over a non-clickable area.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Message"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_message_new_mouse_over" gst_navigation_message_new_mouse_over :: + Ptr Gst.Object.Object -> -- src : TInterface (Name {namespace = "Gst", name = "Object"}) + CInt -> -- active : TBasicType TBoolean + IO (Ptr Gst.Message.Message) + +{- | +Creates a new 'GI.GstVideo.Interfaces.Navigation.Navigation' message with type +@/GST_NAVIGATION_MESSAGE_MOUSE_OVER/@. +-} +navigationMessageNewMouseOver :: + (B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) => + a + {- ^ /@src@/: A 'GI.Gst.Objects.Object.Object' to set as source of the new message. -} + -> Bool + {- ^ /@active@/: 'True' if the mouse has entered a clickable area of the display. +'False' if it over a non-clickable area. -} + -> m Gst.Message.Message + {- ^ __Returns:__ The new 'GI.Gst.Structs.Message.Message'. -} +navigationMessageNewMouseOver src active = liftIO $ do + src' <- unsafeManagedPtrCastPtr src + let active' = (fromIntegral . fromEnum) active + result <- gst_navigation_message_new_mouse_over src' active' + checkUnexpectedReturnNULL "navigationMessageNewMouseOver" result + result' <- (wrapBoxed Gst.Message.Message) result + touchManagedPtr src + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::message_parse_angles_changed +-- method type : MemberFunction +-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gst", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstMessage to inspect.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur_angle", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to a #guint to receive the new\n current angle number, or NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "n_angles", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to a #guint to receive the new angle\n count, or NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_message_parse_angles_changed" gst_navigation_message_parse_angles_changed :: + Ptr Gst.Message.Message -> -- message : TInterface (Name {namespace = "Gst", name = "Message"}) + Ptr Word32 -> -- cur_angle : TBasicType TUInt + Ptr Word32 -> -- n_angles : TBasicType TUInt + IO CInt + +{- | +Parse a 'GI.GstVideo.Interfaces.Navigation.Navigation' message of type GST_NAVIGATION_MESSAGE_ANGLES_CHANGED +and extract the /@curAngle@/ and /@nAngles@/ parameters. +-} +navigationMessageParseAnglesChanged :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Message.Message + {- ^ /@message@/: A 'GI.Gst.Structs.Message.Message' to inspect. -} + -> m ((Bool, Word32, Word32)) + {- ^ __Returns:__ 'True' if the message could be successfully parsed. 'False' if not. -} +navigationMessageParseAnglesChanged message = liftIO $ do + message' <- unsafeManagedPtrGetPtr message + curAngle <- allocMem :: IO (Ptr Word32) + nAngles <- allocMem :: IO (Ptr Word32) + result <- gst_navigation_message_parse_angles_changed message' curAngle nAngles + let result' = (/= 0) result + curAngle' <- peek curAngle + nAngles' <- peek nAngles + touchManagedPtr message + freeMem curAngle + freeMem nAngles + return (result', curAngle', nAngles') + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::message_parse_event +-- method type : MemberFunction +-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gst", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstMessage to inspect.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gst", name = "Event"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GstEvent to receive\n the contained navigation event.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_message_parse_event" gst_navigation_message_parse_event :: + Ptr Gst.Message.Message -> -- message : TInterface (Name {namespace = "Gst", name = "Message"}) + Ptr (Ptr Gst.Event.Event) -> -- event : TInterface (Name {namespace = "Gst", name = "Event"}) + IO CInt + +{- | +Parse a 'GI.GstVideo.Interfaces.Navigation.Navigation' message of type @/GST_NAVIGATION_MESSAGE_EVENT/@ +and extract contained 'GI.Gst.Structs.Event.Event'. The caller must unref the /@event@/ when done +with it. + +/Since: 1.6/ +-} +navigationMessageParseEvent :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Message.Message + {- ^ /@message@/: A 'GI.Gst.Structs.Message.Message' to inspect. -} + -> m ((Bool, Gst.Event.Event)) + {- ^ __Returns:__ 'True' if the message could be successfully parsed. 'False' if not. -} +navigationMessageParseEvent message = liftIO $ do + message' <- unsafeManagedPtrGetPtr message + event <- allocMem :: IO (Ptr (Ptr Gst.Event.Event)) + result <- gst_navigation_message_parse_event message' event + let result' = (/= 0) result + event' <- peek event + event'' <- (wrapBoxed Gst.Event.Event) event' + touchManagedPtr message + freeMem event + return (result', event'') + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::message_parse_mouse_over +-- method type : MemberFunction +-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gst", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstMessage to inspect.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to a gboolean to receive the\n active/inactive state, or NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_message_parse_mouse_over" gst_navigation_message_parse_mouse_over :: + Ptr Gst.Message.Message -> -- message : TInterface (Name {namespace = "Gst", name = "Message"}) + Ptr CInt -> -- active : TBasicType TBoolean + IO CInt + +{- | +Parse a 'GI.GstVideo.Interfaces.Navigation.Navigation' message of type @/GST_NAVIGATION_MESSAGE_MOUSE_OVER/@ +and extract the active\/inactive flag. If the mouse over event is marked +active, it indicates that the mouse is over a clickable area. +-} +navigationMessageParseMouseOver :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Message.Message + {- ^ /@message@/: A 'GI.Gst.Structs.Message.Message' to inspect. -} + -> m ((Bool, Bool)) + {- ^ __Returns:__ 'True' if the message could be successfully parsed. 'False' if not. -} +navigationMessageParseMouseOver message = liftIO $ do + message' <- unsafeManagedPtrGetPtr message + active <- allocMem :: IO (Ptr CInt) + result <- gst_navigation_message_parse_mouse_over message' active + let result' = (/= 0) result + active' <- peek active + let active'' = (/= 0) active' + touchManagedPtr message + freeMem active + return (result', active'') + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::query_get_type +-- method type : MemberFunction +-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The query to inspect", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "NavigationQueryType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_query_get_type" gst_navigation_query_get_type :: + Ptr Gst.Query.Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"}) + IO CUInt + +{- | +Inspect a 'GI.Gst.Structs.Query.Query' and return the 'GI.GstVideo.Enums.NavigationQueryType' associated with +it if it is a 'GI.GstVideo.Interfaces.Navigation.Navigation' query. +-} +navigationQueryGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Query.Query + {- ^ /@query@/: The query to inspect -} + -> m GstVideo.Enums.NavigationQueryType + {- ^ __Returns:__ The 'GI.GstVideo.Enums.NavigationQueryType' of the query, or +@/GST_NAVIGATION_QUERY_INVALID/@ -} +navigationQueryGetType query = liftIO $ do + query' <- unsafeManagedPtrGetPtr query + result <- gst_navigation_query_get_type query' + let result' = (toEnum . fromIntegral) result + touchManagedPtr query + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::query_new_angles +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_query_new_angles" gst_navigation_query_new_angles :: + IO (Ptr Gst.Query.Query) + +{- | +Create a new 'GI.GstVideo.Interfaces.Navigation.Navigation' angles query. When executed, it will +query the pipeline for the set of currently available angles, which may be +greater than one in a multiangle video. +-} +navigationQueryNewAngles :: + (B.CallStack.HasCallStack, MonadIO m) => + m Gst.Query.Query + {- ^ __Returns:__ The new query. -} +navigationQueryNewAngles = liftIO $ do + result <- gst_navigation_query_new_angles + checkUnexpectedReturnNULL "navigationQueryNewAngles" result + result' <- (wrapBoxed Gst.Query.Query) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::query_new_commands +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Query"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_query_new_commands" gst_navigation_query_new_commands :: + IO (Ptr Gst.Query.Query) + +{- | +Create a new 'GI.GstVideo.Interfaces.Navigation.Navigation' commands query. When executed, it will +query the pipeline for the set of currently available commands. +-} +navigationQueryNewCommands :: + (B.CallStack.HasCallStack, MonadIO m) => + m Gst.Query.Query + {- ^ __Returns:__ The new query. -} +navigationQueryNewCommands = liftIO $ do + result <- gst_navigation_query_new_commands + checkUnexpectedReturnNULL "navigationQueryNewCommands" result + result' <- (wrapBoxed Gst.Query.Query) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::query_parse_angles +-- method type : MemberFunction +-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur_angle", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a #guint into which to store the\n currently selected angle value from the query, or NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "n_angles", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to a #guint into which to store the\n number of angles value from the query, or NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_query_parse_angles" gst_navigation_query_parse_angles :: + Ptr Gst.Query.Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"}) + Ptr Word32 -> -- cur_angle : TBasicType TUInt + Ptr Word32 -> -- n_angles : TBasicType TUInt + IO CInt + +{- | +Parse the current angle number in the 'GI.GstVideo.Interfaces.Navigation.Navigation' angles /@query@/ into the +@/guint/@ pointed to by the /@curAngle@/ variable, and the number of available +angles into the @/guint/@ pointed to by the /@nAngles@/ variable. +-} +navigationQueryParseAngles :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Query.Query + {- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -} + -> m ((Bool, Word32, Word32)) + {- ^ __Returns:__ 'True' if the query could be successfully parsed. 'False' if not. -} +navigationQueryParseAngles query = liftIO $ do + query' <- unsafeManagedPtrGetPtr query + curAngle <- allocMem :: IO (Ptr Word32) + nAngles <- allocMem :: IO (Ptr Word32) + result <- gst_navigation_query_parse_angles query' curAngle nAngles + let result' = (/= 0) result + curAngle' <- peek curAngle + nAngles' <- peek nAngles + touchManagedPtr query + freeMem curAngle + freeMem nAngles + return (result', curAngle', nAngles') + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::query_parse_commands_length +-- method type : MemberFunction +-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_cmds", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of commands in this query.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_query_parse_commands_length" gst_navigation_query_parse_commands_length :: + Ptr Gst.Query.Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"}) + Ptr Word32 -> -- n_cmds : TBasicType TUInt + IO CInt + +{- | +Parse the number of commands in the 'GI.GstVideo.Interfaces.Navigation.Navigation' commands /@query@/. +-} +navigationQueryParseCommandsLength :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Query.Query + {- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -} + -> m ((Bool, Word32)) + {- ^ __Returns:__ 'True' if the query could be successfully parsed. 'False' if not. -} +navigationQueryParseCommandsLength query = liftIO $ do + 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') + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::query_parse_commands_nth +-- method type : MemberFunction +-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nth", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the nth command to retrieve.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cmd", argType = TInterface (Name {namespace = "GstVideo", name = "NavigationCommand"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to store the nth command into.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_query_parse_commands_nth" gst_navigation_query_parse_commands_nth :: + Ptr Gst.Query.Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"}) + Word32 -> -- nth : TBasicType TUInt + Ptr CUInt -> -- cmd : TInterface (Name {namespace = "GstVideo", name = "NavigationCommand"}) + IO CInt + +{- | +Parse the 'GI.GstVideo.Interfaces.Navigation.Navigation' command query and retrieve the /@nth@/ command from +it into /@cmd@/. If the list contains less elements than /@nth@/, /@cmd@/ will be +set to @/GST_NAVIGATION_COMMAND_INVALID/@. +-} +navigationQueryParseCommandsNth :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Query.Query + {- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -} + -> Word32 + {- ^ /@nth@/: the nth command to retrieve. -} + -> m ((Bool, GstVideo.Enums.NavigationCommand)) + {- ^ __Returns:__ 'True' if the query could be successfully parsed. 'False' if not. -} +navigationQueryParseCommandsNth query nth = liftIO $ do + 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'') + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::query_set_angles +-- method type : MemberFunction +-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur_angle", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the current viewing angle to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_angles", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of viewing angles to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_query_set_angles" gst_navigation_query_set_angles :: + Ptr Gst.Query.Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"}) + Word32 -> -- cur_angle : TBasicType TUInt + Word32 -> -- n_angles : TBasicType TUInt + IO () + +{- | +Set the 'GI.GstVideo.Interfaces.Navigation.Navigation' angles query result field in /@query@/. +-} +navigationQuerySetAngles :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Query.Query + {- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -} + -> Word32 + {- ^ /@curAngle@/: the current viewing angle to set. -} + -> Word32 + {- ^ /@nAngles@/: the number of viewing angles to set. -} + -> m () +navigationQuerySetAngles query curAngle nAngles = liftIO $ do + query' <- unsafeManagedPtrGetPtr query + gst_navigation_query_set_angles query' curAngle nAngles + touchManagedPtr query + return () + +#if ENABLE_OVERLOADING +#endif + +-- method Navigation::query_set_commandsv +-- method type : MemberFunction +-- Args : [Arg {argCName = "query", argType = TInterface (Name {namespace = "Gst", name = "Query"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstQuery", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_cmds", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of commands to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cmds", argType = TCArray False (-1) 1 (TInterface (Name {namespace = "GstVideo", name = "NavigationCommand"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An array containing @n_cmds\n @GstNavigationCommand values.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "n_cmds", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of commands to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_navigation_query_set_commandsv" gst_navigation_query_set_commandsv :: + Ptr Gst.Query.Query -> -- query : TInterface (Name {namespace = "Gst", name = "Query"}) + Int32 -> -- n_cmds : TBasicType TInt + Ptr CUInt -> -- cmds : TCArray False (-1) 1 (TInterface (Name {namespace = "GstVideo", name = "NavigationCommand"})) + IO () + +{- | +Set the 'GI.GstVideo.Interfaces.Navigation.Navigation' command query result fields in /@query@/. The number +of commands passed must be equal to /@nCommands@/. +-} +navigationQuerySetCommandsv :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Query.Query + {- ^ /@query@/: a 'GI.Gst.Structs.Query.Query' -} + -> [GstVideo.Enums.NavigationCommand] + {- ^ /@cmds@/: An array containing /@nCmds@/ + /@gstNavigationCommand@/ values. -} + -> m () +navigationQuerySetCommandsv query cmds = liftIO $ do + let nCmds = fromIntegral $ length cmds + query' <- unsafeManagedPtrGetPtr query + let cmds' = map (fromIntegral . fromEnum) cmds + cmds'' <- packStorableArray cmds' + gst_navigation_query_set_commandsv query' nCmds cmds'' + touchManagedPtr query + freeMem cmds'' + return () + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GstVideo/Interfaces/Navigation.hs-boot b/GI/GstVideo/Interfaces/Navigation.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Interfaces/Navigation.hs-boot @@ -0,0 +1,39 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Interfaces.Navigation where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Navigation = Navigation (ManagedPtr Navigation) +class ManagedPtrNewtype a => IsNavigation a +instance WrappedPtr Navigation where +#if ENABLE_OVERLOADING +data NavigationSendCommandMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationSendEventMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationSendKeyEventMethodInfo +#endif +#if ENABLE_OVERLOADING +data NavigationSendMouseEventMethodInfo +#endif diff --git a/GI/GstVideo/Interfaces/VideoDirection.hs b/GI/GstVideo/Interfaces/VideoDirection.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Interfaces/VideoDirection.hs @@ -0,0 +1,194 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +The interface allows unified access to control flipping and rotation +operations of video-sources or operators. + +/Since: 1.10/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Interfaces.VideoDirection + ( + +-- * Exported types + VideoDirection(..) , + noVideoDirection , + IsVideoDirection , + toVideoDirection , + + + -- * Properties +-- ** videoDirection #attr:videoDirection# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + VideoDirectionVideoDirectionPropertyInfo, +#endif + constructVideoDirectionVideoDirection , + getVideoDirectionVideoDirection , + setVideoDirectionVideoDirection , +#if ENABLE_OVERLOADING + videoDirectionVideoDirection , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums + +-- interface VideoDirection +-- | Memory-managed wrapper type. +newtype VideoDirection = VideoDirection (ManagedPtr VideoDirection) +-- | A convenience alias for `Nothing` :: `Maybe` `VideoDirection`. +noVideoDirection :: Maybe VideoDirection +noVideoDirection = Nothing + +#if ENABLE_OVERLOADING +type instance O.SignalList VideoDirection = VideoDirectionSignalList +type VideoDirectionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +foreign import ccall "gst_video_direction_get_type" + c_gst_video_direction_get_type :: IO GType + +instance GObject VideoDirection where + gobjectType = c_gst_video_direction_get_type + + +-- | Type class for types which can be safely cast to `VideoDirection`, for instance with `toVideoDirection`. +class (GObject o, O.IsDescendantOf VideoDirection o) => IsVideoDirection o +instance (GObject o, O.IsDescendantOf VideoDirection o) => IsVideoDirection o + +instance O.HasParentTypes VideoDirection +type instance O.ParentTypes VideoDirection = '[GObject.Object.Object] + +-- | Cast to `VideoDirection`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toVideoDirection :: (MonadIO m, IsVideoDirection o) => o -> m VideoDirection +toVideoDirection = liftIO . unsafeCastTo VideoDirection + +-- VVV Prop "video-direction" + -- Type: TInterface (Name {namespace = "GstVideo", name = "VideoOrientationMethod"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@video-direction@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoDirection #videoDirection +@ +-} +getVideoDirectionVideoDirection :: (MonadIO m, IsVideoDirection o) => o -> m GstVideo.Enums.VideoOrientationMethod +getVideoDirectionVideoDirection obj = liftIO $ B.Properties.getObjectPropertyEnum obj "video-direction" + +{- | +Set the value of the “@video-direction@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoDirection [ #videoDirection 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoDirectionVideoDirection :: (MonadIO m, IsVideoDirection o) => o -> GstVideo.Enums.VideoOrientationMethod -> m () +setVideoDirectionVideoDirection obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "video-direction" val + +{- | +Construct a `GValueConstruct` with valid value for the “@video-direction@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructVideoDirectionVideoDirection :: (IsVideoDirection o) => GstVideo.Enums.VideoOrientationMethod -> IO (GValueConstruct o) +constructVideoDirectionVideoDirection val = B.Properties.constructObjectPropertyEnum "video-direction" val + +#if ENABLE_OVERLOADING +data VideoDirectionVideoDirectionPropertyInfo +instance AttrInfo VideoDirectionVideoDirectionPropertyInfo where + type AttrAllowedOps VideoDirectionVideoDirectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint VideoDirectionVideoDirectionPropertyInfo = (~) GstVideo.Enums.VideoOrientationMethod + type AttrBaseTypeConstraint VideoDirectionVideoDirectionPropertyInfo = IsVideoDirection + type AttrGetType VideoDirectionVideoDirectionPropertyInfo = GstVideo.Enums.VideoOrientationMethod + type AttrLabel VideoDirectionVideoDirectionPropertyInfo = "video-direction" + type AttrOrigin VideoDirectionVideoDirectionPropertyInfo = VideoDirection + attrGet _ = getVideoDirectionVideoDirection + attrSet _ = setVideoDirectionVideoDirection + attrConstruct _ = constructVideoDirectionVideoDirection + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoDirection +type instance O.AttributeList VideoDirection = VideoDirectionAttributeList +type VideoDirectionAttributeList = ('[ '("videoDirection", VideoDirectionVideoDirectionPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +videoDirectionVideoDirection :: AttrLabelProxy "videoDirection" +videoDirectionVideoDirection = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoDirectionMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoDirectionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveVideoDirectionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveVideoDirectionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveVideoDirectionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveVideoDirectionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveVideoDirectionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveVideoDirectionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveVideoDirectionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveVideoDirectionMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveVideoDirectionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveVideoDirectionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveVideoDirectionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveVideoDirectionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveVideoDirectionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveVideoDirectionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveVideoDirectionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveVideoDirectionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveVideoDirectionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveVideoDirectionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveVideoDirectionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveVideoDirectionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveVideoDirectionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoDirectionMethod t VideoDirection, O.MethodInfo info VideoDirection p) => OL.IsLabel t (VideoDirection -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Interfaces/VideoDirection.hs-boot b/GI/GstVideo/Interfaces/VideoDirection.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Interfaces/VideoDirection.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Interfaces.VideoDirection where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoDirection = VideoDirection (ManagedPtr VideoDirection) +instance GObject VideoDirection where +class (GObject o, O.IsDescendantOf VideoDirection o) => IsVideoDirection o +instance (GObject o, O.IsDescendantOf VideoDirection o) => IsVideoDirection o +instance O.HasParentTypes VideoDirection +#if ENABLE_OVERLOADING +data VideoDirectionVideoDirectionPropertyInfo +#endif diff --git a/GI/GstVideo/Interfaces/VideoOrientation.hs b/GI/GstVideo/Interfaces/VideoOrientation.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Interfaces/VideoOrientation.hs @@ -0,0 +1,470 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +The interface allows unified access to control flipping and autocenter +operation of video-sources or operators. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Interfaces.VideoOrientation + ( + +-- * Exported types + VideoOrientation(..) , + noVideoOrientation , + IsVideoOrientation , + + + -- * Methods +-- ** getHcenter #method:getHcenter# + +#if ENABLE_OVERLOADING + VideoOrientationGetHcenterMethodInfo , +#endif + videoOrientationGetHcenter , + + +-- ** getHflip #method:getHflip# + +#if ENABLE_OVERLOADING + VideoOrientationGetHflipMethodInfo , +#endif + videoOrientationGetHflip , + + +-- ** getVcenter #method:getVcenter# + +#if ENABLE_OVERLOADING + VideoOrientationGetVcenterMethodInfo , +#endif + videoOrientationGetVcenter , + + +-- ** getVflip #method:getVflip# + +#if ENABLE_OVERLOADING + VideoOrientationGetVflipMethodInfo , +#endif + videoOrientationGetVflip , + + +-- ** setHcenter #method:setHcenter# + +#if ENABLE_OVERLOADING + VideoOrientationSetHcenterMethodInfo , +#endif + videoOrientationSetHcenter , + + +-- ** setHflip #method:setHflip# + +#if ENABLE_OVERLOADING + VideoOrientationSetHflipMethodInfo , +#endif + videoOrientationSetHflip , + + +-- ** setVcenter #method:setVcenter# + +#if ENABLE_OVERLOADING + VideoOrientationSetVcenterMethodInfo , +#endif + videoOrientationSetVcenter , + + +-- ** setVflip #method:setVflip# + +#if ENABLE_OVERLOADING + VideoOrientationSetVflipMethodInfo , +#endif + videoOrientationSetVflip , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- interface VideoOrientation +-- | Memory-managed wrapper type. +newtype VideoOrientation = VideoOrientation (ManagedPtr VideoOrientation) +-- | A convenience alias for `Nothing` :: `Maybe` `VideoOrientation`. +noVideoOrientation :: Maybe VideoOrientation +noVideoOrientation = Nothing + +#if ENABLE_OVERLOADING +type instance O.SignalList VideoOrientation = VideoOrientationSignalList +type VideoOrientationSignalList = ('[ ] :: [(Symbol, *)]) + +#endif + +-- | Type class for types which implement `VideoOrientation`. +class ManagedPtrNewtype a => IsVideoOrientation a +instance IsVideoOrientation VideoOrientation +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr VideoOrientation where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + + +#if ENABLE_OVERLOADING +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 = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoOrientationMethod t VideoOrientation, O.MethodInfo info VideoOrientation p) => OL.IsLabel t (VideoOrientation -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- method VideoOrientation::get_hcenter +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "video_orientation", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoOrientation interface of a #GstElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "center", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_orientation_get_hcenter" gst_video_orientation_get_hcenter :: + Ptr VideoOrientation -> -- video_orientation : TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}) + Ptr Int32 -> -- center : TBasicType TInt + IO CInt + +{- | +Get the horizontal centering offset from the given object. +-} +videoOrientationGetHcenter :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOrientation a) => + a + {- ^ /@videoOrientation@/: 'GI.GstVideo.Interfaces.VideoOrientation.VideoOrientation' interface of a 'GI.Gst.Objects.Element.Element' -} + -> m ((Bool, Int32)) + {- ^ __Returns:__ 'True' in case the element supports centering -} +videoOrientationGetHcenter videoOrientation = liftIO $ do + videoOrientation' <- unsafeManagedPtrCastPtr videoOrientation + center <- allocMem :: IO (Ptr Int32) + result <- gst_video_orientation_get_hcenter videoOrientation' center + let result' = (/= 0) result + center' <- peek center + touchManagedPtr videoOrientation + freeMem center + return (result', center') + +#if ENABLE_OVERLOADING +data VideoOrientationGetHcenterMethodInfo +instance (signature ~ (m ((Bool, Int32))), MonadIO m, IsVideoOrientation a) => O.MethodInfo VideoOrientationGetHcenterMethodInfo a signature where + overloadedMethod _ = videoOrientationGetHcenter + +#endif + +-- method VideoOrientation::get_hflip +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "video_orientation", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoOrientation interface of a #GstElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flip", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_orientation_get_hflip" gst_video_orientation_get_hflip :: + Ptr VideoOrientation -> -- video_orientation : TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}) + Ptr CInt -> -- flip : TBasicType TBoolean + IO CInt + +{- | +Get the horizontal flipping state ('True' for flipped) from the given object. +-} +videoOrientationGetHflip :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOrientation a) => + a + {- ^ /@videoOrientation@/: 'GI.GstVideo.Interfaces.VideoOrientation.VideoOrientation' interface of a 'GI.Gst.Objects.Element.Element' -} + -> m ((Bool, Bool)) + {- ^ __Returns:__ 'True' in case the element supports flipping -} +videoOrientationGetHflip videoOrientation = liftIO $ do + videoOrientation' <- unsafeManagedPtrCastPtr videoOrientation + flip <- allocMem :: IO (Ptr CInt) + result <- gst_video_orientation_get_hflip videoOrientation' flip + let result' = (/= 0) result + flip' <- peek flip + let flip'' = (/= 0) flip' + touchManagedPtr videoOrientation + freeMem flip + return (result', flip'') + +#if ENABLE_OVERLOADING +data VideoOrientationGetHflipMethodInfo +instance (signature ~ (m ((Bool, Bool))), MonadIO m, IsVideoOrientation a) => O.MethodInfo VideoOrientationGetHflipMethodInfo a signature where + overloadedMethod _ = videoOrientationGetHflip + +#endif + +-- method VideoOrientation::get_vcenter +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "video_orientation", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoOrientation interface of a #GstElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "center", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_orientation_get_vcenter" gst_video_orientation_get_vcenter :: + Ptr VideoOrientation -> -- video_orientation : TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}) + Ptr Int32 -> -- center : TBasicType TInt + IO CInt + +{- | +Get the vertical centering offset from the given object. +-} +videoOrientationGetVcenter :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOrientation a) => + a + {- ^ /@videoOrientation@/: 'GI.GstVideo.Interfaces.VideoOrientation.VideoOrientation' interface of a 'GI.Gst.Objects.Element.Element' -} + -> m ((Bool, Int32)) + {- ^ __Returns:__ 'True' in case the element supports centering -} +videoOrientationGetVcenter videoOrientation = liftIO $ do + videoOrientation' <- unsafeManagedPtrCastPtr videoOrientation + center <- allocMem :: IO (Ptr Int32) + result <- gst_video_orientation_get_vcenter videoOrientation' center + let result' = (/= 0) result + center' <- peek center + touchManagedPtr videoOrientation + freeMem center + return (result', center') + +#if ENABLE_OVERLOADING +data VideoOrientationGetVcenterMethodInfo +instance (signature ~ (m ((Bool, Int32))), MonadIO m, IsVideoOrientation a) => O.MethodInfo VideoOrientationGetVcenterMethodInfo a signature where + overloadedMethod _ = videoOrientationGetVcenter + +#endif + +-- method VideoOrientation::get_vflip +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "video_orientation", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoOrientation interface of a #GstElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flip", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_orientation_get_vflip" gst_video_orientation_get_vflip :: + Ptr VideoOrientation -> -- video_orientation : TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}) + Ptr CInt -> -- flip : TBasicType TBoolean + IO CInt + +{- | +Get the vertical flipping state ('True' for flipped) from the given object. +-} +videoOrientationGetVflip :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOrientation a) => + a + {- ^ /@videoOrientation@/: 'GI.GstVideo.Interfaces.VideoOrientation.VideoOrientation' interface of a 'GI.Gst.Objects.Element.Element' -} + -> m ((Bool, Bool)) + {- ^ __Returns:__ 'True' in case the element supports flipping -} +videoOrientationGetVflip videoOrientation = liftIO $ do + videoOrientation' <- unsafeManagedPtrCastPtr videoOrientation + flip <- allocMem :: IO (Ptr CInt) + result <- gst_video_orientation_get_vflip videoOrientation' flip + let result' = (/= 0) result + flip' <- peek flip + let flip'' = (/= 0) flip' + touchManagedPtr videoOrientation + freeMem flip + return (result', flip'') + +#if ENABLE_OVERLOADING +data VideoOrientationGetVflipMethodInfo +instance (signature ~ (m ((Bool, Bool))), MonadIO m, IsVideoOrientation a) => O.MethodInfo VideoOrientationGetVflipMethodInfo a signature where + overloadedMethod _ = videoOrientationGetVflip + +#endif + +-- method VideoOrientation::set_hcenter +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "video_orientation", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoOrientation interface of a #GstElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "center", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "centering offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_orientation_set_hcenter" gst_video_orientation_set_hcenter :: + Ptr VideoOrientation -> -- video_orientation : TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}) + Int32 -> -- center : TBasicType TInt + IO CInt + +{- | +Set the horizontal centering offset for the given object. +-} +videoOrientationSetHcenter :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOrientation a) => + a + {- ^ /@videoOrientation@/: 'GI.GstVideo.Interfaces.VideoOrientation.VideoOrientation' interface of a 'GI.Gst.Objects.Element.Element' -} + -> Int32 + {- ^ /@center@/: centering offset -} + -> m Bool + {- ^ __Returns:__ 'True' in case the element supports centering -} +videoOrientationSetHcenter videoOrientation center = liftIO $ do + videoOrientation' <- unsafeManagedPtrCastPtr videoOrientation + result <- gst_video_orientation_set_hcenter videoOrientation' center + let result' = (/= 0) result + touchManagedPtr videoOrientation + return result' + +#if ENABLE_OVERLOADING +data VideoOrientationSetHcenterMethodInfo +instance (signature ~ (Int32 -> m Bool), MonadIO m, IsVideoOrientation a) => O.MethodInfo VideoOrientationSetHcenterMethodInfo a signature where + overloadedMethod _ = videoOrientationSetHcenter + +#endif + +-- method VideoOrientation::set_hflip +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "video_orientation", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoOrientation interface of a #GstElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flip", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "use flipping", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_orientation_set_hflip" gst_video_orientation_set_hflip :: + Ptr VideoOrientation -> -- video_orientation : TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}) + CInt -> -- flip : TBasicType TBoolean + IO CInt + +{- | +Set the horizontal flipping state ('True' for flipped) for the given object. +-} +videoOrientationSetHflip :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOrientation a) => + a + {- ^ /@videoOrientation@/: 'GI.GstVideo.Interfaces.VideoOrientation.VideoOrientation' interface of a 'GI.Gst.Objects.Element.Element' -} + -> Bool + {- ^ /@flip@/: use flipping -} + -> m Bool + {- ^ __Returns:__ 'True' in case the element supports flipping -} +videoOrientationSetHflip videoOrientation flip = liftIO $ do + videoOrientation' <- unsafeManagedPtrCastPtr videoOrientation + let flip' = (fromIntegral . fromEnum) flip + result <- gst_video_orientation_set_hflip videoOrientation' flip' + let result' = (/= 0) result + touchManagedPtr videoOrientation + return result' + +#if ENABLE_OVERLOADING +data VideoOrientationSetHflipMethodInfo +instance (signature ~ (Bool -> m Bool), MonadIO m, IsVideoOrientation a) => O.MethodInfo VideoOrientationSetHflipMethodInfo a signature where + overloadedMethod _ = videoOrientationSetHflip + +#endif + +-- method VideoOrientation::set_vcenter +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "video_orientation", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoOrientation interface of a #GstElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "center", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "centering offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_orientation_set_vcenter" gst_video_orientation_set_vcenter :: + Ptr VideoOrientation -> -- video_orientation : TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}) + Int32 -> -- center : TBasicType TInt + IO CInt + +{- | +Set the vertical centering offset for the given object. +-} +videoOrientationSetVcenter :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOrientation a) => + a + {- ^ /@videoOrientation@/: 'GI.GstVideo.Interfaces.VideoOrientation.VideoOrientation' interface of a 'GI.Gst.Objects.Element.Element' -} + -> Int32 + {- ^ /@center@/: centering offset -} + -> m Bool + {- ^ __Returns:__ 'True' in case the element supports centering -} +videoOrientationSetVcenter videoOrientation center = liftIO $ do + videoOrientation' <- unsafeManagedPtrCastPtr videoOrientation + result <- gst_video_orientation_set_vcenter videoOrientation' center + let result' = (/= 0) result + touchManagedPtr videoOrientation + return result' + +#if ENABLE_OVERLOADING +data VideoOrientationSetVcenterMethodInfo +instance (signature ~ (Int32 -> m Bool), MonadIO m, IsVideoOrientation a) => O.MethodInfo VideoOrientationSetVcenterMethodInfo a signature where + overloadedMethod _ = videoOrientationSetVcenter + +#endif + +-- method VideoOrientation::set_vflip +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "video_orientation", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoOrientation interface of a #GstElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flip", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "use flipping", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_orientation_set_vflip" gst_video_orientation_set_vflip :: + Ptr VideoOrientation -> -- video_orientation : TInterface (Name {namespace = "GstVideo", name = "VideoOrientation"}) + CInt -> -- flip : TBasicType TBoolean + IO CInt + +{- | +Set the vertical flipping state ('True' for flipped) for the given object. +-} +videoOrientationSetVflip :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOrientation a) => + a + {- ^ /@videoOrientation@/: 'GI.GstVideo.Interfaces.VideoOrientation.VideoOrientation' interface of a 'GI.Gst.Objects.Element.Element' -} + -> Bool + {- ^ /@flip@/: use flipping -} + -> m Bool + {- ^ __Returns:__ 'True' in case the element supports flipping -} +videoOrientationSetVflip videoOrientation flip = liftIO $ do + videoOrientation' <- unsafeManagedPtrCastPtr videoOrientation + let flip' = (fromIntegral . fromEnum) flip + result <- gst_video_orientation_set_vflip videoOrientation' flip' + let result' = (/= 0) result + touchManagedPtr videoOrientation + return result' + +#if ENABLE_OVERLOADING +data VideoOrientationSetVflipMethodInfo +instance (signature ~ (Bool -> m Bool), MonadIO m, IsVideoOrientation a) => O.MethodInfo VideoOrientationSetVflipMethodInfo a signature where + overloadedMethod _ = videoOrientationSetVflip + +#endif + + diff --git a/GI/GstVideo/Interfaces/VideoOrientation.hs-boot b/GI/GstVideo/Interfaces/VideoOrientation.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Interfaces/VideoOrientation.hs-boot @@ -0,0 +1,51 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Interfaces.VideoOrientation where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoOrientation = VideoOrientation (ManagedPtr VideoOrientation) +class ManagedPtrNewtype a => IsVideoOrientation a +instance WrappedPtr VideoOrientation where +#if ENABLE_OVERLOADING +data VideoOrientationGetHcenterMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOrientationGetHflipMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOrientationGetVcenterMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOrientationGetVflipMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOrientationSetHcenterMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOrientationSetHflipMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOrientationSetVcenterMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOrientationSetVflipMethodInfo +#endif diff --git a/GI/GstVideo/Interfaces/VideoOverlay.hs b/GI/GstVideo/Interfaces/VideoOverlay.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Interfaces/VideoOverlay.hs @@ -0,0 +1,695 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +The 'GI.GstVideo.Interfaces.VideoOverlay.VideoOverlay' interface is used for 2 main purposes : + +* To get a grab on the Window where the video sink element is going to render. + This is achieved by either being informed about the Window identifier that + the video sink element generated, or by forcing the video sink element to use + a specific Window identifier for rendering. +* To force a redrawing of the latest video frame the video sink element + displayed on the Window. Indeed if the 'GI.Gst.Objects.Pipeline.Pipeline' is in @/GST_STATE_PAUSED/@ + state, moving the Window around will damage its content. Application + developers will want to handle the Expose events themselves and force the + video sink element to refresh the Window\'s content. + +Using the Window created by the video sink is probably the simplest scenario, +in some cases, though, it might not be flexible enough for application +developers if they need to catch events such as mouse moves and button +clicks. + +Setting a specific Window identifier on the video sink element is the most +flexible solution but it has some issues. Indeed the application needs to set +its Window identifier at the right time to avoid internal Window creation +from the video sink element. To solve this issue a 'GI.Gst.Structs.Message.Message' is posted on +the bus to inform the application that it should set the Window identifier +immediately. Here is an example on how to do that correctly: +> +>static GstBusSyncReply +>create_window (GstBus * bus, GstMessage * message, GstPipeline * pipeline) +>{ +> // ignore anything but 'prepare-window-handle' element messages +> if (!gst_is_video_overlay_prepare_window_handle_message (message)) +> return GST_BUS_PASS; +> +> win = XCreateSimpleWindow (disp, root, 0, 0, 320, 240, 0, 0, 0); +> +> XSetWindowBackgroundPixmap (disp, win, None); +> +> XMapRaised (disp, win); +> +> XSync (disp, FALSE); +> +> gst_video_overlay_set_window_handle (GST_VIDEO_OVERLAY (GST_MESSAGE_SRC (message)), +> win); +> +> gst_message_unref (message); +> +> return GST_BUS_DROP; +>} +>... +>int +>main (int argc, char **argv) +>{ +>... +> bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline)); +> gst_bus_set_sync_handler (bus, (GstBusSyncHandler) create_window, pipeline, +> NULL); +>... +>} + + +== Two basic usage scenarios + +There are two basic usage scenarios: in the simplest case, the application +uses @/playbin/@ or @/plasink/@ or knows exactly what particular element is used +for video output, which is usually the case when the application creates +the videosink to use (e.g. @/xvimagesink/@, @/ximagesink/@, etc.) itself; in this +case, the application can just create the videosink element, create and +realize the window to render the video on and then +call 'GI.GstVideo.Interfaces.VideoOverlay.videoOverlaySetWindowHandle' directly with the XID or native +window handle, before starting up the pipeline. +As @/playbin/@ and @/playsink/@ implement the video overlay interface and proxy +it transparently to the actual video sink even if it is created later, this +case also applies when using these elements. + +In the other and more common case, the application does not know in advance +what GStreamer video sink element will be used for video output. This is +usually the case when an element such as @/autovideosink/@ is used. +In this case, the video sink element itself is created +asynchronously from a GStreamer streaming thread some time after the +pipeline has been started up. When that happens, however, the video sink +will need to know right then whether to render onto an already existing +application window or whether to create its own window. This is when it +posts a prepare-window-handle message, and that is also why this message needs +to be handled in a sync bus handler which will be called from the streaming +thread directly (because the video sink will need an answer right then). + +As response to the prepare-window-handle element message in the bus sync +handler, the application may use 'GI.GstVideo.Interfaces.VideoOverlay.videoOverlaySetWindowHandle' to tell +the video sink to render onto an existing window surface. At this point the +application should already have obtained the window handle \/ XID, so it +just needs to set it. It is generally not advisable to call any GUI toolkit +functions or window system functions from the streaming thread in which the +prepare-window-handle message is handled, because most GUI toolkits and +windowing systems are not thread-safe at all and a lot of care would be +required to co-ordinate the toolkit and window system calls of the +different threads (Gtk+ users please note: prior to Gtk+ 2.18 +@/GDK_WINDOW_XID()/@ was just a simple structure access, so generally fine to do +within the bus sync handler; this macro was changed to a function call in +Gtk+ 2.18 and later, which is likely to cause problems when called from a +sync handler; see below for a better approach without @/GDK_WINDOW_XID()/@ +used in the callback). + +== GstVideoOverlay and Gtk+ + +> +>#include <gst/video/videooverlay.h> +>#include <gtk/gtk.h> +>#ifdef GDK_WINDOWING_X11 +>#include <gdk/gdkx.h> // for GDK_WINDOW_XID +>#endif +>#ifdef GDK_WINDOWING_WIN32 +>#include <gdk/gdkwin32.h> // for GDK_WINDOW_HWND +>#endif +>... +>static guintptr video_window_handle = 0; +>... +>static GstBusSyncReply +>bus_sync_handler (GstBus * bus, GstMessage * message, gpointer user_data) +>{ +> // ignore anything but 'prepare-window-handle' element messages +> if (!gst_is_video_overlay_prepare_window_handle_message (message)) +> return GST_BUS_PASS; +> +> if (video_window_handle != 0) { +> GstVideoOverlay *overlay; +> +> // GST_MESSAGE_SRC (message) will be the video sink element +> overlay = GST_VIDEO_OVERLAY (GST_MESSAGE_SRC (message)); +> gst_video_overlay_set_window_handle (overlay, video_window_handle); +> } else { +> g_warning ("Should have obtained video_window_handle by now!"); +> } +> +> gst_message_unref (message); +> return GST_BUS_DROP; +>} +>... +>static void +>video_widget_realize_cb (GtkWidget * widget, gpointer data) +>{ +>#if GTK_CHECK_VERSION(2,18,0) +> // Tell Gtk+/Gdk to create a native window for this widget instead of +> // drawing onto the parent widget. +> // This is here just for pedagogical purposes, GDK_WINDOW_XID will call +> // it as well in newer Gtk versions +> if (!gdk_window_ensure_native (widget->window)) +> g_error ("Couldn't create native window needed for GstVideoOverlay!"); +>#endif +> +>#ifdef GDK_WINDOWING_X11 +> { +> gulong xid = GDK_WINDOW_XID (gtk_widget_get_window (video_window)); +> video_window_handle = xid; +> } +>#endif +>#ifdef GDK_WINDOWING_WIN32 +> { +> HWND wnd = GDK_WINDOW_HWND (gtk_widget_get_window (video_window)); +> video_window_handle = (guintptr) wnd; +> } +>#endif +>} +>... +>int +>main (int argc, char **argv) +>{ +> GtkWidget *video_window; +> GtkWidget *app_window; +> ... +> app_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); +> ... +> video_window = gtk_drawing_area_new (); +> g_signal_connect (video_window, "realize", +> G_CALLBACK (video_widget_realize_cb), NULL); +> gtk_widget_set_double_buffered (video_window, FALSE); +> ... +> // usually the video_window will not be directly embedded into the +> // application window like this, but there will be many other widgets +> // and the video window will be embedded in one of them instead +> gtk_container_add (GTK_CONTAINER (ap_window), video_window); +> ... +> // show the GUI +> gtk_widget_show_all (app_window); +> +> // realize window now so that the video window gets created and we can +> // obtain its XID/HWND before the pipeline is started up and the videosink +> // asks for the XID/HWND of the window to render onto +> gtk_widget_realize (video_window); +> +> // we should have the XID/HWND now +> g_assert (video_window_handle != 0); +> ... +> // set up sync handler for setting the xid once the pipeline is started +> bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline)); +> gst_bus_set_sync_handler (bus, (GstBusSyncHandler) bus_sync_handler, NULL, +> NULL); +> gst_object_unref (bus); +> ... +> gst_element_set_state (pipeline, GST_STATE_PLAYING); +> ... +>} + + +== GstVideoOverlay and Qt + +> +>#include <glib.h> +>#include <gst/gst.h> +>#include <gst/video/videooverlay.h> +> +>#include <QApplication> +>#include <QTimer> +>#include <QWidget> +> +>int main(int argc, char *argv[]) +>{ +> if (!g_thread_supported ()) +> g_thread_init (NULL); +> +> gst_init (&argc, &argv); +> QApplication app(argc, argv); +> app.connect(&app, SIGNAL(lastWindowClosed()), &app, SLOT(quit ())); +> +> // prepare the pipeline +> +> GstElement *pipeline = gst_pipeline_new ("xvoverlay"); +> GstElement *src = gst_element_factory_make ("videotestsrc", NULL); +> GstElement *sink = gst_element_factory_make ("xvimagesink", NULL); +> gst_bin_add_many (GST_BIN (pipeline), src, sink, NULL); +> gst_element_link (src, sink); +> +> // prepare the ui +> +> QWidget window; +> window.resize(320, 240); +> window.show(); +> +> WId xwinid = window.winId(); +> gst_video_overlay_set_window_handle (GST_VIDEO_OVERLAY (sink), xwinid); +> +> // run the pipeline +> +> GstStateChangeReturn sret = gst_element_set_state (pipeline, +> GST_STATE_PLAYING); +> if (sret == GST_STATE_CHANGE_FAILURE) { +> gst_element_set_state (pipeline, GST_STATE_NULL); +> gst_object_unref (pipeline); +> // Exit application +> QTimer::singleShot(0, QApplication::activeWindow(), SLOT(quit())); +> } +> +> int ret = app.exec(); +> +> window.hide(); +> gst_element_set_state (pipeline, GST_STATE_NULL); +> gst_object_unref (pipeline); +> +> return ret; +>} + +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Interfaces.VideoOverlay + ( + +-- * Exported types + VideoOverlay(..) , + noVideoOverlay , + IsVideoOverlay , + + + -- * Methods +-- ** expose #method:expose# + +#if ENABLE_OVERLOADING + VideoOverlayExposeMethodInfo , +#endif + videoOverlayExpose , + + +-- ** gotWindowHandle #method:gotWindowHandle# + +#if ENABLE_OVERLOADING + VideoOverlayGotWindowHandleMethodInfo , +#endif + videoOverlayGotWindowHandle , + + +-- ** handleEvents #method:handleEvents# + +#if ENABLE_OVERLOADING + VideoOverlayHandleEventsMethodInfo , +#endif + videoOverlayHandleEvents , + + +-- ** prepareWindowHandle #method:prepareWindowHandle# + +#if ENABLE_OVERLOADING + VideoOverlayPrepareWindowHandleMethodInfo, +#endif + videoOverlayPrepareWindowHandle , + + +-- ** setProperty #method:setProperty# + + videoOverlaySetProperty , + + +-- ** setRenderRectangle #method:setRenderRectangle# + +#if ENABLE_OVERLOADING + VideoOverlaySetRenderRectangleMethodInfo, +#endif + videoOverlaySetRenderRectangle , + + +-- ** setWindowHandle #method:setWindowHandle# + +#if ENABLE_OVERLOADING + VideoOverlaySetWindowHandleMethodInfo , +#endif + videoOverlaySetWindowHandle , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object + +-- interface VideoOverlay +-- | Memory-managed wrapper type. +newtype VideoOverlay = VideoOverlay (ManagedPtr VideoOverlay) +-- | A convenience alias for `Nothing` :: `Maybe` `VideoOverlay`. +noVideoOverlay :: Maybe VideoOverlay +noVideoOverlay = Nothing + +#if ENABLE_OVERLOADING +type instance O.SignalList VideoOverlay = VideoOverlaySignalList +type VideoOverlaySignalList = ('[ ] :: [(Symbol, *)]) + +#endif + +-- | Type class for types which implement `VideoOverlay`. +class ManagedPtrNewtype a => IsVideoOverlay a +instance IsVideoOverlay VideoOverlay +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr VideoOverlay where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + + +#if ENABLE_OVERLOADING +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 = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoOverlayMethod t VideoOverlay, O.MethodInfo info VideoOverlay p) => OL.IsLabel t (VideoOverlay -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- method VideoOverlay::expose +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "overlay", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlay"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlay to expose.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_expose" gst_video_overlay_expose :: + Ptr VideoOverlay -> -- overlay : TInterface (Name {namespace = "GstVideo", name = "VideoOverlay"}) + IO () + +{- | +Tell an overlay that it has been exposed. This will redraw the current frame +in the drawable even if the pipeline is PAUSED. +-} +videoOverlayExpose :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOverlay a) => + a + {- ^ /@overlay@/: a 'GI.GstVideo.Interfaces.VideoOverlay.VideoOverlay' to expose. -} + -> m () +videoOverlayExpose overlay = liftIO $ do + overlay' <- unsafeManagedPtrCastPtr overlay + gst_video_overlay_expose overlay' + touchManagedPtr overlay + return () + +#if ENABLE_OVERLOADING +data VideoOverlayExposeMethodInfo +instance (signature ~ (m ()), MonadIO m, IsVideoOverlay a) => O.MethodInfo VideoOverlayExposeMethodInfo a signature where + overloadedMethod _ = videoOverlayExpose + +#endif + +-- method VideoOverlay::got_window_handle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "overlay", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlay"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlay which got a window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handle", argType = TBasicType TUIntPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a platform-specific handle referencing the window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_got_window_handle" gst_video_overlay_got_window_handle :: + Ptr VideoOverlay -> -- overlay : TInterface (Name {namespace = "GstVideo", name = "VideoOverlay"}) + CUIntPtr -> -- handle : TBasicType TUIntPtr + IO () + +{- | +This will post a \"have-window-handle\" element message on the bus. + +This function should only be used by video overlay plugin developers. +-} +videoOverlayGotWindowHandle :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOverlay a) => + a + {- ^ /@overlay@/: a 'GI.GstVideo.Interfaces.VideoOverlay.VideoOverlay' which got a window -} + -> CUIntPtr + {- ^ /@handle@/: a platform-specific handle referencing the window -} + -> m () +videoOverlayGotWindowHandle overlay handle = liftIO $ do + overlay' <- unsafeManagedPtrCastPtr overlay + gst_video_overlay_got_window_handle overlay' handle + touchManagedPtr overlay + return () + +#if ENABLE_OVERLOADING +data VideoOverlayGotWindowHandleMethodInfo +instance (signature ~ (CUIntPtr -> m ()), MonadIO m, IsVideoOverlay a) => O.MethodInfo VideoOverlayGotWindowHandleMethodInfo a signature where + overloadedMethod _ = videoOverlayGotWindowHandle + +#endif + +-- method VideoOverlay::handle_events +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "overlay", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlay"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlay to expose.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handle_events", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gboolean indicating if events should be handled or not.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_handle_events" gst_video_overlay_handle_events :: + Ptr VideoOverlay -> -- overlay : TInterface (Name {namespace = "GstVideo", name = "VideoOverlay"}) + CInt -> -- handle_events : TBasicType TBoolean + IO () + +{- | +Tell an overlay that it should handle events from the window system. These +events are forwarded upstream as navigation events. In some window system, +events are not propagated in the window hierarchy if a client is listening +for them. This method allows you to disable events handling completely +from the 'GI.GstVideo.Interfaces.VideoOverlay.VideoOverlay'. +-} +videoOverlayHandleEvents :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOverlay a) => + a + {- ^ /@overlay@/: a 'GI.GstVideo.Interfaces.VideoOverlay.VideoOverlay' to expose. -} + -> Bool + {- ^ /@handleEvents@/: a 'Bool' indicating if events should be handled or not. -} + -> m () +videoOverlayHandleEvents overlay handleEvents = liftIO $ do + overlay' <- unsafeManagedPtrCastPtr overlay + let handleEvents' = (fromIntegral . fromEnum) handleEvents + gst_video_overlay_handle_events overlay' handleEvents' + touchManagedPtr overlay + return () + +#if ENABLE_OVERLOADING +data VideoOverlayHandleEventsMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsVideoOverlay a) => O.MethodInfo VideoOverlayHandleEventsMethodInfo a signature where + overloadedMethod _ = videoOverlayHandleEvents + +#endif + +-- method VideoOverlay::prepare_window_handle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "overlay", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlay"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlay which does not yet have an Window handle set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_prepare_window_handle" gst_video_overlay_prepare_window_handle :: + Ptr VideoOverlay -> -- overlay : TInterface (Name {namespace = "GstVideo", name = "VideoOverlay"}) + IO () + +{- | +This will post a \"prepare-window-handle\" element message on the bus +to give applications an opportunity to call +'GI.GstVideo.Interfaces.VideoOverlay.videoOverlaySetWindowHandle' before a plugin creates its own +window. + +This function should only be used by video overlay plugin developers. +-} +videoOverlayPrepareWindowHandle :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOverlay a) => + a + {- ^ /@overlay@/: a 'GI.GstVideo.Interfaces.VideoOverlay.VideoOverlay' which does not yet have an Window handle set -} + -> m () +videoOverlayPrepareWindowHandle overlay = liftIO $ do + overlay' <- unsafeManagedPtrCastPtr overlay + gst_video_overlay_prepare_window_handle overlay' + touchManagedPtr overlay + return () + +#if ENABLE_OVERLOADING +data VideoOverlayPrepareWindowHandleMethodInfo +instance (signature ~ (m ()), MonadIO m, IsVideoOverlay a) => O.MethodInfo VideoOverlayPrepareWindowHandleMethodInfo a signature where + overloadedMethod _ = videoOverlayPrepareWindowHandle + +#endif + +-- method VideoOverlay::set_render_rectangle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "overlay", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlay"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the horizontal offset of the render area inside the window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the vertical offset of the render area inside the window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width of the render area inside the window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height of the render area inside the window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_set_render_rectangle" gst_video_overlay_set_render_rectangle :: + Ptr VideoOverlay -> -- overlay : TInterface (Name {namespace = "GstVideo", name = "VideoOverlay"}) + Int32 -> -- x : TBasicType TInt + Int32 -> -- y : TBasicType TInt + Int32 -> -- width : TBasicType TInt + Int32 -> -- height : TBasicType TInt + IO CInt + +{- | +Configure a subregion as a video target within the window set by +'GI.GstVideo.Interfaces.VideoOverlay.videoOverlaySetWindowHandle'. If this is not used or not supported +the video will fill the area of the window set as the overlay to 100%. +By specifying the rectangle, the video can be overlayed to a specific region +of that window only. After setting the new rectangle one should call +'GI.GstVideo.Interfaces.VideoOverlay.videoOverlayExpose' to force a redraw. To unset the region pass -1 for +the /@width@/ and /@height@/ parameters. + +This method is needed for non fullscreen video overlay in UI toolkits that +do not support subwindows. +-} +videoOverlaySetRenderRectangle :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOverlay a) => + a + {- ^ /@overlay@/: a 'GI.GstVideo.Interfaces.VideoOverlay.VideoOverlay' -} + -> Int32 + {- ^ /@x@/: the horizontal offset of the render area inside the window -} + -> Int32 + {- ^ /@y@/: the vertical offset of the render area inside the window -} + -> Int32 + {- ^ /@width@/: the width of the render area inside the window -} + -> Int32 + {- ^ /@height@/: the height of the render area inside the window -} + -> m Bool + {- ^ __Returns:__ 'False' if not supported by the sink. -} +videoOverlaySetRenderRectangle overlay x y width height = liftIO $ do + overlay' <- unsafeManagedPtrCastPtr overlay + result <- gst_video_overlay_set_render_rectangle overlay' x y width height + let result' = (/= 0) result + touchManagedPtr overlay + return result' + +#if ENABLE_OVERLOADING +data VideoOverlaySetRenderRectangleMethodInfo +instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> m Bool), MonadIO m, IsVideoOverlay a) => O.MethodInfo VideoOverlaySetRenderRectangleMethodInfo a signature where + overloadedMethod _ = videoOverlaySetRenderRectangle + +#endif + +-- method VideoOverlay::set_window_handle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "overlay", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlay"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlay to set the window on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handle", argType = TBasicType TUIntPtr, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a handle referencing the window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_set_window_handle" gst_video_overlay_set_window_handle :: + Ptr VideoOverlay -> -- overlay : TInterface (Name {namespace = "GstVideo", name = "VideoOverlay"}) + CUIntPtr -> -- handle : TBasicType TUIntPtr + IO () + +{- | +This will call the video overlay\'s set_window_handle method. You +should use this method to tell to an overlay to display video output to a +specific window (e.g. an XWindow on X11). Passing 0 as the /@handle@/ will +tell the overlay to stop using that window and create an internal one. +-} +videoOverlaySetWindowHandle :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoOverlay a) => + a + {- ^ /@overlay@/: a 'GI.GstVideo.Interfaces.VideoOverlay.VideoOverlay' to set the window on. -} + -> CUIntPtr + {- ^ /@handle@/: a handle referencing the window. -} + -> m () +videoOverlaySetWindowHandle overlay handle = liftIO $ do + overlay' <- unsafeManagedPtrCastPtr overlay + gst_video_overlay_set_window_handle overlay' handle + touchManagedPtr overlay + return () + +#if ENABLE_OVERLOADING +data VideoOverlaySetWindowHandleMethodInfo +instance (signature ~ (CUIntPtr -> m ()), MonadIO m, IsVideoOverlay a) => O.MethodInfo VideoOverlaySetWindowHandleMethodInfo a signature where + overloadedMethod _ = videoOverlaySetWindowHandle + +#endif + +-- method VideoOverlay::set_property +-- method type : MemberFunction +-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The instance on which the property is set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "last_prop_id", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The highest property ID.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The property ID", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GValue to be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_set_property" gst_video_overlay_set_property :: + Ptr GObject.Object.Object -> -- object : TInterface (Name {namespace = "GObject", name = "Object"}) + Int32 -> -- last_prop_id : TBasicType TInt + Word32 -> -- property_id : TBasicType TUInt + Ptr GValue -> -- value : TInterface (Name {namespace = "GObject", name = "Value"}) + IO CInt + +{- | +This helper shall be used by classes implementing the 'GI.GstVideo.Interfaces.VideoOverlay.VideoOverlay' +interface that want the render rectangle to be controllable using +properties. This helper will parse and set the render rectangle calling +'GI.GstVideo.Interfaces.VideoOverlay.videoOverlaySetRenderRectangle'. +-} +videoOverlaySetProperty :: + (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) => + a + {- ^ /@object@/: The instance on which the property is set -} + -> Int32 + {- ^ /@lastPropId@/: The highest property ID. -} + -> Word32 + {- ^ /@propertyId@/: The property ID -} + -> GValue + {- ^ /@value@/: The 'GI.GObject.Structs.Value.Value' to be set -} + -> m Bool + {- ^ __Returns:__ 'True' if the /@propertyId@/ matches the GstVideoOverlay property + +Since 1.14 -} +videoOverlaySetProperty object lastPropId propertyId value = liftIO $ do + object' <- unsafeManagedPtrCastPtr object + value' <- unsafeManagedPtrGetPtr value + result <- gst_video_overlay_set_property object' lastPropId propertyId value' + let result' = (/= 0) result + touchManagedPtr object + touchManagedPtr value + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GstVideo/Interfaces/VideoOverlay.hs-boot b/GI/GstVideo/Interfaces/VideoOverlay.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Interfaces/VideoOverlay.hs-boot @@ -0,0 +1,45 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Interfaces.VideoOverlay where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoOverlay = VideoOverlay (ManagedPtr VideoOverlay) +class ManagedPtrNewtype a => IsVideoOverlay a +instance WrappedPtr VideoOverlay where +#if ENABLE_OVERLOADING +data VideoOverlayExposeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayGotWindowHandleMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayHandleEventsMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayPrepareWindowHandleMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlaySetRenderRectangleMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlaySetWindowHandleMethodInfo +#endif diff --git a/GI/GstVideo/Objects.hs b/GI/GstVideo/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects.hs @@ -0,0 +1,59 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Objects + ( module GI.GstVideo.Objects.ColorBalanceChannel, + module GI.GstVideo.Objects.VideoAggregator, + module GI.GstVideo.Objects.VideoAggregatorConvertPad, + module GI.GstVideo.Objects.VideoAggregatorPad, + module GI.GstVideo.Objects.VideoBufferPool, + module GI.GstVideo.Objects.VideoDecoder , + module GI.GstVideo.Objects.VideoEncoder , + module GI.GstVideo.Objects.VideoFilter , + module GI.GstVideo.Objects.VideoMultiviewFlagsSet, + module GI.GstVideo.Objects.VideoSink , + + + ) where + +import GI.GstVideo.Objects.ColorBalanceChannel +import GI.GstVideo.Objects.VideoAggregator +import GI.GstVideo.Objects.VideoAggregatorConvertPad +import GI.GstVideo.Objects.VideoAggregatorPad +import GI.GstVideo.Objects.VideoBufferPool +import GI.GstVideo.Objects.VideoDecoder +import GI.GstVideo.Objects.VideoEncoder +import GI.GstVideo.Objects.VideoFilter +import GI.GstVideo.Objects.VideoMultiviewFlagsSet +import GI.GstVideo.Objects.VideoSink + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + + diff --git a/GI/GstVideo/Objects/ColorBalanceChannel.hs b/GI/GstVideo/Objects/ColorBalanceChannel.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/ColorBalanceChannel.hs @@ -0,0 +1,217 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +The 'GI.GstVideo.Objects.ColorBalanceChannel.ColorBalanceChannel' object represents a parameter +for modifying the color balance implemented by an element providing the +'GI.GstVideo.Interfaces.ColorBalance.ColorBalance' interface. For example, Hue or Saturation. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Objects.ColorBalanceChannel + ( + +-- * Exported types + ColorBalanceChannel(..) , + IsColorBalanceChannel , + toColorBalanceChannel , + noColorBalanceChannel , + + + -- * Signals +-- ** valueChanged #signal:valueChanged# + + C_ColorBalanceChannelValueChangedCallback, + ColorBalanceChannelValueChangedCallback , +#if ENABLE_OVERLOADING + ColorBalanceChannelValueChangedSignalInfo, +#endif + afterColorBalanceChannelValueChanged , + genClosure_ColorBalanceChannelValueChanged, + mk_ColorBalanceChannelValueChangedCallback, + noColorBalanceChannelValueChangedCallback, + onColorBalanceChannelValueChanged , + wrap_ColorBalanceChannelValueChangedCallback, + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object + +-- | Memory-managed wrapper type. +newtype ColorBalanceChannel = ColorBalanceChannel (ManagedPtr ColorBalanceChannel) +foreign import ccall "gst_color_balance_channel_get_type" + c_gst_color_balance_channel_get_type :: IO GType + +instance GObject ColorBalanceChannel where + gobjectType = c_gst_color_balance_channel_get_type + + +-- | Type class for types which can be safely cast to `ColorBalanceChannel`, for instance with `toColorBalanceChannel`. +class (GObject o, O.IsDescendantOf ColorBalanceChannel o) => IsColorBalanceChannel o +instance (GObject o, O.IsDescendantOf ColorBalanceChannel o) => IsColorBalanceChannel o + +instance O.HasParentTypes ColorBalanceChannel +type instance O.ParentTypes ColorBalanceChannel = '[GObject.Object.Object] + +-- | Cast to `ColorBalanceChannel`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toColorBalanceChannel :: (MonadIO m, IsColorBalanceChannel o) => o -> m ColorBalanceChannel +toColorBalanceChannel = liftIO . unsafeCastTo ColorBalanceChannel + +-- | A convenience alias for `Nothing` :: `Maybe` `ColorBalanceChannel`. +noColorBalanceChannel :: Maybe ColorBalanceChannel +noColorBalanceChannel = Nothing + +#if ENABLE_OVERLOADING +type family ResolveColorBalanceChannelMethod (t :: Symbol) (o :: *) :: * where + ResolveColorBalanceChannelMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveColorBalanceChannelMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveColorBalanceChannelMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveColorBalanceChannelMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveColorBalanceChannelMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveColorBalanceChannelMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveColorBalanceChannelMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveColorBalanceChannelMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveColorBalanceChannelMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveColorBalanceChannelMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveColorBalanceChannelMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveColorBalanceChannelMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveColorBalanceChannelMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveColorBalanceChannelMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveColorBalanceChannelMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveColorBalanceChannelMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveColorBalanceChannelMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveColorBalanceChannelMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveColorBalanceChannelMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveColorBalanceChannelMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveColorBalanceChannelMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveColorBalanceChannelMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveColorBalanceChannelMethod t ColorBalanceChannel, O.MethodInfo info ColorBalanceChannel p) => OL.IsLabel t (ColorBalanceChannel -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- signal ColorBalanceChannel::value-changed +{- | +Fired when the value of the indicated channel has changed. +-} +type ColorBalanceChannelValueChangedCallback = + Int32 + {- ^ /@value@/: The new value -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ColorBalanceChannelValueChangedCallback`@. +noColorBalanceChannelValueChangedCallback :: Maybe ColorBalanceChannelValueChangedCallback +noColorBalanceChannelValueChangedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ColorBalanceChannelValueChangedCallback = + Ptr () -> -- object + Int32 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ColorBalanceChannelValueChangedCallback`. +foreign import ccall "wrapper" + mk_ColorBalanceChannelValueChangedCallback :: C_ColorBalanceChannelValueChangedCallback -> IO (FunPtr C_ColorBalanceChannelValueChangedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ColorBalanceChannelValueChanged :: MonadIO m => ColorBalanceChannelValueChangedCallback -> m (GClosure C_ColorBalanceChannelValueChangedCallback) +genClosure_ColorBalanceChannelValueChanged cb = liftIO $ do + let cb' = wrap_ColorBalanceChannelValueChangedCallback cb + mk_ColorBalanceChannelValueChangedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ColorBalanceChannelValueChangedCallback` into a `C_ColorBalanceChannelValueChangedCallback`. +wrap_ColorBalanceChannelValueChangedCallback :: + ColorBalanceChannelValueChangedCallback -> + C_ColorBalanceChannelValueChangedCallback +wrap_ColorBalanceChannelValueChangedCallback _cb _ value _ = do + _cb value + + +{- | +Connect a signal handler for the “@value-changed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' colorBalanceChannel #valueChanged callback +@ +-} +onColorBalanceChannelValueChanged :: (IsColorBalanceChannel a, MonadIO m) => a -> ColorBalanceChannelValueChangedCallback -> m SignalHandlerId +onColorBalanceChannelValueChanged obj cb = liftIO $ do + let cb' = wrap_ColorBalanceChannelValueChangedCallback cb + cb'' <- mk_ColorBalanceChannelValueChangedCallback cb' + connectSignalFunPtr obj "value-changed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@value-changed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' colorBalanceChannel #valueChanged callback +@ +-} +afterColorBalanceChannelValueChanged :: (IsColorBalanceChannel a, MonadIO m) => a -> ColorBalanceChannelValueChangedCallback -> m SignalHandlerId +afterColorBalanceChannelValueChanged obj cb = liftIO $ do + let cb' = wrap_ColorBalanceChannelValueChangedCallback cb + cb'' <- mk_ColorBalanceChannelValueChangedCallback cb' + connectSignalFunPtr obj "value-changed" cb'' SignalConnectAfter + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ColorBalanceChannel +type instance O.AttributeList ColorBalanceChannel = ColorBalanceChannelAttributeList +type ColorBalanceChannelAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +data ColorBalanceChannelValueChangedSignalInfo +instance SignalInfo ColorBalanceChannelValueChangedSignalInfo where + type HaskellCallbackType ColorBalanceChannelValueChangedSignalInfo = ColorBalanceChannelValueChangedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ColorBalanceChannelValueChangedCallback cb + cb'' <- mk_ColorBalanceChannelValueChangedCallback cb' + connectSignalFunPtr obj "value-changed" cb'' connectMode + +type instance O.SignalList ColorBalanceChannel = ColorBalanceChannelSignalList +type ColorBalanceChannelSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo), '("valueChanged", ColorBalanceChannelValueChangedSignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/GstVideo/Objects/ColorBalanceChannel.hs-boot b/GI/GstVideo/Objects/ColorBalanceChannel.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/ColorBalanceChannel.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Objects.ColorBalanceChannel where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ColorBalanceChannel = ColorBalanceChannel (ManagedPtr ColorBalanceChannel) +instance GObject ColorBalanceChannel where +class (GObject o, O.IsDescendantOf ColorBalanceChannel o) => IsColorBalanceChannel o +instance (GObject o, O.IsDescendantOf ColorBalanceChannel o) => IsColorBalanceChannel o +instance O.HasParentTypes ColorBalanceChannel +#if ENABLE_OVERLOADING +data ColorBalanceChannelValueChangedSignalInfo +#endif diff --git a/GI/GstVideo/Objects/VideoAggregator.hs b/GI/GstVideo/Objects/VideoAggregator.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoAggregator.hs @@ -0,0 +1,224 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +VideoAggregator can accept AYUV, ARGB and BGRA video streams. For each of the requested +sink pads it will compare the incoming geometry and framerate to define the +output parameters. Indeed output video frames will have the geometry of the +biggest incoming video stream and the framerate of the fastest incoming one. + +VideoAggregator will do colorspace conversion. + +Zorder for each input stream can be configured on the +'GI.GstVideo.Objects.VideoAggregatorPad.VideoAggregatorPad'. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Objects.VideoAggregator + ( + +-- * Exported types + VideoAggregator(..) , + IsVideoAggregator , + toVideoAggregator , + noVideoAggregator , + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gst.Objects.Element as Gst.Element +import qualified GI.Gst.Objects.Object as Gst.Object +import qualified GI.GstBase.Objects.Aggregator as GstBase.Aggregator + +-- | Memory-managed wrapper type. +newtype VideoAggregator = VideoAggregator (ManagedPtr VideoAggregator) +foreign import ccall "gst_video_aggregator_get_type" + c_gst_video_aggregator_get_type :: IO GType + +instance GObject VideoAggregator where + gobjectType = c_gst_video_aggregator_get_type + + +-- | Type class for types which can be safely cast to `VideoAggregator`, for instance with `toVideoAggregator`. +class (GObject o, O.IsDescendantOf VideoAggregator o) => IsVideoAggregator o +instance (GObject o, O.IsDescendantOf VideoAggregator o) => IsVideoAggregator o + +instance O.HasParentTypes VideoAggregator +type instance O.ParentTypes VideoAggregator = '[GstBase.Aggregator.Aggregator, Gst.Element.Element, Gst.Object.Object, GObject.Object.Object] + +-- | Cast to `VideoAggregator`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toVideoAggregator :: (MonadIO m, IsVideoAggregator o) => o -> m VideoAggregator +toVideoAggregator = liftIO . unsafeCastTo VideoAggregator + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoAggregator`. +noVideoAggregator :: Maybe VideoAggregator +noVideoAggregator = Nothing + +#if ENABLE_OVERLOADING +type family ResolveVideoAggregatorMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoAggregatorMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo + ResolveVideoAggregatorMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo + ResolveVideoAggregatorMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo + ResolveVideoAggregatorMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo + ResolveVideoAggregatorMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo + ResolveVideoAggregatorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveVideoAggregatorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveVideoAggregatorMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo + ResolveVideoAggregatorMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo + ResolveVideoAggregatorMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo + ResolveVideoAggregatorMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo + ResolveVideoAggregatorMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo + ResolveVideoAggregatorMethod "finishBuffer" o = GstBase.Aggregator.AggregatorFinishBufferMethodInfo + ResolveVideoAggregatorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveVideoAggregatorMethod "foreachPad" o = Gst.Element.ElementForeachPadMethodInfo + ResolveVideoAggregatorMethod "foreachSinkPad" o = Gst.Element.ElementForeachSinkPadMethodInfo + ResolveVideoAggregatorMethod "foreachSrcPad" o = Gst.Element.ElementForeachSrcPadMethodInfo + ResolveVideoAggregatorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveVideoAggregatorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveVideoAggregatorMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo + ResolveVideoAggregatorMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo + ResolveVideoAggregatorMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo + ResolveVideoAggregatorMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo + ResolveVideoAggregatorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveVideoAggregatorMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo + ResolveVideoAggregatorMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo + ResolveVideoAggregatorMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo + ResolveVideoAggregatorMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo + ResolveVideoAggregatorMethod "link" o = Gst.Element.ElementLinkMethodInfo + ResolveVideoAggregatorMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo + ResolveVideoAggregatorMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo + ResolveVideoAggregatorMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo + ResolveVideoAggregatorMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo + ResolveVideoAggregatorMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo + ResolveVideoAggregatorMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo + ResolveVideoAggregatorMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo + ResolveVideoAggregatorMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo + ResolveVideoAggregatorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveVideoAggregatorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveVideoAggregatorMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo + ResolveVideoAggregatorMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo + ResolveVideoAggregatorMethod "query" o = Gst.Element.ElementQueryMethodInfo + ResolveVideoAggregatorMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo + ResolveVideoAggregatorMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo + ResolveVideoAggregatorMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo + ResolveVideoAggregatorMethod "ref" o = Gst.Object.ObjectRefMethodInfo + ResolveVideoAggregatorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveVideoAggregatorMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo + ResolveVideoAggregatorMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo + ResolveVideoAggregatorMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo + ResolveVideoAggregatorMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo + ResolveVideoAggregatorMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo + ResolveVideoAggregatorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveVideoAggregatorMethod "seek" o = Gst.Element.ElementSeekMethodInfo + ResolveVideoAggregatorMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo + ResolveVideoAggregatorMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo + ResolveVideoAggregatorMethod "simpleGetNextTime" o = GstBase.Aggregator.AggregatorSimpleGetNextTimeMethodInfo + ResolveVideoAggregatorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveVideoAggregatorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveVideoAggregatorMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo + ResolveVideoAggregatorMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo + ResolveVideoAggregatorMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo + ResolveVideoAggregatorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveVideoAggregatorMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo + ResolveVideoAggregatorMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo + ResolveVideoAggregatorMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo + ResolveVideoAggregatorMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo + ResolveVideoAggregatorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveVideoAggregatorMethod "getAllocator" o = GstBase.Aggregator.AggregatorGetAllocatorMethodInfo + ResolveVideoAggregatorMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo + ResolveVideoAggregatorMethod "getBufferPool" o = GstBase.Aggregator.AggregatorGetBufferPoolMethodInfo + ResolveVideoAggregatorMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo + ResolveVideoAggregatorMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo + ResolveVideoAggregatorMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo + ResolveVideoAggregatorMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo + ResolveVideoAggregatorMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo + ResolveVideoAggregatorMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo + ResolveVideoAggregatorMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo + ResolveVideoAggregatorMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo + ResolveVideoAggregatorMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo + ResolveVideoAggregatorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveVideoAggregatorMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo + ResolveVideoAggregatorMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo + ResolveVideoAggregatorMethod "getLatency" o = GstBase.Aggregator.AggregatorGetLatencyMethodInfo + ResolveVideoAggregatorMethod "getMetadata" o = Gst.Element.ElementGetMetadataMethodInfo + ResolveVideoAggregatorMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo + ResolveVideoAggregatorMethod "getPadTemplate" o = Gst.Element.ElementGetPadTemplateMethodInfo + ResolveVideoAggregatorMethod "getPadTemplateList" o = Gst.Element.ElementGetPadTemplateListMethodInfo + ResolveVideoAggregatorMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo + ResolveVideoAggregatorMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo + ResolveVideoAggregatorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveVideoAggregatorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveVideoAggregatorMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo + ResolveVideoAggregatorMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo + ResolveVideoAggregatorMethod "getState" o = Gst.Element.ElementGetStateMethodInfo + ResolveVideoAggregatorMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo + ResolveVideoAggregatorMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo + ResolveVideoAggregatorMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo + ResolveVideoAggregatorMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo + ResolveVideoAggregatorMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo + ResolveVideoAggregatorMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo + ResolveVideoAggregatorMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo + ResolveVideoAggregatorMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo + ResolveVideoAggregatorMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo + ResolveVideoAggregatorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveVideoAggregatorMethod "setLatency" o = GstBase.Aggregator.AggregatorSetLatencyMethodInfo + ResolveVideoAggregatorMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo + ResolveVideoAggregatorMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo + ResolveVideoAggregatorMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo + ResolveVideoAggregatorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveVideoAggregatorMethod "setSrcCaps" o = GstBase.Aggregator.AggregatorSetSrcCapsMethodInfo + ResolveVideoAggregatorMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo + ResolveVideoAggregatorMethod "setState" o = Gst.Element.ElementSetStateMethodInfo + ResolveVideoAggregatorMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoAggregatorMethod t VideoAggregator, O.MethodInfo info VideoAggregator p) => OL.IsLabel t (VideoAggregator -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoAggregator +type instance O.AttributeList VideoAggregator = VideoAggregatorAttributeList +type VideoAggregatorAttributeList = ('[ '("latency", GstBase.Aggregator.AggregatorLatencyPropertyInfo), '("minUpstreamLatency", GstBase.Aggregator.AggregatorMinUpstreamLatencyPropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("startTime", GstBase.Aggregator.AggregatorStartTimePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList VideoAggregator = VideoAggregatorSignalList +type VideoAggregatorSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/GstVideo/Objects/VideoAggregator.hs-boot b/GI/GstVideo/Objects/VideoAggregator.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoAggregator.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Objects.VideoAggregator where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoAggregator = VideoAggregator (ManagedPtr VideoAggregator) +instance GObject VideoAggregator where +class (GObject o, O.IsDescendantOf VideoAggregator o) => IsVideoAggregator o +instance (GObject o, O.IsDescendantOf VideoAggregator o) => IsVideoAggregator o +instance O.HasParentTypes VideoAggregator diff --git a/GI/GstVideo/Objects/VideoAggregatorConvertPad.hs b/GI/GstVideo/Objects/VideoAggregatorConvertPad.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoAggregatorConvertPad.hs @@ -0,0 +1,364 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +An implementation of GstPad that can be used with 'GI.GstVideo.Objects.VideoAggregator.VideoAggregator'. + +See 'GI.GstVideo.Objects.VideoAggregator.VideoAggregator' for more details. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Objects.VideoAggregatorConvertPad + ( + +-- * Exported types + VideoAggregatorConvertPad(..) , + IsVideoAggregatorConvertPad , + toVideoAggregatorConvertPad , + noVideoAggregatorConvertPad , + + + -- * Methods +-- ** updateConversionInfo #method:updateConversionInfo# + +#if ENABLE_OVERLOADING + VideoAggregatorConvertPadUpdateConversionInfoMethodInfo, +#endif + videoAggregatorConvertPadUpdateConversionInfo, + + + + + -- * Properties +-- ** converterConfig #attr:converterConfig# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + VideoAggregatorConvertPadConverterConfigPropertyInfo, +#endif + clearVideoAggregatorConvertPadConverterConfig, + constructVideoAggregatorConvertPadConverterConfig, + getVideoAggregatorConvertPadConverterConfig, + setVideoAggregatorConvertPadConverterConfig, +#if ENABLE_OVERLOADING + videoAggregatorConvertPadConverterConfig, +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gst.Objects.Object as Gst.Object +import qualified GI.Gst.Objects.Pad as Gst.Pad +import qualified GI.Gst.Structs.Structure as Gst.Structure +import qualified GI.GstBase.Objects.AggregatorPad as GstBase.AggregatorPad +import {-# SOURCE #-} qualified GI.GstVideo.Objects.VideoAggregatorPad as GstVideo.VideoAggregatorPad + +-- | Memory-managed wrapper type. +newtype VideoAggregatorConvertPad = VideoAggregatorConvertPad (ManagedPtr VideoAggregatorConvertPad) +foreign import ccall "gst_video_aggregator_convert_pad_get_type" + c_gst_video_aggregator_convert_pad_get_type :: IO GType + +instance GObject VideoAggregatorConvertPad where + gobjectType = c_gst_video_aggregator_convert_pad_get_type + + +-- | Type class for types which can be safely cast to `VideoAggregatorConvertPad`, for instance with `toVideoAggregatorConvertPad`. +class (GObject o, O.IsDescendantOf VideoAggregatorConvertPad o) => IsVideoAggregatorConvertPad o +instance (GObject o, O.IsDescendantOf VideoAggregatorConvertPad o) => IsVideoAggregatorConvertPad o + +instance O.HasParentTypes VideoAggregatorConvertPad +type instance O.ParentTypes VideoAggregatorConvertPad = '[GstVideo.VideoAggregatorPad.VideoAggregatorPad, GstBase.AggregatorPad.AggregatorPad, Gst.Pad.Pad, Gst.Object.Object, GObject.Object.Object] + +-- | Cast to `VideoAggregatorConvertPad`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toVideoAggregatorConvertPad :: (MonadIO m, IsVideoAggregatorConvertPad o) => o -> m VideoAggregatorConvertPad +toVideoAggregatorConvertPad = liftIO . unsafeCastTo VideoAggregatorConvertPad + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoAggregatorConvertPad`. +noVideoAggregatorConvertPad :: Maybe VideoAggregatorConvertPad +noVideoAggregatorConvertPad = Nothing + +#if ENABLE_OVERLOADING +type family ResolveVideoAggregatorConvertPadMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoAggregatorConvertPadMethod "activateMode" o = Gst.Pad.PadActivateModeMethodInfo + ResolveVideoAggregatorConvertPadMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo + ResolveVideoAggregatorConvertPadMethod "addProbe" o = Gst.Pad.PadAddProbeMethodInfo + ResolveVideoAggregatorConvertPadMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveVideoAggregatorConvertPadMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveVideoAggregatorConvertPadMethod "canLink" o = Gst.Pad.PadCanLinkMethodInfo + ResolveVideoAggregatorConvertPadMethod "chain" o = Gst.Pad.PadChainMethodInfo + ResolveVideoAggregatorConvertPadMethod "chainList" o = Gst.Pad.PadChainListMethodInfo + ResolveVideoAggregatorConvertPadMethod "checkReconfigure" o = Gst.Pad.PadCheckReconfigureMethodInfo + ResolveVideoAggregatorConvertPadMethod "createStreamId" o = Gst.Pad.PadCreateStreamIdMethodInfo + ResolveVideoAggregatorConvertPadMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo + ResolveVideoAggregatorConvertPadMethod "dropBuffer" o = GstBase.AggregatorPad.AggregatorPadDropBufferMethodInfo + ResolveVideoAggregatorConvertPadMethod "eventDefault" o = Gst.Pad.PadEventDefaultMethodInfo + ResolveVideoAggregatorConvertPadMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveVideoAggregatorConvertPadMethod "forward" o = Gst.Pad.PadForwardMethodInfo + ResolveVideoAggregatorConvertPadMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveVideoAggregatorConvertPadMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveVideoAggregatorConvertPadMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo + ResolveVideoAggregatorConvertPadMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo + ResolveVideoAggregatorConvertPadMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo + ResolveVideoAggregatorConvertPadMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo + ResolveVideoAggregatorConvertPadMethod "hasBuffer" o = GstBase.AggregatorPad.AggregatorPadHasBufferMethodInfo + ResolveVideoAggregatorConvertPadMethod "hasCurrentBuffer" o = GstVideo.VideoAggregatorPad.VideoAggregatorPadHasCurrentBufferMethodInfo + ResolveVideoAggregatorConvertPadMethod "hasCurrentCaps" o = Gst.Pad.PadHasCurrentCapsMethodInfo + ResolveVideoAggregatorConvertPadMethod "isActive" o = Gst.Pad.PadIsActiveMethodInfo + ResolveVideoAggregatorConvertPadMethod "isBlocked" o = Gst.Pad.PadIsBlockedMethodInfo + ResolveVideoAggregatorConvertPadMethod "isBlocking" o = Gst.Pad.PadIsBlockingMethodInfo + ResolveVideoAggregatorConvertPadMethod "isEos" o = GstBase.AggregatorPad.AggregatorPadIsEosMethodInfo + ResolveVideoAggregatorConvertPadMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveVideoAggregatorConvertPadMethod "isLinked" o = Gst.Pad.PadIsLinkedMethodInfo + ResolveVideoAggregatorConvertPadMethod "iterateInternalLinks" o = Gst.Pad.PadIterateInternalLinksMethodInfo + ResolveVideoAggregatorConvertPadMethod "iterateInternalLinksDefault" o = Gst.Pad.PadIterateInternalLinksDefaultMethodInfo + ResolveVideoAggregatorConvertPadMethod "link" o = Gst.Pad.PadLinkMethodInfo + ResolveVideoAggregatorConvertPadMethod "linkFull" o = Gst.Pad.PadLinkFullMethodInfo + ResolveVideoAggregatorConvertPadMethod "linkMaybeGhosting" o = Gst.Pad.PadLinkMaybeGhostingMethodInfo + ResolveVideoAggregatorConvertPadMethod "linkMaybeGhostingFull" o = Gst.Pad.PadLinkMaybeGhostingFullMethodInfo + ResolveVideoAggregatorConvertPadMethod "markReconfigure" o = Gst.Pad.PadMarkReconfigureMethodInfo + ResolveVideoAggregatorConvertPadMethod "needsReconfigure" o = Gst.Pad.PadNeedsReconfigureMethodInfo + ResolveVideoAggregatorConvertPadMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveVideoAggregatorConvertPadMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveVideoAggregatorConvertPadMethod "pauseTask" o = Gst.Pad.PadPauseTaskMethodInfo + ResolveVideoAggregatorConvertPadMethod "peekBuffer" o = GstBase.AggregatorPad.AggregatorPadPeekBufferMethodInfo + ResolveVideoAggregatorConvertPadMethod "peerQuery" o = Gst.Pad.PadPeerQueryMethodInfo + ResolveVideoAggregatorConvertPadMethod "peerQueryAcceptCaps" o = Gst.Pad.PadPeerQueryAcceptCapsMethodInfo + ResolveVideoAggregatorConvertPadMethod "peerQueryCaps" o = Gst.Pad.PadPeerQueryCapsMethodInfo + ResolveVideoAggregatorConvertPadMethod "peerQueryConvert" o = Gst.Pad.PadPeerQueryConvertMethodInfo + ResolveVideoAggregatorConvertPadMethod "peerQueryDuration" o = Gst.Pad.PadPeerQueryDurationMethodInfo + ResolveVideoAggregatorConvertPadMethod "peerQueryPosition" o = Gst.Pad.PadPeerQueryPositionMethodInfo + ResolveVideoAggregatorConvertPadMethod "popBuffer" o = GstBase.AggregatorPad.AggregatorPadPopBufferMethodInfo + ResolveVideoAggregatorConvertPadMethod "proxyQueryAcceptCaps" o = Gst.Pad.PadProxyQueryAcceptCapsMethodInfo + ResolveVideoAggregatorConvertPadMethod "proxyQueryCaps" o = Gst.Pad.PadProxyQueryCapsMethodInfo + ResolveVideoAggregatorConvertPadMethod "pullRange" o = Gst.Pad.PadPullRangeMethodInfo + ResolveVideoAggregatorConvertPadMethod "push" o = Gst.Pad.PadPushMethodInfo + ResolveVideoAggregatorConvertPadMethod "pushEvent" o = Gst.Pad.PadPushEventMethodInfo + ResolveVideoAggregatorConvertPadMethod "pushList" o = Gst.Pad.PadPushListMethodInfo + ResolveVideoAggregatorConvertPadMethod "query" o = Gst.Pad.PadQueryMethodInfo + ResolveVideoAggregatorConvertPadMethod "queryAcceptCaps" o = Gst.Pad.PadQueryAcceptCapsMethodInfo + ResolveVideoAggregatorConvertPadMethod "queryCaps" o = Gst.Pad.PadQueryCapsMethodInfo + ResolveVideoAggregatorConvertPadMethod "queryConvert" o = Gst.Pad.PadQueryConvertMethodInfo + ResolveVideoAggregatorConvertPadMethod "queryDefault" o = Gst.Pad.PadQueryDefaultMethodInfo + ResolveVideoAggregatorConvertPadMethod "queryDuration" o = Gst.Pad.PadQueryDurationMethodInfo + ResolveVideoAggregatorConvertPadMethod "queryPosition" o = Gst.Pad.PadQueryPositionMethodInfo + ResolveVideoAggregatorConvertPadMethod "ref" o = Gst.Object.ObjectRefMethodInfo + ResolveVideoAggregatorConvertPadMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveVideoAggregatorConvertPadMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo + ResolveVideoAggregatorConvertPadMethod "removeProbe" o = Gst.Pad.PadRemoveProbeMethodInfo + ResolveVideoAggregatorConvertPadMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveVideoAggregatorConvertPadMethod "sendEvent" o = Gst.Pad.PadSendEventMethodInfo + ResolveVideoAggregatorConvertPadMethod "startTask" o = Gst.Pad.PadStartTaskMethodInfo + ResolveVideoAggregatorConvertPadMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveVideoAggregatorConvertPadMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveVideoAggregatorConvertPadMethod "stickyEventsForeach" o = Gst.Pad.PadStickyEventsForeachMethodInfo + ResolveVideoAggregatorConvertPadMethod "stopTask" o = Gst.Pad.PadStopTaskMethodInfo + ResolveVideoAggregatorConvertPadMethod "storeStickyEvent" o = Gst.Pad.PadStoreStickyEventMethodInfo + ResolveVideoAggregatorConvertPadMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo + ResolveVideoAggregatorConvertPadMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo + ResolveVideoAggregatorConvertPadMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveVideoAggregatorConvertPadMethod "unlink" o = Gst.Pad.PadUnlinkMethodInfo + ResolveVideoAggregatorConvertPadMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo + ResolveVideoAggregatorConvertPadMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo + ResolveVideoAggregatorConvertPadMethod "updateConversionInfo" o = VideoAggregatorConvertPadUpdateConversionInfoMethodInfo + ResolveVideoAggregatorConvertPadMethod "useFixedCaps" o = Gst.Pad.PadUseFixedCapsMethodInfo + ResolveVideoAggregatorConvertPadMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveVideoAggregatorConvertPadMethod "getAllowedCaps" o = Gst.Pad.PadGetAllowedCapsMethodInfo + ResolveVideoAggregatorConvertPadMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo + ResolveVideoAggregatorConvertPadMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo + ResolveVideoAggregatorConvertPadMethod "getCurrentBuffer" o = GstVideo.VideoAggregatorPad.VideoAggregatorPadGetCurrentBufferMethodInfo + ResolveVideoAggregatorConvertPadMethod "getCurrentCaps" o = Gst.Pad.PadGetCurrentCapsMethodInfo + ResolveVideoAggregatorConvertPadMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveVideoAggregatorConvertPadMethod "getDirection" o = Gst.Pad.PadGetDirectionMethodInfo + ResolveVideoAggregatorConvertPadMethod "getElementPrivate" o = Gst.Pad.PadGetElementPrivateMethodInfo + ResolveVideoAggregatorConvertPadMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo + ResolveVideoAggregatorConvertPadMethod "getLastFlowReturn" o = Gst.Pad.PadGetLastFlowReturnMethodInfo + ResolveVideoAggregatorConvertPadMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo + ResolveVideoAggregatorConvertPadMethod "getOffset" o = Gst.Pad.PadGetOffsetMethodInfo + ResolveVideoAggregatorConvertPadMethod "getPadTemplate" o = Gst.Pad.PadGetPadTemplateMethodInfo + ResolveVideoAggregatorConvertPadMethod "getPadTemplateCaps" o = Gst.Pad.PadGetPadTemplateCapsMethodInfo + ResolveVideoAggregatorConvertPadMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo + ResolveVideoAggregatorConvertPadMethod "getParentElement" o = Gst.Pad.PadGetParentElementMethodInfo + ResolveVideoAggregatorConvertPadMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo + ResolveVideoAggregatorConvertPadMethod "getPeer" o = Gst.Pad.PadGetPeerMethodInfo + ResolveVideoAggregatorConvertPadMethod "getPreparedFrame" o = GstVideo.VideoAggregatorPad.VideoAggregatorPadGetPreparedFrameMethodInfo + ResolveVideoAggregatorConvertPadMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveVideoAggregatorConvertPadMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveVideoAggregatorConvertPadMethod "getRange" o = Gst.Pad.PadGetRangeMethodInfo + ResolveVideoAggregatorConvertPadMethod "getStickyEvent" o = Gst.Pad.PadGetStickyEventMethodInfo + ResolveVideoAggregatorConvertPadMethod "getStream" o = Gst.Pad.PadGetStreamMethodInfo + ResolveVideoAggregatorConvertPadMethod "getStreamId" o = Gst.Pad.PadGetStreamIdMethodInfo + ResolveVideoAggregatorConvertPadMethod "getTaskState" o = Gst.Pad.PadGetTaskStateMethodInfo + ResolveVideoAggregatorConvertPadMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo + ResolveVideoAggregatorConvertPadMethod "setActivateFunctionFull" o = Gst.Pad.PadSetActivateFunctionFullMethodInfo + ResolveVideoAggregatorConvertPadMethod "setActivatemodeFunctionFull" o = Gst.Pad.PadSetActivatemodeFunctionFullMethodInfo + ResolveVideoAggregatorConvertPadMethod "setActive" o = Gst.Pad.PadSetActiveMethodInfo + ResolveVideoAggregatorConvertPadMethod "setChainFunctionFull" o = Gst.Pad.PadSetChainFunctionFullMethodInfo + ResolveVideoAggregatorConvertPadMethod "setChainListFunctionFull" o = Gst.Pad.PadSetChainListFunctionFullMethodInfo + ResolveVideoAggregatorConvertPadMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo + ResolveVideoAggregatorConvertPadMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo + ResolveVideoAggregatorConvertPadMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo + ResolveVideoAggregatorConvertPadMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveVideoAggregatorConvertPadMethod "setElementPrivate" o = Gst.Pad.PadSetElementPrivateMethodInfo + ResolveVideoAggregatorConvertPadMethod "setEventFullFunctionFull" o = Gst.Pad.PadSetEventFullFunctionFullMethodInfo + ResolveVideoAggregatorConvertPadMethod "setEventFunctionFull" o = Gst.Pad.PadSetEventFunctionFullMethodInfo + ResolveVideoAggregatorConvertPadMethod "setGetrangeFunctionFull" o = Gst.Pad.PadSetGetrangeFunctionFullMethodInfo + ResolveVideoAggregatorConvertPadMethod "setIterateInternalLinksFunctionFull" o = Gst.Pad.PadSetIterateInternalLinksFunctionFullMethodInfo + ResolveVideoAggregatorConvertPadMethod "setLinkFunctionFull" o = Gst.Pad.PadSetLinkFunctionFullMethodInfo + ResolveVideoAggregatorConvertPadMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo + ResolveVideoAggregatorConvertPadMethod "setNeedsAlpha" o = GstVideo.VideoAggregatorPad.VideoAggregatorPadSetNeedsAlphaMethodInfo + ResolveVideoAggregatorConvertPadMethod "setOffset" o = Gst.Pad.PadSetOffsetMethodInfo + ResolveVideoAggregatorConvertPadMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo + ResolveVideoAggregatorConvertPadMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveVideoAggregatorConvertPadMethod "setQueryFunctionFull" o = Gst.Pad.PadSetQueryFunctionFullMethodInfo + ResolveVideoAggregatorConvertPadMethod "setUnlinkFunctionFull" o = Gst.Pad.PadSetUnlinkFunctionFullMethodInfo + ResolveVideoAggregatorConvertPadMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoAggregatorConvertPadMethod t VideoAggregatorConvertPad, O.MethodInfo info VideoAggregatorConvertPad p) => OL.IsLabel t (VideoAggregatorConvertPad -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- VVV Prop "converter-config" + -- Type: TInterface (Name {namespace = "Gst", name = "Structure"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@converter-config@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoAggregatorConvertPad #converterConfig +@ +-} +getVideoAggregatorConvertPadConverterConfig :: (MonadIO m, IsVideoAggregatorConvertPad o) => o -> m (Maybe Gst.Structure.Structure) +getVideoAggregatorConvertPadConverterConfig obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "converter-config" Gst.Structure.Structure + +{- | +Set the value of the “@converter-config@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoAggregatorConvertPad [ #converterConfig 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoAggregatorConvertPadConverterConfig :: (MonadIO m, IsVideoAggregatorConvertPad o) => o -> Gst.Structure.Structure -> m () +setVideoAggregatorConvertPadConverterConfig obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "converter-config" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@converter-config@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructVideoAggregatorConvertPadConverterConfig :: (IsVideoAggregatorConvertPad o) => Gst.Structure.Structure -> IO (GValueConstruct o) +constructVideoAggregatorConvertPadConverterConfig val = B.Properties.constructObjectPropertyBoxed "converter-config" (Just val) + +{- | +Set the value of the “@converter-config@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #converterConfig +@ +-} +clearVideoAggregatorConvertPadConverterConfig :: (MonadIO m, IsVideoAggregatorConvertPad o) => o -> m () +clearVideoAggregatorConvertPadConverterConfig obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "converter-config" (Nothing :: Maybe Gst.Structure.Structure) + +#if ENABLE_OVERLOADING +data VideoAggregatorConvertPadConverterConfigPropertyInfo +instance AttrInfo VideoAggregatorConvertPadConverterConfigPropertyInfo where + type AttrAllowedOps VideoAggregatorConvertPadConverterConfigPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoAggregatorConvertPadConverterConfigPropertyInfo = (~) Gst.Structure.Structure + type AttrBaseTypeConstraint VideoAggregatorConvertPadConverterConfigPropertyInfo = IsVideoAggregatorConvertPad + type AttrGetType VideoAggregatorConvertPadConverterConfigPropertyInfo = (Maybe Gst.Structure.Structure) + type AttrLabel VideoAggregatorConvertPadConverterConfigPropertyInfo = "converter-config" + type AttrOrigin VideoAggregatorConvertPadConverterConfigPropertyInfo = VideoAggregatorConvertPad + attrGet _ = getVideoAggregatorConvertPadConverterConfig + attrSet _ = setVideoAggregatorConvertPadConverterConfig + attrConstruct _ = constructVideoAggregatorConvertPadConverterConfig + attrClear _ = clearVideoAggregatorConvertPadConverterConfig +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoAggregatorConvertPad +type instance O.AttributeList VideoAggregatorConvertPad = VideoAggregatorConvertPadAttributeList +type VideoAggregatorConvertPadAttributeList = ('[ '("caps", Gst.Pad.PadCapsPropertyInfo), '("converterConfig", VideoAggregatorConvertPadConverterConfigPropertyInfo), '("direction", Gst.Pad.PadDirectionPropertyInfo), '("emitSignals", GstBase.AggregatorPad.AggregatorPadEmitSignalsPropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("offset", Gst.Pad.PadOffsetPropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("repeatAfterEos", GstVideo.VideoAggregatorPad.VideoAggregatorPadRepeatAfterEosPropertyInfo), '("template", Gst.Pad.PadTemplatePropertyInfo), '("zorder", GstVideo.VideoAggregatorPad.VideoAggregatorPadZorderPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +videoAggregatorConvertPadConverterConfig :: AttrLabelProxy "converterConfig" +videoAggregatorConvertPadConverterConfig = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList VideoAggregatorConvertPad = VideoAggregatorConvertPadSignalList +type VideoAggregatorConvertPadSignalList = ('[ '("bufferConsumed", GstBase.AggregatorPad.AggregatorPadBufferConsumedSignalInfo), '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("linked", Gst.Pad.PadLinkedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("unlinked", Gst.Pad.PadUnlinkedSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method VideoAggregatorConvertPad::update_conversion_info +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAggregatorConvertPad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoAggregatorPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_aggregator_convert_pad_update_conversion_info" gst_video_aggregator_convert_pad_update_conversion_info :: + Ptr VideoAggregatorConvertPad -> -- pad : TInterface (Name {namespace = "GstVideo", name = "VideoAggregatorConvertPad"}) + IO () + +{- | +Requests the pad to check and update the converter before the next usage to +update for any changes that have happened. +-} +videoAggregatorConvertPadUpdateConversionInfo :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoAggregatorConvertPad a) => + a + {- ^ /@pad@/: a 'GI.GstVideo.Objects.VideoAggregatorPad.VideoAggregatorPad' -} + -> m () +videoAggregatorConvertPadUpdateConversionInfo pad = liftIO $ do + pad' <- unsafeManagedPtrCastPtr pad + gst_video_aggregator_convert_pad_update_conversion_info pad' + touchManagedPtr pad + return () + +#if ENABLE_OVERLOADING +data VideoAggregatorConvertPadUpdateConversionInfoMethodInfo +instance (signature ~ (m ()), MonadIO m, IsVideoAggregatorConvertPad a) => O.MethodInfo VideoAggregatorConvertPadUpdateConversionInfoMethodInfo a signature where + overloadedMethod _ = videoAggregatorConvertPadUpdateConversionInfo + +#endif + + diff --git a/GI/GstVideo/Objects/VideoAggregatorConvertPad.hs-boot b/GI/GstVideo/Objects/VideoAggregatorConvertPad.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoAggregatorConvertPad.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Objects.VideoAggregatorConvertPad where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoAggregatorConvertPad = VideoAggregatorConvertPad (ManagedPtr VideoAggregatorConvertPad) +instance GObject VideoAggregatorConvertPad where +class (GObject o, O.IsDescendantOf VideoAggregatorConvertPad o) => IsVideoAggregatorConvertPad o +instance (GObject o, O.IsDescendantOf VideoAggregatorConvertPad o) => IsVideoAggregatorConvertPad o +instance O.HasParentTypes VideoAggregatorConvertPad +#if ENABLE_OVERLOADING +data VideoAggregatorConvertPadConverterConfigPropertyInfo +#endif +#if ENABLE_OVERLOADING +data VideoAggregatorConvertPadUpdateConversionInfoMethodInfo +#endif diff --git a/GI/GstVideo/Objects/VideoAggregatorPad.hs b/GI/GstVideo/Objects/VideoAggregatorPad.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoAggregatorPad.hs @@ -0,0 +1,566 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Objects.VideoAggregatorPad + ( + +-- * Exported types + VideoAggregatorPad(..) , + IsVideoAggregatorPad , + toVideoAggregatorPad , + noVideoAggregatorPad , + + + -- * Methods +-- ** getCurrentBuffer #method:getCurrentBuffer# + +#if ENABLE_OVERLOADING + VideoAggregatorPadGetCurrentBufferMethodInfo, +#endif + videoAggregatorPadGetCurrentBuffer , + + +-- ** getPreparedFrame #method:getPreparedFrame# + +#if ENABLE_OVERLOADING + VideoAggregatorPadGetPreparedFrameMethodInfo, +#endif + videoAggregatorPadGetPreparedFrame , + + +-- ** hasCurrentBuffer #method:hasCurrentBuffer# + +#if ENABLE_OVERLOADING + VideoAggregatorPadHasCurrentBufferMethodInfo, +#endif + videoAggregatorPadHasCurrentBuffer , + + +-- ** setNeedsAlpha #method:setNeedsAlpha# + +#if ENABLE_OVERLOADING + VideoAggregatorPadSetNeedsAlphaMethodInfo, +#endif + videoAggregatorPadSetNeedsAlpha , + + + + + -- * Properties +-- ** repeatAfterEos #attr:repeatAfterEos# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + VideoAggregatorPadRepeatAfterEosPropertyInfo, +#endif + constructVideoAggregatorPadRepeatAfterEos, + getVideoAggregatorPadRepeatAfterEos , + setVideoAggregatorPadRepeatAfterEos , +#if ENABLE_OVERLOADING + videoAggregatorPadRepeatAfterEos , +#endif + + +-- ** zorder #attr:zorder# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + VideoAggregatorPadZorderPropertyInfo , +#endif + constructVideoAggregatorPadZorder , + getVideoAggregatorPadZorder , + setVideoAggregatorPadZorder , +#if ENABLE_OVERLOADING + videoAggregatorPadZorder , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gst.Objects.Object as Gst.Object +import qualified GI.Gst.Objects.Pad as Gst.Pad +import qualified GI.Gst.Structs.Buffer as Gst.Buffer +import qualified GI.GstBase.Objects.AggregatorPad as GstBase.AggregatorPad +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoFrame as GstVideo.VideoFrame + +-- | Memory-managed wrapper type. +newtype VideoAggregatorPad = VideoAggregatorPad (ManagedPtr VideoAggregatorPad) +foreign import ccall "gst_video_aggregator_pad_get_type" + c_gst_video_aggregator_pad_get_type :: IO GType + +instance GObject VideoAggregatorPad where + gobjectType = c_gst_video_aggregator_pad_get_type + + +-- | Type class for types which can be safely cast to `VideoAggregatorPad`, for instance with `toVideoAggregatorPad`. +class (GObject o, O.IsDescendantOf VideoAggregatorPad o) => IsVideoAggregatorPad o +instance (GObject o, O.IsDescendantOf VideoAggregatorPad o) => IsVideoAggregatorPad o + +instance O.HasParentTypes VideoAggregatorPad +type instance O.ParentTypes VideoAggregatorPad = '[GstBase.AggregatorPad.AggregatorPad, Gst.Pad.Pad, Gst.Object.Object, GObject.Object.Object] + +-- | Cast to `VideoAggregatorPad`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toVideoAggregatorPad :: (MonadIO m, IsVideoAggregatorPad o) => o -> m VideoAggregatorPad +toVideoAggregatorPad = liftIO . unsafeCastTo VideoAggregatorPad + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoAggregatorPad`. +noVideoAggregatorPad :: Maybe VideoAggregatorPad +noVideoAggregatorPad = Nothing + +#if ENABLE_OVERLOADING +type family ResolveVideoAggregatorPadMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoAggregatorPadMethod "activateMode" o = Gst.Pad.PadActivateModeMethodInfo + ResolveVideoAggregatorPadMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo + ResolveVideoAggregatorPadMethod "addProbe" o = Gst.Pad.PadAddProbeMethodInfo + ResolveVideoAggregatorPadMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveVideoAggregatorPadMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveVideoAggregatorPadMethod "canLink" o = Gst.Pad.PadCanLinkMethodInfo + ResolveVideoAggregatorPadMethod "chain" o = Gst.Pad.PadChainMethodInfo + ResolveVideoAggregatorPadMethod "chainList" o = Gst.Pad.PadChainListMethodInfo + ResolveVideoAggregatorPadMethod "checkReconfigure" o = Gst.Pad.PadCheckReconfigureMethodInfo + ResolveVideoAggregatorPadMethod "createStreamId" o = Gst.Pad.PadCreateStreamIdMethodInfo + ResolveVideoAggregatorPadMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo + ResolveVideoAggregatorPadMethod "dropBuffer" o = GstBase.AggregatorPad.AggregatorPadDropBufferMethodInfo + ResolveVideoAggregatorPadMethod "eventDefault" o = Gst.Pad.PadEventDefaultMethodInfo + ResolveVideoAggregatorPadMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveVideoAggregatorPadMethod "forward" o = Gst.Pad.PadForwardMethodInfo + ResolveVideoAggregatorPadMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveVideoAggregatorPadMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveVideoAggregatorPadMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo + ResolveVideoAggregatorPadMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo + ResolveVideoAggregatorPadMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo + ResolveVideoAggregatorPadMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo + ResolveVideoAggregatorPadMethod "hasBuffer" o = GstBase.AggregatorPad.AggregatorPadHasBufferMethodInfo + ResolveVideoAggregatorPadMethod "hasCurrentBuffer" o = VideoAggregatorPadHasCurrentBufferMethodInfo + ResolveVideoAggregatorPadMethod "hasCurrentCaps" o = Gst.Pad.PadHasCurrentCapsMethodInfo + ResolveVideoAggregatorPadMethod "isActive" o = Gst.Pad.PadIsActiveMethodInfo + ResolveVideoAggregatorPadMethod "isBlocked" o = Gst.Pad.PadIsBlockedMethodInfo + ResolveVideoAggregatorPadMethod "isBlocking" o = Gst.Pad.PadIsBlockingMethodInfo + ResolveVideoAggregatorPadMethod "isEos" o = GstBase.AggregatorPad.AggregatorPadIsEosMethodInfo + ResolveVideoAggregatorPadMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveVideoAggregatorPadMethod "isLinked" o = Gst.Pad.PadIsLinkedMethodInfo + ResolveVideoAggregatorPadMethod "iterateInternalLinks" o = Gst.Pad.PadIterateInternalLinksMethodInfo + ResolveVideoAggregatorPadMethod "iterateInternalLinksDefault" o = Gst.Pad.PadIterateInternalLinksDefaultMethodInfo + ResolveVideoAggregatorPadMethod "link" o = Gst.Pad.PadLinkMethodInfo + ResolveVideoAggregatorPadMethod "linkFull" o = Gst.Pad.PadLinkFullMethodInfo + ResolveVideoAggregatorPadMethod "linkMaybeGhosting" o = Gst.Pad.PadLinkMaybeGhostingMethodInfo + ResolveVideoAggregatorPadMethod "linkMaybeGhostingFull" o = Gst.Pad.PadLinkMaybeGhostingFullMethodInfo + ResolveVideoAggregatorPadMethod "markReconfigure" o = Gst.Pad.PadMarkReconfigureMethodInfo + ResolveVideoAggregatorPadMethod "needsReconfigure" o = Gst.Pad.PadNeedsReconfigureMethodInfo + ResolveVideoAggregatorPadMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveVideoAggregatorPadMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveVideoAggregatorPadMethod "pauseTask" o = Gst.Pad.PadPauseTaskMethodInfo + ResolveVideoAggregatorPadMethod "peekBuffer" o = GstBase.AggregatorPad.AggregatorPadPeekBufferMethodInfo + ResolveVideoAggregatorPadMethod "peerQuery" o = Gst.Pad.PadPeerQueryMethodInfo + ResolveVideoAggregatorPadMethod "peerQueryAcceptCaps" o = Gst.Pad.PadPeerQueryAcceptCapsMethodInfo + ResolveVideoAggregatorPadMethod "peerQueryCaps" o = Gst.Pad.PadPeerQueryCapsMethodInfo + ResolveVideoAggregatorPadMethod "peerQueryConvert" o = Gst.Pad.PadPeerQueryConvertMethodInfo + ResolveVideoAggregatorPadMethod "peerQueryDuration" o = Gst.Pad.PadPeerQueryDurationMethodInfo + ResolveVideoAggregatorPadMethod "peerQueryPosition" o = Gst.Pad.PadPeerQueryPositionMethodInfo + ResolveVideoAggregatorPadMethod "popBuffer" o = GstBase.AggregatorPad.AggregatorPadPopBufferMethodInfo + ResolveVideoAggregatorPadMethod "proxyQueryAcceptCaps" o = Gst.Pad.PadProxyQueryAcceptCapsMethodInfo + ResolveVideoAggregatorPadMethod "proxyQueryCaps" o = Gst.Pad.PadProxyQueryCapsMethodInfo + ResolveVideoAggregatorPadMethod "pullRange" o = Gst.Pad.PadPullRangeMethodInfo + ResolveVideoAggregatorPadMethod "push" o = Gst.Pad.PadPushMethodInfo + ResolveVideoAggregatorPadMethod "pushEvent" o = Gst.Pad.PadPushEventMethodInfo + ResolveVideoAggregatorPadMethod "pushList" o = Gst.Pad.PadPushListMethodInfo + ResolveVideoAggregatorPadMethod "query" o = Gst.Pad.PadQueryMethodInfo + ResolveVideoAggregatorPadMethod "queryAcceptCaps" o = Gst.Pad.PadQueryAcceptCapsMethodInfo + ResolveVideoAggregatorPadMethod "queryCaps" o = Gst.Pad.PadQueryCapsMethodInfo + ResolveVideoAggregatorPadMethod "queryConvert" o = Gst.Pad.PadQueryConvertMethodInfo + ResolveVideoAggregatorPadMethod "queryDefault" o = Gst.Pad.PadQueryDefaultMethodInfo + ResolveVideoAggregatorPadMethod "queryDuration" o = Gst.Pad.PadQueryDurationMethodInfo + ResolveVideoAggregatorPadMethod "queryPosition" o = Gst.Pad.PadQueryPositionMethodInfo + ResolveVideoAggregatorPadMethod "ref" o = Gst.Object.ObjectRefMethodInfo + ResolveVideoAggregatorPadMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveVideoAggregatorPadMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo + ResolveVideoAggregatorPadMethod "removeProbe" o = Gst.Pad.PadRemoveProbeMethodInfo + ResolveVideoAggregatorPadMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveVideoAggregatorPadMethod "sendEvent" o = Gst.Pad.PadSendEventMethodInfo + ResolveVideoAggregatorPadMethod "startTask" o = Gst.Pad.PadStartTaskMethodInfo + ResolveVideoAggregatorPadMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveVideoAggregatorPadMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveVideoAggregatorPadMethod "stickyEventsForeach" o = Gst.Pad.PadStickyEventsForeachMethodInfo + ResolveVideoAggregatorPadMethod "stopTask" o = Gst.Pad.PadStopTaskMethodInfo + ResolveVideoAggregatorPadMethod "storeStickyEvent" o = Gst.Pad.PadStoreStickyEventMethodInfo + ResolveVideoAggregatorPadMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo + ResolveVideoAggregatorPadMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo + ResolveVideoAggregatorPadMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveVideoAggregatorPadMethod "unlink" o = Gst.Pad.PadUnlinkMethodInfo + ResolveVideoAggregatorPadMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo + ResolveVideoAggregatorPadMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo + ResolveVideoAggregatorPadMethod "useFixedCaps" o = Gst.Pad.PadUseFixedCapsMethodInfo + ResolveVideoAggregatorPadMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveVideoAggregatorPadMethod "getAllowedCaps" o = Gst.Pad.PadGetAllowedCapsMethodInfo + ResolveVideoAggregatorPadMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo + ResolveVideoAggregatorPadMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo + ResolveVideoAggregatorPadMethod "getCurrentBuffer" o = VideoAggregatorPadGetCurrentBufferMethodInfo + ResolveVideoAggregatorPadMethod "getCurrentCaps" o = Gst.Pad.PadGetCurrentCapsMethodInfo + ResolveVideoAggregatorPadMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveVideoAggregatorPadMethod "getDirection" o = Gst.Pad.PadGetDirectionMethodInfo + ResolveVideoAggregatorPadMethod "getElementPrivate" o = Gst.Pad.PadGetElementPrivateMethodInfo + ResolveVideoAggregatorPadMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo + ResolveVideoAggregatorPadMethod "getLastFlowReturn" o = Gst.Pad.PadGetLastFlowReturnMethodInfo + ResolveVideoAggregatorPadMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo + ResolveVideoAggregatorPadMethod "getOffset" o = Gst.Pad.PadGetOffsetMethodInfo + ResolveVideoAggregatorPadMethod "getPadTemplate" o = Gst.Pad.PadGetPadTemplateMethodInfo + ResolveVideoAggregatorPadMethod "getPadTemplateCaps" o = Gst.Pad.PadGetPadTemplateCapsMethodInfo + ResolveVideoAggregatorPadMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo + ResolveVideoAggregatorPadMethod "getParentElement" o = Gst.Pad.PadGetParentElementMethodInfo + ResolveVideoAggregatorPadMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo + ResolveVideoAggregatorPadMethod "getPeer" o = Gst.Pad.PadGetPeerMethodInfo + ResolveVideoAggregatorPadMethod "getPreparedFrame" o = VideoAggregatorPadGetPreparedFrameMethodInfo + ResolveVideoAggregatorPadMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveVideoAggregatorPadMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveVideoAggregatorPadMethod "getRange" o = Gst.Pad.PadGetRangeMethodInfo + ResolveVideoAggregatorPadMethod "getStickyEvent" o = Gst.Pad.PadGetStickyEventMethodInfo + ResolveVideoAggregatorPadMethod "getStream" o = Gst.Pad.PadGetStreamMethodInfo + ResolveVideoAggregatorPadMethod "getStreamId" o = Gst.Pad.PadGetStreamIdMethodInfo + ResolveVideoAggregatorPadMethod "getTaskState" o = Gst.Pad.PadGetTaskStateMethodInfo + ResolveVideoAggregatorPadMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo + ResolveVideoAggregatorPadMethod "setActivateFunctionFull" o = Gst.Pad.PadSetActivateFunctionFullMethodInfo + ResolveVideoAggregatorPadMethod "setActivatemodeFunctionFull" o = Gst.Pad.PadSetActivatemodeFunctionFullMethodInfo + ResolveVideoAggregatorPadMethod "setActive" o = Gst.Pad.PadSetActiveMethodInfo + ResolveVideoAggregatorPadMethod "setChainFunctionFull" o = Gst.Pad.PadSetChainFunctionFullMethodInfo + ResolveVideoAggregatorPadMethod "setChainListFunctionFull" o = Gst.Pad.PadSetChainListFunctionFullMethodInfo + ResolveVideoAggregatorPadMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo + ResolveVideoAggregatorPadMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo + ResolveVideoAggregatorPadMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo + ResolveVideoAggregatorPadMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveVideoAggregatorPadMethod "setElementPrivate" o = Gst.Pad.PadSetElementPrivateMethodInfo + ResolveVideoAggregatorPadMethod "setEventFullFunctionFull" o = Gst.Pad.PadSetEventFullFunctionFullMethodInfo + ResolveVideoAggregatorPadMethod "setEventFunctionFull" o = Gst.Pad.PadSetEventFunctionFullMethodInfo + ResolveVideoAggregatorPadMethod "setGetrangeFunctionFull" o = Gst.Pad.PadSetGetrangeFunctionFullMethodInfo + ResolveVideoAggregatorPadMethod "setIterateInternalLinksFunctionFull" o = Gst.Pad.PadSetIterateInternalLinksFunctionFullMethodInfo + ResolveVideoAggregatorPadMethod "setLinkFunctionFull" o = Gst.Pad.PadSetLinkFunctionFullMethodInfo + ResolveVideoAggregatorPadMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo + ResolveVideoAggregatorPadMethod "setNeedsAlpha" o = VideoAggregatorPadSetNeedsAlphaMethodInfo + ResolveVideoAggregatorPadMethod "setOffset" o = Gst.Pad.PadSetOffsetMethodInfo + ResolveVideoAggregatorPadMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo + ResolveVideoAggregatorPadMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveVideoAggregatorPadMethod "setQueryFunctionFull" o = Gst.Pad.PadSetQueryFunctionFullMethodInfo + ResolveVideoAggregatorPadMethod "setUnlinkFunctionFull" o = Gst.Pad.PadSetUnlinkFunctionFullMethodInfo + ResolveVideoAggregatorPadMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoAggregatorPadMethod t VideoAggregatorPad, O.MethodInfo info VideoAggregatorPad p) => OL.IsLabel t (VideoAggregatorPad -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- VVV Prop "repeat-after-eos" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@repeat-after-eos@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoAggregatorPad #repeatAfterEos +@ +-} +getVideoAggregatorPadRepeatAfterEos :: (MonadIO m, IsVideoAggregatorPad o) => o -> m Bool +getVideoAggregatorPadRepeatAfterEos obj = liftIO $ B.Properties.getObjectPropertyBool obj "repeat-after-eos" + +{- | +Set the value of the “@repeat-after-eos@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoAggregatorPad [ #repeatAfterEos 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoAggregatorPadRepeatAfterEos :: (MonadIO m, IsVideoAggregatorPad o) => o -> Bool -> m () +setVideoAggregatorPadRepeatAfterEos obj val = liftIO $ B.Properties.setObjectPropertyBool obj "repeat-after-eos" val + +{- | +Construct a `GValueConstruct` with valid value for the “@repeat-after-eos@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructVideoAggregatorPadRepeatAfterEos :: (IsVideoAggregatorPad o) => Bool -> IO (GValueConstruct o) +constructVideoAggregatorPadRepeatAfterEos val = B.Properties.constructObjectPropertyBool "repeat-after-eos" val + +#if ENABLE_OVERLOADING +data VideoAggregatorPadRepeatAfterEosPropertyInfo +instance AttrInfo VideoAggregatorPadRepeatAfterEosPropertyInfo where + type AttrAllowedOps VideoAggregatorPadRepeatAfterEosPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint VideoAggregatorPadRepeatAfterEosPropertyInfo = (~) Bool + type AttrBaseTypeConstraint VideoAggregatorPadRepeatAfterEosPropertyInfo = IsVideoAggregatorPad + type AttrGetType VideoAggregatorPadRepeatAfterEosPropertyInfo = Bool + type AttrLabel VideoAggregatorPadRepeatAfterEosPropertyInfo = "repeat-after-eos" + type AttrOrigin VideoAggregatorPadRepeatAfterEosPropertyInfo = VideoAggregatorPad + attrGet _ = getVideoAggregatorPadRepeatAfterEos + attrSet _ = setVideoAggregatorPadRepeatAfterEos + attrConstruct _ = constructVideoAggregatorPadRepeatAfterEos + attrClear _ = undefined +#endif + +-- VVV Prop "zorder" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@zorder@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoAggregatorPad #zorder +@ +-} +getVideoAggregatorPadZorder :: (MonadIO m, IsVideoAggregatorPad o) => o -> m Word32 +getVideoAggregatorPadZorder obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "zorder" + +{- | +Set the value of the “@zorder@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoAggregatorPad [ #zorder 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoAggregatorPadZorder :: (MonadIO m, IsVideoAggregatorPad o) => o -> Word32 -> m () +setVideoAggregatorPadZorder obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "zorder" val + +{- | +Construct a `GValueConstruct` with valid value for the “@zorder@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructVideoAggregatorPadZorder :: (IsVideoAggregatorPad o) => Word32 -> IO (GValueConstruct o) +constructVideoAggregatorPadZorder val = B.Properties.constructObjectPropertyUInt32 "zorder" val + +#if ENABLE_OVERLOADING +data VideoAggregatorPadZorderPropertyInfo +instance AttrInfo VideoAggregatorPadZorderPropertyInfo where + type AttrAllowedOps VideoAggregatorPadZorderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint VideoAggregatorPadZorderPropertyInfo = (~) Word32 + type AttrBaseTypeConstraint VideoAggregatorPadZorderPropertyInfo = IsVideoAggregatorPad + type AttrGetType VideoAggregatorPadZorderPropertyInfo = Word32 + type AttrLabel VideoAggregatorPadZorderPropertyInfo = "zorder" + type AttrOrigin VideoAggregatorPadZorderPropertyInfo = VideoAggregatorPad + attrGet _ = getVideoAggregatorPadZorder + attrSet _ = setVideoAggregatorPadZorder + attrConstruct _ = constructVideoAggregatorPadZorder + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoAggregatorPad +type instance O.AttributeList VideoAggregatorPad = VideoAggregatorPadAttributeList +type VideoAggregatorPadAttributeList = ('[ '("caps", Gst.Pad.PadCapsPropertyInfo), '("direction", Gst.Pad.PadDirectionPropertyInfo), '("emitSignals", GstBase.AggregatorPad.AggregatorPadEmitSignalsPropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("offset", Gst.Pad.PadOffsetPropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("repeatAfterEos", VideoAggregatorPadRepeatAfterEosPropertyInfo), '("template", Gst.Pad.PadTemplatePropertyInfo), '("zorder", VideoAggregatorPadZorderPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +videoAggregatorPadRepeatAfterEos :: AttrLabelProxy "repeatAfterEos" +videoAggregatorPadRepeatAfterEos = AttrLabelProxy + +videoAggregatorPadZorder :: AttrLabelProxy "zorder" +videoAggregatorPadZorder = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList VideoAggregatorPad = VideoAggregatorPadSignalList +type VideoAggregatorPadSignalList = ('[ '("bufferConsumed", GstBase.AggregatorPad.AggregatorPadBufferConsumedSignalInfo), '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("linked", Gst.Pad.PadLinkedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("unlinked", Gst.Pad.PadUnlinkedSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method VideoAggregatorPad::get_current_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAggregatorPad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoAggregatorPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Buffer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_aggregator_pad_get_current_buffer" gst_video_aggregator_pad_get_current_buffer :: + Ptr VideoAggregatorPad -> -- pad : TInterface (Name {namespace = "GstVideo", name = "VideoAggregatorPad"}) + IO (Ptr Gst.Buffer.Buffer) + +{- | +Returns the currently queued buffer that is going to be used +for the current output frame. + +This must only be called from the @/aggregate_frames()/@ virtual method, +or from the @/prepare_frame()/@ virtual method of the aggregator pads. + +The return value is only valid until @/aggregate_frames()/@ or @/prepare_frames()/@ +returns. +-} +videoAggregatorPadGetCurrentBuffer :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoAggregatorPad a) => + a + {- ^ /@pad@/: a 'GI.GstVideo.Objects.VideoAggregatorPad.VideoAggregatorPad' -} + -> m Gst.Buffer.Buffer + {- ^ __Returns:__ The currently queued buffer -} +videoAggregatorPadGetCurrentBuffer pad = liftIO $ do + pad' <- unsafeManagedPtrCastPtr pad + result <- gst_video_aggregator_pad_get_current_buffer pad' + checkUnexpectedReturnNULL "videoAggregatorPadGetCurrentBuffer" result + result' <- (newBoxed Gst.Buffer.Buffer) result + touchManagedPtr pad + return result' + +#if ENABLE_OVERLOADING +data VideoAggregatorPadGetCurrentBufferMethodInfo +instance (signature ~ (m Gst.Buffer.Buffer), MonadIO m, IsVideoAggregatorPad a) => O.MethodInfo VideoAggregatorPadGetCurrentBufferMethodInfo a signature where + overloadedMethod _ = videoAggregatorPadGetCurrentBuffer + +#endif + +-- method VideoAggregatorPad::get_prepared_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAggregatorPad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoAggregatorPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoFrame"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_aggregator_pad_get_prepared_frame" gst_video_aggregator_pad_get_prepared_frame :: + Ptr VideoAggregatorPad -> -- pad : TInterface (Name {namespace = "GstVideo", name = "VideoAggregatorPad"}) + IO (Ptr GstVideo.VideoFrame.VideoFrame) + +{- | +Returns the currently prepared video frame that has to be aggregated into +the current output frame. + +This must only be called from the @/aggregate_frames()/@ virtual method, +or from the @/prepare_frame()/@ virtual method of the aggregator pads. + +The return value is only valid until @/aggregate_frames()/@ or @/prepare_frames()/@ +returns. +-} +videoAggregatorPadGetPreparedFrame :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoAggregatorPad a) => + a + {- ^ /@pad@/: a 'GI.GstVideo.Objects.VideoAggregatorPad.VideoAggregatorPad' -} + -> m GstVideo.VideoFrame.VideoFrame + {- ^ __Returns:__ The currently prepared video frame -} +videoAggregatorPadGetPreparedFrame pad = liftIO $ do + pad' <- unsafeManagedPtrCastPtr pad + result <- gst_video_aggregator_pad_get_prepared_frame pad' + checkUnexpectedReturnNULL "videoAggregatorPadGetPreparedFrame" result + result' <- (newPtr GstVideo.VideoFrame.VideoFrame) result + touchManagedPtr pad + return result' + +#if ENABLE_OVERLOADING +data VideoAggregatorPadGetPreparedFrameMethodInfo +instance (signature ~ (m GstVideo.VideoFrame.VideoFrame), MonadIO m, IsVideoAggregatorPad a) => O.MethodInfo VideoAggregatorPadGetPreparedFrameMethodInfo a signature where + overloadedMethod _ = videoAggregatorPadGetPreparedFrame + +#endif + +-- method VideoAggregatorPad::has_current_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAggregatorPad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoAggregatorPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_aggregator_pad_has_current_buffer" gst_video_aggregator_pad_has_current_buffer :: + Ptr VideoAggregatorPad -> -- pad : TInterface (Name {namespace = "GstVideo", name = "VideoAggregatorPad"}) + IO CInt + +{- | +Checks if the pad currently has a buffer queued that is going to be used +for the current output frame. + +This must only be called from the @/aggregate_frames()/@ virtual method, +or from the @/prepare_frame()/@ virtual method of the aggregator pads. +-} +videoAggregatorPadHasCurrentBuffer :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoAggregatorPad a) => + a + {- ^ /@pad@/: a 'GI.GstVideo.Objects.VideoAggregatorPad.VideoAggregatorPad' -} + -> m Bool + {- ^ __Returns:__ 'True' if the pad has currently a buffer queued -} +videoAggregatorPadHasCurrentBuffer pad = liftIO $ do + pad' <- unsafeManagedPtrCastPtr pad + result <- gst_video_aggregator_pad_has_current_buffer pad' + let result' = (/= 0) result + touchManagedPtr pad + return result' + +#if ENABLE_OVERLOADING +data VideoAggregatorPadHasCurrentBufferMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsVideoAggregatorPad a) => O.MethodInfo VideoAggregatorPadHasCurrentBufferMethodInfo a signature where + overloadedMethod _ = videoAggregatorPadHasCurrentBuffer + +#endif + +-- method VideoAggregatorPad::set_needs_alpha +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "pad", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAggregatorPad"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoAggregatorPad", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "needs_alpha", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if this pad requires alpha output", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_aggregator_pad_set_needs_alpha" gst_video_aggregator_pad_set_needs_alpha :: + Ptr VideoAggregatorPad -> -- pad : TInterface (Name {namespace = "GstVideo", name = "VideoAggregatorPad"}) + CInt -> -- needs_alpha : TBasicType TBoolean + IO () + +{- | +Allows selecting that this pad requires an output format with alpha +-} +videoAggregatorPadSetNeedsAlpha :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoAggregatorPad a) => + a + {- ^ /@pad@/: a 'GI.GstVideo.Objects.VideoAggregatorPad.VideoAggregatorPad' -} + -> Bool + {- ^ /@needsAlpha@/: 'True' if this pad requires alpha output -} + -> m () +videoAggregatorPadSetNeedsAlpha pad needsAlpha = liftIO $ do + pad' <- unsafeManagedPtrCastPtr pad + let needsAlpha' = (fromIntegral . fromEnum) needsAlpha + gst_video_aggregator_pad_set_needs_alpha pad' needsAlpha' + touchManagedPtr pad + return () + +#if ENABLE_OVERLOADING +data VideoAggregatorPadSetNeedsAlphaMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsVideoAggregatorPad a) => O.MethodInfo VideoAggregatorPadSetNeedsAlphaMethodInfo a signature where + overloadedMethod _ = videoAggregatorPadSetNeedsAlpha + +#endif + + diff --git a/GI/GstVideo/Objects/VideoAggregatorPad.hs-boot b/GI/GstVideo/Objects/VideoAggregatorPad.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoAggregatorPad.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Objects.VideoAggregatorPad where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoAggregatorPad = VideoAggregatorPad (ManagedPtr VideoAggregatorPad) +instance GObject VideoAggregatorPad where +class (GObject o, O.IsDescendantOf VideoAggregatorPad o) => IsVideoAggregatorPad o +instance (GObject o, O.IsDescendantOf VideoAggregatorPad o) => IsVideoAggregatorPad o +instance O.HasParentTypes VideoAggregatorPad +#if ENABLE_OVERLOADING +data VideoAggregatorPadRepeatAfterEosPropertyInfo +#endif +#if ENABLE_OVERLOADING +data VideoAggregatorPadZorderPropertyInfo +#endif +#if ENABLE_OVERLOADING +data VideoAggregatorPadGetCurrentBufferMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoAggregatorPadGetPreparedFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoAggregatorPadHasCurrentBufferMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoAggregatorPadSetNeedsAlphaMethodInfo +#endif diff --git a/GI/GstVideo/Objects/VideoBufferPool.hs b/GI/GstVideo/Objects/VideoBufferPool.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoBufferPool.hs @@ -0,0 +1,190 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Objects.VideoBufferPool + ( + +-- * Exported types + VideoBufferPool(..) , + IsVideoBufferPool , + toVideoBufferPool , + noVideoBufferPool , + + + -- * Methods +-- ** new #method:new# + + videoBufferPoolNew , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gst.Objects.BufferPool as Gst.BufferPool +import qualified GI.Gst.Objects.Object as Gst.Object + +-- | Memory-managed wrapper type. +newtype VideoBufferPool = VideoBufferPool (ManagedPtr VideoBufferPool) +foreign import ccall "gst_video_buffer_pool_get_type" + c_gst_video_buffer_pool_get_type :: IO GType + +instance GObject VideoBufferPool where + gobjectType = c_gst_video_buffer_pool_get_type + + +-- | Type class for types which can be safely cast to `VideoBufferPool`, for instance with `toVideoBufferPool`. +class (GObject o, O.IsDescendantOf VideoBufferPool o) => IsVideoBufferPool o +instance (GObject o, O.IsDescendantOf VideoBufferPool o) => IsVideoBufferPool o + +instance O.HasParentTypes VideoBufferPool +type instance O.ParentTypes VideoBufferPool = '[Gst.BufferPool.BufferPool, Gst.Object.Object, GObject.Object.Object] + +-- | Cast to `VideoBufferPool`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toVideoBufferPool :: (MonadIO m, IsVideoBufferPool o) => o -> m VideoBufferPool +toVideoBufferPool = liftIO . unsafeCastTo VideoBufferPool + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoBufferPool`. +noVideoBufferPool :: Maybe VideoBufferPool +noVideoBufferPool = Nothing + +#if ENABLE_OVERLOADING +type family ResolveVideoBufferPoolMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoBufferPoolMethod "acquireBuffer" o = Gst.BufferPool.BufferPoolAcquireBufferMethodInfo + ResolveVideoBufferPoolMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo + ResolveVideoBufferPoolMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveVideoBufferPoolMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveVideoBufferPoolMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo + ResolveVideoBufferPoolMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveVideoBufferPoolMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveVideoBufferPoolMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveVideoBufferPoolMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo + ResolveVideoBufferPoolMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo + ResolveVideoBufferPoolMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo + ResolveVideoBufferPoolMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo + ResolveVideoBufferPoolMethod "hasOption" o = Gst.BufferPool.BufferPoolHasOptionMethodInfo + ResolveVideoBufferPoolMethod "isActive" o = Gst.BufferPool.BufferPoolIsActiveMethodInfo + ResolveVideoBufferPoolMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveVideoBufferPoolMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveVideoBufferPoolMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveVideoBufferPoolMethod "ref" o = Gst.Object.ObjectRefMethodInfo + ResolveVideoBufferPoolMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveVideoBufferPoolMethod "releaseBuffer" o = Gst.BufferPool.BufferPoolReleaseBufferMethodInfo + ResolveVideoBufferPoolMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo + ResolveVideoBufferPoolMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveVideoBufferPoolMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveVideoBufferPoolMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveVideoBufferPoolMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo + ResolveVideoBufferPoolMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo + ResolveVideoBufferPoolMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveVideoBufferPoolMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo + ResolveVideoBufferPoolMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo + ResolveVideoBufferPoolMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveVideoBufferPoolMethod "getConfig" o = Gst.BufferPool.BufferPoolGetConfigMethodInfo + ResolveVideoBufferPoolMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo + ResolveVideoBufferPoolMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo + ResolveVideoBufferPoolMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveVideoBufferPoolMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo + ResolveVideoBufferPoolMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo + ResolveVideoBufferPoolMethod "getOptions" o = Gst.BufferPool.BufferPoolGetOptionsMethodInfo + ResolveVideoBufferPoolMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo + ResolveVideoBufferPoolMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo + ResolveVideoBufferPoolMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveVideoBufferPoolMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveVideoBufferPoolMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo + ResolveVideoBufferPoolMethod "setActive" o = Gst.BufferPool.BufferPoolSetActiveMethodInfo + ResolveVideoBufferPoolMethod "setConfig" o = Gst.BufferPool.BufferPoolSetConfigMethodInfo + ResolveVideoBufferPoolMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo + ResolveVideoBufferPoolMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo + ResolveVideoBufferPoolMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo + ResolveVideoBufferPoolMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveVideoBufferPoolMethod "setFlushing" o = Gst.BufferPool.BufferPoolSetFlushingMethodInfo + ResolveVideoBufferPoolMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo + ResolveVideoBufferPoolMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo + ResolveVideoBufferPoolMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveVideoBufferPoolMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoBufferPoolMethod t VideoBufferPool, O.MethodInfo info VideoBufferPool p) => OL.IsLabel t (VideoBufferPool -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoBufferPool +type instance O.AttributeList VideoBufferPool = VideoBufferPoolAttributeList +type VideoBufferPoolAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList VideoBufferPool = VideoBufferPoolSignalList +type VideoBufferPoolSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method VideoBufferPool::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoBufferPool"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_buffer_pool_new" gst_video_buffer_pool_new :: + IO (Ptr VideoBufferPool) + +{- | +Create a new bufferpool that can allocate video frames. This bufferpool +supports all the video bufferpool options. +-} +videoBufferPoolNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m VideoBufferPool + {- ^ __Returns:__ a new 'GI.Gst.Objects.BufferPool.BufferPool' to allocate video frames -} +videoBufferPoolNew = liftIO $ do + result <- gst_video_buffer_pool_new + checkUnexpectedReturnNULL "videoBufferPoolNew" result + result' <- (wrapObject VideoBufferPool) result + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GstVideo/Objects/VideoBufferPool.hs-boot b/GI/GstVideo/Objects/VideoBufferPool.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoBufferPool.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Objects.VideoBufferPool where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoBufferPool = VideoBufferPool (ManagedPtr VideoBufferPool) +instance GObject VideoBufferPool where +class (GObject o, O.IsDescendantOf VideoBufferPool o) => IsVideoBufferPool o +instance (GObject o, O.IsDescendantOf VideoBufferPool o) => IsVideoBufferPool o +instance O.HasParentTypes VideoBufferPool diff --git a/GI/GstVideo/Objects/VideoDecoder.hs b/GI/GstVideo/Objects/VideoDecoder.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoDecoder.hs @@ -0,0 +1,2011 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +This base class is for video decoders turning encoded data into raw video +frames. + +The GstVideoDecoder base class and derived subclasses should cooperate as +follows: + +== Configuration + + * Initially, GstVideoDecoder calls /@start@/ when the decoder element + is activated, which allows the subclass to perform any global setup. + + * GstVideoDecoder calls /@setFormat@/ to inform the subclass of caps + describing input video data that it is about to receive, including + possibly configuration data. + While unlikely, it might be called more than once, if changing input + parameters require reconfiguration. + + * Incoming data buffers are processed as needed, described in Data + Processing below. + + * GstVideoDecoder calls /@stop@/ at end of all processing. + +== Data processing + + * The base class gathers input data, and optionally allows subclass + to parse this into subsequently manageable chunks, typically + corresponding to and referred to as \'frames\'. + + * Each input frame is provided in turn to the subclass\' /@handleFrame@/ + callback. + The ownership of the frame is given to the /@handleFrame@/ callback. + + * If codec processing results in decoded data, the subclass should call + /@gstVideoDecoderFinishFrame@/ to have decoded data pushed. + downstream. Otherwise, the subclass must call + /@gstVideoDecoderDropFrame@/, to allow the base class to do timestamp + and offset tracking, and possibly to requeue the frame for a later + attempt in the case of reverse playback. + +== Shutdown phase + + * The GstVideoDecoder class calls /@stop@/ to inform the subclass that data + parsing will be stopped. + +== Additional Notes + + * Seeking\/Flushing + + * When the pipeline is seeked or otherwise flushed, the subclass is + informed via a call to its /@reset@/ callback, with the hard parameter + set to true. This indicates the subclass should drop any internal data + queues and timestamps and prepare for a fresh set of buffers to arrive + for parsing and decoding. + + * End Of Stream + + * At end-of-stream, the subclass /@parse@/ function may be called some final + times with the at_eos parameter set to true, indicating that the element + should not expect any more data to be arriving, and it should parse and + remaining frames and call 'GI.GstVideo.Objects.VideoDecoder.videoDecoderHaveFrame' if possible. + +The subclass is responsible for providing pad template caps for +source and sink pads. The pads need to be named \"sink\" and \"src\". It also +needs to provide information about the ouptput caps, when they are known. +This may be when the base class calls the subclass\' /@setFormat@/ function, +though it might be during decoding, before calling +/@gstVideoDecoderFinishFrame@/. This is done via +/@gstVideoDecoderSetOutputState@/ + +The subclass is also responsible for providing (presentation) timestamps +(likely based on corresponding input ones). If that is not applicable +or possible, the base class provides limited framerate based interpolation. + +Similarly, the base class provides some limited (legacy) seeking support +if specifically requested by the subclass, as full-fledged support +should rather be left to upstream demuxer, parser or alike. This simple +approach caters for seeking and duration reporting using estimated input +bitrates. To enable it, a subclass should call +/@gstVideoDecoderSetEstimateRate@/ to enable handling of incoming +byte-streams. + +The base class provides some support for reverse playback, in particular +in case incoming data is not packetized or upstream does not provide +fragments on keyframe boundaries. However, the subclass should then be +prepared for the parsing and frame processing stage to occur separately +(in normal forward processing, the latter immediately follows the former), +The subclass also needs to ensure the parsing stage properly marks +keyframes, unless it knows the upstream elements will do so properly for +incoming data. + +The bare minimum that a functional subclass needs to implement is: + + * Provide pad templates + * Inform the base class of output caps via + /@gstVideoDecoderSetOutputState@/ + + * Parse input data, if it is not considered packetized from upstream + Data will be provided to /@parse@/ which should invoke + /@gstVideoDecoderAddToFrame@/ and /@gstVideoDecoderHaveFrame@/ to + separate the data belonging to each video frame. + + * Accept data in /@handleFrame@/ and provide decoded results to + /@gstVideoDecoderFinishFrame@/, or call /@gstVideoDecoderDropFrame@/. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Objects.VideoDecoder + ( + +-- * Exported types + VideoDecoder(..) , + IsVideoDecoder , + toVideoDecoder , + noVideoDecoder , + + + -- * Methods +-- ** addToFrame #method:addToFrame# + +#if ENABLE_OVERLOADING + VideoDecoderAddToFrameMethodInfo , +#endif + videoDecoderAddToFrame , + + +-- ** allocateOutputBuffer #method:allocateOutputBuffer# + +#if ENABLE_OVERLOADING + VideoDecoderAllocateOutputBufferMethodInfo, +#endif + videoDecoderAllocateOutputBuffer , + + +-- ** allocateOutputFrame #method:allocateOutputFrame# + +#if ENABLE_OVERLOADING + VideoDecoderAllocateOutputFrameMethodInfo, +#endif + videoDecoderAllocateOutputFrame , + + +-- ** allocateOutputFrameWithParams #method:allocateOutputFrameWithParams# + +#if ENABLE_OVERLOADING + VideoDecoderAllocateOutputFrameWithParamsMethodInfo, +#endif + videoDecoderAllocateOutputFrameWithParams, + + +-- ** dropFrame #method:dropFrame# + +#if ENABLE_OVERLOADING + VideoDecoderDropFrameMethodInfo , +#endif + videoDecoderDropFrame , + + +-- ** finishFrame #method:finishFrame# + +#if ENABLE_OVERLOADING + VideoDecoderFinishFrameMethodInfo , +#endif + videoDecoderFinishFrame , + + +-- ** getAllocator #method:getAllocator# + +#if ENABLE_OVERLOADING + VideoDecoderGetAllocatorMethodInfo , +#endif + videoDecoderGetAllocator , + + +-- ** getBufferPool #method:getBufferPool# + +#if ENABLE_OVERLOADING + VideoDecoderGetBufferPoolMethodInfo , +#endif + videoDecoderGetBufferPool , + + +-- ** getEstimateRate #method:getEstimateRate# + +#if ENABLE_OVERLOADING + VideoDecoderGetEstimateRateMethodInfo , +#endif + videoDecoderGetEstimateRate , + + +-- ** getFrame #method:getFrame# + +#if ENABLE_OVERLOADING + VideoDecoderGetFrameMethodInfo , +#endif + videoDecoderGetFrame , + + +-- ** getFrames #method:getFrames# + +#if ENABLE_OVERLOADING + VideoDecoderGetFramesMethodInfo , +#endif + videoDecoderGetFrames , + + +-- ** getLatency #method:getLatency# + +#if ENABLE_OVERLOADING + VideoDecoderGetLatencyMethodInfo , +#endif + videoDecoderGetLatency , + + +-- ** getMaxDecodeTime #method:getMaxDecodeTime# + +#if ENABLE_OVERLOADING + VideoDecoderGetMaxDecodeTimeMethodInfo , +#endif + videoDecoderGetMaxDecodeTime , + + +-- ** getMaxErrors #method:getMaxErrors# + +#if ENABLE_OVERLOADING + VideoDecoderGetMaxErrorsMethodInfo , +#endif + videoDecoderGetMaxErrors , + + +-- ** getNeedsFormat #method:getNeedsFormat# + +#if ENABLE_OVERLOADING + VideoDecoderGetNeedsFormatMethodInfo , +#endif + videoDecoderGetNeedsFormat , + + +-- ** getOldestFrame #method:getOldestFrame# + +#if ENABLE_OVERLOADING + VideoDecoderGetOldestFrameMethodInfo , +#endif + videoDecoderGetOldestFrame , + + +-- ** getOutputState #method:getOutputState# + +#if ENABLE_OVERLOADING + VideoDecoderGetOutputStateMethodInfo , +#endif + videoDecoderGetOutputState , + + +-- ** getPacketized #method:getPacketized# + +#if ENABLE_OVERLOADING + VideoDecoderGetPacketizedMethodInfo , +#endif + videoDecoderGetPacketized , + + +-- ** getPendingFrameSize #method:getPendingFrameSize# + +#if ENABLE_OVERLOADING + VideoDecoderGetPendingFrameSizeMethodInfo, +#endif + videoDecoderGetPendingFrameSize , + + +-- ** getQosProportion #method:getQosProportion# + +#if ENABLE_OVERLOADING + VideoDecoderGetQosProportionMethodInfo , +#endif + videoDecoderGetQosProportion , + + +-- ** haveFrame #method:haveFrame# + +#if ENABLE_OVERLOADING + VideoDecoderHaveFrameMethodInfo , +#endif + videoDecoderHaveFrame , + + +-- ** mergeTags #method:mergeTags# + +#if ENABLE_OVERLOADING + VideoDecoderMergeTagsMethodInfo , +#endif + videoDecoderMergeTags , + + +-- ** negotiate #method:negotiate# + +#if ENABLE_OVERLOADING + VideoDecoderNegotiateMethodInfo , +#endif + videoDecoderNegotiate , + + +-- ** proxyGetcaps #method:proxyGetcaps# + +#if ENABLE_OVERLOADING + VideoDecoderProxyGetcapsMethodInfo , +#endif + videoDecoderProxyGetcaps , + + +-- ** releaseFrame #method:releaseFrame# + +#if ENABLE_OVERLOADING + VideoDecoderReleaseFrameMethodInfo , +#endif + videoDecoderReleaseFrame , + + +-- ** setEstimateRate #method:setEstimateRate# + +#if ENABLE_OVERLOADING + VideoDecoderSetEstimateRateMethodInfo , +#endif + videoDecoderSetEstimateRate , + + +-- ** setInterlacedOutputState #method:setInterlacedOutputState# + +#if ENABLE_OVERLOADING + VideoDecoderSetInterlacedOutputStateMethodInfo, +#endif + videoDecoderSetInterlacedOutputState , + + +-- ** setLatency #method:setLatency# + +#if ENABLE_OVERLOADING + VideoDecoderSetLatencyMethodInfo , +#endif + videoDecoderSetLatency , + + +-- ** setMaxErrors #method:setMaxErrors# + +#if ENABLE_OVERLOADING + VideoDecoderSetMaxErrorsMethodInfo , +#endif + videoDecoderSetMaxErrors , + + +-- ** setNeedsFormat #method:setNeedsFormat# + +#if ENABLE_OVERLOADING + VideoDecoderSetNeedsFormatMethodInfo , +#endif + videoDecoderSetNeedsFormat , + + +-- ** setOutputState #method:setOutputState# + +#if ENABLE_OVERLOADING + VideoDecoderSetOutputStateMethodInfo , +#endif + videoDecoderSetOutputState , + + +-- ** setPacketized #method:setPacketized# + +#if ENABLE_OVERLOADING + VideoDecoderSetPacketizedMethodInfo , +#endif + videoDecoderSetPacketized , + + +-- ** setUseDefaultPadAcceptcaps #method:setUseDefaultPadAcceptcaps# + +#if ENABLE_OVERLOADING + VideoDecoderSetUseDefaultPadAcceptcapsMethodInfo, +#endif + videoDecoderSetUseDefaultPadAcceptcaps , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gst.Enums as Gst.Enums +import qualified GI.Gst.Objects.Allocator as Gst.Allocator +import qualified GI.Gst.Objects.BufferPool as Gst.BufferPool +import qualified GI.Gst.Objects.Element as Gst.Element +import qualified GI.Gst.Objects.Object as Gst.Object +import qualified GI.Gst.Structs.AllocationParams as Gst.AllocationParams +import qualified GI.Gst.Structs.Buffer as Gst.Buffer +import qualified GI.Gst.Structs.BufferPoolAcquireParams as Gst.BufferPoolAcquireParams +import qualified GI.Gst.Structs.Caps as Gst.Caps +import qualified GI.Gst.Structs.TagList as Gst.TagList +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoCodecFrame as GstVideo.VideoCodecFrame +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoCodecState as GstVideo.VideoCodecState + +-- | Memory-managed wrapper type. +newtype VideoDecoder = VideoDecoder (ManagedPtr VideoDecoder) +foreign import ccall "gst_video_decoder_get_type" + c_gst_video_decoder_get_type :: IO GType + +instance GObject VideoDecoder where + gobjectType = c_gst_video_decoder_get_type + + +-- | Type class for types which can be safely cast to `VideoDecoder`, for instance with `toVideoDecoder`. +class (GObject o, O.IsDescendantOf VideoDecoder o) => IsVideoDecoder o +instance (GObject o, O.IsDescendantOf VideoDecoder o) => IsVideoDecoder o + +instance O.HasParentTypes VideoDecoder +type instance O.ParentTypes VideoDecoder = '[Gst.Element.Element, Gst.Object.Object, GObject.Object.Object] + +-- | Cast to `VideoDecoder`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toVideoDecoder :: (MonadIO m, IsVideoDecoder o) => o -> m VideoDecoder +toVideoDecoder = liftIO . unsafeCastTo VideoDecoder + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoDecoder`. +noVideoDecoder :: Maybe VideoDecoder +noVideoDecoder = Nothing + +#if ENABLE_OVERLOADING +type family ResolveVideoDecoderMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoDecoderMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo + ResolveVideoDecoderMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo + ResolveVideoDecoderMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo + ResolveVideoDecoderMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo + ResolveVideoDecoderMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo + ResolveVideoDecoderMethod "addToFrame" o = VideoDecoderAddToFrameMethodInfo + ResolveVideoDecoderMethod "allocateOutputBuffer" o = VideoDecoderAllocateOutputBufferMethodInfo + ResolveVideoDecoderMethod "allocateOutputFrame" o = VideoDecoderAllocateOutputFrameMethodInfo + ResolveVideoDecoderMethod "allocateOutputFrameWithParams" o = VideoDecoderAllocateOutputFrameWithParamsMethodInfo + ResolveVideoDecoderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveVideoDecoderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveVideoDecoderMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo + ResolveVideoDecoderMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo + ResolveVideoDecoderMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo + ResolveVideoDecoderMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo + ResolveVideoDecoderMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo + ResolveVideoDecoderMethod "dropFrame" o = VideoDecoderDropFrameMethodInfo + ResolveVideoDecoderMethod "finishFrame" o = VideoDecoderFinishFrameMethodInfo + ResolveVideoDecoderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveVideoDecoderMethod "foreachPad" o = Gst.Element.ElementForeachPadMethodInfo + ResolveVideoDecoderMethod "foreachSinkPad" o = Gst.Element.ElementForeachSinkPadMethodInfo + ResolveVideoDecoderMethod "foreachSrcPad" o = Gst.Element.ElementForeachSrcPadMethodInfo + ResolveVideoDecoderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveVideoDecoderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveVideoDecoderMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo + ResolveVideoDecoderMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo + ResolveVideoDecoderMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo + ResolveVideoDecoderMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo + ResolveVideoDecoderMethod "haveFrame" o = VideoDecoderHaveFrameMethodInfo + ResolveVideoDecoderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveVideoDecoderMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo + ResolveVideoDecoderMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo + ResolveVideoDecoderMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo + ResolveVideoDecoderMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo + ResolveVideoDecoderMethod "link" o = Gst.Element.ElementLinkMethodInfo + ResolveVideoDecoderMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo + ResolveVideoDecoderMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo + ResolveVideoDecoderMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo + ResolveVideoDecoderMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo + ResolveVideoDecoderMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo + ResolveVideoDecoderMethod "mergeTags" o = VideoDecoderMergeTagsMethodInfo + ResolveVideoDecoderMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo + ResolveVideoDecoderMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo + ResolveVideoDecoderMethod "negotiate" o = VideoDecoderNegotiateMethodInfo + ResolveVideoDecoderMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo + ResolveVideoDecoderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveVideoDecoderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveVideoDecoderMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo + ResolveVideoDecoderMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo + ResolveVideoDecoderMethod "proxyGetcaps" o = VideoDecoderProxyGetcapsMethodInfo + ResolveVideoDecoderMethod "query" o = Gst.Element.ElementQueryMethodInfo + ResolveVideoDecoderMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo + ResolveVideoDecoderMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo + ResolveVideoDecoderMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo + ResolveVideoDecoderMethod "ref" o = Gst.Object.ObjectRefMethodInfo + ResolveVideoDecoderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveVideoDecoderMethod "releaseFrame" o = VideoDecoderReleaseFrameMethodInfo + ResolveVideoDecoderMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo + ResolveVideoDecoderMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo + ResolveVideoDecoderMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo + ResolveVideoDecoderMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo + ResolveVideoDecoderMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo + ResolveVideoDecoderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveVideoDecoderMethod "seek" o = Gst.Element.ElementSeekMethodInfo + ResolveVideoDecoderMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo + ResolveVideoDecoderMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo + ResolveVideoDecoderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveVideoDecoderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveVideoDecoderMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo + ResolveVideoDecoderMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo + ResolveVideoDecoderMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo + ResolveVideoDecoderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveVideoDecoderMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo + ResolveVideoDecoderMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo + ResolveVideoDecoderMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo + ResolveVideoDecoderMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo + ResolveVideoDecoderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveVideoDecoderMethod "getAllocator" o = VideoDecoderGetAllocatorMethodInfo + ResolveVideoDecoderMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo + ResolveVideoDecoderMethod "getBufferPool" o = VideoDecoderGetBufferPoolMethodInfo + ResolveVideoDecoderMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo + ResolveVideoDecoderMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo + ResolveVideoDecoderMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo + ResolveVideoDecoderMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo + ResolveVideoDecoderMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo + ResolveVideoDecoderMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo + ResolveVideoDecoderMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo + ResolveVideoDecoderMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo + ResolveVideoDecoderMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo + ResolveVideoDecoderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveVideoDecoderMethod "getEstimateRate" o = VideoDecoderGetEstimateRateMethodInfo + ResolveVideoDecoderMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo + ResolveVideoDecoderMethod "getFrame" o = VideoDecoderGetFrameMethodInfo + ResolveVideoDecoderMethod "getFrames" o = VideoDecoderGetFramesMethodInfo + ResolveVideoDecoderMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo + ResolveVideoDecoderMethod "getLatency" o = VideoDecoderGetLatencyMethodInfo + ResolveVideoDecoderMethod "getMaxDecodeTime" o = VideoDecoderGetMaxDecodeTimeMethodInfo + ResolveVideoDecoderMethod "getMaxErrors" o = VideoDecoderGetMaxErrorsMethodInfo + ResolveVideoDecoderMethod "getMetadata" o = Gst.Element.ElementGetMetadataMethodInfo + ResolveVideoDecoderMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo + ResolveVideoDecoderMethod "getNeedsFormat" o = VideoDecoderGetNeedsFormatMethodInfo + ResolveVideoDecoderMethod "getOldestFrame" o = VideoDecoderGetOldestFrameMethodInfo + ResolveVideoDecoderMethod "getOutputState" o = VideoDecoderGetOutputStateMethodInfo + ResolveVideoDecoderMethod "getPacketized" o = VideoDecoderGetPacketizedMethodInfo + ResolveVideoDecoderMethod "getPadTemplate" o = Gst.Element.ElementGetPadTemplateMethodInfo + ResolveVideoDecoderMethod "getPadTemplateList" o = Gst.Element.ElementGetPadTemplateListMethodInfo + ResolveVideoDecoderMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo + ResolveVideoDecoderMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo + ResolveVideoDecoderMethod "getPendingFrameSize" o = VideoDecoderGetPendingFrameSizeMethodInfo + ResolveVideoDecoderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveVideoDecoderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveVideoDecoderMethod "getQosProportion" o = VideoDecoderGetQosProportionMethodInfo + ResolveVideoDecoderMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo + ResolveVideoDecoderMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo + ResolveVideoDecoderMethod "getState" o = Gst.Element.ElementGetStateMethodInfo + ResolveVideoDecoderMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo + ResolveVideoDecoderMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo + ResolveVideoDecoderMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo + ResolveVideoDecoderMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo + ResolveVideoDecoderMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo + ResolveVideoDecoderMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo + ResolveVideoDecoderMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo + ResolveVideoDecoderMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo + ResolveVideoDecoderMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo + ResolveVideoDecoderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveVideoDecoderMethod "setEstimateRate" o = VideoDecoderSetEstimateRateMethodInfo + ResolveVideoDecoderMethod "setInterlacedOutputState" o = VideoDecoderSetInterlacedOutputStateMethodInfo + ResolveVideoDecoderMethod "setLatency" o = VideoDecoderSetLatencyMethodInfo + ResolveVideoDecoderMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo + ResolveVideoDecoderMethod "setMaxErrors" o = VideoDecoderSetMaxErrorsMethodInfo + ResolveVideoDecoderMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo + ResolveVideoDecoderMethod "setNeedsFormat" o = VideoDecoderSetNeedsFormatMethodInfo + ResolveVideoDecoderMethod "setOutputState" o = VideoDecoderSetOutputStateMethodInfo + ResolveVideoDecoderMethod "setPacketized" o = VideoDecoderSetPacketizedMethodInfo + ResolveVideoDecoderMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo + ResolveVideoDecoderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveVideoDecoderMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo + ResolveVideoDecoderMethod "setState" o = Gst.Element.ElementSetStateMethodInfo + ResolveVideoDecoderMethod "setUseDefaultPadAcceptcaps" o = VideoDecoderSetUseDefaultPadAcceptcapsMethodInfo + ResolveVideoDecoderMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoDecoderMethod t VideoDecoder, O.MethodInfo info VideoDecoder p) => OL.IsLabel t (VideoDecoder -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoDecoder +type instance O.AttributeList VideoDecoder = VideoDecoderAttributeList +type VideoDecoderAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList VideoDecoder = VideoDecoderSignalList +type VideoDecoderSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method VideoDecoder::add_to_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_bytes", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_add_to_frame" gst_video_decoder_add_to_frame :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Int32 -> -- n_bytes : TBasicType TInt + IO () + +{- | +Removes next /@nBytes@/ of input data and adds it to currently parsed frame. +-} +videoDecoderAddToFrame :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> Int32 + {- ^ /@nBytes@/: the number of bytes to add -} + -> m () +videoDecoderAddToFrame decoder nBytes = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + gst_video_decoder_add_to_frame decoder' nBytes + touchManagedPtr decoder + return () + +#if ENABLE_OVERLOADING +data VideoDecoderAddToFrameMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderAddToFrameMethodInfo a signature where + overloadedMethod _ = videoDecoderAddToFrame + +#endif + +-- method VideoDecoder::allocate_output_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Buffer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_allocate_output_buffer" gst_video_decoder_allocate_output_buffer :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + IO (Ptr Gst.Buffer.Buffer) + +{- | +Helper function that allocates a buffer to hold a video frame for /@decoder@/\'s +current 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState'. + +You should use 'GI.GstVideo.Objects.VideoDecoder.videoDecoderAllocateOutputFrame' instead of this +function, if possible at all. +-} +videoDecoderAllocateOutputBuffer :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m Gst.Buffer.Buffer + {- ^ __Returns:__ allocated buffer, or NULL if no buffer could be + allocated (e.g. when downstream is flushing or shutting down) -} +videoDecoderAllocateOutputBuffer decoder = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + result <- gst_video_decoder_allocate_output_buffer decoder' + checkUnexpectedReturnNULL "videoDecoderAllocateOutputBuffer" result + result' <- (wrapBoxed Gst.Buffer.Buffer) result + touchManagedPtr decoder + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderAllocateOutputBufferMethodInfo +instance (signature ~ (m Gst.Buffer.Buffer), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderAllocateOutputBufferMethodInfo a signature where + overloadedMethod _ = videoDecoderAllocateOutputBuffer + +#endif + +-- method VideoDecoder::allocate_output_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoCodecFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_allocate_output_frame" gst_video_decoder_allocate_output_frame :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Ptr GstVideo.VideoCodecFrame.VideoCodecFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}) + IO CInt + +{- | +Helper function that allocates a buffer to hold a video frame for /@decoder@/\'s +current 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState'. Subclass should already have configured video +state and set src pad caps. + +The buffer allocated here is owned by the frame and you should only +keep references to the frame, not the buffer. +-} +videoDecoderAllocateOutputFrame :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> GstVideo.VideoCodecFrame.VideoCodecFrame + {- ^ /@frame@/: a 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -} + -> m Gst.Enums.FlowReturn + {- ^ __Returns:__ 'GI.Gst.Enums.FlowReturnOk' if an output buffer could be allocated -} +videoDecoderAllocateOutputFrame decoder frame = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + frame' <- unsafeManagedPtrGetPtr frame + result <- gst_video_decoder_allocate_output_frame decoder' frame' + let result' = (toEnum . fromIntegral) result + touchManagedPtr decoder + touchManagedPtr frame + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderAllocateOutputFrameMethodInfo +instance (signature ~ (GstVideo.VideoCodecFrame.VideoCodecFrame -> m Gst.Enums.FlowReturn), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderAllocateOutputFrameMethodInfo a signature where + overloadedMethod _ = videoDecoderAllocateOutputFrame + +#endif + +-- method VideoDecoder::allocate_output_frame_with_params +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoCodecFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface (Name {namespace = "Gst", name = "BufferPoolAcquireParams"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBufferPoolAcquireParams", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_allocate_output_frame_with_params" gst_video_decoder_allocate_output_frame_with_params :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Ptr GstVideo.VideoCodecFrame.VideoCodecFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}) + Ptr Gst.BufferPoolAcquireParams.BufferPoolAcquireParams -> -- params : TInterface (Name {namespace = "Gst", name = "BufferPoolAcquireParams"}) + IO CInt + +{- | +Same as @/gst_video_decoder_allocate_output_frame/@ except it allows passing +'GI.Gst.Structs.BufferPoolAcquireParams.BufferPoolAcquireParams' to the sub call gst_buffer_pool_acquire_buffer. + +/Since: 1.12/ +-} +videoDecoderAllocateOutputFrameWithParams :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> GstVideo.VideoCodecFrame.VideoCodecFrame + {- ^ /@frame@/: a 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -} + -> Gst.BufferPoolAcquireParams.BufferPoolAcquireParams + {- ^ /@params@/: a 'GI.Gst.Structs.BufferPoolAcquireParams.BufferPoolAcquireParams' -} + -> m Gst.Enums.FlowReturn + {- ^ __Returns:__ 'GI.Gst.Enums.FlowReturnOk' if an output buffer could be allocated -} +videoDecoderAllocateOutputFrameWithParams decoder frame params = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + frame' <- unsafeManagedPtrGetPtr frame + params' <- unsafeManagedPtrGetPtr params + result <- gst_video_decoder_allocate_output_frame_with_params decoder' frame' params' + let result' = (toEnum . fromIntegral) result + touchManagedPtr decoder + touchManagedPtr frame + touchManagedPtr params + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderAllocateOutputFrameWithParamsMethodInfo +instance (signature ~ (GstVideo.VideoCodecFrame.VideoCodecFrame -> Gst.BufferPoolAcquireParams.BufferPoolAcquireParams -> m Gst.Enums.FlowReturn), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderAllocateOutputFrameWithParamsMethodInfo a signature where + overloadedMethod _ = videoDecoderAllocateOutputFrameWithParams + +#endif + +-- method VideoDecoder::drop_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dec", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstVideoCodecFrame to drop", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_drop_frame" gst_video_decoder_drop_frame :: + Ptr VideoDecoder -> -- dec : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Ptr GstVideo.VideoCodecFrame.VideoCodecFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}) + IO CInt + +{- | +Similar to 'GI.GstVideo.Objects.VideoDecoder.videoDecoderFinishFrame', but drops /@frame@/ in any +case and posts a QoS message with the frame\'s details on the bus. +In any case, the frame is considered finished and released. +-} +videoDecoderDropFrame :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@dec@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> GstVideo.VideoCodecFrame.VideoCodecFrame + {- ^ /@frame@/: the 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' to drop -} + -> m Gst.Enums.FlowReturn + {- ^ __Returns:__ a 'GI.Gst.Enums.FlowReturn', usually GST_FLOW_OK. -} +videoDecoderDropFrame dec frame = liftIO $ do + dec' <- unsafeManagedPtrCastPtr dec + frame' <- B.ManagedPtr.disownBoxed frame + result <- gst_video_decoder_drop_frame dec' frame' + let result' = (toEnum . fromIntegral) result + touchManagedPtr dec + touchManagedPtr frame + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderDropFrameMethodInfo +instance (signature ~ (GstVideo.VideoCodecFrame.VideoCodecFrame -> m Gst.Enums.FlowReturn), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderDropFrameMethodInfo a signature where + overloadedMethod _ = videoDecoderDropFrame + +#endif + +-- method VideoDecoder::finish_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a decoded #GstVideoCodecFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_finish_frame" gst_video_decoder_finish_frame :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Ptr GstVideo.VideoCodecFrame.VideoCodecFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}) + IO CInt + +{- | +/@frame@/ should have a valid decoded data buffer, whose metadata fields +are then appropriately set according to frame data and pushed downstream. +If no output data is provided, /@frame@/ is considered skipped. +In any case, the frame is considered finished and released. + +After calling this function the output buffer of the frame is to be +considered read-only. This function will also change the metadata +of the buffer. +-} +videoDecoderFinishFrame :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> GstVideo.VideoCodecFrame.VideoCodecFrame + {- ^ /@frame@/: a decoded 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -} + -> m Gst.Enums.FlowReturn + {- ^ __Returns:__ a 'GI.Gst.Enums.FlowReturn' resulting from sending data downstream -} +videoDecoderFinishFrame decoder frame = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + frame' <- B.ManagedPtr.disownBoxed frame + result <- gst_video_decoder_finish_frame decoder' frame' + let result' = (toEnum . fromIntegral) result + touchManagedPtr decoder + touchManagedPtr frame + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderFinishFrameMethodInfo +instance (signature ~ (GstVideo.VideoCodecFrame.VideoCodecFrame -> m Gst.Enums.FlowReturn), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderFinishFrameMethodInfo a signature where + overloadedMethod _ = videoDecoderFinishFrame + +#endif + +-- method VideoDecoder::get_allocator +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface (Name {namespace = "Gst", name = "Allocator"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstAllocator\nused", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TInterface (Name {namespace = "Gst", name = "AllocationParams"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the\n#GstAllocationParams of @allocator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_get_allocator" gst_video_decoder_get_allocator :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Ptr (Ptr Gst.Allocator.Allocator) -> -- allocator : TInterface (Name {namespace = "Gst", name = "Allocator"}) + Ptr Gst.AllocationParams.AllocationParams -> -- params : TInterface (Name {namespace = "Gst", name = "AllocationParams"}) + IO () + +{- | +Lets 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' sub-classes to know the memory /@allocator@/ +used by the base class and its /@params@/. + +Unref the /@allocator@/ after use it. +-} +videoDecoderGetAllocator :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m ((Gst.Allocator.Allocator, Gst.AllocationParams.AllocationParams)) +videoDecoderGetAllocator decoder = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + allocator <- allocMem :: IO (Ptr (Ptr Gst.Allocator.Allocator)) + params <- callocBoxedBytes 64 :: IO (Ptr Gst.AllocationParams.AllocationParams) + gst_video_decoder_get_allocator decoder' allocator params + allocator' <- peek allocator + allocator'' <- (wrapObject Gst.Allocator.Allocator) allocator' + params' <- (wrapBoxed Gst.AllocationParams.AllocationParams) params + touchManagedPtr decoder + freeMem allocator + return (allocator'', params') + +#if ENABLE_OVERLOADING +data VideoDecoderGetAllocatorMethodInfo +instance (signature ~ (m ((Gst.Allocator.Allocator, Gst.AllocationParams.AllocationParams))), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetAllocatorMethodInfo a signature where + overloadedMethod _ = videoDecoderGetAllocator + +#endif + +-- method VideoDecoder::get_buffer_pool +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "BufferPool"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_get_buffer_pool" gst_video_decoder_get_buffer_pool :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + IO (Ptr Gst.BufferPool.BufferPool) + +{- | +/No description available in the introspection data./ +-} +videoDecoderGetBufferPool :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m Gst.BufferPool.BufferPool + {- ^ __Returns:__ the instance of the 'GI.Gst.Objects.BufferPool.BufferPool' used +by the decoder; free it after use it -} +videoDecoderGetBufferPool decoder = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + result <- gst_video_decoder_get_buffer_pool decoder' + checkUnexpectedReturnNULL "videoDecoderGetBufferPool" result + result' <- (wrapObject Gst.BufferPool.BufferPool) result + touchManagedPtr decoder + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderGetBufferPoolMethodInfo +instance (signature ~ (m Gst.BufferPool.BufferPool), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetBufferPoolMethodInfo a signature where + overloadedMethod _ = videoDecoderGetBufferPool + +#endif + +-- method VideoDecoder::get_estimate_rate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dec", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_get_estimate_rate" gst_video_decoder_get_estimate_rate :: + Ptr VideoDecoder -> -- dec : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + IO Int32 + +{- | +/No description available in the introspection data./ +-} +videoDecoderGetEstimateRate :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@dec@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m Int32 + {- ^ __Returns:__ currently configured byte to time conversion setting -} +videoDecoderGetEstimateRate dec = liftIO $ do + dec' <- unsafeManagedPtrCastPtr dec + result <- gst_video_decoder_get_estimate_rate dec' + touchManagedPtr dec + return result + +#if ENABLE_OVERLOADING +data VideoDecoderGetEstimateRateMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetEstimateRateMethodInfo a signature where + overloadedMethod _ = videoDecoderGetEstimateRate + +#endif + +-- method VideoDecoder::get_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame_number", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "system_frame_number of a frame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_get_frame" gst_video_decoder_get_frame :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Int32 -> -- frame_number : TBasicType TInt + IO (Ptr GstVideo.VideoCodecFrame.VideoCodecFrame) + +{- | +Get a pending unfinished 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' +-} +videoDecoderGetFrame :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> Int32 + {- ^ /@frameNumber@/: system_frame_number of a frame -} + -> m GstVideo.VideoCodecFrame.VideoCodecFrame + {- ^ __Returns:__ pending unfinished 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' identified by /@frameNumber@/. -} +videoDecoderGetFrame decoder frameNumber = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + result <- gst_video_decoder_get_frame decoder' frameNumber + checkUnexpectedReturnNULL "videoDecoderGetFrame" result + result' <- (wrapBoxed GstVideo.VideoCodecFrame.VideoCodecFrame) result + touchManagedPtr decoder + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderGetFrameMethodInfo +instance (signature ~ (Int32 -> m GstVideo.VideoCodecFrame.VideoCodecFrame), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetFrameMethodInfo a signature where + overloadedMethod _ = videoDecoderGetFrame + +#endif + +-- method VideoDecoder::get_frames +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_get_frames" gst_video_decoder_get_frames :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + IO (Ptr (GList (Ptr GstVideo.VideoCodecFrame.VideoCodecFrame))) + +{- | +Get all pending unfinished 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' +-} +videoDecoderGetFrames :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m [GstVideo.VideoCodecFrame.VideoCodecFrame] + {- ^ __Returns:__ pending unfinished 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame'. -} +videoDecoderGetFrames decoder = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + result <- gst_video_decoder_get_frames decoder' + result' <- unpackGList result + result'' <- mapM (wrapBoxed GstVideo.VideoCodecFrame.VideoCodecFrame) result' + g_list_free result + touchManagedPtr decoder + return result'' + +#if ENABLE_OVERLOADING +data VideoDecoderGetFramesMethodInfo +instance (signature ~ (m [GstVideo.VideoCodecFrame.VideoCodecFrame]), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetFramesMethodInfo a signature where + overloadedMethod _ = videoDecoderGetFrames + +#endif + +-- method VideoDecoder::get_latency +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address of variable in which to store the\n configured minimum latency, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address of variable in which to store the\n configured mximum latency, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_get_latency" gst_video_decoder_get_latency :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Ptr Word64 -> -- min_latency : TBasicType TUInt64 + Ptr Word64 -> -- max_latency : TBasicType TUInt64 + IO () + +{- | +Query the configured decoder latency. Results will be returned via +/@minLatency@/ and /@maxLatency@/. +-} +videoDecoderGetLatency :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m ((Word64, Word64)) +videoDecoderGetLatency decoder = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + minLatency <- allocMem :: IO (Ptr Word64) + maxLatency <- allocMem :: IO (Ptr Word64) + gst_video_decoder_get_latency decoder' minLatency maxLatency + minLatency' <- peek minLatency + maxLatency' <- peek maxLatency + touchManagedPtr decoder + freeMem minLatency + freeMem maxLatency + return (minLatency', maxLatency') + +#if ENABLE_OVERLOADING +data VideoDecoderGetLatencyMethodInfo +instance (signature ~ (m ((Word64, Word64))), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetLatencyMethodInfo a signature where + overloadedMethod _ = videoDecoderGetLatency + +#endif + +-- method VideoDecoder::get_max_decode_time +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoCodecFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (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 -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Ptr GstVideo.VideoCodecFrame.VideoCodecFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}) + IO Int64 + +{- | +Determines maximum possible decoding time for /@frame@/ that will +allow it to decode and arrive in time (as determined by QoS events). +In particular, a negative result means decoding in time is no longer possible +and should therefore occur as soon\/skippy as possible. +-} +videoDecoderGetMaxDecodeTime :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> GstVideo.VideoCodecFrame.VideoCodecFrame + {- ^ /@frame@/: a 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -} + -> m Int64 + {- ^ __Returns:__ max decoding time. -} +videoDecoderGetMaxDecodeTime decoder frame = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + frame' <- unsafeManagedPtrGetPtr frame + result <- gst_video_decoder_get_max_decode_time decoder' frame' + touchManagedPtr decoder + touchManagedPtr frame + return result + +#if ENABLE_OVERLOADING +data VideoDecoderGetMaxDecodeTimeMethodInfo +instance (signature ~ (GstVideo.VideoCodecFrame.VideoCodecFrame -> m Int64), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetMaxDecodeTimeMethodInfo a signature where + overloadedMethod _ = videoDecoderGetMaxDecodeTime + +#endif + +-- method VideoDecoder::get_max_errors +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dec", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_get_max_errors" gst_video_decoder_get_max_errors :: + Ptr VideoDecoder -> -- dec : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + IO Int32 + +{- | +/No description available in the introspection data./ +-} +videoDecoderGetMaxErrors :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@dec@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m Int32 + {- ^ __Returns:__ currently configured decoder tolerated error count. -} +videoDecoderGetMaxErrors dec = liftIO $ do + dec' <- unsafeManagedPtrCastPtr dec + result <- gst_video_decoder_get_max_errors dec' + touchManagedPtr dec + return result + +#if ENABLE_OVERLOADING +data VideoDecoderGetMaxErrorsMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetMaxErrorsMethodInfo a signature where + overloadedMethod _ = videoDecoderGetMaxErrors + +#endif + +-- method VideoDecoder::get_needs_format +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dec", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_get_needs_format" gst_video_decoder_get_needs_format :: + Ptr VideoDecoder -> -- dec : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + IO CInt + +{- | +Queries decoder required format handling. + +/Since: 1.4/ +-} +videoDecoderGetNeedsFormat :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@dec@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m Bool + {- ^ __Returns:__ 'True' if required format handling is enabled. -} +videoDecoderGetNeedsFormat dec = liftIO $ do + dec' <- unsafeManagedPtrCastPtr dec + result <- gst_video_decoder_get_needs_format dec' + let result' = (/= 0) result + touchManagedPtr dec + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderGetNeedsFormatMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetNeedsFormatMethodInfo a signature where + overloadedMethod _ = videoDecoderGetNeedsFormat + +#endif + +-- method VideoDecoder::get_oldest_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_get_oldest_frame" gst_video_decoder_get_oldest_frame :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + IO (Ptr GstVideo.VideoCodecFrame.VideoCodecFrame) + +{- | +Get the oldest pending unfinished 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' +-} +videoDecoderGetOldestFrame :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m GstVideo.VideoCodecFrame.VideoCodecFrame + {- ^ __Returns:__ oldest pending unfinished 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame'. -} +videoDecoderGetOldestFrame decoder = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + result <- gst_video_decoder_get_oldest_frame decoder' + checkUnexpectedReturnNULL "videoDecoderGetOldestFrame" result + result' <- (wrapBoxed GstVideo.VideoCodecFrame.VideoCodecFrame) result + touchManagedPtr decoder + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderGetOldestFrameMethodInfo +instance (signature ~ (m GstVideo.VideoCodecFrame.VideoCodecFrame), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetOldestFrameMethodInfo a signature where + overloadedMethod _ = videoDecoderGetOldestFrame + +#endif + +-- method VideoDecoder::get_output_state +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_get_output_state" gst_video_decoder_get_output_state :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + IO (Ptr GstVideo.VideoCodecState.VideoCodecState) + +{- | +Get the 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState' currently describing the output stream. +-} +videoDecoderGetOutputState :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m GstVideo.VideoCodecState.VideoCodecState + {- ^ __Returns:__ 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState' describing format of video data. -} +videoDecoderGetOutputState decoder = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + result <- gst_video_decoder_get_output_state decoder' + checkUnexpectedReturnNULL "videoDecoderGetOutputState" result + result' <- (wrapBoxed GstVideo.VideoCodecState.VideoCodecState) result + touchManagedPtr decoder + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderGetOutputStateMethodInfo +instance (signature ~ (m GstVideo.VideoCodecState.VideoCodecState), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetOutputStateMethodInfo a signature where + overloadedMethod _ = videoDecoderGetOutputState + +#endif + +-- method VideoDecoder::get_packetized +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_get_packetized" gst_video_decoder_get_packetized :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + IO CInt + +{- | +Queries whether input data is considered packetized or not by the +base class. +-} +videoDecoderGetPacketized :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m Bool + {- ^ __Returns:__ TRUE if input data is considered packetized. -} +videoDecoderGetPacketized decoder = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + result <- gst_video_decoder_get_packetized decoder' + let result' = (/= 0) result + touchManagedPtr decoder + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderGetPacketizedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetPacketizedMethodInfo a signature where + overloadedMethod _ = videoDecoderGetPacketized + +#endif + +-- method VideoDecoder::get_pending_frame_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (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 -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + IO Word64 + +{- | +Returns the number of bytes previously added to the current frame +by calling 'GI.GstVideo.Objects.VideoDecoder.videoDecoderAddToFrame'. + +/Since: 1.4/ +-} +videoDecoderGetPendingFrameSize :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m Word64 + {- ^ __Returns:__ The number of bytes pending for the current frame -} +videoDecoderGetPendingFrameSize decoder = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + result <- gst_video_decoder_get_pending_frame_size decoder' + touchManagedPtr decoder + return result + +#if ENABLE_OVERLOADING +data VideoDecoderGetPendingFrameSizeMethodInfo +instance (signature ~ (m Word64), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetPendingFrameSizeMethodInfo a signature where + overloadedMethod _ = videoDecoderGetPendingFrameSize + +#endif + +-- method VideoDecoder::get_qos_proportion +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder\n current QoS proportion, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_get_qos_proportion" gst_video_decoder_get_qos_proportion :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + IO CDouble + +{- | +/No description available in the introspection data./ + +/Since: 1.0.3/ +-} +videoDecoderGetQosProportion :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' + current QoS proportion, or 'Nothing' -} + -> m Double + {- ^ __Returns:__ The current QoS proportion. -} +videoDecoderGetQosProportion decoder = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + result <- gst_video_decoder_get_qos_proportion decoder' + let result' = realToFrac result + touchManagedPtr decoder + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderGetQosProportionMethodInfo +instance (signature ~ (m Double), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderGetQosProportionMethodInfo a signature where + overloadedMethod _ = videoDecoderGetQosProportion + +#endif + +-- method VideoDecoder::have_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_have_frame" gst_video_decoder_have_frame :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + IO CInt + +{- | +Gathers all data collected for currently parsed frame, gathers corresponding +metadata and passes it along for further processing, i.e. /@handleFrame@/. +-} +videoDecoderHaveFrame :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m Gst.Enums.FlowReturn + {- ^ __Returns:__ a 'GI.Gst.Enums.FlowReturn' -} +videoDecoderHaveFrame decoder = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + result <- gst_video_decoder_have_frame decoder' + let result' = (toEnum . fromIntegral) result + touchManagedPtr decoder + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderHaveFrameMethodInfo +instance (signature ~ (m Gst.Enums.FlowReturn), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderHaveFrameMethodInfo a signature where + overloadedMethod _ = videoDecoderHaveFrame + +#endif + +-- method VideoDecoder::merge_tags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface (Name {namespace = "Gst", name = "TagList"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GstTagList to merge, or NULL to unset\n previously-set tags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Gst", name = "TagMergeMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstTagMergeMode to use, usually #GST_TAG_MERGE_REPLACE", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_merge_tags" gst_video_decoder_merge_tags :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Ptr Gst.TagList.TagList -> -- tags : TInterface (Name {namespace = "Gst", name = "TagList"}) + CUInt -> -- mode : TInterface (Name {namespace = "Gst", name = "TagMergeMode"}) + IO () + +{- | +Sets the audio decoder tags and how they should be merged with any +upstream stream tags. This will override any tags previously-set +with @/gst_audio_decoder_merge_tags()/@. + +Note that this is provided for convenience, and the subclass is +not required to use this and can still do tag handling on its own. + +MT safe. +-} +videoDecoderMergeTags :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> Maybe (Gst.TagList.TagList) + {- ^ /@tags@/: a 'GI.Gst.Structs.TagList.TagList' to merge, or NULL to unset + previously-set tags -} + -> Gst.Enums.TagMergeMode + {- ^ /@mode@/: the 'GI.Gst.Enums.TagMergeMode' to use, usually @/GST_TAG_MERGE_REPLACE/@ -} + -> m () +videoDecoderMergeTags decoder tags mode = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + maybeTags <- case tags of + Nothing -> return nullPtr + Just jTags -> do + jTags' <- unsafeManagedPtrGetPtr jTags + return jTags' + let mode' = (fromIntegral . fromEnum) mode + gst_video_decoder_merge_tags decoder' maybeTags mode' + touchManagedPtr decoder + whenJust tags touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data VideoDecoderMergeTagsMethodInfo +instance (signature ~ (Maybe (Gst.TagList.TagList) -> Gst.Enums.TagMergeMode -> m ()), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderMergeTagsMethodInfo a signature where + overloadedMethod _ = videoDecoderMergeTags + +#endif + +-- method VideoDecoder::negotiate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_negotiate" gst_video_decoder_negotiate :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + IO CInt + +{- | +Negotiate with downstream elements to currently configured 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState'. +Unmark GST_PAD_FLAG_NEED_RECONFIGURE in any case. But mark it again if +negotiate fails. +-} +videoDecoderNegotiate :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> m Bool + {- ^ __Returns:__ 'True' if the negotiation succeeded, else 'False'. -} +videoDecoderNegotiate decoder = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + result <- gst_video_decoder_negotiate decoder' + let result' = (/= 0) result + touchManagedPtr decoder + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderNegotiateMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderNegotiateMethodInfo a signature where + overloadedMethod _ = videoDecoderNegotiate + +#endif + +-- method VideoDecoder::proxy_getcaps +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "initial caps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "filter caps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Caps"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_proxy_getcaps" gst_video_decoder_proxy_getcaps :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Ptr Gst.Caps.Caps -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"}) + Ptr Gst.Caps.Caps -> -- filter : TInterface (Name {namespace = "Gst", name = "Caps"}) + IO (Ptr Gst.Caps.Caps) + +{- | +Returns caps that express /@caps@/ (or sink template caps if /@caps@/ == NULL) +restricted to resolution\/format\/... combinations supported by downstream +elements. + +/Since: 1.6/ +-} +videoDecoderProxyGetcaps :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> Maybe (Gst.Caps.Caps) + {- ^ /@caps@/: initial caps -} + -> Maybe (Gst.Caps.Caps) + {- ^ /@filter@/: filter caps -} + -> m Gst.Caps.Caps + {- ^ __Returns:__ a 'GI.Gst.Structs.Caps.Caps' owned by caller -} +videoDecoderProxyGetcaps decoder caps filter = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + maybeCaps <- case caps of + Nothing -> return nullPtr + Just jCaps -> do + jCaps' <- unsafeManagedPtrGetPtr jCaps + return jCaps' + maybeFilter <- case filter of + Nothing -> return nullPtr + Just jFilter -> do + jFilter' <- unsafeManagedPtrGetPtr jFilter + return jFilter' + result <- gst_video_decoder_proxy_getcaps decoder' maybeCaps maybeFilter + checkUnexpectedReturnNULL "videoDecoderProxyGetcaps" result + result' <- (wrapBoxed Gst.Caps.Caps) result + touchManagedPtr decoder + whenJust caps touchManagedPtr + whenJust filter touchManagedPtr + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderProxyGetcapsMethodInfo +instance (signature ~ (Maybe (Gst.Caps.Caps) -> Maybe (Gst.Caps.Caps) -> m Gst.Caps.Caps), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderProxyGetcapsMethodInfo a signature where + overloadedMethod _ = videoDecoderProxyGetcaps + +#endif + +-- method VideoDecoder::release_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dec", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstVideoCodecFrame to release", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_release_frame" gst_video_decoder_release_frame :: + Ptr VideoDecoder -> -- dec : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Ptr GstVideo.VideoCodecFrame.VideoCodecFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}) + IO () + +{- | +Similar to 'GI.GstVideo.Objects.VideoDecoder.videoDecoderDropFrame', but simply releases /@frame@/ +without any processing other than removing it from list of pending frames, +after which it is considered finished and released. + +/Since: 1.2.2/ +-} +videoDecoderReleaseFrame :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@dec@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> GstVideo.VideoCodecFrame.VideoCodecFrame + {- ^ /@frame@/: the 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' to release -} + -> m () +videoDecoderReleaseFrame dec frame = liftIO $ do + dec' <- unsafeManagedPtrCastPtr dec + frame' <- B.ManagedPtr.disownBoxed frame + gst_video_decoder_release_frame dec' frame' + touchManagedPtr dec + touchManagedPtr frame + return () + +#if ENABLE_OVERLOADING +data VideoDecoderReleaseFrameMethodInfo +instance (signature ~ (GstVideo.VideoCodecFrame.VideoCodecFrame -> m ()), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderReleaseFrameMethodInfo a signature where + overloadedMethod _ = videoDecoderReleaseFrame + +#endif + +-- method VideoDecoder::set_estimate_rate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dec", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to enable byte to time conversion", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_set_estimate_rate" gst_video_decoder_set_estimate_rate :: + Ptr VideoDecoder -> -- dec : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Allows baseclass to perform byte to time estimated conversion. +-} +videoDecoderSetEstimateRate :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@dec@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> Bool + {- ^ /@enabled@/: whether to enable byte to time conversion -} + -> m () +videoDecoderSetEstimateRate dec enabled = liftIO $ do + dec' <- unsafeManagedPtrCastPtr dec + let enabled' = (fromIntegral . fromEnum) enabled + gst_video_decoder_set_estimate_rate dec' enabled' + touchManagedPtr dec + return () + +#if ENABLE_OVERLOADING +data VideoDecoderSetEstimateRateMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderSetEstimateRateMethodInfo a signature where + overloadedMethod _ = videoDecoderSetEstimateRate + +#endif + +-- method VideoDecoder::set_interlaced_output_state +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fmt", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInterlaceMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstVideoInterlaceMode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The width in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The height in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "reference", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "An optional reference #GstVideoCodecState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_set_interlaced_output_state" gst_video_decoder_set_interlaced_output_state :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + CUInt -> -- fmt : TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}) + CUInt -> -- mode : TInterface (Name {namespace = "GstVideo", name = "VideoInterlaceMode"}) + Word32 -> -- width : TBasicType TUInt + Word32 -> -- height : TBasicType TUInt + Ptr GstVideo.VideoCodecState.VideoCodecState -> -- reference : TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}) + IO (Ptr GstVideo.VideoCodecState.VideoCodecState) + +{- | +Same as @/gst_video_decoder_set_output_state/@() but also allows you to also set +the interlacing mode. + +/Since: 1.16./ +-} +videoDecoderSetInterlacedOutputState :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> GstVideo.Enums.VideoFormat + {- ^ /@fmt@/: a 'GI.GstVideo.Enums.VideoFormat' -} + -> GstVideo.Enums.VideoInterlaceMode + {- ^ /@mode@/: A 'GI.GstVideo.Enums.VideoInterlaceMode' -} + -> Word32 + {- ^ /@width@/: The width in pixels -} + -> Word32 + {- ^ /@height@/: The height in pixels -} + -> Maybe (GstVideo.VideoCodecState.VideoCodecState) + {- ^ /@reference@/: An optional reference 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState' -} + -> m GstVideo.VideoCodecState.VideoCodecState + {- ^ __Returns:__ the newly configured output state. -} +videoDecoderSetInterlacedOutputState decoder fmt mode width height reference = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + let fmt' = (fromIntegral . fromEnum) fmt + let mode' = (fromIntegral . fromEnum) mode + maybeReference <- case reference of + Nothing -> return nullPtr + Just jReference -> do + jReference' <- unsafeManagedPtrGetPtr jReference + return jReference' + result <- gst_video_decoder_set_interlaced_output_state decoder' fmt' mode' width height maybeReference + checkUnexpectedReturnNULL "videoDecoderSetInterlacedOutputState" result + result' <- (wrapBoxed GstVideo.VideoCodecState.VideoCodecState) result + touchManagedPtr decoder + whenJust reference touchManagedPtr + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderSetInterlacedOutputStateMethodInfo +instance (signature ~ (GstVideo.Enums.VideoFormat -> GstVideo.Enums.VideoInterlaceMode -> Word32 -> Word32 -> Maybe (GstVideo.VideoCodecState.VideoCodecState) -> m GstVideo.VideoCodecState.VideoCodecState), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderSetInterlacedOutputStateMethodInfo a signature where + overloadedMethod _ = videoDecoderSetInterlacedOutputState + +#endif + +-- method VideoDecoder::set_latency +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "minimum latency", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "maximum latency", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_set_latency" gst_video_decoder_set_latency :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Word64 -> -- min_latency : TBasicType TUInt64 + Word64 -> -- max_latency : TBasicType TUInt64 + IO () + +{- | +Lets 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' sub-classes tell the baseclass what the decoder +latency is. Will also post a LATENCY message on the bus so the pipeline +can reconfigure its global latency. +-} +videoDecoderSetLatency :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> Word64 + {- ^ /@minLatency@/: minimum latency -} + -> Word64 + {- ^ /@maxLatency@/: maximum latency -} + -> m () +videoDecoderSetLatency decoder minLatency maxLatency = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + gst_video_decoder_set_latency decoder' minLatency maxLatency + touchManagedPtr decoder + return () + +#if ENABLE_OVERLOADING +data VideoDecoderSetLatencyMethodInfo +instance (signature ~ (Word64 -> Word64 -> m ()), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderSetLatencyMethodInfo a signature where + overloadedMethod _ = videoDecoderSetLatency + +#endif + +-- method VideoDecoder::set_max_errors +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dec", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "max tolerated errors", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_set_max_errors" gst_video_decoder_set_max_errors :: + Ptr VideoDecoder -> -- dec : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + Int32 -> -- num : TBasicType TInt + IO () + +{- | +Sets numbers of tolerated decoder errors, where a tolerated one is then only +warned about, but more than tolerated will lead to fatal error. You can set +-1 for never returning fatal errors. Default is set to +GST_VIDEO_DECODER_MAX_ERRORS. + +The \'-1\' option was added in 1.4 +-} +videoDecoderSetMaxErrors :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@dec@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> Int32 + {- ^ /@num@/: max tolerated errors -} + -> m () +videoDecoderSetMaxErrors dec num = liftIO $ do + dec' <- unsafeManagedPtrCastPtr dec + gst_video_decoder_set_max_errors dec' num + touchManagedPtr dec + return () + +#if ENABLE_OVERLOADING +data VideoDecoderSetMaxErrorsMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderSetMaxErrorsMethodInfo a signature where + overloadedMethod _ = videoDecoderSetMaxErrors + +#endif + +-- method VideoDecoder::set_needs_format +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dec", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_set_needs_format" gst_video_decoder_set_needs_format :: + Ptr VideoDecoder -> -- dec : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Configures decoder format needs. If enabled, subclass needs to be +negotiated with format caps before it can process any data. It will then +never be handed any data before it has been configured. +Otherwise, it might be handed data without having been configured and +is then expected being able to do so either by default +or based on the input data. + +/Since: 1.4/ +-} +videoDecoderSetNeedsFormat :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@dec@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> Bool + {- ^ /@enabled@/: new state -} + -> m () +videoDecoderSetNeedsFormat dec enabled = liftIO $ do + dec' <- unsafeManagedPtrCastPtr dec + let enabled' = (fromIntegral . fromEnum) enabled + gst_video_decoder_set_needs_format dec' enabled' + touchManagedPtr dec + return () + +#if ENABLE_OVERLOADING +data VideoDecoderSetNeedsFormatMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderSetNeedsFormatMethodInfo a signature where + overloadedMethod _ = videoDecoderSetNeedsFormat + +#endif + +-- method VideoDecoder::set_output_state +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fmt", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The width in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The height in pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "reference", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "An optional reference #GstVideoCodecState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_set_output_state" gst_video_decoder_set_output_state :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + CUInt -> -- fmt : TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}) + Word32 -> -- width : TBasicType TUInt + Word32 -> -- height : TBasicType TUInt + Ptr GstVideo.VideoCodecState.VideoCodecState -> -- reference : TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}) + IO (Ptr GstVideo.VideoCodecState.VideoCodecState) + +{- | +Creates a new 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState' with the specified /@fmt@/, /@width@/ and /@height@/ +as the output state for the decoder. +Any previously set output state on /@decoder@/ will be replaced by the newly +created one. + +If the subclass wishes to copy over existing fields (like pixel aspec ratio, +or framerate) from an existing 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState', it can be provided as a +/@reference@/. + +If the subclass wishes to override some fields from the output state (like +pixel-aspect-ratio or framerate) it can do so on the returned 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState'. + +The new output state will only take effect (set on pads and buffers) starting +from the next call to @/gst_video_decoder_finish_frame/@(). +-} +videoDecoderSetOutputState :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> GstVideo.Enums.VideoFormat + {- ^ /@fmt@/: a 'GI.GstVideo.Enums.VideoFormat' -} + -> Word32 + {- ^ /@width@/: The width in pixels -} + -> Word32 + {- ^ /@height@/: The height in pixels -} + -> Maybe (GstVideo.VideoCodecState.VideoCodecState) + {- ^ /@reference@/: An optional reference 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState' -} + -> m GstVideo.VideoCodecState.VideoCodecState + {- ^ __Returns:__ the newly configured output state. -} +videoDecoderSetOutputState decoder fmt width height reference = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + let fmt' = (fromIntegral . fromEnum) fmt + maybeReference <- case reference of + Nothing -> return nullPtr + Just jReference -> do + jReference' <- unsafeManagedPtrGetPtr jReference + return jReference' + result <- gst_video_decoder_set_output_state decoder' fmt' width height maybeReference + checkUnexpectedReturnNULL "videoDecoderSetOutputState" result + result' <- (wrapBoxed GstVideo.VideoCodecState.VideoCodecState) result + touchManagedPtr decoder + whenJust reference touchManagedPtr + return result' + +#if ENABLE_OVERLOADING +data VideoDecoderSetOutputStateMethodInfo +instance (signature ~ (GstVideo.Enums.VideoFormat -> Word32 -> Word32 -> Maybe (GstVideo.VideoCodecState.VideoCodecState) -> m GstVideo.VideoCodecState.VideoCodecState), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderSetOutputStateMethodInfo a signature where + overloadedMethod _ = videoDecoderSetOutputState + +#endif + +-- method VideoDecoder::set_packetized +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "packetized", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the input data should be considered as packetized.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_set_packetized" gst_video_decoder_set_packetized :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + CInt -> -- packetized : TBasicType TBoolean + IO () + +{- | +Allows baseclass to consider input data as packetized or not. If the +input is packetized, then the /@parse@/ method will not be called. +-} +videoDecoderSetPacketized :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> Bool + {- ^ /@packetized@/: whether the input data should be considered as packetized. -} + -> m () +videoDecoderSetPacketized decoder packetized = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + let packetized' = (fromIntegral . fromEnum) packetized + gst_video_decoder_set_packetized decoder' packetized' + touchManagedPtr decoder + return () + +#if ENABLE_OVERLOADING +data VideoDecoderSetPacketizedMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderSetPacketizedMethodInfo a signature where + overloadedMethod _ = videoDecoderSetPacketized + +#endif + +-- method VideoDecoder::set_use_default_pad_acceptcaps +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "decoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDecoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "use", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if the default pad accept-caps query handling should be used", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_decoder_set_use_default_pad_acceptcaps" gst_video_decoder_set_use_default_pad_acceptcaps :: + Ptr VideoDecoder -> -- decoder : TInterface (Name {namespace = "GstVideo", name = "VideoDecoder"}) + CInt -> -- use : TBasicType TBoolean + IO () + +{- | +Lets 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' sub-classes decide if they want the sink pad +to use the default pad query handler to reply to accept-caps queries. + +By setting this to true it is possible to further customize the default +handler with @/GST_PAD_SET_ACCEPT_INTERSECT/@ and +@/GST_PAD_SET_ACCEPT_TEMPLATE/@ + +/Since: 1.6/ +-} +videoDecoderSetUseDefaultPadAcceptcaps :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoDecoder a) => + a + {- ^ /@decoder@/: a 'GI.GstVideo.Objects.VideoDecoder.VideoDecoder' -} + -> Bool + {- ^ /@use@/: if the default pad accept-caps query handling should be used -} + -> m () +videoDecoderSetUseDefaultPadAcceptcaps decoder use = liftIO $ do + decoder' <- unsafeManagedPtrCastPtr decoder + let use' = (fromIntegral . fromEnum) use + gst_video_decoder_set_use_default_pad_acceptcaps decoder' use' + touchManagedPtr decoder + return () + +#if ENABLE_OVERLOADING +data VideoDecoderSetUseDefaultPadAcceptcapsMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsVideoDecoder a) => O.MethodInfo VideoDecoderSetUseDefaultPadAcceptcapsMethodInfo a signature where + overloadedMethod _ = videoDecoderSetUseDefaultPadAcceptcaps + +#endif + + diff --git a/GI/GstVideo/Objects/VideoDecoder.hs-boot b/GI/GstVideo/Objects/VideoDecoder.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoDecoder.hs-boot @@ -0,0 +1,128 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Objects.VideoDecoder where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoDecoder = VideoDecoder (ManagedPtr VideoDecoder) +instance GObject VideoDecoder where +class (GObject o, O.IsDescendantOf VideoDecoder o) => IsVideoDecoder o +instance (GObject o, O.IsDescendantOf VideoDecoder o) => IsVideoDecoder o +instance O.HasParentTypes VideoDecoder +#if ENABLE_OVERLOADING +data VideoDecoderAddToFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderAllocateOutputBufferMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderAllocateOutputFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderAllocateOutputFrameWithParamsMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderDropFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderFinishFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetAllocatorMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetBufferPoolMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetEstimateRateMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetFramesMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetLatencyMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetMaxDecodeTimeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetMaxErrorsMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetNeedsFormatMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetOldestFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetOutputStateMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetPacketizedMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetPendingFrameSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderGetQosProportionMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderHaveFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderMergeTagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderNegotiateMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderProxyGetcapsMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderReleaseFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderSetEstimateRateMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderSetInterlacedOutputStateMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderSetLatencyMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderSetMaxErrorsMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderSetNeedsFormatMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderSetOutputStateMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderSetPacketizedMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDecoderSetUseDefaultPadAcceptcapsMethodInfo +#endif diff --git a/GI/GstVideo/Objects/VideoEncoder.hs b/GI/GstVideo/Objects/VideoEncoder.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoEncoder.hs @@ -0,0 +1,1352 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +This base class is for video encoders turning raw video into +encoded video data. + +GstVideoEncoder and subclass should cooperate as follows. + +== Configuration + + * Initially, GstVideoEncoder calls /@start@/ when the encoder element + is activated, which allows subclass to perform any global setup. + * GstVideoEncoder calls /@setFormat@/ to inform subclass of the format + of input video data that it is about to receive. Subclass should + setup for encoding and configure base class as appropriate + (e.g. latency). While unlikely, it might be called more than once, + if changing input parameters require reconfiguration. Baseclass + will ensure that processing of current configuration is finished. + * GstVideoEncoder calls /@stop@/ at end of all processing. + +== Data processing + + * Base class collects input data and metadata into a frame and hands + this to subclass\' /@handleFrame@/. + + * If codec processing results in encoded data, subclass should call + /@gstVideoEncoderFinishFrame@/ to have encoded data pushed + downstream. + + * If implemented, baseclass calls subclass /@prePush@/ just prior to + pushing to allow subclasses to modify some metadata on the buffer. + If it returns GST_FLOW_OK, the buffer is pushed downstream. + + * GstVideoEncoderClass will handle both srcpad and sinkpad events. + Sink events will be passed to subclass if /@event@/ callback has been + provided. + +== Shutdown phase + + * GstVideoEncoder class calls /@stop@/ to inform the subclass that data + parsing will be stopped. + +Subclass is responsible for providing pad template caps for +source and sink pads. The pads need to be named \"sink\" and \"src\". It should +also be able to provide fixed src pad caps in /@getcaps@/ by the time it calls +/@gstVideoEncoderFinishFrame@/. + +Things that subclass need to take care of: + + * Provide pad templates + * Provide source pad caps before pushing the first buffer + * Accept data in /@handleFrame@/ and provide encoded results to + /@gstVideoEncoderFinishFrame@/. + + +The 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder':@/qos/@ property will enable the Quality-of-Service +features of the encoder which gather statistics about the real-time +performance of the downstream elements. If enabled, subclasses can +use 'GI.GstVideo.Objects.VideoEncoder.videoEncoderGetMaxEncodeTime' to check if input frames +are already late and drop them right away to give a chance to the +pipeline to catch up. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Objects.VideoEncoder + ( + +-- * Exported types + VideoEncoder(..) , + IsVideoEncoder , + toVideoEncoder , + noVideoEncoder , + + + -- * Methods +-- ** allocateOutputBuffer #method:allocateOutputBuffer# + +#if ENABLE_OVERLOADING + VideoEncoderAllocateOutputBufferMethodInfo, +#endif + videoEncoderAllocateOutputBuffer , + + +-- ** allocateOutputFrame #method:allocateOutputFrame# + +#if ENABLE_OVERLOADING + VideoEncoderAllocateOutputFrameMethodInfo, +#endif + videoEncoderAllocateOutputFrame , + + +-- ** finishFrame #method:finishFrame# + +#if ENABLE_OVERLOADING + VideoEncoderFinishFrameMethodInfo , +#endif + videoEncoderFinishFrame , + + +-- ** getAllocator #method:getAllocator# + +#if ENABLE_OVERLOADING + VideoEncoderGetAllocatorMethodInfo , +#endif + videoEncoderGetAllocator , + + +-- ** getFrame #method:getFrame# + +#if ENABLE_OVERLOADING + VideoEncoderGetFrameMethodInfo , +#endif + videoEncoderGetFrame , + + +-- ** getFrames #method:getFrames# + +#if ENABLE_OVERLOADING + VideoEncoderGetFramesMethodInfo , +#endif + videoEncoderGetFrames , + + +-- ** getLatency #method:getLatency# + +#if ENABLE_OVERLOADING + VideoEncoderGetLatencyMethodInfo , +#endif + videoEncoderGetLatency , + + +-- ** getMaxEncodeTime #method:getMaxEncodeTime# + +#if ENABLE_OVERLOADING + VideoEncoderGetMaxEncodeTimeMethodInfo , +#endif + videoEncoderGetMaxEncodeTime , + + +-- ** getOldestFrame #method:getOldestFrame# + +#if ENABLE_OVERLOADING + VideoEncoderGetOldestFrameMethodInfo , +#endif + videoEncoderGetOldestFrame , + + +-- ** getOutputState #method:getOutputState# + +#if ENABLE_OVERLOADING + VideoEncoderGetOutputStateMethodInfo , +#endif + videoEncoderGetOutputState , + + +-- ** isQosEnabled #method:isQosEnabled# + +#if ENABLE_OVERLOADING + VideoEncoderIsQosEnabledMethodInfo , +#endif + videoEncoderIsQosEnabled , + + +-- ** mergeTags #method:mergeTags# + +#if ENABLE_OVERLOADING + VideoEncoderMergeTagsMethodInfo , +#endif + videoEncoderMergeTags , + + +-- ** negotiate #method:negotiate# + +#if ENABLE_OVERLOADING + VideoEncoderNegotiateMethodInfo , +#endif + videoEncoderNegotiate , + + +-- ** proxyGetcaps #method:proxyGetcaps# + +#if ENABLE_OVERLOADING + VideoEncoderProxyGetcapsMethodInfo , +#endif + videoEncoderProxyGetcaps , + + +-- ** setHeaders #method:setHeaders# + +#if ENABLE_OVERLOADING + VideoEncoderSetHeadersMethodInfo , +#endif + videoEncoderSetHeaders , + + +-- ** setLatency #method:setLatency# + +#if ENABLE_OVERLOADING + VideoEncoderSetLatencyMethodInfo , +#endif + videoEncoderSetLatency , + + +-- ** setMinPts #method:setMinPts# + +#if ENABLE_OVERLOADING + VideoEncoderSetMinPtsMethodInfo , +#endif + videoEncoderSetMinPts , + + +-- ** setOutputState #method:setOutputState# + +#if ENABLE_OVERLOADING + VideoEncoderSetOutputStateMethodInfo , +#endif + videoEncoderSetOutputState , + + +-- ** setQosEnabled #method:setQosEnabled# + +#if ENABLE_OVERLOADING + VideoEncoderSetQosEnabledMethodInfo , +#endif + videoEncoderSetQosEnabled , + + + + + -- * Properties +-- ** qos #attr:qos# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + VideoEncoderQosPropertyInfo , +#endif + constructVideoEncoderQos , + getVideoEncoderQos , + setVideoEncoderQos , +#if ENABLE_OVERLOADING + videoEncoderQos , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gst.Enums as Gst.Enums +import qualified GI.Gst.Interfaces.Preset as Gst.Preset +import qualified GI.Gst.Objects.Allocator as Gst.Allocator +import qualified GI.Gst.Objects.Element as Gst.Element +import qualified GI.Gst.Objects.Object as Gst.Object +import qualified GI.Gst.Structs.AllocationParams as Gst.AllocationParams +import qualified GI.Gst.Structs.Buffer as Gst.Buffer +import qualified GI.Gst.Structs.Caps as Gst.Caps +import qualified GI.Gst.Structs.TagList as Gst.TagList +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoCodecFrame as GstVideo.VideoCodecFrame +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoCodecState as GstVideo.VideoCodecState + +-- | Memory-managed wrapper type. +newtype VideoEncoder = VideoEncoder (ManagedPtr VideoEncoder) +foreign import ccall "gst_video_encoder_get_type" + c_gst_video_encoder_get_type :: IO GType + +instance GObject VideoEncoder where + gobjectType = c_gst_video_encoder_get_type + + +-- | Type class for types which can be safely cast to `VideoEncoder`, for instance with `toVideoEncoder`. +class (GObject o, O.IsDescendantOf VideoEncoder o) => IsVideoEncoder o +instance (GObject o, O.IsDescendantOf VideoEncoder o) => IsVideoEncoder o + +instance O.HasParentTypes VideoEncoder +type instance O.ParentTypes VideoEncoder = '[Gst.Element.Element, Gst.Object.Object, GObject.Object.Object, Gst.Preset.Preset] + +-- | Cast to `VideoEncoder`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toVideoEncoder :: (MonadIO m, IsVideoEncoder o) => o -> m VideoEncoder +toVideoEncoder = liftIO . unsafeCastTo VideoEncoder + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoEncoder`. +noVideoEncoder :: Maybe VideoEncoder +noVideoEncoder = Nothing + +#if ENABLE_OVERLOADING +type family ResolveVideoEncoderMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoEncoderMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo + ResolveVideoEncoderMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo + ResolveVideoEncoderMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo + ResolveVideoEncoderMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo + ResolveVideoEncoderMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo + ResolveVideoEncoderMethod "allocateOutputBuffer" o = VideoEncoderAllocateOutputBufferMethodInfo + ResolveVideoEncoderMethod "allocateOutputFrame" o = VideoEncoderAllocateOutputFrameMethodInfo + ResolveVideoEncoderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveVideoEncoderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveVideoEncoderMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo + ResolveVideoEncoderMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo + ResolveVideoEncoderMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo + ResolveVideoEncoderMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo + ResolveVideoEncoderMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo + ResolveVideoEncoderMethod "deletePreset" o = Gst.Preset.PresetDeletePresetMethodInfo + ResolveVideoEncoderMethod "finishFrame" o = VideoEncoderFinishFrameMethodInfo + ResolveVideoEncoderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveVideoEncoderMethod "foreachPad" o = Gst.Element.ElementForeachPadMethodInfo + ResolveVideoEncoderMethod "foreachSinkPad" o = Gst.Element.ElementForeachSinkPadMethodInfo + ResolveVideoEncoderMethod "foreachSrcPad" o = Gst.Element.ElementForeachSrcPadMethodInfo + ResolveVideoEncoderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveVideoEncoderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveVideoEncoderMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo + ResolveVideoEncoderMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo + ResolveVideoEncoderMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo + ResolveVideoEncoderMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo + ResolveVideoEncoderMethod "isEditable" o = Gst.Preset.PresetIsEditableMethodInfo + ResolveVideoEncoderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveVideoEncoderMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo + ResolveVideoEncoderMethod "isQosEnabled" o = VideoEncoderIsQosEnabledMethodInfo + ResolveVideoEncoderMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo + ResolveVideoEncoderMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo + ResolveVideoEncoderMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo + ResolveVideoEncoderMethod "link" o = Gst.Element.ElementLinkMethodInfo + ResolveVideoEncoderMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo + ResolveVideoEncoderMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo + ResolveVideoEncoderMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo + ResolveVideoEncoderMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo + ResolveVideoEncoderMethod "loadPreset" o = Gst.Preset.PresetLoadPresetMethodInfo + ResolveVideoEncoderMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo + ResolveVideoEncoderMethod "mergeTags" o = VideoEncoderMergeTagsMethodInfo + ResolveVideoEncoderMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo + ResolveVideoEncoderMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo + ResolveVideoEncoderMethod "negotiate" o = VideoEncoderNegotiateMethodInfo + ResolveVideoEncoderMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo + ResolveVideoEncoderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveVideoEncoderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveVideoEncoderMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo + ResolveVideoEncoderMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo + ResolveVideoEncoderMethod "proxyGetcaps" o = VideoEncoderProxyGetcapsMethodInfo + ResolveVideoEncoderMethod "query" o = Gst.Element.ElementQueryMethodInfo + ResolveVideoEncoderMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo + ResolveVideoEncoderMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo + ResolveVideoEncoderMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo + ResolveVideoEncoderMethod "ref" o = Gst.Object.ObjectRefMethodInfo + ResolveVideoEncoderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveVideoEncoderMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo + ResolveVideoEncoderMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo + ResolveVideoEncoderMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo + ResolveVideoEncoderMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo + ResolveVideoEncoderMethod "renamePreset" o = Gst.Preset.PresetRenamePresetMethodInfo + ResolveVideoEncoderMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo + ResolveVideoEncoderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveVideoEncoderMethod "savePreset" o = Gst.Preset.PresetSavePresetMethodInfo + ResolveVideoEncoderMethod "seek" o = Gst.Element.ElementSeekMethodInfo + ResolveVideoEncoderMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo + ResolveVideoEncoderMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo + ResolveVideoEncoderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveVideoEncoderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveVideoEncoderMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo + ResolveVideoEncoderMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo + ResolveVideoEncoderMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo + ResolveVideoEncoderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveVideoEncoderMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo + ResolveVideoEncoderMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo + ResolveVideoEncoderMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo + ResolveVideoEncoderMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo + ResolveVideoEncoderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveVideoEncoderMethod "getAllocator" o = VideoEncoderGetAllocatorMethodInfo + ResolveVideoEncoderMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo + ResolveVideoEncoderMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo + ResolveVideoEncoderMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo + ResolveVideoEncoderMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo + ResolveVideoEncoderMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo + ResolveVideoEncoderMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo + ResolveVideoEncoderMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo + ResolveVideoEncoderMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo + ResolveVideoEncoderMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo + ResolveVideoEncoderMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo + ResolveVideoEncoderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveVideoEncoderMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo + ResolveVideoEncoderMethod "getFrame" o = VideoEncoderGetFrameMethodInfo + ResolveVideoEncoderMethod "getFrames" o = VideoEncoderGetFramesMethodInfo + ResolveVideoEncoderMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo + ResolveVideoEncoderMethod "getLatency" o = VideoEncoderGetLatencyMethodInfo + ResolveVideoEncoderMethod "getMaxEncodeTime" o = VideoEncoderGetMaxEncodeTimeMethodInfo + ResolveVideoEncoderMethod "getMeta" o = Gst.Preset.PresetGetMetaMethodInfo + ResolveVideoEncoderMethod "getMetadata" o = Gst.Element.ElementGetMetadataMethodInfo + ResolveVideoEncoderMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo + ResolveVideoEncoderMethod "getOldestFrame" o = VideoEncoderGetOldestFrameMethodInfo + ResolveVideoEncoderMethod "getOutputState" o = VideoEncoderGetOutputStateMethodInfo + ResolveVideoEncoderMethod "getPadTemplate" o = Gst.Element.ElementGetPadTemplateMethodInfo + ResolveVideoEncoderMethod "getPadTemplateList" o = Gst.Element.ElementGetPadTemplateListMethodInfo + ResolveVideoEncoderMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo + ResolveVideoEncoderMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo + ResolveVideoEncoderMethod "getPresetNames" o = Gst.Preset.PresetGetPresetNamesMethodInfo + ResolveVideoEncoderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveVideoEncoderMethod "getPropertyNames" o = Gst.Preset.PresetGetPropertyNamesMethodInfo + ResolveVideoEncoderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveVideoEncoderMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo + ResolveVideoEncoderMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo + ResolveVideoEncoderMethod "getState" o = Gst.Element.ElementGetStateMethodInfo + ResolveVideoEncoderMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo + ResolveVideoEncoderMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo + ResolveVideoEncoderMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo + ResolveVideoEncoderMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo + ResolveVideoEncoderMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo + ResolveVideoEncoderMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo + ResolveVideoEncoderMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo + ResolveVideoEncoderMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo + ResolveVideoEncoderMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo + ResolveVideoEncoderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveVideoEncoderMethod "setHeaders" o = VideoEncoderSetHeadersMethodInfo + ResolveVideoEncoderMethod "setLatency" o = VideoEncoderSetLatencyMethodInfo + ResolveVideoEncoderMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo + ResolveVideoEncoderMethod "setMeta" o = Gst.Preset.PresetSetMetaMethodInfo + ResolveVideoEncoderMethod "setMinPts" o = VideoEncoderSetMinPtsMethodInfo + ResolveVideoEncoderMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo + ResolveVideoEncoderMethod "setOutputState" o = VideoEncoderSetOutputStateMethodInfo + ResolveVideoEncoderMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo + ResolveVideoEncoderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveVideoEncoderMethod "setQosEnabled" o = VideoEncoderSetQosEnabledMethodInfo + ResolveVideoEncoderMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo + ResolveVideoEncoderMethod "setState" o = Gst.Element.ElementSetStateMethodInfo + ResolveVideoEncoderMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoEncoderMethod t VideoEncoder, O.MethodInfo info VideoEncoder p) => OL.IsLabel t (VideoEncoder -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- VVV Prop "qos" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@qos@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoEncoder #qos +@ +-} +getVideoEncoderQos :: (MonadIO m, IsVideoEncoder o) => o -> m Bool +getVideoEncoderQos obj = liftIO $ B.Properties.getObjectPropertyBool obj "qos" + +{- | +Set the value of the “@qos@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoEncoder [ #qos 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoEncoderQos :: (MonadIO m, IsVideoEncoder o) => o -> Bool -> m () +setVideoEncoderQos obj val = liftIO $ B.Properties.setObjectPropertyBool obj "qos" val + +{- | +Construct a `GValueConstruct` with valid value for the “@qos@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructVideoEncoderQos :: (IsVideoEncoder o) => Bool -> IO (GValueConstruct o) +constructVideoEncoderQos val = B.Properties.constructObjectPropertyBool "qos" val + +#if ENABLE_OVERLOADING +data VideoEncoderQosPropertyInfo +instance AttrInfo VideoEncoderQosPropertyInfo where + type AttrAllowedOps VideoEncoderQosPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint VideoEncoderQosPropertyInfo = (~) Bool + type AttrBaseTypeConstraint VideoEncoderQosPropertyInfo = IsVideoEncoder + type AttrGetType VideoEncoderQosPropertyInfo = Bool + type AttrLabel VideoEncoderQosPropertyInfo = "qos" + type AttrOrigin VideoEncoderQosPropertyInfo = VideoEncoder + attrGet _ = getVideoEncoderQos + attrSet _ = setVideoEncoderQos + attrConstruct _ = constructVideoEncoderQos + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoEncoder +type instance O.AttributeList VideoEncoder = VideoEncoderAttributeList +type VideoEncoderAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("qos", VideoEncoderQosPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +videoEncoderQos :: AttrLabelProxy "qos" +videoEncoderQos = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList VideoEncoder = VideoEncoderSignalList +type VideoEncoderSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method VideoEncoder::allocate_output_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "size of the buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Buffer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_allocate_output_buffer" gst_video_encoder_allocate_output_buffer :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + Word64 -> -- size : TBasicType TUInt64 + IO (Ptr Gst.Buffer.Buffer) + +{- | +Helper function that allocates a buffer to hold an encoded video frame +for /@encoder@/\'s current 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState'. +-} +videoEncoderAllocateOutputBuffer :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> Word64 + {- ^ /@size@/: size of the buffer -} + -> m Gst.Buffer.Buffer + {- ^ __Returns:__ allocated buffer -} +videoEncoderAllocateOutputBuffer encoder size = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + result <- gst_video_encoder_allocate_output_buffer encoder' size + checkUnexpectedReturnNULL "videoEncoderAllocateOutputBuffer" result + result' <- (wrapBoxed Gst.Buffer.Buffer) result + touchManagedPtr encoder + return result' + +#if ENABLE_OVERLOADING +data VideoEncoderAllocateOutputBufferMethodInfo +instance (signature ~ (Word64 -> m Gst.Buffer.Buffer), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderAllocateOutputBufferMethodInfo a signature where + overloadedMethod _ = videoEncoderAllocateOutputBuffer + +#endif + +-- method VideoEncoder::allocate_output_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoCodecFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "size of the buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_allocate_output_frame" gst_video_encoder_allocate_output_frame :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + Ptr GstVideo.VideoCodecFrame.VideoCodecFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}) + Word64 -> -- size : TBasicType TUInt64 + IO CInt + +{- | +Helper function that allocates a buffer to hold an encoded video frame for /@encoder@/\'s +current 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState'. Subclass should already have configured video +state and set src pad caps. + +The buffer allocated here is owned by the frame and you should only +keep references to the frame, not the buffer. +-} +videoEncoderAllocateOutputFrame :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> GstVideo.VideoCodecFrame.VideoCodecFrame + {- ^ /@frame@/: a 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -} + -> Word64 + {- ^ /@size@/: size of the buffer -} + -> m Gst.Enums.FlowReturn + {- ^ __Returns:__ 'GI.Gst.Enums.FlowReturnOk' if an output buffer could be allocated -} +videoEncoderAllocateOutputFrame encoder frame size = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + frame' <- unsafeManagedPtrGetPtr frame + result <- gst_video_encoder_allocate_output_frame encoder' frame' size + let result' = (toEnum . fromIntegral) result + touchManagedPtr encoder + touchManagedPtr frame + return result' + +#if ENABLE_OVERLOADING +data VideoEncoderAllocateOutputFrameMethodInfo +instance (signature ~ (GstVideo.VideoCodecFrame.VideoCodecFrame -> Word64 -> m Gst.Enums.FlowReturn), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderAllocateOutputFrameMethodInfo a signature where + overloadedMethod _ = videoEncoderAllocateOutputFrame + +#endif + +-- method VideoEncoder::finish_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an encoded #GstVideoCodecFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "FlowReturn"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_finish_frame" gst_video_encoder_finish_frame :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + Ptr GstVideo.VideoCodecFrame.VideoCodecFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}) + IO CInt + +{- | +/@frame@/ must have a valid encoded data buffer, whose metadata fields +are then appropriately set according to frame data or no buffer at +all if the frame should be dropped. +It is subsequently pushed downstream or provided to /@prePush@/. +In any case, the frame is considered finished and released. + +After calling this function the output buffer of the frame is to be +considered read-only. This function will also change the metadata +of the buffer. +-} +videoEncoderFinishFrame :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> GstVideo.VideoCodecFrame.VideoCodecFrame + {- ^ /@frame@/: an encoded 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -} + -> m Gst.Enums.FlowReturn + {- ^ __Returns:__ a 'GI.Gst.Enums.FlowReturn' resulting from sending data downstream -} +videoEncoderFinishFrame encoder frame = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + frame' <- B.ManagedPtr.disownBoxed frame + result <- gst_video_encoder_finish_frame encoder' frame' + let result' = (toEnum . fromIntegral) result + touchManagedPtr encoder + touchManagedPtr frame + return result' + +#if ENABLE_OVERLOADING +data VideoEncoderFinishFrameMethodInfo +instance (signature ~ (GstVideo.VideoCodecFrame.VideoCodecFrame -> m Gst.Enums.FlowReturn), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderFinishFrameMethodInfo a signature where + overloadedMethod _ = videoEncoderFinishFrame + +#endif + +-- method VideoEncoder::get_allocator +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface (Name {namespace = "Gst", name = "Allocator"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstAllocator\nused", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TInterface (Name {namespace = "Gst", name = "AllocationParams"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the\n#GstAllocationParams of @allocator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_get_allocator" gst_video_encoder_get_allocator :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + Ptr (Ptr Gst.Allocator.Allocator) -> -- allocator : TInterface (Name {namespace = "Gst", name = "Allocator"}) + Ptr Gst.AllocationParams.AllocationParams -> -- params : TInterface (Name {namespace = "Gst", name = "AllocationParams"}) + IO () + +{- | +Lets 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' sub-classes to know the memory /@allocator@/ +used by the base class and its /@params@/. + +Unref the /@allocator@/ after use it. +-} +videoEncoderGetAllocator :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> m ((Gst.Allocator.Allocator, Gst.AllocationParams.AllocationParams)) +videoEncoderGetAllocator encoder = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + allocator <- allocMem :: IO (Ptr (Ptr Gst.Allocator.Allocator)) + params <- callocBoxedBytes 64 :: IO (Ptr Gst.AllocationParams.AllocationParams) + gst_video_encoder_get_allocator encoder' allocator params + allocator' <- peek allocator + allocator'' <- (wrapObject Gst.Allocator.Allocator) allocator' + params' <- (wrapBoxed Gst.AllocationParams.AllocationParams) params + touchManagedPtr encoder + freeMem allocator + return (allocator'', params') + +#if ENABLE_OVERLOADING +data VideoEncoderGetAllocatorMethodInfo +instance (signature ~ (m ((Gst.Allocator.Allocator, Gst.AllocationParams.AllocationParams))), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetAllocatorMethodInfo a signature where + overloadedMethod _ = videoEncoderGetAllocator + +#endif + +-- method VideoEncoder::get_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame_number", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "system_frame_number of a frame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_get_frame" gst_video_encoder_get_frame :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + Int32 -> -- frame_number : TBasicType TInt + IO (Ptr GstVideo.VideoCodecFrame.VideoCodecFrame) + +{- | +Get a pending unfinished 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' +-} +videoEncoderGetFrame :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> Int32 + {- ^ /@frameNumber@/: system_frame_number of a frame -} + -> m GstVideo.VideoCodecFrame.VideoCodecFrame + {- ^ __Returns:__ pending unfinished 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' identified by /@frameNumber@/. -} +videoEncoderGetFrame encoder frameNumber = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + result <- gst_video_encoder_get_frame encoder' frameNumber + checkUnexpectedReturnNULL "videoEncoderGetFrame" result + result' <- (wrapBoxed GstVideo.VideoCodecFrame.VideoCodecFrame) result + touchManagedPtr encoder + return result' + +#if ENABLE_OVERLOADING +data VideoEncoderGetFrameMethodInfo +instance (signature ~ (Int32 -> m GstVideo.VideoCodecFrame.VideoCodecFrame), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetFrameMethodInfo a signature where + overloadedMethod _ = videoEncoderGetFrame + +#endif + +-- method VideoEncoder::get_frames +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_get_frames" gst_video_encoder_get_frames :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + IO (Ptr (GList (Ptr GstVideo.VideoCodecFrame.VideoCodecFrame))) + +{- | +Get all pending unfinished 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' +-} +videoEncoderGetFrames :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> m [GstVideo.VideoCodecFrame.VideoCodecFrame] + {- ^ __Returns:__ pending unfinished 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame'. -} +videoEncoderGetFrames encoder = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + result <- gst_video_encoder_get_frames encoder' + result' <- unpackGList result + result'' <- mapM (wrapBoxed GstVideo.VideoCodecFrame.VideoCodecFrame) result' + g_list_free result + touchManagedPtr encoder + return result'' + +#if ENABLE_OVERLOADING +data VideoEncoderGetFramesMethodInfo +instance (signature ~ (m [GstVideo.VideoCodecFrame.VideoCodecFrame]), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetFramesMethodInfo a signature where + overloadedMethod _ = videoEncoderGetFrames + +#endif + +-- method VideoEncoder::get_latency +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address of variable in which to store the\n configured minimum latency, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address of variable in which to store the\n configured maximum latency, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_get_latency" gst_video_encoder_get_latency :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + Ptr Word64 -> -- min_latency : TBasicType TUInt64 + Ptr Word64 -> -- max_latency : TBasicType TUInt64 + IO () + +{- | +Query the configured encoding latency. Results will be returned via +/@minLatency@/ and /@maxLatency@/. +-} +videoEncoderGetLatency :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> m ((Word64, Word64)) +videoEncoderGetLatency encoder = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + minLatency <- allocMem :: IO (Ptr Word64) + maxLatency <- allocMem :: IO (Ptr Word64) + gst_video_encoder_get_latency encoder' minLatency maxLatency + minLatency' <- peek minLatency + maxLatency' <- peek maxLatency + touchManagedPtr encoder + freeMem minLatency + freeMem maxLatency + return (minLatency', maxLatency') + +#if ENABLE_OVERLOADING +data VideoEncoderGetLatencyMethodInfo +instance (signature ~ (m ((Word64, Word64))), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetLatencyMethodInfo a signature where + overloadedMethod _ = videoEncoderGetLatency + +#endif + +-- method VideoEncoder::get_max_encode_time +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoCodecFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_get_max_encode_time" gst_video_encoder_get_max_encode_time :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + Ptr GstVideo.VideoCodecFrame.VideoCodecFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}) + IO Int64 + +{- | +Determines maximum possible encoding time for /@frame@/ that will +allow it to encode and arrive in time (as determined by QoS events). +In particular, a negative result means encoding in time is no longer possible +and should therefore occur as soon\/skippy as possible. + +If no QoS events have been received from downstream, or if +'GI.GstVideo.Objects.VideoEncoder.VideoEncoder':@/qos/@ is disabled this function returns 'GI.GLib.Constants.MAXINT64'. + +/Since: 1.14/ +-} +videoEncoderGetMaxEncodeTime :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> GstVideo.VideoCodecFrame.VideoCodecFrame + {- ^ /@frame@/: a 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -} + -> m Int64 + {- ^ __Returns:__ max decoding time. -} +videoEncoderGetMaxEncodeTime encoder frame = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + frame' <- unsafeManagedPtrGetPtr frame + result <- gst_video_encoder_get_max_encode_time encoder' frame' + touchManagedPtr encoder + touchManagedPtr frame + return result + +#if ENABLE_OVERLOADING +data VideoEncoderGetMaxEncodeTimeMethodInfo +instance (signature ~ (GstVideo.VideoCodecFrame.VideoCodecFrame -> m Int64), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetMaxEncodeTimeMethodInfo a signature where + overloadedMethod _ = videoEncoderGetMaxEncodeTime + +#endif + +-- method VideoEncoder::get_oldest_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_get_oldest_frame" gst_video_encoder_get_oldest_frame :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + IO (Ptr GstVideo.VideoCodecFrame.VideoCodecFrame) + +{- | +Get the oldest unfinished pending 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' +-} +videoEncoderGetOldestFrame :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> m GstVideo.VideoCodecFrame.VideoCodecFrame + {- ^ __Returns:__ oldest unfinished pending 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -} +videoEncoderGetOldestFrame encoder = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + result <- gst_video_encoder_get_oldest_frame encoder' + checkUnexpectedReturnNULL "videoEncoderGetOldestFrame" result + result' <- (wrapBoxed GstVideo.VideoCodecFrame.VideoCodecFrame) result + touchManagedPtr encoder + return result' + +#if ENABLE_OVERLOADING +data VideoEncoderGetOldestFrameMethodInfo +instance (signature ~ (m GstVideo.VideoCodecFrame.VideoCodecFrame), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetOldestFrameMethodInfo a signature where + overloadedMethod _ = videoEncoderGetOldestFrame + +#endif + +-- method VideoEncoder::get_output_state +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_get_output_state" gst_video_encoder_get_output_state :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + IO (Ptr GstVideo.VideoCodecState.VideoCodecState) + +{- | +Get the current 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState' +-} +videoEncoderGetOutputState :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> m GstVideo.VideoCodecState.VideoCodecState + {- ^ __Returns:__ 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState' describing format of video data. -} +videoEncoderGetOutputState encoder = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + result <- gst_video_encoder_get_output_state encoder' + checkUnexpectedReturnNULL "videoEncoderGetOutputState" result + result' <- (wrapBoxed GstVideo.VideoCodecState.VideoCodecState) result + touchManagedPtr encoder + return result' + +#if ENABLE_OVERLOADING +data VideoEncoderGetOutputStateMethodInfo +instance (signature ~ (m GstVideo.VideoCodecState.VideoCodecState), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderGetOutputStateMethodInfo a signature where + overloadedMethod _ = videoEncoderGetOutputState + +#endif + +-- method VideoEncoder::is_qos_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the encoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_is_qos_enabled" gst_video_encoder_is_qos_enabled :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + IO CInt + +{- | +Checks if /@encoder@/ is currently configured to handle Quality-of-Service +events from downstream. + +/Since: 1.14/ +-} +videoEncoderIsQosEnabled :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: the encoder -} + -> m Bool + {- ^ __Returns:__ 'True' if the encoder is configured to perform Quality-of-Service. -} +videoEncoderIsQosEnabled encoder = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + result <- gst_video_encoder_is_qos_enabled encoder' + let result' = (/= 0) result + touchManagedPtr encoder + return result' + +#if ENABLE_OVERLOADING +data VideoEncoderIsQosEnabledMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderIsQosEnabledMethodInfo a signature where + overloadedMethod _ = videoEncoderIsQosEnabled + +#endif + +-- method VideoEncoder::merge_tags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface (Name {namespace = "Gst", name = "TagList"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GstTagList to merge, or NULL to unset\n previously-set tags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Gst", name = "TagMergeMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstTagMergeMode to use, usually #GST_TAG_MERGE_REPLACE", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_merge_tags" gst_video_encoder_merge_tags :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + Ptr Gst.TagList.TagList -> -- tags : TInterface (Name {namespace = "Gst", name = "TagList"}) + CUInt -> -- mode : TInterface (Name {namespace = "Gst", name = "TagMergeMode"}) + IO () + +{- | +Sets the video encoder tags and how they should be merged with any +upstream stream tags. This will override any tags previously-set +with 'GI.GstVideo.Objects.VideoEncoder.videoEncoderMergeTags'. + +Note that this is provided for convenience, and the subclass is +not required to use this and can still do tag handling on its own. + +MT safe. +-} +videoEncoderMergeTags :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> Maybe (Gst.TagList.TagList) + {- ^ /@tags@/: a 'GI.Gst.Structs.TagList.TagList' to merge, or NULL to unset + previously-set tags -} + -> Gst.Enums.TagMergeMode + {- ^ /@mode@/: the 'GI.Gst.Enums.TagMergeMode' to use, usually @/GST_TAG_MERGE_REPLACE/@ -} + -> m () +videoEncoderMergeTags encoder tags mode = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + maybeTags <- case tags of + Nothing -> return nullPtr + Just jTags -> do + jTags' <- unsafeManagedPtrGetPtr jTags + return jTags' + let mode' = (fromIntegral . fromEnum) mode + gst_video_encoder_merge_tags encoder' maybeTags mode' + touchManagedPtr encoder + whenJust tags touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data VideoEncoderMergeTagsMethodInfo +instance (signature ~ (Maybe (Gst.TagList.TagList) -> Gst.Enums.TagMergeMode -> m ()), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderMergeTagsMethodInfo a signature where + overloadedMethod _ = videoEncoderMergeTags + +#endif + +-- method VideoEncoder::negotiate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_negotiate" gst_video_encoder_negotiate :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + IO CInt + +{- | +Negotiate with downstream elements to currently configured 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState'. +Unmark GST_PAD_FLAG_NEED_RECONFIGURE in any case. But mark it again if +negotiate fails. +-} +videoEncoderNegotiate :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> m Bool + {- ^ __Returns:__ 'True' if the negotiation succeeded, else 'False'. -} +videoEncoderNegotiate encoder = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + result <- gst_video_encoder_negotiate encoder' + let result' = (/= 0) result + touchManagedPtr encoder + return result' + +#if ENABLE_OVERLOADING +data VideoEncoderNegotiateMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderNegotiateMethodInfo a signature where + overloadedMethod _ = videoEncoderNegotiate + +#endif + +-- method VideoEncoder::proxy_getcaps +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "initial caps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "filter caps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Caps"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_proxy_getcaps" gst_video_encoder_proxy_getcaps :: + Ptr VideoEncoder -> -- enc : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + Ptr Gst.Caps.Caps -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"}) + Ptr Gst.Caps.Caps -> -- filter : TInterface (Name {namespace = "Gst", name = "Caps"}) + IO (Ptr Gst.Caps.Caps) + +{- | +Returns caps that express /@caps@/ (or sink template caps if /@caps@/ == NULL) +restricted to resolution\/format\/... combinations supported by downstream +elements (e.g. muxers). +-} +videoEncoderProxyGetcaps :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@enc@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> Maybe (Gst.Caps.Caps) + {- ^ /@caps@/: initial caps -} + -> Maybe (Gst.Caps.Caps) + {- ^ /@filter@/: filter caps -} + -> m Gst.Caps.Caps + {- ^ __Returns:__ a 'GI.Gst.Structs.Caps.Caps' owned by caller -} +videoEncoderProxyGetcaps enc caps filter = liftIO $ do + enc' <- unsafeManagedPtrCastPtr enc + maybeCaps <- case caps of + Nothing -> return nullPtr + Just jCaps -> do + jCaps' <- unsafeManagedPtrGetPtr jCaps + return jCaps' + maybeFilter <- case filter of + Nothing -> return nullPtr + Just jFilter -> do + jFilter' <- unsafeManagedPtrGetPtr jFilter + return jFilter' + result <- gst_video_encoder_proxy_getcaps enc' maybeCaps maybeFilter + checkUnexpectedReturnNULL "videoEncoderProxyGetcaps" result + result' <- (wrapBoxed Gst.Caps.Caps) result + touchManagedPtr enc + whenJust caps touchManagedPtr + whenJust filter touchManagedPtr + return result' + +#if ENABLE_OVERLOADING +data VideoEncoderProxyGetcapsMethodInfo +instance (signature ~ (Maybe (Gst.Caps.Caps) -> Maybe (Gst.Caps.Caps) -> m Gst.Caps.Caps), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderProxyGetcapsMethodInfo a signature where + overloadedMethod _ = videoEncoderProxyGetcaps + +#endif + +-- method VideoEncoder::set_headers +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "headers", argType = TGList (TInterface (Name {namespace = "Gst", name = "Buffer"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a list of #GstBuffer containing the codec header", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_set_headers" gst_video_encoder_set_headers :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + Ptr (GList (Ptr Gst.Buffer.Buffer)) -> -- headers : TGList (TInterface (Name {namespace = "Gst", name = "Buffer"})) + IO () + +{- | +Set the codec headers to be sent downstream whenever requested. +-} +videoEncoderSetHeaders :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> [Gst.Buffer.Buffer] + {- ^ /@headers@/: a list of 'GI.Gst.Structs.Buffer.Buffer' containing the codec header -} + -> m () +videoEncoderSetHeaders encoder headers = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + headers' <- mapM B.ManagedPtr.disownBoxed headers + headers'' <- packGList headers' + gst_video_encoder_set_headers encoder' headers'' + touchManagedPtr encoder + mapM_ touchManagedPtr headers + return () + +#if ENABLE_OVERLOADING +data VideoEncoderSetHeadersMethodInfo +instance (signature ~ ([Gst.Buffer.Buffer] -> m ()), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderSetHeadersMethodInfo a signature where + overloadedMethod _ = videoEncoderSetHeaders + +#endif + +-- method VideoEncoder::set_latency +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "minimum latency", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "maximum latency", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_set_latency" gst_video_encoder_set_latency :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + Word64 -> -- min_latency : TBasicType TUInt64 + Word64 -> -- max_latency : TBasicType TUInt64 + IO () + +{- | +Informs baseclass of encoding latency. +-} +videoEncoderSetLatency :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> Word64 + {- ^ /@minLatency@/: minimum latency -} + -> Word64 + {- ^ /@maxLatency@/: maximum latency -} + -> m () +videoEncoderSetLatency encoder minLatency maxLatency = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + gst_video_encoder_set_latency encoder' minLatency maxLatency + touchManagedPtr encoder + return () + +#if ENABLE_OVERLOADING +data VideoEncoderSetLatencyMethodInfo +instance (signature ~ (Word64 -> Word64 -> m ()), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderSetLatencyMethodInfo a signature where + overloadedMethod _ = videoEncoderSetLatency + +#endif + +-- method VideoEncoder::set_min_pts +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_pts", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "minimal PTS that will be passed to handle_frame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_set_min_pts" gst_video_encoder_set_min_pts :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + Word64 -> -- min_pts : TBasicType TUInt64 + IO () + +{- | +Request minimal value for PTS passed to handle_frame. + +For streams with reordered frames this can be used to ensure that there +is enough time to accomodate first DTS, which may be less than first PTS + +Since 1.6 +-} +videoEncoderSetMinPts :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> Word64 + {- ^ /@minPts@/: minimal PTS that will be passed to handle_frame -} + -> m () +videoEncoderSetMinPts encoder minPts = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + gst_video_encoder_set_min_pts encoder' minPts + touchManagedPtr encoder + return () + +#if ENABLE_OVERLOADING +data VideoEncoderSetMinPtsMethodInfo +instance (signature ~ (Word64 -> m ()), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderSetMinPtsMethodInfo a signature where + overloadedMethod _ = videoEncoderSetMinPts + +#endif + +-- method VideoEncoder::set_output_state +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstCaps to use for the output", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "reference", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "An optional reference @GstVideoCodecState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_set_output_state" gst_video_encoder_set_output_state :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + Ptr Gst.Caps.Caps -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"}) + Ptr GstVideo.VideoCodecState.VideoCodecState -> -- reference : TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}) + IO (Ptr GstVideo.VideoCodecState.VideoCodecState) + +{- | +Creates a new 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState' with the specified caps as the output state +for the encoder. +Any previously set output state on /@encoder@/ will be replaced by the newly +created one. + +The specified /@caps@/ should not contain any resolution, pixel-aspect-ratio, +framerate, codec-data, .... Those should be specified instead in the returned +'GI.GstVideo.Structs.VideoCodecState.VideoCodecState'. + +If the subclass wishes to copy over existing fields (like pixel aspect ratio, +or framerate) from an existing 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState', it can be provided as a +/@reference@/. + +If the subclass wishes to override some fields from the output state (like +pixel-aspect-ratio or framerate) it can do so on the returned 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState'. + +The new output state will only take effect (set on pads and buffers) starting +from the next call to @/gst_video_encoder_finish_frame/@(). +-} +videoEncoderSetOutputState :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: a 'GI.GstVideo.Objects.VideoEncoder.VideoEncoder' -} + -> Gst.Caps.Caps + {- ^ /@caps@/: the 'GI.Gst.Structs.Caps.Caps' to use for the output -} + -> Maybe (GstVideo.VideoCodecState.VideoCodecState) + {- ^ /@reference@/: An optional reference /@gstVideoCodecState@/ -} + -> m GstVideo.VideoCodecState.VideoCodecState + {- ^ __Returns:__ the newly configured output state. -} +videoEncoderSetOutputState encoder caps reference = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + caps' <- B.ManagedPtr.disownBoxed caps + maybeReference <- case reference of + Nothing -> return nullPtr + Just jReference -> do + jReference' <- unsafeManagedPtrGetPtr jReference + return jReference' + result <- gst_video_encoder_set_output_state encoder' caps' maybeReference + checkUnexpectedReturnNULL "videoEncoderSetOutputState" result + result' <- (wrapBoxed GstVideo.VideoCodecState.VideoCodecState) result + touchManagedPtr encoder + touchManagedPtr caps + whenJust reference touchManagedPtr + return result' + +#if ENABLE_OVERLOADING +data VideoEncoderSetOutputStateMethodInfo +instance (signature ~ (Gst.Caps.Caps -> Maybe (GstVideo.VideoCodecState.VideoCodecState) -> m GstVideo.VideoCodecState.VideoCodecState), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderSetOutputStateMethodInfo a signature where + overloadedMethod _ = videoEncoderSetOutputState + +#endif + +-- method VideoEncoder::set_qos_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the encoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new qos value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_encoder_set_qos_enabled" gst_video_encoder_set_qos_enabled :: + Ptr VideoEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoEncoder"}) + CInt -> -- enabled : TBasicType TBoolean + IO () + +{- | +Configures /@encoder@/ to handle Quality-of-Service events from downstream. + +/Since: 1.14/ +-} +videoEncoderSetQosEnabled :: + (B.CallStack.HasCallStack, MonadIO m, IsVideoEncoder a) => + a + {- ^ /@encoder@/: the encoder -} + -> Bool + {- ^ /@enabled@/: the new qos value. -} + -> m () +videoEncoderSetQosEnabled encoder enabled = liftIO $ do + encoder' <- unsafeManagedPtrCastPtr encoder + let enabled' = (fromIntegral . fromEnum) enabled + gst_video_encoder_set_qos_enabled encoder' enabled' + touchManagedPtr encoder + return () + +#if ENABLE_OVERLOADING +data VideoEncoderSetQosEnabledMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsVideoEncoder a) => O.MethodInfo VideoEncoderSetQosEnabledMethodInfo a signature where + overloadedMethod _ = videoEncoderSetQosEnabled + +#endif + + diff --git a/GI/GstVideo/Objects/VideoEncoder.hs-boot b/GI/GstVideo/Objects/VideoEncoder.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoEncoder.hs-boot @@ -0,0 +1,89 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Objects.VideoEncoder where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoEncoder = VideoEncoder (ManagedPtr VideoEncoder) +instance GObject VideoEncoder where +class (GObject o, O.IsDescendantOf VideoEncoder o) => IsVideoEncoder o +instance (GObject o, O.IsDescendantOf VideoEncoder o) => IsVideoEncoder o +instance O.HasParentTypes VideoEncoder +#if ENABLE_OVERLOADING +data VideoEncoderQosPropertyInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderAllocateOutputBufferMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderAllocateOutputFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderFinishFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderGetAllocatorMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderGetFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderGetFramesMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderGetLatencyMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderGetMaxEncodeTimeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderGetOldestFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderGetOutputStateMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderIsQosEnabledMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderMergeTagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderNegotiateMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderProxyGetcapsMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderSetHeadersMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderSetLatencyMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderSetMinPtsMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderSetOutputStateMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoEncoderSetQosEnabledMethodInfo +#endif diff --git a/GI/GstVideo/Objects/VideoFilter.hs b/GI/GstVideo/Objects/VideoFilter.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoFilter.hs @@ -0,0 +1,226 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Provides useful functions and a base class for video filters. + +The videofilter will by default enable QoS on the parent GstBaseTransform +to implement frame dropping. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Objects.VideoFilter + ( + +-- * Exported types + VideoFilter(..) , + IsVideoFilter , + toVideoFilter , + noVideoFilter , + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gst.Objects.Element as Gst.Element +import qualified GI.Gst.Objects.Object as Gst.Object +import qualified GI.GstBase.Objects.BaseTransform as GstBase.BaseTransform + +-- | Memory-managed wrapper type. +newtype VideoFilter = VideoFilter (ManagedPtr VideoFilter) +foreign import ccall "gst_video_filter_get_type" + c_gst_video_filter_get_type :: IO GType + +instance GObject VideoFilter where + gobjectType = c_gst_video_filter_get_type + + +-- | Type class for types which can be safely cast to `VideoFilter`, for instance with `toVideoFilter`. +class (GObject o, O.IsDescendantOf VideoFilter o) => IsVideoFilter o +instance (GObject o, O.IsDescendantOf VideoFilter o) => IsVideoFilter o + +instance O.HasParentTypes VideoFilter +type instance O.ParentTypes VideoFilter = '[GstBase.BaseTransform.BaseTransform, Gst.Element.Element, Gst.Object.Object, GObject.Object.Object] + +-- | Cast to `VideoFilter`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toVideoFilter :: (MonadIO m, IsVideoFilter o) => o -> m VideoFilter +toVideoFilter = liftIO . unsafeCastTo VideoFilter + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoFilter`. +noVideoFilter :: Maybe VideoFilter +noVideoFilter = Nothing + +#if ENABLE_OVERLOADING +type family ResolveVideoFilterMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoFilterMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo + ResolveVideoFilterMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo + ResolveVideoFilterMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo + ResolveVideoFilterMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo + ResolveVideoFilterMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo + ResolveVideoFilterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveVideoFilterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveVideoFilterMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo + ResolveVideoFilterMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo + ResolveVideoFilterMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo + ResolveVideoFilterMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo + ResolveVideoFilterMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo + ResolveVideoFilterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveVideoFilterMethod "foreachPad" o = Gst.Element.ElementForeachPadMethodInfo + ResolveVideoFilterMethod "foreachSinkPad" o = Gst.Element.ElementForeachSinkPadMethodInfo + ResolveVideoFilterMethod "foreachSrcPad" o = Gst.Element.ElementForeachSrcPadMethodInfo + ResolveVideoFilterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveVideoFilterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveVideoFilterMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo + ResolveVideoFilterMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo + ResolveVideoFilterMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo + ResolveVideoFilterMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo + ResolveVideoFilterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveVideoFilterMethod "isInPlace" o = GstBase.BaseTransform.BaseTransformIsInPlaceMethodInfo + ResolveVideoFilterMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo + ResolveVideoFilterMethod "isPassthrough" o = GstBase.BaseTransform.BaseTransformIsPassthroughMethodInfo + ResolveVideoFilterMethod "isQosEnabled" o = GstBase.BaseTransform.BaseTransformIsQosEnabledMethodInfo + ResolveVideoFilterMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo + ResolveVideoFilterMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo + ResolveVideoFilterMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo + ResolveVideoFilterMethod "link" o = Gst.Element.ElementLinkMethodInfo + ResolveVideoFilterMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo + ResolveVideoFilterMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo + ResolveVideoFilterMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo + ResolveVideoFilterMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo + ResolveVideoFilterMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo + ResolveVideoFilterMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo + ResolveVideoFilterMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo + ResolveVideoFilterMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo + ResolveVideoFilterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveVideoFilterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveVideoFilterMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo + ResolveVideoFilterMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo + ResolveVideoFilterMethod "query" o = Gst.Element.ElementQueryMethodInfo + ResolveVideoFilterMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo + ResolveVideoFilterMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo + ResolveVideoFilterMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo + ResolveVideoFilterMethod "reconfigureSink" o = GstBase.BaseTransform.BaseTransformReconfigureSinkMethodInfo + ResolveVideoFilterMethod "reconfigureSrc" o = GstBase.BaseTransform.BaseTransformReconfigureSrcMethodInfo + ResolveVideoFilterMethod "ref" o = Gst.Object.ObjectRefMethodInfo + ResolveVideoFilterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveVideoFilterMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo + ResolveVideoFilterMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo + ResolveVideoFilterMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo + ResolveVideoFilterMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo + ResolveVideoFilterMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo + ResolveVideoFilterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveVideoFilterMethod "seek" o = Gst.Element.ElementSeekMethodInfo + ResolveVideoFilterMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo + ResolveVideoFilterMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo + ResolveVideoFilterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveVideoFilterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveVideoFilterMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo + ResolveVideoFilterMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo + ResolveVideoFilterMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo + ResolveVideoFilterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveVideoFilterMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo + ResolveVideoFilterMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo + ResolveVideoFilterMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo + ResolveVideoFilterMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo + ResolveVideoFilterMethod "updateQos" o = GstBase.BaseTransform.BaseTransformUpdateQosMethodInfo + ResolveVideoFilterMethod "updateSrcCaps" o = GstBase.BaseTransform.BaseTransformUpdateSrcCapsMethodInfo + ResolveVideoFilterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveVideoFilterMethod "getAllocator" o = GstBase.BaseTransform.BaseTransformGetAllocatorMethodInfo + ResolveVideoFilterMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo + ResolveVideoFilterMethod "getBufferPool" o = GstBase.BaseTransform.BaseTransformGetBufferPoolMethodInfo + ResolveVideoFilterMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo + ResolveVideoFilterMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo + ResolveVideoFilterMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo + ResolveVideoFilterMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo + ResolveVideoFilterMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo + ResolveVideoFilterMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo + ResolveVideoFilterMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo + ResolveVideoFilterMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo + ResolveVideoFilterMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo + ResolveVideoFilterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveVideoFilterMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo + ResolveVideoFilterMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo + ResolveVideoFilterMethod "getMetadata" o = Gst.Element.ElementGetMetadataMethodInfo + ResolveVideoFilterMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo + ResolveVideoFilterMethod "getPadTemplate" o = Gst.Element.ElementGetPadTemplateMethodInfo + ResolveVideoFilterMethod "getPadTemplateList" o = Gst.Element.ElementGetPadTemplateListMethodInfo + ResolveVideoFilterMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo + ResolveVideoFilterMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo + ResolveVideoFilterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveVideoFilterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveVideoFilterMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo + ResolveVideoFilterMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo + ResolveVideoFilterMethod "getState" o = Gst.Element.ElementGetStateMethodInfo + ResolveVideoFilterMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo + ResolveVideoFilterMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo + ResolveVideoFilterMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo + ResolveVideoFilterMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo + ResolveVideoFilterMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo + ResolveVideoFilterMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo + ResolveVideoFilterMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo + ResolveVideoFilterMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo + ResolveVideoFilterMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo + ResolveVideoFilterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveVideoFilterMethod "setGapAware" o = GstBase.BaseTransform.BaseTransformSetGapAwareMethodInfo + ResolveVideoFilterMethod "setInPlace" o = GstBase.BaseTransform.BaseTransformSetInPlaceMethodInfo + ResolveVideoFilterMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo + ResolveVideoFilterMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo + ResolveVideoFilterMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo + ResolveVideoFilterMethod "setPassthrough" o = GstBase.BaseTransform.BaseTransformSetPassthroughMethodInfo + ResolveVideoFilterMethod "setPreferPassthrough" o = GstBase.BaseTransform.BaseTransformSetPreferPassthroughMethodInfo + ResolveVideoFilterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveVideoFilterMethod "setQosEnabled" o = GstBase.BaseTransform.BaseTransformSetQosEnabledMethodInfo + ResolveVideoFilterMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo + ResolveVideoFilterMethod "setState" o = Gst.Element.ElementSetStateMethodInfo + ResolveVideoFilterMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoFilterMethod t VideoFilter, O.MethodInfo info VideoFilter p) => OL.IsLabel t (VideoFilter -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoFilter +type instance O.AttributeList VideoFilter = VideoFilterAttributeList +type VideoFilterAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("qos", GstBase.BaseTransform.BaseTransformQosPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList VideoFilter = VideoFilterSignalList +type VideoFilterSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/GstVideo/Objects/VideoFilter.hs-boot b/GI/GstVideo/Objects/VideoFilter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoFilter.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Objects.VideoFilter where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoFilter = VideoFilter (ManagedPtr VideoFilter) +instance GObject VideoFilter where +class (GObject o, O.IsDescendantOf VideoFilter o) => IsVideoFilter o +instance (GObject o, O.IsDescendantOf VideoFilter o) => IsVideoFilter o +instance O.HasParentTypes VideoFilter diff --git a/GI/GstVideo/Objects/VideoMultiviewFlagsSet.hs b/GI/GstVideo/Objects/VideoMultiviewFlagsSet.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoMultiviewFlagsSet.hs @@ -0,0 +1,36 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Objects.VideoMultiviewFlagsSet () where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- APIObject "VideoMultiviewFlagsSet" does not descend from GObject, it will be ignored. + diff --git a/GI/GstVideo/Objects/VideoSink.hs b/GI/GstVideo/Objects/VideoSink.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoSink.hs @@ -0,0 +1,367 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Provides useful functions and a base class for video sinks. + +GstVideoSink will configure the default base sink to drop frames that +arrive later than 20ms as this is considered the default threshold for +observing out-of-sync frames. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Objects.VideoSink + ( + +-- * Exported types + VideoSink(..) , + IsVideoSink , + toVideoSink , + noVideoSink , + + + -- * Methods +-- ** centerRect #method:centerRect# + + videoSinkCenterRect , + + + + + -- * Properties +-- ** showPrerollFrame #attr:showPrerollFrame# +{- | Whether to show video frames during preroll. If set to 'False', video +frames will only be rendered in PLAYING state. +-} +#if ENABLE_OVERLOADING + VideoSinkShowPrerollFramePropertyInfo , +#endif + constructVideoSinkShowPrerollFrame , + getVideoSinkShowPrerollFrame , + setVideoSinkShowPrerollFrame , +#if ENABLE_OVERLOADING + videoSinkShowPrerollFrame , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gst.Objects.Element as Gst.Element +import qualified GI.Gst.Objects.Object as Gst.Object +import qualified GI.GstBase.Objects.BaseSink as GstBase.BaseSink +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoRectangle as GstVideo.VideoRectangle + +-- | Memory-managed wrapper type. +newtype VideoSink = VideoSink (ManagedPtr VideoSink) +foreign import ccall "gst_video_sink_get_type" + c_gst_video_sink_get_type :: IO GType + +instance GObject VideoSink where + gobjectType = c_gst_video_sink_get_type + + +-- | Type class for types which can be safely cast to `VideoSink`, for instance with `toVideoSink`. +class (GObject o, O.IsDescendantOf VideoSink o) => IsVideoSink o +instance (GObject o, O.IsDescendantOf VideoSink o) => IsVideoSink o + +instance O.HasParentTypes VideoSink +type instance O.ParentTypes VideoSink = '[GstBase.BaseSink.BaseSink, Gst.Element.Element, Gst.Object.Object, GObject.Object.Object] + +-- | Cast to `VideoSink`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toVideoSink :: (MonadIO m, IsVideoSink o) => o -> m VideoSink +toVideoSink = liftIO . unsafeCastTo VideoSink + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoSink`. +noVideoSink :: Maybe VideoSink +noVideoSink = Nothing + +#if ENABLE_OVERLOADING +type family ResolveVideoSinkMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoSinkMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo + ResolveVideoSinkMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo + ResolveVideoSinkMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo + ResolveVideoSinkMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo + ResolveVideoSinkMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo + ResolveVideoSinkMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveVideoSinkMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveVideoSinkMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo + ResolveVideoSinkMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo + ResolveVideoSinkMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo + ResolveVideoSinkMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo + ResolveVideoSinkMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo + ResolveVideoSinkMethod "doPreroll" o = GstBase.BaseSink.BaseSinkDoPrerollMethodInfo + ResolveVideoSinkMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveVideoSinkMethod "foreachPad" o = Gst.Element.ElementForeachPadMethodInfo + ResolveVideoSinkMethod "foreachSinkPad" o = Gst.Element.ElementForeachSinkPadMethodInfo + ResolveVideoSinkMethod "foreachSrcPad" o = Gst.Element.ElementForeachSrcPadMethodInfo + ResolveVideoSinkMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveVideoSinkMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveVideoSinkMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo + ResolveVideoSinkMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo + ResolveVideoSinkMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo + ResolveVideoSinkMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo + ResolveVideoSinkMethod "isAsyncEnabled" o = GstBase.BaseSink.BaseSinkIsAsyncEnabledMethodInfo + ResolveVideoSinkMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveVideoSinkMethod "isLastSampleEnabled" o = GstBase.BaseSink.BaseSinkIsLastSampleEnabledMethodInfo + ResolveVideoSinkMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo + ResolveVideoSinkMethod "isQosEnabled" o = GstBase.BaseSink.BaseSinkIsQosEnabledMethodInfo + ResolveVideoSinkMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo + ResolveVideoSinkMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo + ResolveVideoSinkMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo + ResolveVideoSinkMethod "link" o = Gst.Element.ElementLinkMethodInfo + ResolveVideoSinkMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo + ResolveVideoSinkMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo + ResolveVideoSinkMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo + ResolveVideoSinkMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo + ResolveVideoSinkMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo + ResolveVideoSinkMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo + ResolveVideoSinkMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo + ResolveVideoSinkMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo + ResolveVideoSinkMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveVideoSinkMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveVideoSinkMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo + ResolveVideoSinkMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo + ResolveVideoSinkMethod "query" o = Gst.Element.ElementQueryMethodInfo + ResolveVideoSinkMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo + ResolveVideoSinkMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo + ResolveVideoSinkMethod "queryLatency" o = GstBase.BaseSink.BaseSinkQueryLatencyMethodInfo + ResolveVideoSinkMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo + ResolveVideoSinkMethod "ref" o = Gst.Object.ObjectRefMethodInfo + ResolveVideoSinkMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveVideoSinkMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo + ResolveVideoSinkMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo + ResolveVideoSinkMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo + ResolveVideoSinkMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo + ResolveVideoSinkMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo + ResolveVideoSinkMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveVideoSinkMethod "seek" o = Gst.Element.ElementSeekMethodInfo + ResolveVideoSinkMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo + ResolveVideoSinkMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo + ResolveVideoSinkMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveVideoSinkMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveVideoSinkMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo + ResolveVideoSinkMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo + ResolveVideoSinkMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo + ResolveVideoSinkMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveVideoSinkMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo + ResolveVideoSinkMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo + ResolveVideoSinkMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo + ResolveVideoSinkMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo + ResolveVideoSinkMethod "wait" o = GstBase.BaseSink.BaseSinkWaitMethodInfo + ResolveVideoSinkMethod "waitClock" o = GstBase.BaseSink.BaseSinkWaitClockMethodInfo + ResolveVideoSinkMethod "waitPreroll" o = GstBase.BaseSink.BaseSinkWaitPrerollMethodInfo + ResolveVideoSinkMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveVideoSinkMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo + ResolveVideoSinkMethod "getBlocksize" o = GstBase.BaseSink.BaseSinkGetBlocksizeMethodInfo + ResolveVideoSinkMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo + ResolveVideoSinkMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo + ResolveVideoSinkMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo + ResolveVideoSinkMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo + ResolveVideoSinkMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo + ResolveVideoSinkMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo + ResolveVideoSinkMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo + ResolveVideoSinkMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo + ResolveVideoSinkMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo + ResolveVideoSinkMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveVideoSinkMethod "getDropOutOfSegment" o = GstBase.BaseSink.BaseSinkGetDropOutOfSegmentMethodInfo + ResolveVideoSinkMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo + ResolveVideoSinkMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo + ResolveVideoSinkMethod "getLastSample" o = GstBase.BaseSink.BaseSinkGetLastSampleMethodInfo + ResolveVideoSinkMethod "getLatency" o = GstBase.BaseSink.BaseSinkGetLatencyMethodInfo + ResolveVideoSinkMethod "getMaxBitrate" o = GstBase.BaseSink.BaseSinkGetMaxBitrateMethodInfo + ResolveVideoSinkMethod "getMaxLateness" o = GstBase.BaseSink.BaseSinkGetMaxLatenessMethodInfo + ResolveVideoSinkMethod "getMetadata" o = Gst.Element.ElementGetMetadataMethodInfo + ResolveVideoSinkMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo + ResolveVideoSinkMethod "getPadTemplate" o = Gst.Element.ElementGetPadTemplateMethodInfo + ResolveVideoSinkMethod "getPadTemplateList" o = Gst.Element.ElementGetPadTemplateListMethodInfo + ResolveVideoSinkMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo + ResolveVideoSinkMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo + ResolveVideoSinkMethod "getProcessingDeadline" o = GstBase.BaseSink.BaseSinkGetProcessingDeadlineMethodInfo + ResolveVideoSinkMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveVideoSinkMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveVideoSinkMethod "getRenderDelay" o = GstBase.BaseSink.BaseSinkGetRenderDelayMethodInfo + ResolveVideoSinkMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo + ResolveVideoSinkMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo + ResolveVideoSinkMethod "getState" o = Gst.Element.ElementGetStateMethodInfo + ResolveVideoSinkMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo + ResolveVideoSinkMethod "getSync" o = GstBase.BaseSink.BaseSinkGetSyncMethodInfo + ResolveVideoSinkMethod "getThrottleTime" o = GstBase.BaseSink.BaseSinkGetThrottleTimeMethodInfo + ResolveVideoSinkMethod "getTsOffset" o = GstBase.BaseSink.BaseSinkGetTsOffsetMethodInfo + ResolveVideoSinkMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo + ResolveVideoSinkMethod "setAsyncEnabled" o = GstBase.BaseSink.BaseSinkSetAsyncEnabledMethodInfo + ResolveVideoSinkMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo + ResolveVideoSinkMethod "setBlocksize" o = GstBase.BaseSink.BaseSinkSetBlocksizeMethodInfo + ResolveVideoSinkMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo + ResolveVideoSinkMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo + ResolveVideoSinkMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo + ResolveVideoSinkMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo + ResolveVideoSinkMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo + ResolveVideoSinkMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo + ResolveVideoSinkMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveVideoSinkMethod "setDropOutOfSegment" o = GstBase.BaseSink.BaseSinkSetDropOutOfSegmentMethodInfo + ResolveVideoSinkMethod "setLastSampleEnabled" o = GstBase.BaseSink.BaseSinkSetLastSampleEnabledMethodInfo + ResolveVideoSinkMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo + ResolveVideoSinkMethod "setMaxBitrate" o = GstBase.BaseSink.BaseSinkSetMaxBitrateMethodInfo + ResolveVideoSinkMethod "setMaxLateness" o = GstBase.BaseSink.BaseSinkSetMaxLatenessMethodInfo + ResolveVideoSinkMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo + ResolveVideoSinkMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo + ResolveVideoSinkMethod "setProcessingDeadline" o = GstBase.BaseSink.BaseSinkSetProcessingDeadlineMethodInfo + ResolveVideoSinkMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveVideoSinkMethod "setQosEnabled" o = GstBase.BaseSink.BaseSinkSetQosEnabledMethodInfo + ResolveVideoSinkMethod "setRenderDelay" o = GstBase.BaseSink.BaseSinkSetRenderDelayMethodInfo + ResolveVideoSinkMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo + ResolveVideoSinkMethod "setState" o = Gst.Element.ElementSetStateMethodInfo + ResolveVideoSinkMethod "setSync" o = GstBase.BaseSink.BaseSinkSetSyncMethodInfo + ResolveVideoSinkMethod "setThrottleTime" o = GstBase.BaseSink.BaseSinkSetThrottleTimeMethodInfo + ResolveVideoSinkMethod "setTsOffset" o = GstBase.BaseSink.BaseSinkSetTsOffsetMethodInfo + ResolveVideoSinkMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoSinkMethod t VideoSink, O.MethodInfo info VideoSink p) => OL.IsLabel t (VideoSink -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- VVV Prop "show-preroll-frame" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@show-preroll-frame@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoSink #showPrerollFrame +@ +-} +getVideoSinkShowPrerollFrame :: (MonadIO m, IsVideoSink o) => o -> m Bool +getVideoSinkShowPrerollFrame obj = liftIO $ B.Properties.getObjectPropertyBool obj "show-preroll-frame" + +{- | +Set the value of the “@show-preroll-frame@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoSink [ #showPrerollFrame 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoSinkShowPrerollFrame :: (MonadIO m, IsVideoSink o) => o -> Bool -> m () +setVideoSinkShowPrerollFrame obj val = liftIO $ B.Properties.setObjectPropertyBool obj "show-preroll-frame" val + +{- | +Construct a `GValueConstruct` with valid value for the “@show-preroll-frame@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructVideoSinkShowPrerollFrame :: (IsVideoSink o) => Bool -> IO (GValueConstruct o) +constructVideoSinkShowPrerollFrame val = B.Properties.constructObjectPropertyBool "show-preroll-frame" val + +#if ENABLE_OVERLOADING +data VideoSinkShowPrerollFramePropertyInfo +instance AttrInfo VideoSinkShowPrerollFramePropertyInfo where + type AttrAllowedOps VideoSinkShowPrerollFramePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint VideoSinkShowPrerollFramePropertyInfo = (~) Bool + type AttrBaseTypeConstraint VideoSinkShowPrerollFramePropertyInfo = IsVideoSink + type AttrGetType VideoSinkShowPrerollFramePropertyInfo = Bool + type AttrLabel VideoSinkShowPrerollFramePropertyInfo = "show-preroll-frame" + type AttrOrigin VideoSinkShowPrerollFramePropertyInfo = VideoSink + attrGet _ = getVideoSinkShowPrerollFrame + attrSet _ = setVideoSinkShowPrerollFrame + attrConstruct _ = constructVideoSinkShowPrerollFrame + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoSink +type instance O.AttributeList VideoSink = VideoSinkAttributeList +type VideoSinkAttributeList = ('[ '("async", GstBase.BaseSink.BaseSinkAsyncPropertyInfo), '("blocksize", GstBase.BaseSink.BaseSinkBlocksizePropertyInfo), '("enableLastSample", GstBase.BaseSink.BaseSinkEnableLastSamplePropertyInfo), '("lastSample", GstBase.BaseSink.BaseSinkLastSamplePropertyInfo), '("maxBitrate", GstBase.BaseSink.BaseSinkMaxBitratePropertyInfo), '("maxLateness", GstBase.BaseSink.BaseSinkMaxLatenessPropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("processingDeadline", GstBase.BaseSink.BaseSinkProcessingDeadlinePropertyInfo), '("qos", GstBase.BaseSink.BaseSinkQosPropertyInfo), '("renderDelay", GstBase.BaseSink.BaseSinkRenderDelayPropertyInfo), '("showPrerollFrame", VideoSinkShowPrerollFramePropertyInfo), '("sync", GstBase.BaseSink.BaseSinkSyncPropertyInfo), '("throttleTime", GstBase.BaseSink.BaseSinkThrottleTimePropertyInfo), '("tsOffset", GstBase.BaseSink.BaseSinkTsOffsetPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +videoSinkShowPrerollFrame :: AttrLabelProxy "showPrerollFrame" +videoSinkShowPrerollFrame = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList VideoSink = VideoSinkSignalList +type VideoSinkSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method VideoSink::center_rect +-- method type : MemberFunction +-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GstVideo", name = "VideoRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstVideoRectangle describing the source area", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dst", argType = TInterface (Name {namespace = "GstVideo", name = "VideoRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstVideoRectangle describing the destination area", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "GstVideo", name = "VideoRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GstVideoRectangle which will receive the result area", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scaling", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gboolean indicating if scaling should be applied or not", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_sink_center_rect" gst_video_sink_center_rect :: + Ptr GstVideo.VideoRectangle.VideoRectangle -> -- src : TInterface (Name {namespace = "GstVideo", name = "VideoRectangle"}) + Ptr GstVideo.VideoRectangle.VideoRectangle -> -- dst : TInterface (Name {namespace = "GstVideo", name = "VideoRectangle"}) + Ptr GstVideo.VideoRectangle.VideoRectangle -> -- result : TInterface (Name {namespace = "GstVideo", name = "VideoRectangle"}) + CInt -> -- scaling : TBasicType TBoolean + IO () + +{- | +Takes /@src@/ rectangle and position it at the center of /@dst@/ rectangle with or +without /@scaling@/. It handles clipping if the /@src@/ rectangle is bigger than +the /@dst@/ one and /@scaling@/ is set to FALSE. +-} +videoSinkCenterRect :: + (B.CallStack.HasCallStack, MonadIO m) => + GstVideo.VideoRectangle.VideoRectangle + {- ^ /@src@/: the 'GI.GstVideo.Structs.VideoRectangle.VideoRectangle' describing the source area -} + -> GstVideo.VideoRectangle.VideoRectangle + {- ^ /@dst@/: the 'GI.GstVideo.Structs.VideoRectangle.VideoRectangle' describing the destination area -} + -> GstVideo.VideoRectangle.VideoRectangle + {- ^ /@result@/: a pointer to a 'GI.GstVideo.Structs.VideoRectangle.VideoRectangle' which will receive the result area -} + -> Bool + {- ^ /@scaling@/: a 'Bool' indicating if scaling should be applied or not -} + -> m () +videoSinkCenterRect src dst result_ scaling = liftIO $ do + src' <- unsafeManagedPtrGetPtr src + dst' <- unsafeManagedPtrGetPtr dst + result_' <- unsafeManagedPtrGetPtr result_ + let scaling' = (fromIntegral . fromEnum) scaling + gst_video_sink_center_rect src' dst' result_' scaling' + touchManagedPtr src + touchManagedPtr dst + touchManagedPtr result_ + return () + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GstVideo/Objects/VideoSink.hs-boot b/GI/GstVideo/Objects/VideoSink.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Objects/VideoSink.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Objects.VideoSink where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoSink = VideoSink (ManagedPtr VideoSink) +instance GObject VideoSink where +class (GObject o, O.IsDescendantOf VideoSink o) => IsVideoSink o +instance (GObject o, O.IsDescendantOf VideoSink o) => IsVideoSink o +instance O.HasParentTypes VideoSink +#if ENABLE_OVERLOADING +data VideoSinkShowPrerollFramePropertyInfo +#endif diff --git a/GI/GstVideo/Structs.hs b/GI/GstVideo/Structs.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs.hs @@ -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 (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs + ( module GI.GstVideo.Structs.VideoAffineTransformationMeta, + module GI.GstVideo.Structs.VideoAlignment, + module GI.GstVideo.Structs.VideoAncillary, + module GI.GstVideo.Structs.VideoCaptionMeta, + 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.Structs.VideoTimeCode, + module GI.GstVideo.Structs.VideoTimeCodeConfig, + module GI.GstVideo.Structs.VideoTimeCodeInterval, + module GI.GstVideo.Structs.VideoTimeCodeMeta, + module GI.GstVideo.Structs.VideoVBIEncoder, + module GI.GstVideo.Structs.VideoVBIParser, + + + ) where + +import GI.GstVideo.Structs.VideoAffineTransformationMeta +import GI.GstVideo.Structs.VideoAlignment +import GI.GstVideo.Structs.VideoAncillary +import GI.GstVideo.Structs.VideoCaptionMeta +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 GI.GstVideo.Structs.VideoTimeCode +import GI.GstVideo.Structs.VideoTimeCodeConfig +import GI.GstVideo.Structs.VideoTimeCodeInterval +import GI.GstVideo.Structs.VideoTimeCodeMeta +import GI.GstVideo.Structs.VideoVBIEncoder +import GI.GstVideo.Structs.VideoVBIParser + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + + diff --git a/GI/GstVideo/Structs/VideoAffineTransformationMeta.hs b/GI/GstVideo/Structs/VideoAffineTransformationMeta.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoAffineTransformationMeta.hs @@ -0,0 +1,231 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Extra buffer metadata for performing an affine transformation using a 4x4 +matrix. The transformation matrix can be composed with +'GI.GstVideo.Structs.VideoAffineTransformationMeta.videoAffineTransformationMetaApplyMatrix'. + +The vertices operated on are all in the range 0 to 1, not in +Normalized Device Coordinates (-1 to +1). Transforming points in this space +are assumed to have an origin at (0.5, 0.5, 0.5) in a left-handed coordinate +system with the x-axis moving horizontally (positive values to the right), +the y-axis moving vertically (positive values up the screen) and the z-axis +perpendicular to the screen (positive values into the screen). + +/Since: 1.8/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoAffineTransformationMeta + ( + +-- * Exported types + VideoAffineTransformationMeta(..) , + newZeroVideoAffineTransformationMeta , + noVideoAffineTransformationMeta , + + + -- * Methods +-- ** applyMatrix #method:applyMatrix# + +#if ENABLE_OVERLOADING + VideoAffineTransformationMetaApplyMatrixMethodInfo, +#endif + videoAffineTransformationMetaApplyMatrix, + + +-- ** getInfo #method:getInfo# + + videoAffineTransformationMetaGetInfo , + + + + + -- * Properties +-- ** meta #attr:meta# +{- | parent 'GI.Gst.Structs.Meta.Meta' +-} + getVideoAffineTransformationMetaMeta , +#if ENABLE_OVERLOADING + videoAffineTransformationMeta_meta , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Structs.Meta as Gst.Meta +import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo + +-- | Memory-managed wrapper type. +newtype VideoAffineTransformationMeta = VideoAffineTransformationMeta (ManagedPtr VideoAffineTransformationMeta) +instance WrappedPtr VideoAffineTransformationMeta where + wrappedPtrCalloc = callocBytes 80 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 80 >=> wrapPtr VideoAffineTransformationMeta) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoAffineTransformationMeta` struct initialized to zero. +newZeroVideoAffineTransformationMeta :: MonadIO m => m VideoAffineTransformationMeta +newZeroVideoAffineTransformationMeta = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoAffineTransformationMeta + +instance tag ~ 'AttrSet => Constructible VideoAffineTransformationMeta tag where + new _ attrs = do + o <- newZeroVideoAffineTransformationMeta + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoAffineTransformationMeta`. +noVideoAffineTransformationMeta :: Maybe VideoAffineTransformationMeta +noVideoAffineTransformationMeta = Nothing + +{- | +Get the value of the “@meta@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoAffineTransformationMeta #meta +@ +-} +getVideoAffineTransformationMetaMeta :: MonadIO m => VideoAffineTransformationMeta -> m Gst.Meta.Meta +getVideoAffineTransformationMetaMeta s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Gst.Meta.Meta) + val' <- (newPtr Gst.Meta.Meta) val + return val' + +#if ENABLE_OVERLOADING +data VideoAffineTransformationMetaMetaFieldInfo +instance AttrInfo VideoAffineTransformationMetaMetaFieldInfo where + type AttrAllowedOps VideoAffineTransformationMetaMetaFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint VideoAffineTransformationMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta) + type AttrBaseTypeConstraint VideoAffineTransformationMetaMetaFieldInfo = (~) VideoAffineTransformationMeta + type AttrGetType VideoAffineTransformationMetaMetaFieldInfo = Gst.Meta.Meta + type AttrLabel VideoAffineTransformationMetaMetaFieldInfo = "meta" + type AttrOrigin VideoAffineTransformationMetaMetaFieldInfo = VideoAffineTransformationMeta + attrGet _ = getVideoAffineTransformationMetaMeta + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +videoAffineTransformationMeta_meta :: AttrLabelProxy "meta" +videoAffineTransformationMeta_meta = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "VideoAffineTransformationMeta:matrix" :: Not implemented: "Don't know how to unpack C array of type TCArray False 16 (-1) (TBasicType TFloat)" + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoAffineTransformationMeta +type instance O.AttributeList VideoAffineTransformationMeta = VideoAffineTransformationMetaAttributeList +type VideoAffineTransformationMetaAttributeList = ('[ '("meta", VideoAffineTransformationMetaMetaFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoAffineTransformationMeta::apply_matrix +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAffineTransformationMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoAffineTransformationMeta", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "matrix", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a 4x4 transformation matrix to be applied", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_affine_transformation_meta_apply_matrix" gst_video_affine_transformation_meta_apply_matrix :: + Ptr VideoAffineTransformationMeta -> -- meta : TInterface (Name {namespace = "GstVideo", name = "VideoAffineTransformationMeta"}) + CFloat -> -- matrix : TBasicType TFloat + IO () + +{- | +Apply a transformation using the given 4x4 transformation matrix. +Performs the multiplication, meta->matrix X matrix. + +/Since: 1.8/ +-} +videoAffineTransformationMetaApplyMatrix :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoAffineTransformationMeta + {- ^ /@meta@/: a 'GI.GstVideo.Structs.VideoAffineTransformationMeta.VideoAffineTransformationMeta' -} + -> Float + {- ^ /@matrix@/: a 4x4 transformation matrix to be applied -} + -> m () +videoAffineTransformationMetaApplyMatrix meta matrix = liftIO $ do + meta' <- unsafeManagedPtrGetPtr meta + let matrix' = realToFrac matrix + gst_video_affine_transformation_meta_apply_matrix meta' matrix' + touchManagedPtr meta + return () + +#if ENABLE_OVERLOADING +data VideoAffineTransformationMetaApplyMatrixMethodInfo +instance (signature ~ (Float -> m ()), MonadIO m) => O.MethodInfo VideoAffineTransformationMetaApplyMatrixMethodInfo VideoAffineTransformationMeta signature where + overloadedMethod _ = videoAffineTransformationMetaApplyMatrix + +#endif + +-- method VideoAffineTransformationMeta::get_info +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "MetaInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_affine_transformation_meta_get_info" gst_video_affine_transformation_meta_get_info :: + IO (Ptr Gst.MetaInfo.MetaInfo) + +{- | +/No description available in the introspection data./ +-} +videoAffineTransformationMetaGetInfo :: + (B.CallStack.HasCallStack, MonadIO m) => + m Gst.MetaInfo.MetaInfo +videoAffineTransformationMetaGetInfo = liftIO $ do + result <- gst_video_affine_transformation_meta_get_info + checkUnexpectedReturnNULL "videoAffineTransformationMetaGetInfo" result + result' <- (newPtr Gst.MetaInfo.MetaInfo) result + return result' + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoAffineTransformationMetaMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoAffineTransformationMetaMethod "applyMatrix" o = VideoAffineTransformationMetaApplyMatrixMethodInfo + ResolveVideoAffineTransformationMetaMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoAffineTransformationMetaMethod t VideoAffineTransformationMeta, O.MethodInfo info VideoAffineTransformationMeta p) => OL.IsLabel t (VideoAffineTransformationMeta -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoAffineTransformationMeta.hs-boot b/GI/GstVideo/Structs/VideoAffineTransformationMeta.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoAffineTransformationMeta.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoAffineTransformationMeta where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoAffineTransformationMeta = VideoAffineTransformationMeta (ManagedPtr VideoAffineTransformationMeta) +instance WrappedPtr VideoAffineTransformationMeta where +#if ENABLE_OVERLOADING +data VideoAffineTransformationMetaApplyMatrixMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoAlignment.hs b/GI/GstVideo/Structs/VideoAlignment.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoAlignment.hs @@ -0,0 +1,359 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Extra alignment parameters for the memory of video buffers. This +structure is usually used to configure the bufferpool if it supports the +'GI.GstVideo.Constants.BUFFER_POOL_OPTION_VIDEO_ALIGNMENT'. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoAlignment + ( + +-- * Exported types + VideoAlignment(..) , + newZeroVideoAlignment , + noVideoAlignment , + + + -- * Methods +-- ** reset #method:reset# + +#if ENABLE_OVERLOADING + VideoAlignmentResetMethodInfo , +#endif + videoAlignmentReset , + + + + + -- * Properties +-- ** paddingBottom #attr:paddingBottom# +{- | extra pixels on the bottom +-} + getVideoAlignmentPaddingBottom , + setVideoAlignmentPaddingBottom , +#if ENABLE_OVERLOADING + videoAlignment_paddingBottom , +#endif + + +-- ** paddingLeft #attr:paddingLeft# +{- | extra pixels on the left side +-} + getVideoAlignmentPaddingLeft , + setVideoAlignmentPaddingLeft , +#if ENABLE_OVERLOADING + videoAlignment_paddingLeft , +#endif + + +-- ** paddingRight #attr:paddingRight# +{- | extra pixels on the right side +-} + getVideoAlignmentPaddingRight , + setVideoAlignmentPaddingRight , +#if ENABLE_OVERLOADING + videoAlignment_paddingRight , +#endif + + +-- ** paddingTop #attr:paddingTop# +{- | extra pixels on the top +-} + getVideoAlignmentPaddingTop , + setVideoAlignmentPaddingTop , +#if ENABLE_OVERLOADING + videoAlignment_paddingTop , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- | Memory-managed wrapper type. +newtype VideoAlignment = VideoAlignment (ManagedPtr VideoAlignment) +instance WrappedPtr VideoAlignment where + wrappedPtrCalloc = callocBytes 32 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 32 >=> wrapPtr VideoAlignment) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoAlignment` struct initialized to zero. +newZeroVideoAlignment :: MonadIO m => m VideoAlignment +newZeroVideoAlignment = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoAlignment + +instance tag ~ 'AttrSet => Constructible VideoAlignment tag where + new _ attrs = do + o <- newZeroVideoAlignment + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoAlignment`. +noVideoAlignment :: Maybe VideoAlignment +noVideoAlignment = Nothing + +{- | +Get the value of the “@padding_top@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoAlignment #paddingTop +@ +-} +getVideoAlignmentPaddingTop :: MonadIO m => VideoAlignment -> m Word32 +getVideoAlignmentPaddingTop s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word32 + return val + +{- | +Set the value of the “@padding_top@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoAlignment [ #paddingTop 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoAlignmentPaddingTop :: MonadIO m => VideoAlignment -> Word32 -> m () +setVideoAlignmentPaddingTop s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoAlignmentPaddingTopFieldInfo +instance AttrInfo VideoAlignmentPaddingTopFieldInfo where + type AttrAllowedOps VideoAlignmentPaddingTopFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoAlignmentPaddingTopFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoAlignmentPaddingTopFieldInfo = (~) VideoAlignment + type AttrGetType VideoAlignmentPaddingTopFieldInfo = Word32 + type AttrLabel VideoAlignmentPaddingTopFieldInfo = "padding_top" + type AttrOrigin VideoAlignmentPaddingTopFieldInfo = VideoAlignment + attrGet _ = getVideoAlignmentPaddingTop + attrSet _ = setVideoAlignmentPaddingTop + attrConstruct = undefined + attrClear _ = undefined + +videoAlignment_paddingTop :: AttrLabelProxy "paddingTop" +videoAlignment_paddingTop = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@padding_bottom@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoAlignment #paddingBottom +@ +-} +getVideoAlignmentPaddingBottom :: MonadIO m => VideoAlignment -> m Word32 +getVideoAlignmentPaddingBottom s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 4) :: IO Word32 + return val + +{- | +Set the value of the “@padding_bottom@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoAlignment [ #paddingBottom 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoAlignmentPaddingBottom :: MonadIO m => VideoAlignment -> Word32 -> m () +setVideoAlignmentPaddingBottom s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 4) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoAlignmentPaddingBottomFieldInfo +instance AttrInfo VideoAlignmentPaddingBottomFieldInfo where + type AttrAllowedOps VideoAlignmentPaddingBottomFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoAlignmentPaddingBottomFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoAlignmentPaddingBottomFieldInfo = (~) VideoAlignment + type AttrGetType VideoAlignmentPaddingBottomFieldInfo = Word32 + type AttrLabel VideoAlignmentPaddingBottomFieldInfo = "padding_bottom" + type AttrOrigin VideoAlignmentPaddingBottomFieldInfo = VideoAlignment + attrGet _ = getVideoAlignmentPaddingBottom + attrSet _ = setVideoAlignmentPaddingBottom + attrConstruct = undefined + attrClear _ = undefined + +videoAlignment_paddingBottom :: AttrLabelProxy "paddingBottom" +videoAlignment_paddingBottom = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@padding_left@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoAlignment #paddingLeft +@ +-} +getVideoAlignmentPaddingLeft :: MonadIO m => VideoAlignment -> m Word32 +getVideoAlignmentPaddingLeft s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO Word32 + return val + +{- | +Set the value of the “@padding_left@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoAlignment [ #paddingLeft 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoAlignmentPaddingLeft :: MonadIO m => VideoAlignment -> Word32 -> m () +setVideoAlignmentPaddingLeft s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoAlignmentPaddingLeftFieldInfo +instance AttrInfo VideoAlignmentPaddingLeftFieldInfo where + type AttrAllowedOps VideoAlignmentPaddingLeftFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoAlignmentPaddingLeftFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoAlignmentPaddingLeftFieldInfo = (~) VideoAlignment + type AttrGetType VideoAlignmentPaddingLeftFieldInfo = Word32 + type AttrLabel VideoAlignmentPaddingLeftFieldInfo = "padding_left" + type AttrOrigin VideoAlignmentPaddingLeftFieldInfo = VideoAlignment + attrGet _ = getVideoAlignmentPaddingLeft + attrSet _ = setVideoAlignmentPaddingLeft + attrConstruct = undefined + attrClear _ = undefined + +videoAlignment_paddingLeft :: AttrLabelProxy "paddingLeft" +videoAlignment_paddingLeft = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@padding_right@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoAlignment #paddingRight +@ +-} +getVideoAlignmentPaddingRight :: MonadIO m => VideoAlignment -> m Word32 +getVideoAlignmentPaddingRight s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 12) :: IO Word32 + return val + +{- | +Set the value of the “@padding_right@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoAlignment [ #paddingRight 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoAlignmentPaddingRight :: MonadIO m => VideoAlignment -> Word32 -> m () +setVideoAlignmentPaddingRight s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 12) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoAlignmentPaddingRightFieldInfo +instance AttrInfo VideoAlignmentPaddingRightFieldInfo where + type AttrAllowedOps VideoAlignmentPaddingRightFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoAlignmentPaddingRightFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoAlignmentPaddingRightFieldInfo = (~) VideoAlignment + type AttrGetType VideoAlignmentPaddingRightFieldInfo = Word32 + type AttrLabel VideoAlignmentPaddingRightFieldInfo = "padding_right" + type AttrOrigin VideoAlignmentPaddingRightFieldInfo = VideoAlignment + attrGet _ = getVideoAlignmentPaddingRight + attrSet _ = setVideoAlignmentPaddingRight + attrConstruct = undefined + attrClear _ = undefined + +videoAlignment_paddingRight :: AttrLabelProxy "paddingRight" +videoAlignment_paddingRight = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "VideoAlignment:stride_align" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt)" + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoAlignment +type instance O.AttributeList VideoAlignment = VideoAlignmentAttributeList +type VideoAlignmentAttributeList = ('[ '("paddingTop", VideoAlignmentPaddingTopFieldInfo), '("paddingBottom", VideoAlignmentPaddingBottomFieldInfo), '("paddingLeft", VideoAlignmentPaddingLeftFieldInfo), '("paddingRight", VideoAlignmentPaddingRightFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoAlignment::reset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "align", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoAlignment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_alignment_reset" gst_video_alignment_reset :: + Ptr VideoAlignment -> -- align : TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"}) + IO () + +{- | +Set /@align@/ to its default values with no padding and no alignment. +-} +videoAlignmentReset :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoAlignment + {- ^ /@align@/: a 'GI.GstVideo.Structs.VideoAlignment.VideoAlignment' -} + -> m () +videoAlignmentReset align = liftIO $ do + align' <- unsafeManagedPtrGetPtr align + gst_video_alignment_reset align' + touchManagedPtr align + return () + +#if ENABLE_OVERLOADING +data VideoAlignmentResetMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoAlignmentResetMethodInfo VideoAlignment signature where + overloadedMethod _ = videoAlignmentReset + +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoAlignmentMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoAlignmentMethod "reset" o = VideoAlignmentResetMethodInfo + ResolveVideoAlignmentMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoAlignmentMethod t VideoAlignment, O.MethodInfo info VideoAlignment p) => OL.IsLabel t (VideoAlignment -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoAlignment.hs-boot b/GI/GstVideo/Structs/VideoAlignment.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoAlignment.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoAlignment where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoAlignment = VideoAlignment (ManagedPtr VideoAlignment) +instance WrappedPtr VideoAlignment where +#if ENABLE_OVERLOADING +data VideoAlignmentResetMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoAncillary.hs b/GI/GstVideo/Structs/VideoAncillary.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoAncillary.hs @@ -0,0 +1,263 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Video Ancillary data, according to SMPTE-291M specification. + +Note that the contents of the data are always stored as 8bit data (i.e. do not contain +the parity check bits). + +/Since: 1.16/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoAncillary + ( + +-- * Exported types + VideoAncillary(..) , + newZeroVideoAncillary , + noVideoAncillary , + + + -- * Properties +-- ** dID #attr:dID# +{- | The Data Identifier +-} + getVideoAncillaryDID , + setVideoAncillaryDID , +#if ENABLE_OVERLOADING + videoAncillary_dID , +#endif + + +-- ** dataCount #attr:dataCount# +{- | The amount of data (in bytes) in /@data@/ (max 255 bytes) +-} + getVideoAncillaryDataCount , + setVideoAncillaryDataCount , +#if ENABLE_OVERLOADING + videoAncillary_dataCount , +#endif + + +-- ** sDIDBlockNumber #attr:sDIDBlockNumber# +{- | The Secondary Data Identifier (if type 2) or the Data + Block Number (if type 1) +-} + getVideoAncillarySDIDBlockNumber , + setVideoAncillarySDIDBlockNumber , +#if ENABLE_OVERLOADING + videoAncillary_sDIDBlockNumber , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- | Memory-managed wrapper type. +newtype VideoAncillary = VideoAncillary (ManagedPtr VideoAncillary) +instance WrappedPtr VideoAncillary where + wrappedPtrCalloc = callocBytes 48 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 48 >=> wrapPtr VideoAncillary) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoAncillary` struct initialized to zero. +newZeroVideoAncillary :: MonadIO m => m VideoAncillary +newZeroVideoAncillary = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoAncillary + +instance tag ~ 'AttrSet => Constructible VideoAncillary tag where + new _ attrs = do + o <- newZeroVideoAncillary + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoAncillary`. +noVideoAncillary :: Maybe VideoAncillary +noVideoAncillary = Nothing + +{- | +Get the value of the “@DID@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoAncillary #dID +@ +-} +getVideoAncillaryDID :: MonadIO m => VideoAncillary -> m Word8 +getVideoAncillaryDID s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word8 + return val + +{- | +Set the value of the “@DID@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoAncillary [ #dID 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoAncillaryDID :: MonadIO m => VideoAncillary -> Word8 -> m () +setVideoAncillaryDID s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word8) + +#if ENABLE_OVERLOADING +data VideoAncillaryDIDFieldInfo +instance AttrInfo VideoAncillaryDIDFieldInfo where + type AttrAllowedOps VideoAncillaryDIDFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoAncillaryDIDFieldInfo = (~) Word8 + type AttrBaseTypeConstraint VideoAncillaryDIDFieldInfo = (~) VideoAncillary + type AttrGetType VideoAncillaryDIDFieldInfo = Word8 + type AttrLabel VideoAncillaryDIDFieldInfo = "DID" + type AttrOrigin VideoAncillaryDIDFieldInfo = VideoAncillary + attrGet _ = getVideoAncillaryDID + attrSet _ = setVideoAncillaryDID + attrConstruct = undefined + attrClear _ = undefined + +videoAncillary_dID :: AttrLabelProxy "dID" +videoAncillary_dID = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@SDID_block_number@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoAncillary #sDIDBlockNumber +@ +-} +getVideoAncillarySDIDBlockNumber :: MonadIO m => VideoAncillary -> m Word8 +getVideoAncillarySDIDBlockNumber s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 1) :: IO Word8 + return val + +{- | +Set the value of the “@SDID_block_number@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoAncillary [ #sDIDBlockNumber 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoAncillarySDIDBlockNumber :: MonadIO m => VideoAncillary -> Word8 -> m () +setVideoAncillarySDIDBlockNumber s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 1) (val :: Word8) + +#if ENABLE_OVERLOADING +data VideoAncillarySDIDBlockNumberFieldInfo +instance AttrInfo VideoAncillarySDIDBlockNumberFieldInfo where + type AttrAllowedOps VideoAncillarySDIDBlockNumberFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoAncillarySDIDBlockNumberFieldInfo = (~) Word8 + type AttrBaseTypeConstraint VideoAncillarySDIDBlockNumberFieldInfo = (~) VideoAncillary + type AttrGetType VideoAncillarySDIDBlockNumberFieldInfo = Word8 + type AttrLabel VideoAncillarySDIDBlockNumberFieldInfo = "SDID_block_number" + type AttrOrigin VideoAncillarySDIDBlockNumberFieldInfo = VideoAncillary + attrGet _ = getVideoAncillarySDIDBlockNumber + attrSet _ = setVideoAncillarySDIDBlockNumber + attrConstruct = undefined + attrClear _ = undefined + +videoAncillary_sDIDBlockNumber :: AttrLabelProxy "sDIDBlockNumber" +videoAncillary_sDIDBlockNumber = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@data_count@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoAncillary #dataCount +@ +-} +getVideoAncillaryDataCount :: MonadIO m => VideoAncillary -> m Word8 +getVideoAncillaryDataCount s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 2) :: IO Word8 + return val + +{- | +Set the value of the “@data_count@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoAncillary [ #dataCount 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoAncillaryDataCount :: MonadIO m => VideoAncillary -> Word8 -> m () +setVideoAncillaryDataCount s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 2) (val :: Word8) + +#if ENABLE_OVERLOADING +data VideoAncillaryDataCountFieldInfo +instance AttrInfo VideoAncillaryDataCountFieldInfo where + type AttrAllowedOps VideoAncillaryDataCountFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoAncillaryDataCountFieldInfo = (~) Word8 + type AttrBaseTypeConstraint VideoAncillaryDataCountFieldInfo = (~) VideoAncillary + type AttrGetType VideoAncillaryDataCountFieldInfo = Word8 + type AttrLabel VideoAncillaryDataCountFieldInfo = "data_count" + type AttrOrigin VideoAncillaryDataCountFieldInfo = VideoAncillary + attrGet _ = getVideoAncillaryDataCount + attrSet _ = setVideoAncillaryDataCount + attrConstruct = undefined + attrClear _ = undefined + +videoAncillary_dataCount :: AttrLabelProxy "dataCount" +videoAncillary_dataCount = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "VideoAncillary:data" :: Not implemented: "Don't know how to unpack C array of type TCArray False (-1) 2 (TBasicType TUInt8)" + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoAncillary +type instance O.AttributeList VideoAncillary = VideoAncillaryAttributeList +type VideoAncillaryAttributeList = ('[ '("dID", VideoAncillaryDIDFieldInfo), '("sDIDBlockNumber", VideoAncillarySDIDBlockNumberFieldInfo), '("dataCount", VideoAncillaryDataCountFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoAncillaryMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoAncillaryMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoAncillaryMethod t VideoAncillary, O.MethodInfo info VideoAncillary p) => OL.IsLabel t (VideoAncillary -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoAncillary.hs-boot b/GI/GstVideo/Structs/VideoAncillary.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoAncillary.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoAncillary where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoAncillary = VideoAncillary (ManagedPtr VideoAncillary) +instance WrappedPtr VideoAncillary where diff --git a/GI/GstVideo/Structs/VideoCaptionMeta.hs b/GI/GstVideo/Structs/VideoCaptionMeta.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoCaptionMeta.hs @@ -0,0 +1,286 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Extra buffer metadata providing Closed Caption. + +/Since: 1.16/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoCaptionMeta + ( + +-- * Exported types + VideoCaptionMeta(..) , + newZeroVideoCaptionMeta , + noVideoCaptionMeta , + + + -- * Methods +-- ** getInfo #method:getInfo# + + videoCaptionMetaGetInfo , + + + + + -- * Properties +-- ** captionType #attr:captionType# +{- | The type of Closed Caption contained in the meta. +-} + getVideoCaptionMetaCaptionType , + setVideoCaptionMetaCaptionType , +#if ENABLE_OVERLOADING + videoCaptionMeta_captionType , +#endif + + +-- ** meta #attr:meta# +{- | parent 'GI.Gst.Structs.Meta.Meta' +-} + getVideoCaptionMetaMeta , +#if ENABLE_OVERLOADING + videoCaptionMeta_meta , +#endif + + +-- ** size #attr:size# +{- | The size in bytes of /@data@/ +-} + getVideoCaptionMetaSize , + setVideoCaptionMetaSize , +#if ENABLE_OVERLOADING + videoCaptionMeta_size , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Structs.Meta as Gst.Meta +import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums + +-- | Memory-managed wrapper type. +newtype VideoCaptionMeta = VideoCaptionMeta (ManagedPtr VideoCaptionMeta) +instance WrappedPtr VideoCaptionMeta where + wrappedPtrCalloc = callocBytes 40 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 40 >=> wrapPtr VideoCaptionMeta) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoCaptionMeta` struct initialized to zero. +newZeroVideoCaptionMeta :: MonadIO m => m VideoCaptionMeta +newZeroVideoCaptionMeta = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoCaptionMeta + +instance tag ~ 'AttrSet => Constructible VideoCaptionMeta tag where + new _ attrs = do + o <- newZeroVideoCaptionMeta + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoCaptionMeta`. +noVideoCaptionMeta :: Maybe VideoCaptionMeta +noVideoCaptionMeta = Nothing + +{- | +Get the value of the “@meta@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCaptionMeta #meta +@ +-} +getVideoCaptionMetaMeta :: MonadIO m => VideoCaptionMeta -> m Gst.Meta.Meta +getVideoCaptionMetaMeta s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Gst.Meta.Meta) + val' <- (newPtr Gst.Meta.Meta) val + return val' + +#if ENABLE_OVERLOADING +data VideoCaptionMetaMetaFieldInfo +instance AttrInfo VideoCaptionMetaMetaFieldInfo where + type AttrAllowedOps VideoCaptionMetaMetaFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint VideoCaptionMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta) + type AttrBaseTypeConstraint VideoCaptionMetaMetaFieldInfo = (~) VideoCaptionMeta + type AttrGetType VideoCaptionMetaMetaFieldInfo = Gst.Meta.Meta + type AttrLabel VideoCaptionMetaMetaFieldInfo = "meta" + type AttrOrigin VideoCaptionMetaMetaFieldInfo = VideoCaptionMeta + attrGet _ = getVideoCaptionMetaMeta + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +videoCaptionMeta_meta :: AttrLabelProxy "meta" +videoCaptionMeta_meta = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@caption_type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCaptionMeta #captionType +@ +-} +getVideoCaptionMetaCaptionType :: MonadIO m => VideoCaptionMeta -> m GstVideo.Enums.VideoCaptionType +getVideoCaptionMetaCaptionType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@caption_type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCaptionMeta [ #captionType 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCaptionMetaCaptionType :: MonadIO m => VideoCaptionMeta -> GstVideo.Enums.VideoCaptionType -> m () +setVideoCaptionMetaCaptionType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 16) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoCaptionMetaCaptionTypeFieldInfo +instance AttrInfo VideoCaptionMetaCaptionTypeFieldInfo where + type AttrAllowedOps VideoCaptionMetaCaptionTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoCaptionMetaCaptionTypeFieldInfo = (~) GstVideo.Enums.VideoCaptionType + type AttrBaseTypeConstraint VideoCaptionMetaCaptionTypeFieldInfo = (~) VideoCaptionMeta + type AttrGetType VideoCaptionMetaCaptionTypeFieldInfo = GstVideo.Enums.VideoCaptionType + type AttrLabel VideoCaptionMetaCaptionTypeFieldInfo = "caption_type" + type AttrOrigin VideoCaptionMetaCaptionTypeFieldInfo = VideoCaptionMeta + attrGet _ = getVideoCaptionMetaCaptionType + attrSet _ = setVideoCaptionMetaCaptionType + attrConstruct = undefined + attrClear _ = undefined + +videoCaptionMeta_captionType :: AttrLabelProxy "captionType" +videoCaptionMeta_captionType = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "VideoCaptionMeta:data" :: Not implemented: "Don't know how to unpack C array of type TCArray False (-1) 3 (TBasicType TUInt8)" +{- | +Get the value of the “@size@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCaptionMeta #size +@ +-} +getVideoCaptionMetaSize :: MonadIO m => VideoCaptionMeta -> m Word64 +getVideoCaptionMetaSize s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Word64 + return val + +{- | +Set the value of the “@size@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCaptionMeta [ #size 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCaptionMetaSize :: MonadIO m => VideoCaptionMeta -> Word64 -> m () +setVideoCaptionMetaSize s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Word64) + +#if ENABLE_OVERLOADING +data VideoCaptionMetaSizeFieldInfo +instance AttrInfo VideoCaptionMetaSizeFieldInfo where + type AttrAllowedOps VideoCaptionMetaSizeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoCaptionMetaSizeFieldInfo = (~) Word64 + type AttrBaseTypeConstraint VideoCaptionMetaSizeFieldInfo = (~) VideoCaptionMeta + type AttrGetType VideoCaptionMetaSizeFieldInfo = Word64 + type AttrLabel VideoCaptionMetaSizeFieldInfo = "size" + type AttrOrigin VideoCaptionMetaSizeFieldInfo = VideoCaptionMeta + attrGet _ = getVideoCaptionMetaSize + attrSet _ = setVideoCaptionMetaSize + attrConstruct = undefined + attrClear _ = undefined + +videoCaptionMeta_size :: AttrLabelProxy "size" +videoCaptionMeta_size = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoCaptionMeta +type instance O.AttributeList VideoCaptionMeta = VideoCaptionMetaAttributeList +type VideoCaptionMetaAttributeList = ('[ '("meta", VideoCaptionMetaMetaFieldInfo), '("captionType", VideoCaptionMetaCaptionTypeFieldInfo), '("size", VideoCaptionMetaSizeFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoCaptionMeta::get_info +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "MetaInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_caption_meta_get_info" gst_video_caption_meta_get_info :: + IO (Ptr Gst.MetaInfo.MetaInfo) + +{- | +/No description available in the introspection data./ +-} +videoCaptionMetaGetInfo :: + (B.CallStack.HasCallStack, MonadIO m) => + m Gst.MetaInfo.MetaInfo +videoCaptionMetaGetInfo = liftIO $ do + result <- gst_video_caption_meta_get_info + checkUnexpectedReturnNULL "videoCaptionMetaGetInfo" result + result' <- (newPtr Gst.MetaInfo.MetaInfo) result + return result' + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoCaptionMetaMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoCaptionMetaMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoCaptionMetaMethod t VideoCaptionMeta, O.MethodInfo info VideoCaptionMeta p) => OL.IsLabel t (VideoCaptionMeta -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoCaptionMeta.hs-boot b/GI/GstVideo/Structs/VideoCaptionMeta.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoCaptionMeta.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoCaptionMeta where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoCaptionMeta = VideoCaptionMeta (ManagedPtr VideoCaptionMeta) +instance WrappedPtr VideoCaptionMeta where diff --git a/GI/GstVideo/Structs/VideoChromaResample.hs b/GI/GstVideo/Structs/VideoChromaResample.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoChromaResample.hs @@ -0,0 +1,171 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoChromaResample + ( + +-- * Exported types + VideoChromaResample(..) , + noVideoChromaResample , + + + -- * Methods +-- ** free #method:free# + +#if ENABLE_OVERLOADING + VideoChromaResampleFreeMethodInfo , +#endif + videoChromaResampleFree , + + +-- ** getInfo #method:getInfo# + +#if ENABLE_OVERLOADING + VideoChromaResampleGetInfoMethodInfo , +#endif + videoChromaResampleGetInfo , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- | Memory-managed wrapper type. +newtype VideoChromaResample = VideoChromaResample (ManagedPtr VideoChromaResample) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr VideoChromaResample where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoChromaResample`. +noVideoChromaResample :: Maybe VideoChromaResample +noVideoChromaResample = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoChromaResample +type instance O.AttributeList VideoChromaResample = VideoChromaResampleAttributeList +type VideoChromaResampleAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method VideoChromaResample::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "resample", argType = TInterface (Name {namespace = "GstVideo", name = "VideoChromaResample"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoChromaResample", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_chroma_resample_free" gst_video_chroma_resample_free :: + Ptr VideoChromaResample -> -- resample : TInterface (Name {namespace = "GstVideo", name = "VideoChromaResample"}) + IO () + +{- | +Free /@resample@/ +-} +videoChromaResampleFree :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoChromaResample + {- ^ /@resample@/: a 'GI.GstVideo.Structs.VideoChromaResample.VideoChromaResample' -} + -> m () +videoChromaResampleFree resample = liftIO $ do + resample' <- unsafeManagedPtrGetPtr resample + gst_video_chroma_resample_free resample' + touchManagedPtr resample + return () + +#if ENABLE_OVERLOADING +data VideoChromaResampleFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoChromaResampleFreeMethodInfo VideoChromaResample signature where + overloadedMethod _ = videoChromaResampleFree + +#endif + +-- method VideoChromaResample::get_info +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "resample", argType = TInterface (Name {namespace = "GstVideo", name = "VideoChromaResample"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoChromaResample", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_lines", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of input lines", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the first line", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_chroma_resample_get_info" gst_video_chroma_resample_get_info :: + Ptr VideoChromaResample -> -- resample : TInterface (Name {namespace = "GstVideo", name = "VideoChromaResample"}) + Word32 -> -- n_lines : TBasicType TUInt + Int32 -> -- offset : TBasicType TInt + IO () + +{- | +The resampler must be fed /@nLines@/ at a time. The first line should be +at /@offset@/. +-} +videoChromaResampleGetInfo :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoChromaResample + {- ^ /@resample@/: a 'GI.GstVideo.Structs.VideoChromaResample.VideoChromaResample' -} + -> Word32 + {- ^ /@nLines@/: the number of input lines -} + -> Int32 + {- ^ /@offset@/: the first line -} + -> m () +videoChromaResampleGetInfo resample nLines offset = liftIO $ do + resample' <- unsafeManagedPtrGetPtr resample + gst_video_chroma_resample_get_info resample' nLines offset + touchManagedPtr resample + return () + +#if ENABLE_OVERLOADING +data VideoChromaResampleGetInfoMethodInfo +instance (signature ~ (Word32 -> Int32 -> m ()), MonadIO m) => O.MethodInfo VideoChromaResampleGetInfoMethodInfo VideoChromaResample signature where + overloadedMethod _ = videoChromaResampleGetInfo + +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoChromaResampleMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoChromaResampleMethod "free" o = VideoChromaResampleFreeMethodInfo + ResolveVideoChromaResampleMethod "getInfo" o = VideoChromaResampleGetInfoMethodInfo + ResolveVideoChromaResampleMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoChromaResampleMethod t VideoChromaResample, O.MethodInfo info VideoChromaResample p) => OL.IsLabel t (VideoChromaResample -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoChromaResample.hs-boot b/GI/GstVideo/Structs/VideoChromaResample.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoChromaResample.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoChromaResample where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoChromaResample = VideoChromaResample (ManagedPtr VideoChromaResample) +instance WrappedPtr VideoChromaResample where +#if ENABLE_OVERLOADING +data VideoChromaResampleFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoChromaResampleGetInfoMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoCodecFrame.hs b/GI/GstVideo/Structs/VideoCodecFrame.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoCodecFrame.hs @@ -0,0 +1,766 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' represents a video frame both in raw and +encoded form. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoCodecFrame + ( + +-- * Exported types + VideoCodecFrame(..) , + newZeroVideoCodecFrame , + noVideoCodecFrame , + + + -- * Methods +-- ** getUserData #method:getUserData# + +#if ENABLE_OVERLOADING + VideoCodecFrameGetUserDataMethodInfo , +#endif + videoCodecFrameGetUserData , + + +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + VideoCodecFrameRefMethodInfo , +#endif + videoCodecFrameRef , + + +-- ** setUserData #method:setUserData# + +#if ENABLE_OVERLOADING + VideoCodecFrameSetUserDataMethodInfo , +#endif + videoCodecFrameSetUserData , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + VideoCodecFrameUnrefMethodInfo , +#endif + videoCodecFrameUnref , + + + + + -- * Properties +-- ** deadline #attr:deadline# +{- | Running time when the frame will be used. +-} + getVideoCodecFrameDeadline , + setVideoCodecFrameDeadline , +#if ENABLE_OVERLOADING + videoCodecFrame_deadline , +#endif + + +-- ** distanceFromSync #attr:distanceFromSync# +{- | Distance in frames from the last synchronization point. +-} + getVideoCodecFrameDistanceFromSync , + setVideoCodecFrameDistanceFromSync , +#if ENABLE_OVERLOADING + videoCodecFrame_distanceFromSync , +#endif + + +-- ** dts #attr:dts# +{- | Decoding timestamp +-} + getVideoCodecFrameDts , + setVideoCodecFrameDts , +#if ENABLE_OVERLOADING + videoCodecFrame_dts , +#endif + + +-- ** duration #attr:duration# +{- | Duration of the frame +-} + getVideoCodecFrameDuration , + setVideoCodecFrameDuration , +#if ENABLE_OVERLOADING + videoCodecFrame_duration , +#endif + + +-- ** inputBuffer #attr:inputBuffer# +{- | the input 'GI.Gst.Structs.Buffer.Buffer' that created this frame. The buffer is owned + by the frame and references to the frame instead of the buffer should + be kept. +-} + clearVideoCodecFrameInputBuffer , + getVideoCodecFrameInputBuffer , + setVideoCodecFrameInputBuffer , +#if ENABLE_OVERLOADING + videoCodecFrame_inputBuffer , +#endif + + +-- ** outputBuffer #attr:outputBuffer# +{- | the output 'GI.Gst.Structs.Buffer.Buffer'. Implementations should set this either + directly, or by using the + /@gstVideoDecoderAllocateOutputFrame@/() or + /@gstVideoDecoderAllocateOutputBuffer@/() methods. The buffer is + owned by the frame and references to the frame instead of the + buffer should be kept. +-} + clearVideoCodecFrameOutputBuffer , + getVideoCodecFrameOutputBuffer , + setVideoCodecFrameOutputBuffer , +#if ENABLE_OVERLOADING + videoCodecFrame_outputBuffer , +#endif + + +-- ** pts #attr:pts# +{- | Presentation timestamp +-} + getVideoCodecFramePts , + setVideoCodecFramePts , +#if ENABLE_OVERLOADING + videoCodecFrame_pts , +#endif + + +-- ** systemFrameNumber #attr:systemFrameNumber# +{- | Unique identifier for the frame. Use this if you need + to get hold of the frame later (like when data is being decoded). + Typical usage in decoders is to set this on the opaque value provided + to the library and get back the frame using 'GI.GstVideo.Objects.VideoDecoder.videoDecoderGetFrame' +-} + getVideoCodecFrameSystemFrameNumber , + setVideoCodecFrameSystemFrameNumber , +#if ENABLE_OVERLOADING + videoCodecFrame_systemFrameNumber , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.Gst.Structs.Buffer as Gst.Buffer + +-- | Memory-managed wrapper type. +newtype VideoCodecFrame = VideoCodecFrame (ManagedPtr 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 + +instance tag ~ 'AttrSet => Constructible VideoCodecFrame tag where + new _ attrs = do + o <- newZeroVideoCodecFrame + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoCodecFrame`. +noVideoCodecFrame :: Maybe VideoCodecFrame +noVideoCodecFrame = Nothing + +{- | +Get the value of the “@system_frame_number@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCodecFrame #systemFrameNumber +@ +-} +getVideoCodecFrameSystemFrameNumber :: MonadIO m => VideoCodecFrame -> m Word32 +getVideoCodecFrameSystemFrameNumber s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO Word32 + return val + +{- | +Set the value of the “@system_frame_number@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCodecFrame [ #systemFrameNumber 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCodecFrameSystemFrameNumber :: MonadIO m => VideoCodecFrame -> Word32 -> m () +setVideoCodecFrameSystemFrameNumber s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoCodecFrameSystemFrameNumberFieldInfo +instance AttrInfo VideoCodecFrameSystemFrameNumberFieldInfo where + type AttrAllowedOps VideoCodecFrameSystemFrameNumberFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoCodecFrameSystemFrameNumberFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoCodecFrameSystemFrameNumberFieldInfo = (~) VideoCodecFrame + type AttrGetType VideoCodecFrameSystemFrameNumberFieldInfo = Word32 + type AttrLabel VideoCodecFrameSystemFrameNumberFieldInfo = "system_frame_number" + type AttrOrigin VideoCodecFrameSystemFrameNumberFieldInfo = VideoCodecFrame + attrGet _ = getVideoCodecFrameSystemFrameNumber + attrSet _ = setVideoCodecFrameSystemFrameNumber + attrConstruct = undefined + attrClear _ = undefined + +videoCodecFrame_systemFrameNumber :: AttrLabelProxy "systemFrameNumber" +videoCodecFrame_systemFrameNumber = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@dts@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCodecFrame #dts +@ +-} +getVideoCodecFrameDts :: MonadIO m => VideoCodecFrame -> m Word64 +getVideoCodecFrameDts s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO Word64 + return val + +{- | +Set the value of the “@dts@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCodecFrame [ #dts 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCodecFrameDts :: MonadIO m => VideoCodecFrame -> Word64 -> m () +setVideoCodecFrameDts s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: Word64) + +#if ENABLE_OVERLOADING +data VideoCodecFrameDtsFieldInfo +instance AttrInfo VideoCodecFrameDtsFieldInfo where + type AttrAllowedOps VideoCodecFrameDtsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoCodecFrameDtsFieldInfo = (~) Word64 + type AttrBaseTypeConstraint VideoCodecFrameDtsFieldInfo = (~) VideoCodecFrame + type AttrGetType VideoCodecFrameDtsFieldInfo = Word64 + type AttrLabel VideoCodecFrameDtsFieldInfo = "dts" + type AttrOrigin VideoCodecFrameDtsFieldInfo = VideoCodecFrame + attrGet _ = getVideoCodecFrameDts + attrSet _ = setVideoCodecFrameDts + attrConstruct = undefined + attrClear _ = undefined + +videoCodecFrame_dts :: AttrLabelProxy "dts" +videoCodecFrame_dts = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@pts@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCodecFrame #pts +@ +-} +getVideoCodecFramePts :: MonadIO m => VideoCodecFrame -> m Word64 +getVideoCodecFramePts s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Word64 + return val + +{- | +Set the value of the “@pts@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCodecFrame [ #pts 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCodecFramePts :: MonadIO m => VideoCodecFrame -> Word64 -> m () +setVideoCodecFramePts s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Word64) + +#if ENABLE_OVERLOADING +data VideoCodecFramePtsFieldInfo +instance AttrInfo VideoCodecFramePtsFieldInfo where + type AttrAllowedOps VideoCodecFramePtsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoCodecFramePtsFieldInfo = (~) Word64 + type AttrBaseTypeConstraint VideoCodecFramePtsFieldInfo = (~) VideoCodecFrame + type AttrGetType VideoCodecFramePtsFieldInfo = Word64 + type AttrLabel VideoCodecFramePtsFieldInfo = "pts" + type AttrOrigin VideoCodecFramePtsFieldInfo = VideoCodecFrame + attrGet _ = getVideoCodecFramePts + attrSet _ = setVideoCodecFramePts + attrConstruct = undefined + attrClear _ = undefined + +videoCodecFrame_pts :: AttrLabelProxy "pts" +videoCodecFrame_pts = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@duration@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCodecFrame #duration +@ +-} +getVideoCodecFrameDuration :: MonadIO m => VideoCodecFrame -> m Word64 +getVideoCodecFrameDuration s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO Word64 + return val + +{- | +Set the value of the “@duration@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCodecFrame [ #duration 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCodecFrameDuration :: MonadIO m => VideoCodecFrame -> Word64 -> m () +setVideoCodecFrameDuration s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (val :: Word64) + +#if ENABLE_OVERLOADING +data VideoCodecFrameDurationFieldInfo +instance AttrInfo VideoCodecFrameDurationFieldInfo where + type AttrAllowedOps VideoCodecFrameDurationFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoCodecFrameDurationFieldInfo = (~) Word64 + type AttrBaseTypeConstraint VideoCodecFrameDurationFieldInfo = (~) VideoCodecFrame + type AttrGetType VideoCodecFrameDurationFieldInfo = Word64 + type AttrLabel VideoCodecFrameDurationFieldInfo = "duration" + type AttrOrigin VideoCodecFrameDurationFieldInfo = VideoCodecFrame + attrGet _ = getVideoCodecFrameDuration + attrSet _ = setVideoCodecFrameDuration + attrConstruct = undefined + attrClear _ = undefined + +videoCodecFrame_duration :: AttrLabelProxy "duration" +videoCodecFrame_duration = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@distance_from_sync@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCodecFrame #distanceFromSync +@ +-} +getVideoCodecFrameDistanceFromSync :: MonadIO m => VideoCodecFrame -> m Int32 +getVideoCodecFrameDistanceFromSync s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 48) :: IO Int32 + return val + +{- | +Set the value of the “@distance_from_sync@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCodecFrame [ #distanceFromSync 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCodecFrameDistanceFromSync :: MonadIO m => VideoCodecFrame -> Int32 -> m () +setVideoCodecFrameDistanceFromSync s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 48) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoCodecFrameDistanceFromSyncFieldInfo +instance AttrInfo VideoCodecFrameDistanceFromSyncFieldInfo where + type AttrAllowedOps VideoCodecFrameDistanceFromSyncFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoCodecFrameDistanceFromSyncFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoCodecFrameDistanceFromSyncFieldInfo = (~) VideoCodecFrame + type AttrGetType VideoCodecFrameDistanceFromSyncFieldInfo = Int32 + type AttrLabel VideoCodecFrameDistanceFromSyncFieldInfo = "distance_from_sync" + type AttrOrigin VideoCodecFrameDistanceFromSyncFieldInfo = VideoCodecFrame + attrGet _ = getVideoCodecFrameDistanceFromSync + attrSet _ = setVideoCodecFrameDistanceFromSync + attrConstruct = undefined + attrClear _ = undefined + +videoCodecFrame_distanceFromSync :: AttrLabelProxy "distanceFromSync" +videoCodecFrame_distanceFromSync = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@input_buffer@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCodecFrame #inputBuffer +@ +-} +getVideoCodecFrameInputBuffer :: MonadIO m => VideoCodecFrame -> m (Maybe Gst.Buffer.Buffer) +getVideoCodecFrameInputBuffer s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 56) :: IO (Ptr Gst.Buffer.Buffer) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed Gst.Buffer.Buffer) val' + return val'' + return result + +{- | +Set the value of the “@input_buffer@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCodecFrame [ #inputBuffer 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCodecFrameInputBuffer :: MonadIO m => VideoCodecFrame -> Ptr Gst.Buffer.Buffer -> m () +setVideoCodecFrameInputBuffer s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 56) (val :: Ptr Gst.Buffer.Buffer) + +{- | +Set the value of the “@input_buffer@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #inputBuffer +@ +-} +clearVideoCodecFrameInputBuffer :: MonadIO m => VideoCodecFrame -> m () +clearVideoCodecFrameInputBuffer s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 56) (FP.nullPtr :: Ptr Gst.Buffer.Buffer) + +#if ENABLE_OVERLOADING +data VideoCodecFrameInputBufferFieldInfo +instance AttrInfo VideoCodecFrameInputBufferFieldInfo where + type AttrAllowedOps VideoCodecFrameInputBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoCodecFrameInputBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer) + type AttrBaseTypeConstraint VideoCodecFrameInputBufferFieldInfo = (~) VideoCodecFrame + type AttrGetType VideoCodecFrameInputBufferFieldInfo = Maybe Gst.Buffer.Buffer + type AttrLabel VideoCodecFrameInputBufferFieldInfo = "input_buffer" + type AttrOrigin VideoCodecFrameInputBufferFieldInfo = VideoCodecFrame + attrGet _ = getVideoCodecFrameInputBuffer + attrSet _ = setVideoCodecFrameInputBuffer + attrConstruct = undefined + attrClear _ = clearVideoCodecFrameInputBuffer + +videoCodecFrame_inputBuffer :: AttrLabelProxy "inputBuffer" +videoCodecFrame_inputBuffer = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@output_buffer@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCodecFrame #outputBuffer +@ +-} +getVideoCodecFrameOutputBuffer :: MonadIO m => VideoCodecFrame -> m (Maybe Gst.Buffer.Buffer) +getVideoCodecFrameOutputBuffer s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 64) :: IO (Ptr Gst.Buffer.Buffer) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed Gst.Buffer.Buffer) val' + return val'' + return result + +{- | +Set the value of the “@output_buffer@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCodecFrame [ #outputBuffer 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCodecFrameOutputBuffer :: MonadIO m => VideoCodecFrame -> Ptr Gst.Buffer.Buffer -> m () +setVideoCodecFrameOutputBuffer s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 64) (val :: Ptr Gst.Buffer.Buffer) + +{- | +Set the value of the “@output_buffer@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #outputBuffer +@ +-} +clearVideoCodecFrameOutputBuffer :: MonadIO m => VideoCodecFrame -> m () +clearVideoCodecFrameOutputBuffer s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 64) (FP.nullPtr :: Ptr Gst.Buffer.Buffer) + +#if ENABLE_OVERLOADING +data VideoCodecFrameOutputBufferFieldInfo +instance AttrInfo VideoCodecFrameOutputBufferFieldInfo where + type AttrAllowedOps VideoCodecFrameOutputBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoCodecFrameOutputBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer) + type AttrBaseTypeConstraint VideoCodecFrameOutputBufferFieldInfo = (~) VideoCodecFrame + type AttrGetType VideoCodecFrameOutputBufferFieldInfo = Maybe Gst.Buffer.Buffer + type AttrLabel VideoCodecFrameOutputBufferFieldInfo = "output_buffer" + type AttrOrigin VideoCodecFrameOutputBufferFieldInfo = VideoCodecFrame + attrGet _ = getVideoCodecFrameOutputBuffer + attrSet _ = setVideoCodecFrameOutputBuffer + attrConstruct = undefined + attrClear _ = clearVideoCodecFrameOutputBuffer + +videoCodecFrame_outputBuffer :: AttrLabelProxy "outputBuffer" +videoCodecFrame_outputBuffer = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@deadline@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCodecFrame #deadline +@ +-} +getVideoCodecFrameDeadline :: MonadIO m => VideoCodecFrame -> m Word64 +getVideoCodecFrameDeadline s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 72) :: IO Word64 + return val + +{- | +Set the value of the “@deadline@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCodecFrame [ #deadline 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCodecFrameDeadline :: MonadIO m => VideoCodecFrame -> Word64 -> m () +setVideoCodecFrameDeadline s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 72) (val :: Word64) + +#if ENABLE_OVERLOADING +data VideoCodecFrameDeadlineFieldInfo +instance AttrInfo VideoCodecFrameDeadlineFieldInfo where + type AttrAllowedOps VideoCodecFrameDeadlineFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoCodecFrameDeadlineFieldInfo = (~) Word64 + type AttrBaseTypeConstraint VideoCodecFrameDeadlineFieldInfo = (~) VideoCodecFrame + type AttrGetType VideoCodecFrameDeadlineFieldInfo = Word64 + type AttrLabel VideoCodecFrameDeadlineFieldInfo = "deadline" + type AttrOrigin VideoCodecFrameDeadlineFieldInfo = VideoCodecFrame + attrGet _ = getVideoCodecFrameDeadline + attrSet _ = setVideoCodecFrameDeadline + attrConstruct = undefined + attrClear _ = undefined + +videoCodecFrame_deadline :: AttrLabelProxy "deadline" +videoCodecFrame_deadline = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoCodecFrame +type instance O.AttributeList VideoCodecFrame = VideoCodecFrameAttributeList +type VideoCodecFrameAttributeList = ('[ '("systemFrameNumber", VideoCodecFrameSystemFrameNumberFieldInfo), '("dts", VideoCodecFrameDtsFieldInfo), '("pts", VideoCodecFramePtsFieldInfo), '("duration", VideoCodecFrameDurationFieldInfo), '("distanceFromSync", VideoCodecFrameDistanceFromSyncFieldInfo), '("inputBuffer", VideoCodecFrameInputBufferFieldInfo), '("outputBuffer", VideoCodecFrameOutputBufferFieldInfo), '("deadline", VideoCodecFrameDeadlineFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoCodecFrame::get_user_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoCodecFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_codec_frame_get_user_data" gst_video_codec_frame_get_user_data :: + Ptr VideoCodecFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}) + IO (Ptr ()) + +{- | +Gets private data set on the frame by the subclass via +'GI.GstVideo.Structs.VideoCodecFrame.videoCodecFrameSetUserData' previously. +-} +videoCodecFrameGetUserData :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoCodecFrame + {- ^ /@frame@/: a 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -} + -> m (Ptr ()) + {- ^ __Returns:__ The previously set user_data -} +videoCodecFrameGetUserData frame = liftIO $ do + frame' <- unsafeManagedPtrGetPtr frame + result <- gst_video_codec_frame_get_user_data frame' + touchManagedPtr frame + return result + +#if ENABLE_OVERLOADING +data VideoCodecFrameGetUserDataMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m) => O.MethodInfo VideoCodecFrameGetUserDataMethodInfo VideoCodecFrame signature where + overloadedMethod _ = videoCodecFrameGetUserData + +#endif + +-- method VideoCodecFrame::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoCodecFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_codec_frame_ref" gst_video_codec_frame_ref :: + Ptr VideoCodecFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}) + IO (Ptr VideoCodecFrame) + +{- | +Increases the refcount of the given frame by one. +-} +videoCodecFrameRef :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoCodecFrame + {- ^ /@frame@/: a 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -} + -> m VideoCodecFrame + {- ^ __Returns:__ /@buf@/ -} +videoCodecFrameRef frame = liftIO $ do + frame' <- unsafeManagedPtrGetPtr frame + result <- gst_video_codec_frame_ref frame' + checkUnexpectedReturnNULL "videoCodecFrameRef" result + result' <- (wrapBoxed VideoCodecFrame) result + touchManagedPtr frame + return result' + +#if ENABLE_OVERLOADING +data VideoCodecFrameRefMethodInfo +instance (signature ~ (m VideoCodecFrame), MonadIO m) => O.MethodInfo VideoCodecFrameRefMethodInfo VideoCodecFrame signature where + overloadedMethod _ = videoCodecFrameRef + +#endif + +-- method VideoCodecFrame::set_user_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoCodecFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "private data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDestroyNotify", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_codec_frame_set_user_data" gst_video_codec_frame_set_user_data :: + Ptr VideoCodecFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}) + Ptr () -> -- user_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + IO () + +{- | +Sets /@userData@/ on the frame and the 'GI.GLib.Callbacks.DestroyNotify' that will be called when +the frame is freed. Allows to attach private data by the subclass to frames. + +If a /@userData@/ was previously set, then the previous set /@notify@/ will be called +before the /@userData@/ is replaced. +-} +videoCodecFrameSetUserData :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoCodecFrame + {- ^ /@frame@/: a 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -} + -> GLib.Callbacks.DestroyNotify + {- ^ /@notify@/: a 'GI.GLib.Callbacks.DestroyNotify' -} + -> m () +videoCodecFrameSetUserData frame notify = liftIO $ do + frame' <- unsafeManagedPtrGetPtr frame + ptrnotify <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify)) + notify' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrnotify) notify) + poke ptrnotify notify' + let userData = nullPtr + gst_video_codec_frame_set_user_data frame' userData notify' + touchManagedPtr frame + return () + +#if ENABLE_OVERLOADING +data VideoCodecFrameSetUserDataMethodInfo +instance (signature ~ (GLib.Callbacks.DestroyNotify -> m ()), MonadIO m) => O.MethodInfo VideoCodecFrameSetUserDataMethodInfo VideoCodecFrame signature where + overloadedMethod _ = videoCodecFrameSetUserData + +#endif + +-- method VideoCodecFrame::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoCodecFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_codec_frame_unref" gst_video_codec_frame_unref :: + Ptr VideoCodecFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoCodecFrame"}) + IO () + +{- | +Decreases the refcount of the frame. If the refcount reaches 0, the frame +will be freed. +-} +videoCodecFrameUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoCodecFrame + {- ^ /@frame@/: a 'GI.GstVideo.Structs.VideoCodecFrame.VideoCodecFrame' -} + -> m () +videoCodecFrameUnref frame = liftIO $ do + frame' <- unsafeManagedPtrGetPtr frame + gst_video_codec_frame_unref frame' + touchManagedPtr frame + return () + +#if ENABLE_OVERLOADING +data VideoCodecFrameUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoCodecFrameUnrefMethodInfo VideoCodecFrame signature where + overloadedMethod _ = videoCodecFrameUnref + +#endif + +#if ENABLE_OVERLOADING +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 = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoCodecFrameMethod t VideoCodecFrame, O.MethodInfo info VideoCodecFrame p) => OL.IsLabel t (VideoCodecFrame -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoCodecFrame.hs-boot b/GI/GstVideo/Structs/VideoCodecFrame.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoCodecFrame.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoCodecFrame where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoCodecFrame = VideoCodecFrame (ManagedPtr VideoCodecFrame) +instance BoxedObject VideoCodecFrame where +#if ENABLE_OVERLOADING +data VideoCodecFrameGetUserDataMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoCodecFrameRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoCodecFrameSetUserDataMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoCodecFrameUnrefMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoCodecState.hs b/GI/GstVideo/Structs/VideoCodecState.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoCodecState.hs @@ -0,0 +1,452 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +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 /@setFormat@/ vmethods. + +Decoders and encoders can set the downstream state, by using the +/@gstVideoDecoderSetOutputState@/() or +/@gstVideoEncoderSetOutputState@/() methods. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoCodecState + ( + +-- * Exported types + VideoCodecState(..) , + newZeroVideoCodecState , + noVideoCodecState , + + + -- * Methods +-- ** ref #method:ref# + +#if ENABLE_OVERLOADING + VideoCodecStateRefMethodInfo , +#endif + videoCodecStateRef , + + +-- ** unref #method:unref# + +#if ENABLE_OVERLOADING + VideoCodecStateUnrefMethodInfo , +#endif + videoCodecStateUnref , + + + + + -- * Properties +-- ** allocationCaps #attr:allocationCaps# +{- | The 'GI.Gst.Structs.Caps.Caps' for allocation query and pool + negotiation. Since: 1.10 +-} + clearVideoCodecStateAllocationCaps , + getVideoCodecStateAllocationCaps , + setVideoCodecStateAllocationCaps , +#if ENABLE_OVERLOADING + videoCodecState_allocationCaps , +#endif + + +-- ** caps #attr:caps# +{- | The 'GI.Gst.Structs.Caps.Caps' used in the caps negotiation of the pad. +-} + clearVideoCodecStateCaps , + getVideoCodecStateCaps , + setVideoCodecStateCaps , +#if ENABLE_OVERLOADING + videoCodecState_caps , +#endif + + +-- ** codecData #attr:codecData# +{- | a 'GI.Gst.Structs.Buffer.Buffer' corresponding to the + \'codec_data\' field of a stream, or NULL. +-} + clearVideoCodecStateCodecData , + getVideoCodecStateCodecData , + setVideoCodecStateCodecData , +#if ENABLE_OVERLOADING + videoCodecState_codecData , +#endif + + +-- ** info #attr:info# +{- | The 'GI.GstVideo.Structs.VideoInfo.VideoInfo' describing the stream +-} + getVideoCodecStateInfo , +#if ENABLE_OVERLOADING + videoCodecState_info , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Structs.Buffer as Gst.Buffer +import qualified GI.Gst.Structs.Caps as Gst.Caps +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoInfo as GstVideo.VideoInfo + +-- | Memory-managed wrapper type. +newtype VideoCodecState = VideoCodecState (ManagedPtr 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 + +instance tag ~ 'AttrSet => Constructible VideoCodecState tag where + new _ attrs = do + o <- newZeroVideoCodecState + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoCodecState`. +noVideoCodecState :: Maybe VideoCodecState +noVideoCodecState = Nothing + +{- | +Get the value of the “@info@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCodecState #info +@ +-} +getVideoCodecStateInfo :: MonadIO m => VideoCodecState -> m GstVideo.VideoInfo.VideoInfo +getVideoCodecStateInfo s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 8 :: (Ptr GstVideo.VideoInfo.VideoInfo) + val' <- (newBoxed GstVideo.VideoInfo.VideoInfo) val + return val' + +#if ENABLE_OVERLOADING +data VideoCodecStateInfoFieldInfo +instance AttrInfo VideoCodecStateInfoFieldInfo where + type AttrAllowedOps VideoCodecStateInfoFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint VideoCodecStateInfoFieldInfo = (~) (Ptr GstVideo.VideoInfo.VideoInfo) + type AttrBaseTypeConstraint VideoCodecStateInfoFieldInfo = (~) VideoCodecState + type AttrGetType VideoCodecStateInfoFieldInfo = GstVideo.VideoInfo.VideoInfo + type AttrLabel VideoCodecStateInfoFieldInfo = "info" + type AttrOrigin VideoCodecStateInfoFieldInfo = VideoCodecState + attrGet _ = getVideoCodecStateInfo + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +videoCodecState_info :: AttrLabelProxy "info" +videoCodecState_info = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@caps@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCodecState #caps +@ +-} +getVideoCodecStateCaps :: MonadIO m => VideoCodecState -> m (Maybe Gst.Caps.Caps) +getVideoCodecStateCaps s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 128) :: IO (Ptr Gst.Caps.Caps) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed Gst.Caps.Caps) val' + return val'' + return result + +{- | +Set the value of the “@caps@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCodecState [ #caps 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCodecStateCaps :: MonadIO m => VideoCodecState -> Ptr Gst.Caps.Caps -> m () +setVideoCodecStateCaps s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 128) (val :: Ptr Gst.Caps.Caps) + +{- | +Set the value of the “@caps@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #caps +@ +-} +clearVideoCodecStateCaps :: MonadIO m => VideoCodecState -> m () +clearVideoCodecStateCaps s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 128) (FP.nullPtr :: Ptr Gst.Caps.Caps) + +#if ENABLE_OVERLOADING +data VideoCodecStateCapsFieldInfo +instance AttrInfo VideoCodecStateCapsFieldInfo where + type AttrAllowedOps VideoCodecStateCapsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoCodecStateCapsFieldInfo = (~) (Ptr Gst.Caps.Caps) + type AttrBaseTypeConstraint VideoCodecStateCapsFieldInfo = (~) VideoCodecState + type AttrGetType VideoCodecStateCapsFieldInfo = Maybe Gst.Caps.Caps + type AttrLabel VideoCodecStateCapsFieldInfo = "caps" + type AttrOrigin VideoCodecStateCapsFieldInfo = VideoCodecState + attrGet _ = getVideoCodecStateCaps + attrSet _ = setVideoCodecStateCaps + attrConstruct = undefined + attrClear _ = clearVideoCodecStateCaps + +videoCodecState_caps :: AttrLabelProxy "caps" +videoCodecState_caps = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@codec_data@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCodecState #codecData +@ +-} +getVideoCodecStateCodecData :: MonadIO m => VideoCodecState -> m (Maybe Gst.Buffer.Buffer) +getVideoCodecStateCodecData s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 136) :: IO (Ptr Gst.Buffer.Buffer) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed Gst.Buffer.Buffer) val' + return val'' + return result + +{- | +Set the value of the “@codec_data@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCodecState [ #codecData 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCodecStateCodecData :: MonadIO m => VideoCodecState -> Ptr Gst.Buffer.Buffer -> m () +setVideoCodecStateCodecData s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 136) (val :: Ptr Gst.Buffer.Buffer) + +{- | +Set the value of the “@codec_data@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #codecData +@ +-} +clearVideoCodecStateCodecData :: MonadIO m => VideoCodecState -> m () +clearVideoCodecStateCodecData s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 136) (FP.nullPtr :: Ptr Gst.Buffer.Buffer) + +#if ENABLE_OVERLOADING +data VideoCodecStateCodecDataFieldInfo +instance AttrInfo VideoCodecStateCodecDataFieldInfo where + type AttrAllowedOps VideoCodecStateCodecDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoCodecStateCodecDataFieldInfo = (~) (Ptr Gst.Buffer.Buffer) + type AttrBaseTypeConstraint VideoCodecStateCodecDataFieldInfo = (~) VideoCodecState + type AttrGetType VideoCodecStateCodecDataFieldInfo = Maybe Gst.Buffer.Buffer + type AttrLabel VideoCodecStateCodecDataFieldInfo = "codec_data" + type AttrOrigin VideoCodecStateCodecDataFieldInfo = VideoCodecState + attrGet _ = getVideoCodecStateCodecData + attrSet _ = setVideoCodecStateCodecData + attrConstruct = undefined + attrClear _ = clearVideoCodecStateCodecData + +videoCodecState_codecData :: AttrLabelProxy "codecData" +videoCodecState_codecData = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@allocation_caps@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCodecState #allocationCaps +@ +-} +getVideoCodecStateAllocationCaps :: MonadIO m => VideoCodecState -> m (Maybe Gst.Caps.Caps) +getVideoCodecStateAllocationCaps s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 144) :: IO (Ptr Gst.Caps.Caps) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed Gst.Caps.Caps) val' + return val'' + return result + +{- | +Set the value of the “@allocation_caps@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCodecState [ #allocationCaps 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCodecStateAllocationCaps :: MonadIO m => VideoCodecState -> Ptr Gst.Caps.Caps -> m () +setVideoCodecStateAllocationCaps s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 144) (val :: Ptr Gst.Caps.Caps) + +{- | +Set the value of the “@allocation_caps@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #allocationCaps +@ +-} +clearVideoCodecStateAllocationCaps :: MonadIO m => VideoCodecState -> m () +clearVideoCodecStateAllocationCaps s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 144) (FP.nullPtr :: Ptr Gst.Caps.Caps) + +#if ENABLE_OVERLOADING +data VideoCodecStateAllocationCapsFieldInfo +instance AttrInfo VideoCodecStateAllocationCapsFieldInfo where + type AttrAllowedOps VideoCodecStateAllocationCapsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoCodecStateAllocationCapsFieldInfo = (~) (Ptr Gst.Caps.Caps) + type AttrBaseTypeConstraint VideoCodecStateAllocationCapsFieldInfo = (~) VideoCodecState + type AttrGetType VideoCodecStateAllocationCapsFieldInfo = Maybe Gst.Caps.Caps + type AttrLabel VideoCodecStateAllocationCapsFieldInfo = "allocation_caps" + type AttrOrigin VideoCodecStateAllocationCapsFieldInfo = VideoCodecState + attrGet _ = getVideoCodecStateAllocationCaps + attrSet _ = setVideoCodecStateAllocationCaps + attrConstruct = undefined + attrClear _ = clearVideoCodecStateAllocationCaps + +videoCodecState_allocationCaps :: AttrLabelProxy "allocationCaps" +videoCodecState_allocationCaps = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoCodecState +type instance O.AttributeList VideoCodecState = VideoCodecStateAttributeList +type VideoCodecStateAttributeList = ('[ '("info", VideoCodecStateInfoFieldInfo), '("caps", VideoCodecStateCapsFieldInfo), '("codecData", VideoCodecStateCodecDataFieldInfo), '("allocationCaps", VideoCodecStateAllocationCapsFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoCodecState::ref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "state", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoCodecState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_codec_state_ref" gst_video_codec_state_ref :: + Ptr VideoCodecState -> -- state : TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}) + IO (Ptr VideoCodecState) + +{- | +Increases the refcount of the given state by one. +-} +videoCodecStateRef :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoCodecState + {- ^ /@state@/: a 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState' -} + -> m VideoCodecState + {- ^ __Returns:__ /@buf@/ -} +videoCodecStateRef state = liftIO $ do + state' <- unsafeManagedPtrGetPtr state + result <- gst_video_codec_state_ref state' + checkUnexpectedReturnNULL "videoCodecStateRef" result + result' <- (wrapBoxed VideoCodecState) result + touchManagedPtr state + return result' + +#if ENABLE_OVERLOADING +data VideoCodecStateRefMethodInfo +instance (signature ~ (m VideoCodecState), MonadIO m) => O.MethodInfo VideoCodecStateRefMethodInfo VideoCodecState signature where + overloadedMethod _ = videoCodecStateRef + +#endif + +-- method VideoCodecState::unref +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "state", argType = TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoCodecState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_codec_state_unref" gst_video_codec_state_unref :: + Ptr VideoCodecState -> -- state : TInterface (Name {namespace = "GstVideo", name = "VideoCodecState"}) + IO () + +{- | +Decreases the refcount of the state. If the refcount reaches 0, the state +will be freed. +-} +videoCodecStateUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoCodecState + {- ^ /@state@/: a 'GI.GstVideo.Structs.VideoCodecState.VideoCodecState' -} + -> m () +videoCodecStateUnref state = liftIO $ do + state' <- unsafeManagedPtrGetPtr state + gst_video_codec_state_unref state' + touchManagedPtr state + return () + +#if ENABLE_OVERLOADING +data VideoCodecStateUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoCodecStateUnrefMethodInfo VideoCodecState signature where + overloadedMethod _ = videoCodecStateUnref + +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoCodecStateMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoCodecStateMethod "ref" o = VideoCodecStateRefMethodInfo + ResolveVideoCodecStateMethod "unref" o = VideoCodecStateUnrefMethodInfo + ResolveVideoCodecStateMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoCodecStateMethod t VideoCodecState, O.MethodInfo info VideoCodecState p) => OL.IsLabel t (VideoCodecState -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoCodecState.hs-boot b/GI/GstVideo/Structs/VideoCodecState.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoCodecState.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoCodecState where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoCodecState = VideoCodecState (ManagedPtr VideoCodecState) +instance BoxedObject VideoCodecState where +#if ENABLE_OVERLOADING +data VideoCodecStateRefMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoCodecStateUnrefMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoColorPrimariesInfo.hs b/GI/GstVideo/Structs/VideoColorPrimariesInfo.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoColorPrimariesInfo.hs @@ -0,0 +1,609 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +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. + +/Since: 1.6/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoColorPrimariesInfo + ( + +-- * Exported types + VideoColorPrimariesInfo(..) , + newZeroVideoColorPrimariesInfo , + noVideoColorPrimariesInfo , + + + -- * Properties +-- ** bx #attr:bx# +{- | blue x coordinate +-} + getVideoColorPrimariesInfoBx , + setVideoColorPrimariesInfoBx , +#if ENABLE_OVERLOADING + videoColorPrimariesInfo_bx , +#endif + + +-- ** by #attr:by# +{- | blue y coordinate +-} + getVideoColorPrimariesInfoBy , + setVideoColorPrimariesInfoBy , +#if ENABLE_OVERLOADING + videoColorPrimariesInfo_by , +#endif + + +-- ** gx #attr:gx# +{- | green x coordinate +-} + getVideoColorPrimariesInfoGx , + setVideoColorPrimariesInfoGx , +#if ENABLE_OVERLOADING + videoColorPrimariesInfo_gx , +#endif + + +-- ** gy #attr:gy# +{- | green y coordinate +-} + getVideoColorPrimariesInfoGy , + setVideoColorPrimariesInfoGy , +#if ENABLE_OVERLOADING + videoColorPrimariesInfo_gy , +#endif + + +-- ** primaries #attr:primaries# +{- | a 'GI.GstVideo.Enums.VideoColorPrimaries' +-} + getVideoColorPrimariesInfoPrimaries , + setVideoColorPrimariesInfoPrimaries , +#if ENABLE_OVERLOADING + videoColorPrimariesInfo_primaries , +#endif + + +-- ** rx #attr:rx# +{- | red x coordinate +-} + getVideoColorPrimariesInfoRx , + setVideoColorPrimariesInfoRx , +#if ENABLE_OVERLOADING + videoColorPrimariesInfo_rx , +#endif + + +-- ** ry #attr:ry# +{- | red y coordinate +-} + getVideoColorPrimariesInfoRy , + setVideoColorPrimariesInfoRy , +#if ENABLE_OVERLOADING + videoColorPrimariesInfo_ry , +#endif + + +-- ** wx #attr:wx# +{- | reference white x coordinate +-} + getVideoColorPrimariesInfoWx , + setVideoColorPrimariesInfoWx , +#if ENABLE_OVERLOADING + videoColorPrimariesInfo_wx , +#endif + + +-- ** wy #attr:wy# +{- | reference white y coordinate +-} + getVideoColorPrimariesInfoWy , + setVideoColorPrimariesInfoWy , +#if ENABLE_OVERLOADING + videoColorPrimariesInfo_wy , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums + +-- | Memory-managed wrapper type. +newtype VideoColorPrimariesInfo = VideoColorPrimariesInfo (ManagedPtr VideoColorPrimariesInfo) +instance WrappedPtr VideoColorPrimariesInfo where + wrappedPtrCalloc = callocBytes 72 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 72 >=> wrapPtr VideoColorPrimariesInfo) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoColorPrimariesInfo` struct initialized to zero. +newZeroVideoColorPrimariesInfo :: MonadIO m => m VideoColorPrimariesInfo +newZeroVideoColorPrimariesInfo = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoColorPrimariesInfo + +instance tag ~ 'AttrSet => Constructible VideoColorPrimariesInfo tag where + new _ attrs = do + o <- newZeroVideoColorPrimariesInfo + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoColorPrimariesInfo`. +noVideoColorPrimariesInfo :: Maybe VideoColorPrimariesInfo +noVideoColorPrimariesInfo = Nothing + +{- | +Get the value of the “@primaries@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoColorPrimariesInfo #primaries +@ +-} +getVideoColorPrimariesInfoPrimaries :: MonadIO m => VideoColorPrimariesInfo -> m GstVideo.Enums.VideoColorPrimaries +getVideoColorPrimariesInfoPrimaries s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@primaries@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoColorPrimariesInfo [ #primaries 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoColorPrimariesInfoPrimaries :: MonadIO m => VideoColorPrimariesInfo -> GstVideo.Enums.VideoColorPrimaries -> m () +setVideoColorPrimariesInfoPrimaries s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoColorPrimariesInfoPrimariesFieldInfo +instance AttrInfo VideoColorPrimariesInfoPrimariesFieldInfo where + type AttrAllowedOps VideoColorPrimariesInfoPrimariesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoColorPrimariesInfoPrimariesFieldInfo = (~) GstVideo.Enums.VideoColorPrimaries + type AttrBaseTypeConstraint VideoColorPrimariesInfoPrimariesFieldInfo = (~) VideoColorPrimariesInfo + type AttrGetType VideoColorPrimariesInfoPrimariesFieldInfo = GstVideo.Enums.VideoColorPrimaries + type AttrLabel VideoColorPrimariesInfoPrimariesFieldInfo = "primaries" + type AttrOrigin VideoColorPrimariesInfoPrimariesFieldInfo = VideoColorPrimariesInfo + attrGet _ = getVideoColorPrimariesInfoPrimaries + attrSet _ = setVideoColorPrimariesInfoPrimaries + attrConstruct = undefined + attrClear _ = undefined + +videoColorPrimariesInfo_primaries :: AttrLabelProxy "primaries" +videoColorPrimariesInfo_primaries = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@Wx@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoColorPrimariesInfo #wx +@ +-} +getVideoColorPrimariesInfoWx :: MonadIO m => VideoColorPrimariesInfo -> m Double +getVideoColorPrimariesInfoWx s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@Wx@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoColorPrimariesInfo [ #wx 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoColorPrimariesInfoWx :: MonadIO m => VideoColorPrimariesInfo -> Double -> m () +setVideoColorPrimariesInfoWx s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 8) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data VideoColorPrimariesInfoWxFieldInfo +instance AttrInfo VideoColorPrimariesInfoWxFieldInfo where + type AttrAllowedOps VideoColorPrimariesInfoWxFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoColorPrimariesInfoWxFieldInfo = (~) Double + type AttrBaseTypeConstraint VideoColorPrimariesInfoWxFieldInfo = (~) VideoColorPrimariesInfo + type AttrGetType VideoColorPrimariesInfoWxFieldInfo = Double + type AttrLabel VideoColorPrimariesInfoWxFieldInfo = "Wx" + type AttrOrigin VideoColorPrimariesInfoWxFieldInfo = VideoColorPrimariesInfo + attrGet _ = getVideoColorPrimariesInfoWx + attrSet _ = setVideoColorPrimariesInfoWx + attrConstruct = undefined + attrClear _ = undefined + +videoColorPrimariesInfo_wx :: AttrLabelProxy "wx" +videoColorPrimariesInfo_wx = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@Wy@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoColorPrimariesInfo #wy +@ +-} +getVideoColorPrimariesInfoWy :: MonadIO m => VideoColorPrimariesInfo -> m Double +getVideoColorPrimariesInfoWy s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@Wy@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoColorPrimariesInfo [ #wy 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoColorPrimariesInfoWy :: MonadIO m => VideoColorPrimariesInfo -> Double -> m () +setVideoColorPrimariesInfoWy s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 16) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data VideoColorPrimariesInfoWyFieldInfo +instance AttrInfo VideoColorPrimariesInfoWyFieldInfo where + type AttrAllowedOps VideoColorPrimariesInfoWyFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoColorPrimariesInfoWyFieldInfo = (~) Double + type AttrBaseTypeConstraint VideoColorPrimariesInfoWyFieldInfo = (~) VideoColorPrimariesInfo + type AttrGetType VideoColorPrimariesInfoWyFieldInfo = Double + type AttrLabel VideoColorPrimariesInfoWyFieldInfo = "Wy" + type AttrOrigin VideoColorPrimariesInfoWyFieldInfo = VideoColorPrimariesInfo + attrGet _ = getVideoColorPrimariesInfoWy + attrSet _ = setVideoColorPrimariesInfoWy + attrConstruct = undefined + attrClear _ = undefined + +videoColorPrimariesInfo_wy :: AttrLabelProxy "wy" +videoColorPrimariesInfo_wy = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@Rx@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoColorPrimariesInfo #rx +@ +-} +getVideoColorPrimariesInfoRx :: MonadIO m => VideoColorPrimariesInfo -> m Double +getVideoColorPrimariesInfoRx s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@Rx@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoColorPrimariesInfo [ #rx 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoColorPrimariesInfoRx :: MonadIO m => VideoColorPrimariesInfo -> Double -> m () +setVideoColorPrimariesInfoRx s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 24) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data VideoColorPrimariesInfoRxFieldInfo +instance AttrInfo VideoColorPrimariesInfoRxFieldInfo where + type AttrAllowedOps VideoColorPrimariesInfoRxFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoColorPrimariesInfoRxFieldInfo = (~) Double + type AttrBaseTypeConstraint VideoColorPrimariesInfoRxFieldInfo = (~) VideoColorPrimariesInfo + type AttrGetType VideoColorPrimariesInfoRxFieldInfo = Double + type AttrLabel VideoColorPrimariesInfoRxFieldInfo = "Rx" + type AttrOrigin VideoColorPrimariesInfoRxFieldInfo = VideoColorPrimariesInfo + attrGet _ = getVideoColorPrimariesInfoRx + attrSet _ = setVideoColorPrimariesInfoRx + attrConstruct = undefined + attrClear _ = undefined + +videoColorPrimariesInfo_rx :: AttrLabelProxy "rx" +videoColorPrimariesInfo_rx = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@Ry@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoColorPrimariesInfo #ry +@ +-} +getVideoColorPrimariesInfoRy :: MonadIO m => VideoColorPrimariesInfo -> m Double +getVideoColorPrimariesInfoRy s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@Ry@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoColorPrimariesInfo [ #ry 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoColorPrimariesInfoRy :: MonadIO m => VideoColorPrimariesInfo -> Double -> m () +setVideoColorPrimariesInfoRy s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 32) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data VideoColorPrimariesInfoRyFieldInfo +instance AttrInfo VideoColorPrimariesInfoRyFieldInfo where + type AttrAllowedOps VideoColorPrimariesInfoRyFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoColorPrimariesInfoRyFieldInfo = (~) Double + type AttrBaseTypeConstraint VideoColorPrimariesInfoRyFieldInfo = (~) VideoColorPrimariesInfo + type AttrGetType VideoColorPrimariesInfoRyFieldInfo = Double + type AttrLabel VideoColorPrimariesInfoRyFieldInfo = "Ry" + type AttrOrigin VideoColorPrimariesInfoRyFieldInfo = VideoColorPrimariesInfo + attrGet _ = getVideoColorPrimariesInfoRy + attrSet _ = setVideoColorPrimariesInfoRy + attrConstruct = undefined + attrClear _ = undefined + +videoColorPrimariesInfo_ry :: AttrLabelProxy "ry" +videoColorPrimariesInfo_ry = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@Gx@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoColorPrimariesInfo #gx +@ +-} +getVideoColorPrimariesInfoGx :: MonadIO m => VideoColorPrimariesInfo -> m Double +getVideoColorPrimariesInfoGx s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@Gx@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoColorPrimariesInfo [ #gx 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoColorPrimariesInfoGx :: MonadIO m => VideoColorPrimariesInfo -> Double -> m () +setVideoColorPrimariesInfoGx s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 40) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data VideoColorPrimariesInfoGxFieldInfo +instance AttrInfo VideoColorPrimariesInfoGxFieldInfo where + type AttrAllowedOps VideoColorPrimariesInfoGxFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoColorPrimariesInfoGxFieldInfo = (~) Double + type AttrBaseTypeConstraint VideoColorPrimariesInfoGxFieldInfo = (~) VideoColorPrimariesInfo + type AttrGetType VideoColorPrimariesInfoGxFieldInfo = Double + type AttrLabel VideoColorPrimariesInfoGxFieldInfo = "Gx" + type AttrOrigin VideoColorPrimariesInfoGxFieldInfo = VideoColorPrimariesInfo + attrGet _ = getVideoColorPrimariesInfoGx + attrSet _ = setVideoColorPrimariesInfoGx + attrConstruct = undefined + attrClear _ = undefined + +videoColorPrimariesInfo_gx :: AttrLabelProxy "gx" +videoColorPrimariesInfo_gx = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@Gy@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoColorPrimariesInfo #gy +@ +-} +getVideoColorPrimariesInfoGy :: MonadIO m => VideoColorPrimariesInfo -> m Double +getVideoColorPrimariesInfoGy s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 48) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@Gy@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoColorPrimariesInfo [ #gy 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoColorPrimariesInfoGy :: MonadIO m => VideoColorPrimariesInfo -> Double -> m () +setVideoColorPrimariesInfoGy s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 48) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data VideoColorPrimariesInfoGyFieldInfo +instance AttrInfo VideoColorPrimariesInfoGyFieldInfo where + type AttrAllowedOps VideoColorPrimariesInfoGyFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoColorPrimariesInfoGyFieldInfo = (~) Double + type AttrBaseTypeConstraint VideoColorPrimariesInfoGyFieldInfo = (~) VideoColorPrimariesInfo + type AttrGetType VideoColorPrimariesInfoGyFieldInfo = Double + type AttrLabel VideoColorPrimariesInfoGyFieldInfo = "Gy" + type AttrOrigin VideoColorPrimariesInfoGyFieldInfo = VideoColorPrimariesInfo + attrGet _ = getVideoColorPrimariesInfoGy + attrSet _ = setVideoColorPrimariesInfoGy + attrConstruct = undefined + attrClear _ = undefined + +videoColorPrimariesInfo_gy :: AttrLabelProxy "gy" +videoColorPrimariesInfo_gy = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@Bx@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoColorPrimariesInfo #bx +@ +-} +getVideoColorPrimariesInfoBx :: MonadIO m => VideoColorPrimariesInfo -> m Double +getVideoColorPrimariesInfoBx s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 56) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@Bx@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoColorPrimariesInfo [ #bx 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoColorPrimariesInfoBx :: MonadIO m => VideoColorPrimariesInfo -> Double -> m () +setVideoColorPrimariesInfoBx s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 56) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data VideoColorPrimariesInfoBxFieldInfo +instance AttrInfo VideoColorPrimariesInfoBxFieldInfo where + type AttrAllowedOps VideoColorPrimariesInfoBxFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoColorPrimariesInfoBxFieldInfo = (~) Double + type AttrBaseTypeConstraint VideoColorPrimariesInfoBxFieldInfo = (~) VideoColorPrimariesInfo + type AttrGetType VideoColorPrimariesInfoBxFieldInfo = Double + type AttrLabel VideoColorPrimariesInfoBxFieldInfo = "Bx" + type AttrOrigin VideoColorPrimariesInfoBxFieldInfo = VideoColorPrimariesInfo + attrGet _ = getVideoColorPrimariesInfoBx + attrSet _ = setVideoColorPrimariesInfoBx + attrConstruct = undefined + attrClear _ = undefined + +videoColorPrimariesInfo_bx :: AttrLabelProxy "bx" +videoColorPrimariesInfo_bx = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@By@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoColorPrimariesInfo #by +@ +-} +getVideoColorPrimariesInfoBy :: MonadIO m => VideoColorPrimariesInfo -> m Double +getVideoColorPrimariesInfoBy s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 64) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@By@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoColorPrimariesInfo [ #by 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoColorPrimariesInfoBy :: MonadIO m => VideoColorPrimariesInfo -> Double -> m () +setVideoColorPrimariesInfoBy s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 64) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data VideoColorPrimariesInfoByFieldInfo +instance AttrInfo VideoColorPrimariesInfoByFieldInfo where + type AttrAllowedOps VideoColorPrimariesInfoByFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoColorPrimariesInfoByFieldInfo = (~) Double + type AttrBaseTypeConstraint VideoColorPrimariesInfoByFieldInfo = (~) VideoColorPrimariesInfo + type AttrGetType VideoColorPrimariesInfoByFieldInfo = Double + type AttrLabel VideoColorPrimariesInfoByFieldInfo = "By" + type AttrOrigin VideoColorPrimariesInfoByFieldInfo = VideoColorPrimariesInfo + attrGet _ = getVideoColorPrimariesInfoBy + attrSet _ = setVideoColorPrimariesInfoBy + attrConstruct = undefined + attrClear _ = undefined + +videoColorPrimariesInfo_by :: AttrLabelProxy "by" +videoColorPrimariesInfo_by = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoColorPrimariesInfo +type instance O.AttributeList VideoColorPrimariesInfo = VideoColorPrimariesInfoAttributeList +type VideoColorPrimariesInfoAttributeList = ('[ '("primaries", VideoColorPrimariesInfoPrimariesFieldInfo), '("wx", VideoColorPrimariesInfoWxFieldInfo), '("wy", VideoColorPrimariesInfoWyFieldInfo), '("rx", VideoColorPrimariesInfoRxFieldInfo), '("ry", VideoColorPrimariesInfoRyFieldInfo), '("gx", VideoColorPrimariesInfoGxFieldInfo), '("gy", VideoColorPrimariesInfoGyFieldInfo), '("bx", VideoColorPrimariesInfoBxFieldInfo), '("by", VideoColorPrimariesInfoByFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoColorPrimariesInfoMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoColorPrimariesInfoMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoColorPrimariesInfoMethod t VideoColorPrimariesInfo, O.MethodInfo info VideoColorPrimariesInfo p) => OL.IsLabel t (VideoColorPrimariesInfo -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoColorPrimariesInfo.hs-boot b/GI/GstVideo/Structs/VideoColorPrimariesInfo.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoColorPrimariesInfo.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoColorPrimariesInfo where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoColorPrimariesInfo = VideoColorPrimariesInfo (ManagedPtr VideoColorPrimariesInfo) +instance WrappedPtr VideoColorPrimariesInfo where diff --git a/GI/GstVideo/Structs/VideoColorimetry.hs b/GI/GstVideo/Structs/VideoColorimetry.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoColorimetry.hs @@ -0,0 +1,523 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Structure describing the color info. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoColorimetry + ( + +-- * Exported types + VideoColorimetry(..) , + newZeroVideoColorimetry , + noVideoColorimetry , + + + -- * Methods +-- ** fromString #method:fromString# + +#if ENABLE_OVERLOADING + VideoColorimetryFromStringMethodInfo , +#endif + videoColorimetryFromString , + + +-- ** isEqual #method:isEqual# + +#if ENABLE_OVERLOADING + VideoColorimetryIsEqualMethodInfo , +#endif + videoColorimetryIsEqual , + + +-- ** matches #method:matches# + +#if ENABLE_OVERLOADING + VideoColorimetryMatchesMethodInfo , +#endif + videoColorimetryMatches , + + +-- ** toString #method:toString# + +#if ENABLE_OVERLOADING + VideoColorimetryToStringMethodInfo , +#endif + videoColorimetryToString , + + + + + -- * Properties +-- ** matrix #attr:matrix# +{- | the color matrix. Used to convert between Y\'PbPr and + non-linear RGB (R\'G\'B\') +-} + getVideoColorimetryMatrix , + setVideoColorimetryMatrix , +#if ENABLE_OVERLOADING + videoColorimetry_matrix , +#endif + + +-- ** primaries #attr:primaries# +{- | color primaries. used to convert between R\'G\'B\' and CIE XYZ +-} + getVideoColorimetryPrimaries , + setVideoColorimetryPrimaries , +#if ENABLE_OVERLOADING + videoColorimetry_primaries , +#endif + + +-- ** range #attr:range# +{- | the color range. This is the valid range for the samples. + It is used to convert the samples to Y\'PbPr values. +-} + getVideoColorimetryRange , + setVideoColorimetryRange , +#if ENABLE_OVERLOADING + videoColorimetry_range , +#endif + + +-- ** transfer #attr:transfer# +{- | the transfer function. used to convert between R\'G\'B\' and RGB +-} + getVideoColorimetryTransfer , + setVideoColorimetryTransfer , +#if ENABLE_OVERLOADING + videoColorimetry_transfer , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums + +-- | Memory-managed wrapper type. +newtype VideoColorimetry = VideoColorimetry (ManagedPtr VideoColorimetry) +instance WrappedPtr VideoColorimetry where + wrappedPtrCalloc = callocBytes 16 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 16 >=> wrapPtr VideoColorimetry) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoColorimetry` struct initialized to zero. +newZeroVideoColorimetry :: MonadIO m => m VideoColorimetry +newZeroVideoColorimetry = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoColorimetry + +instance tag ~ 'AttrSet => Constructible VideoColorimetry tag where + new _ attrs = do + o <- newZeroVideoColorimetry + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoColorimetry`. +noVideoColorimetry :: Maybe VideoColorimetry +noVideoColorimetry = Nothing + +{- | +Get the value of the “@range@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoColorimetry #range +@ +-} +getVideoColorimetryRange :: MonadIO m => VideoColorimetry -> m GstVideo.Enums.VideoColorRange +getVideoColorimetryRange s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@range@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoColorimetry [ #range 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoColorimetryRange :: MonadIO m => VideoColorimetry -> GstVideo.Enums.VideoColorRange -> m () +setVideoColorimetryRange s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoColorimetryRangeFieldInfo +instance AttrInfo VideoColorimetryRangeFieldInfo where + type AttrAllowedOps VideoColorimetryRangeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoColorimetryRangeFieldInfo = (~) GstVideo.Enums.VideoColorRange + type AttrBaseTypeConstraint VideoColorimetryRangeFieldInfo = (~) VideoColorimetry + type AttrGetType VideoColorimetryRangeFieldInfo = GstVideo.Enums.VideoColorRange + type AttrLabel VideoColorimetryRangeFieldInfo = "range" + type AttrOrigin VideoColorimetryRangeFieldInfo = VideoColorimetry + attrGet _ = getVideoColorimetryRange + attrSet _ = setVideoColorimetryRange + attrConstruct = undefined + attrClear _ = undefined + +videoColorimetry_range :: AttrLabelProxy "range" +videoColorimetry_range = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@matrix@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoColorimetry #matrix +@ +-} +getVideoColorimetryMatrix :: MonadIO m => VideoColorimetry -> m GstVideo.Enums.VideoColorMatrix +getVideoColorimetryMatrix s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 4) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@matrix@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoColorimetry [ #matrix 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoColorimetryMatrix :: MonadIO m => VideoColorimetry -> GstVideo.Enums.VideoColorMatrix -> m () +setVideoColorimetryMatrix s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 4) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoColorimetryMatrixFieldInfo +instance AttrInfo VideoColorimetryMatrixFieldInfo where + type AttrAllowedOps VideoColorimetryMatrixFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoColorimetryMatrixFieldInfo = (~) GstVideo.Enums.VideoColorMatrix + type AttrBaseTypeConstraint VideoColorimetryMatrixFieldInfo = (~) VideoColorimetry + type AttrGetType VideoColorimetryMatrixFieldInfo = GstVideo.Enums.VideoColorMatrix + type AttrLabel VideoColorimetryMatrixFieldInfo = "matrix" + type AttrOrigin VideoColorimetryMatrixFieldInfo = VideoColorimetry + attrGet _ = getVideoColorimetryMatrix + attrSet _ = setVideoColorimetryMatrix + attrConstruct = undefined + attrClear _ = undefined + +videoColorimetry_matrix :: AttrLabelProxy "matrix" +videoColorimetry_matrix = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@transfer@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoColorimetry #transfer +@ +-} +getVideoColorimetryTransfer :: MonadIO m => VideoColorimetry -> m GstVideo.Enums.VideoTransferFunction +getVideoColorimetryTransfer s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@transfer@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoColorimetry [ #transfer 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoColorimetryTransfer :: MonadIO m => VideoColorimetry -> GstVideo.Enums.VideoTransferFunction -> m () +setVideoColorimetryTransfer s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 8) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoColorimetryTransferFieldInfo +instance AttrInfo VideoColorimetryTransferFieldInfo where + type AttrAllowedOps VideoColorimetryTransferFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoColorimetryTransferFieldInfo = (~) GstVideo.Enums.VideoTransferFunction + type AttrBaseTypeConstraint VideoColorimetryTransferFieldInfo = (~) VideoColorimetry + type AttrGetType VideoColorimetryTransferFieldInfo = GstVideo.Enums.VideoTransferFunction + type AttrLabel VideoColorimetryTransferFieldInfo = "transfer" + type AttrOrigin VideoColorimetryTransferFieldInfo = VideoColorimetry + attrGet _ = getVideoColorimetryTransfer + attrSet _ = setVideoColorimetryTransfer + attrConstruct = undefined + attrClear _ = undefined + +videoColorimetry_transfer :: AttrLabelProxy "transfer" +videoColorimetry_transfer = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@primaries@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoColorimetry #primaries +@ +-} +getVideoColorimetryPrimaries :: MonadIO m => VideoColorimetry -> m GstVideo.Enums.VideoColorPrimaries +getVideoColorimetryPrimaries s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 12) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@primaries@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoColorimetry [ #primaries 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoColorimetryPrimaries :: MonadIO m => VideoColorimetry -> GstVideo.Enums.VideoColorPrimaries -> m () +setVideoColorimetryPrimaries s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 12) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoColorimetryPrimariesFieldInfo +instance AttrInfo VideoColorimetryPrimariesFieldInfo where + type AttrAllowedOps VideoColorimetryPrimariesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoColorimetryPrimariesFieldInfo = (~) GstVideo.Enums.VideoColorPrimaries + type AttrBaseTypeConstraint VideoColorimetryPrimariesFieldInfo = (~) VideoColorimetry + type AttrGetType VideoColorimetryPrimariesFieldInfo = GstVideo.Enums.VideoColorPrimaries + type AttrLabel VideoColorimetryPrimariesFieldInfo = "primaries" + type AttrOrigin VideoColorimetryPrimariesFieldInfo = VideoColorimetry + attrGet _ = getVideoColorimetryPrimaries + attrSet _ = setVideoColorimetryPrimaries + attrConstruct = undefined + attrClear _ = undefined + +videoColorimetry_primaries :: AttrLabelProxy "primaries" +videoColorimetry_primaries = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoColorimetry +type instance O.AttributeList VideoColorimetry = VideoColorimetryAttributeList +type VideoColorimetryAttributeList = ('[ '("range", VideoColorimetryRangeFieldInfo), '("matrix", VideoColorimetryMatrixFieldInfo), '("transfer", VideoColorimetryTransferFieldInfo), '("primaries", VideoColorimetryPrimariesFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoColorimetry::from_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cinfo", argType = TInterface (Name {namespace = "GstVideo", name = "VideoColorimetry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoColorimetry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a colorimetry string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_colorimetry_from_string" gst_video_colorimetry_from_string :: + Ptr VideoColorimetry -> -- cinfo : TInterface (Name {namespace = "GstVideo", name = "VideoColorimetry"}) + CString -> -- color : TBasicType TUTF8 + IO CInt + +{- | +Parse the colorimetry string and update /@cinfo@/ with the parsed +values. +-} +videoColorimetryFromString :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoColorimetry + {- ^ /@cinfo@/: a 'GI.GstVideo.Structs.VideoColorimetry.VideoColorimetry' -} + -> T.Text + {- ^ /@color@/: a colorimetry string -} + -> m Bool + {- ^ __Returns:__ 'True' if /@color@/ points to valid colorimetry info. -} +videoColorimetryFromString cinfo color = liftIO $ do + cinfo' <- unsafeManagedPtrGetPtr cinfo + color' <- textToCString color + result <- gst_video_colorimetry_from_string cinfo' color' + let result' = (/= 0) result + touchManagedPtr cinfo + freeMem color' + return result' + +#if ENABLE_OVERLOADING +data VideoColorimetryFromStringMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo VideoColorimetryFromStringMethodInfo VideoColorimetry signature where + overloadedMethod _ = videoColorimetryFromString + +#endif + +-- method VideoColorimetry::is_equal +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cinfo", argType = TInterface (Name {namespace = "GstVideo", name = "VideoColorimetry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoColorimetry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "other", argType = TInterface (Name {namespace = "GstVideo", name = "VideoColorimetry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "another #GstVideoColorimetry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_colorimetry_is_equal" gst_video_colorimetry_is_equal :: + Ptr VideoColorimetry -> -- cinfo : TInterface (Name {namespace = "GstVideo", name = "VideoColorimetry"}) + Ptr VideoColorimetry -> -- other : TInterface (Name {namespace = "GstVideo", name = "VideoColorimetry"}) + IO CInt + +{- | +Compare the 2 colorimetry sets for equality + +/Since: 1.6/ +-} +videoColorimetryIsEqual :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoColorimetry + {- ^ /@cinfo@/: a 'GI.GstVideo.Structs.VideoColorimetry.VideoColorimetry' -} + -> VideoColorimetry + {- ^ /@other@/: another 'GI.GstVideo.Structs.VideoColorimetry.VideoColorimetry' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@cinfo@/ and /@other@/ are equal. -} +videoColorimetryIsEqual cinfo other = liftIO $ do + cinfo' <- unsafeManagedPtrGetPtr cinfo + other' <- unsafeManagedPtrGetPtr other + result <- gst_video_colorimetry_is_equal cinfo' other' + let result' = (/= 0) result + touchManagedPtr cinfo + touchManagedPtr other + return result' + +#if ENABLE_OVERLOADING +data VideoColorimetryIsEqualMethodInfo +instance (signature ~ (VideoColorimetry -> m Bool), MonadIO m) => O.MethodInfo VideoColorimetryIsEqualMethodInfo VideoColorimetry signature where + overloadedMethod _ = videoColorimetryIsEqual + +#endif + +-- method VideoColorimetry::matches +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cinfo", argType = TInterface (Name {namespace = "GstVideo", name = "VideoColorimetry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a colorimetry string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_colorimetry_matches" gst_video_colorimetry_matches :: + Ptr VideoColorimetry -> -- cinfo : TInterface (Name {namespace = "GstVideo", name = "VideoColorimetry"}) + CString -> -- color : TBasicType TUTF8 + IO CInt + +{- | +Check if the colorimetry information in /@info@/ matches that of the +string /@color@/. +-} +videoColorimetryMatches :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoColorimetry + {- ^ /@cinfo@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> T.Text + {- ^ /@color@/: a colorimetry string -} + -> m Bool + {- ^ __Returns:__ 'True' if /@color@/ conveys the same colorimetry info as the color +information in /@info@/. -} +videoColorimetryMatches cinfo color = liftIO $ do + cinfo' <- unsafeManagedPtrGetPtr cinfo + color' <- textToCString color + result <- gst_video_colorimetry_matches cinfo' color' + let result' = (/= 0) result + touchManagedPtr cinfo + freeMem color' + return result' + +#if ENABLE_OVERLOADING +data VideoColorimetryMatchesMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo VideoColorimetryMatchesMethodInfo VideoColorimetry signature where + overloadedMethod _ = videoColorimetryMatches + +#endif + +-- method VideoColorimetry::to_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cinfo", argType = TInterface (Name {namespace = "GstVideo", name = "VideoColorimetry"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoColorimetry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_colorimetry_to_string" gst_video_colorimetry_to_string :: + Ptr VideoColorimetry -> -- cinfo : TInterface (Name {namespace = "GstVideo", name = "VideoColorimetry"}) + IO CString + +{- | +Make a string representation of /@cinfo@/. +-} +videoColorimetryToString :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoColorimetry + {- ^ /@cinfo@/: a 'GI.GstVideo.Structs.VideoColorimetry.VideoColorimetry' -} + -> m T.Text + {- ^ __Returns:__ a string representation of /@cinfo@/. -} +videoColorimetryToString cinfo = liftIO $ do + cinfo' <- unsafeManagedPtrGetPtr cinfo + result <- gst_video_colorimetry_to_string cinfo' + checkUnexpectedReturnNULL "videoColorimetryToString" result + result' <- cstringToText result + freeMem result + touchManagedPtr cinfo + return result' + +#if ENABLE_OVERLOADING +data VideoColorimetryToStringMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo VideoColorimetryToStringMethodInfo VideoColorimetry signature where + overloadedMethod _ = videoColorimetryToString + +#endif + +#if ENABLE_OVERLOADING +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 = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoColorimetryMethod t VideoColorimetry, O.MethodInfo info VideoColorimetry p) => OL.IsLabel t (VideoColorimetry -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoColorimetry.hs-boot b/GI/GstVideo/Structs/VideoColorimetry.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoColorimetry.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoColorimetry where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoColorimetry = VideoColorimetry (ManagedPtr VideoColorimetry) +instance WrappedPtr VideoColorimetry where +#if ENABLE_OVERLOADING +data VideoColorimetryFromStringMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoColorimetryIsEqualMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoColorimetryMatchesMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoColorimetryToStringMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoConverter.hs b/GI/GstVideo/Structs/VideoConverter.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoConverter.hs @@ -0,0 +1,284 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoConverter + ( + +-- * Exported types + VideoConverter(..) , + noVideoConverter , + + + -- * Methods +-- ** frame #method:frame# + +#if ENABLE_OVERLOADING + VideoConverterFrameMethodInfo , +#endif + videoConverterFrame , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + VideoConverterFreeMethodInfo , +#endif + videoConverterFree , + + +-- ** getConfig #method:getConfig# + +#if ENABLE_OVERLOADING + VideoConverterGetConfigMethodInfo , +#endif + videoConverterGetConfig , + + +-- ** setConfig #method:setConfig# + +#if ENABLE_OVERLOADING + VideoConverterSetConfigMethodInfo , +#endif + videoConverterSetConfig , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Structs.Structure as Gst.Structure +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoFrame as GstVideo.VideoFrame + +-- | Memory-managed wrapper type. +newtype VideoConverter = VideoConverter (ManagedPtr VideoConverter) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr VideoConverter where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoConverter`. +noVideoConverter :: Maybe VideoConverter +noVideoConverter = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoConverter +type instance O.AttributeList VideoConverter = VideoConverterAttributeList +type VideoConverterAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method VideoConverter::frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "convert", argType = TInterface (Name {namespace = "GstVideo", name = "VideoConverter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoConverter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_converter_frame" gst_video_converter_frame :: + Ptr VideoConverter -> -- convert : TInterface (Name {namespace = "GstVideo", name = "VideoConverter"}) + Ptr GstVideo.VideoFrame.VideoFrame -> -- src : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) + Ptr GstVideo.VideoFrame.VideoFrame -> -- dest : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) + IO () + +{- | +Convert the pixels of /@src@/ into /@dest@/ using /@convert@/. + +/Since: 1.6/ +-} +videoConverterFrame :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoConverter + {- ^ /@convert@/: a 'GI.GstVideo.Structs.VideoConverter.VideoConverter' -} + -> GstVideo.VideoFrame.VideoFrame + {- ^ /@src@/: a 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} + -> GstVideo.VideoFrame.VideoFrame + {- ^ /@dest@/: a 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} + -> m () +videoConverterFrame convert src dest = liftIO $ do + convert' <- unsafeManagedPtrGetPtr convert + src' <- unsafeManagedPtrGetPtr src + dest' <- unsafeManagedPtrGetPtr dest + gst_video_converter_frame convert' src' dest' + touchManagedPtr convert + touchManagedPtr src + touchManagedPtr dest + return () + +#if ENABLE_OVERLOADING +data VideoConverterFrameMethodInfo +instance (signature ~ (GstVideo.VideoFrame.VideoFrame -> GstVideo.VideoFrame.VideoFrame -> m ()), MonadIO m) => O.MethodInfo VideoConverterFrameMethodInfo VideoConverter signature where + overloadedMethod _ = videoConverterFrame + +#endif + +-- method VideoConverter::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "convert", argType = TInterface (Name {namespace = "GstVideo", name = "VideoConverter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoConverter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_converter_free" gst_video_converter_free :: + Ptr VideoConverter -> -- convert : TInterface (Name {namespace = "GstVideo", name = "VideoConverter"}) + IO () + +{- | +Free /@convert@/ + +/Since: 1.6/ +-} +videoConverterFree :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoConverter + {- ^ /@convert@/: a 'GI.GstVideo.Structs.VideoConverter.VideoConverter' -} + -> m () +videoConverterFree convert = liftIO $ do + convert' <- unsafeManagedPtrGetPtr convert + gst_video_converter_free convert' + touchManagedPtr convert + return () + +#if ENABLE_OVERLOADING +data VideoConverterFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoConverterFreeMethodInfo VideoConverter signature where + overloadedMethod _ = videoConverterFree + +#endif + +-- method VideoConverter::get_config +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "convert", argType = TInterface (Name {namespace = "GstVideo", name = "VideoConverter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoConverter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Structure"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_converter_get_config" gst_video_converter_get_config :: + Ptr VideoConverter -> -- convert : TInterface (Name {namespace = "GstVideo", name = "VideoConverter"}) + IO (Ptr Gst.Structure.Structure) + +{- | +Get the current configuration of /@convert@/. +-} +videoConverterGetConfig :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoConverter + {- ^ /@convert@/: a 'GI.GstVideo.Structs.VideoConverter.VideoConverter' -} + -> m Gst.Structure.Structure + {- ^ __Returns:__ a 'GI.Gst.Structs.Structure.Structure' that remains valid for as long as /@convert@/ is valid + or until 'GI.GstVideo.Structs.VideoConverter.videoConverterSetConfig' is called. -} +videoConverterGetConfig convert = liftIO $ do + convert' <- unsafeManagedPtrGetPtr convert + result <- gst_video_converter_get_config convert' + checkUnexpectedReturnNULL "videoConverterGetConfig" result + result' <- (newBoxed Gst.Structure.Structure) result + touchManagedPtr convert + return result' + +#if ENABLE_OVERLOADING +data VideoConverterGetConfigMethodInfo +instance (signature ~ (m Gst.Structure.Structure), MonadIO m) => O.MethodInfo VideoConverterGetConfigMethodInfo VideoConverter signature where + overloadedMethod _ = videoConverterGetConfig + +#endif + +-- method VideoConverter::set_config +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "convert", argType = TInterface (Name {namespace = "GstVideo", name = "VideoConverter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoConverter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "config", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_converter_set_config" gst_video_converter_set_config :: + Ptr VideoConverter -> -- convert : TInterface (Name {namespace = "GstVideo", name = "VideoConverter"}) + Ptr Gst.Structure.Structure -> -- config : TInterface (Name {namespace = "Gst", name = "Structure"}) + IO CInt + +{- | +Set /@config@/ as extra configuraion for /@convert@/. + +If the parameters in /@config@/ can not be set exactly, this function returns +'False' and will try to update as much state as possible. The new state can +then be retrieved and refined with 'GI.GstVideo.Structs.VideoConverter.videoConverterGetConfig'. + +Look at the @/GST_VIDEO_CONVERTER_OPT_/@* fields to check valid configuration +option and values. + +/Since: 1.6/ +-} +videoConverterSetConfig :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoConverter + {- ^ /@convert@/: a 'GI.GstVideo.Structs.VideoConverter.VideoConverter' -} + -> Gst.Structure.Structure + {- ^ /@config@/: a 'GI.Gst.Structs.Structure.Structure' -} + -> m Bool + {- ^ __Returns:__ 'True' when /@config@/ could be set. -} +videoConverterSetConfig convert config = liftIO $ do + convert' <- unsafeManagedPtrGetPtr convert + config' <- B.ManagedPtr.disownBoxed config + result <- gst_video_converter_set_config convert' config' + let result' = (/= 0) result + touchManagedPtr convert + touchManagedPtr config + return result' + +#if ENABLE_OVERLOADING +data VideoConverterSetConfigMethodInfo +instance (signature ~ (Gst.Structure.Structure -> m Bool), MonadIO m) => O.MethodInfo VideoConverterSetConfigMethodInfo VideoConverter signature where + overloadedMethod _ = videoConverterSetConfig + +#endif + +#if ENABLE_OVERLOADING +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 = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoConverterMethod t VideoConverter, O.MethodInfo info VideoConverter p) => OL.IsLabel t (VideoConverter -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoConverter.hs-boot b/GI/GstVideo/Structs/VideoConverter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoConverter.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoConverter where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoConverter = VideoConverter (ManagedPtr VideoConverter) +instance WrappedPtr VideoConverter where +#if ENABLE_OVERLOADING +data VideoConverterFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoConverterFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoConverterGetConfigMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoConverterSetConfigMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoCropMeta.hs b/GI/GstVideo/Structs/VideoCropMeta.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoCropMeta.hs @@ -0,0 +1,390 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Extra buffer metadata describing image cropping. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoCropMeta + ( + +-- * Exported types + VideoCropMeta(..) , + newZeroVideoCropMeta , + noVideoCropMeta , + + + -- * Methods +-- ** getInfo #method:getInfo# + + videoCropMetaGetInfo , + + + + + -- * Properties +-- ** height #attr:height# +{- | the cropped height +-} + getVideoCropMetaHeight , + setVideoCropMetaHeight , +#if ENABLE_OVERLOADING + videoCropMeta_height , +#endif + + +-- ** meta #attr:meta# +{- | parent 'GI.Gst.Structs.Meta.Meta' +-} + getVideoCropMetaMeta , +#if ENABLE_OVERLOADING + videoCropMeta_meta , +#endif + + +-- ** width #attr:width# +{- | the cropped width +-} + getVideoCropMetaWidth , + setVideoCropMetaWidth , +#if ENABLE_OVERLOADING + videoCropMeta_width , +#endif + + +-- ** x #attr:x# +{- | the horizontal offset +-} + getVideoCropMetaX , + setVideoCropMetaX , +#if ENABLE_OVERLOADING + videoCropMeta_x , +#endif + + +-- ** y #attr:y# +{- | the vertical offset +-} + getVideoCropMetaY , + setVideoCropMetaY , +#if ENABLE_OVERLOADING + videoCropMeta_y , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Structs.Meta as Gst.Meta +import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo + +-- | Memory-managed wrapper type. +newtype VideoCropMeta = VideoCropMeta (ManagedPtr VideoCropMeta) +instance WrappedPtr VideoCropMeta where + wrappedPtrCalloc = callocBytes 32 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 32 >=> wrapPtr VideoCropMeta) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoCropMeta` struct initialized to zero. +newZeroVideoCropMeta :: MonadIO m => m VideoCropMeta +newZeroVideoCropMeta = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoCropMeta + +instance tag ~ 'AttrSet => Constructible VideoCropMeta tag where + new _ attrs = do + o <- newZeroVideoCropMeta + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoCropMeta`. +noVideoCropMeta :: Maybe VideoCropMeta +noVideoCropMeta = Nothing + +{- | +Get the value of the “@meta@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCropMeta #meta +@ +-} +getVideoCropMetaMeta :: MonadIO m => VideoCropMeta -> m Gst.Meta.Meta +getVideoCropMetaMeta s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Gst.Meta.Meta) + val' <- (newPtr Gst.Meta.Meta) val + return val' + +#if ENABLE_OVERLOADING +data VideoCropMetaMetaFieldInfo +instance AttrInfo VideoCropMetaMetaFieldInfo where + type AttrAllowedOps VideoCropMetaMetaFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint VideoCropMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta) + type AttrBaseTypeConstraint VideoCropMetaMetaFieldInfo = (~) VideoCropMeta + type AttrGetType VideoCropMetaMetaFieldInfo = Gst.Meta.Meta + type AttrLabel VideoCropMetaMetaFieldInfo = "meta" + type AttrOrigin VideoCropMetaMetaFieldInfo = VideoCropMeta + attrGet _ = getVideoCropMetaMeta + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +videoCropMeta_meta :: AttrLabelProxy "meta" +videoCropMeta_meta = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@x@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCropMeta #x +@ +-} +getVideoCropMetaX :: MonadIO m => VideoCropMeta -> m Word32 +getVideoCropMetaX s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO Word32 + return val + +{- | +Set the value of the “@x@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCropMeta [ #x 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCropMetaX :: MonadIO m => VideoCropMeta -> Word32 -> m () +setVideoCropMetaX s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoCropMetaXFieldInfo +instance AttrInfo VideoCropMetaXFieldInfo where + type AttrAllowedOps VideoCropMetaXFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoCropMetaXFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoCropMetaXFieldInfo = (~) VideoCropMeta + type AttrGetType VideoCropMetaXFieldInfo = Word32 + type AttrLabel VideoCropMetaXFieldInfo = "x" + type AttrOrigin VideoCropMetaXFieldInfo = VideoCropMeta + attrGet _ = getVideoCropMetaX + attrSet _ = setVideoCropMetaX + attrConstruct = undefined + attrClear _ = undefined + +videoCropMeta_x :: AttrLabelProxy "x" +videoCropMeta_x = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@y@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCropMeta #y +@ +-} +getVideoCropMetaY :: MonadIO m => VideoCropMeta -> m Word32 +getVideoCropMetaY s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 20) :: IO Word32 + return val + +{- | +Set the value of the “@y@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCropMeta [ #y 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCropMetaY :: MonadIO m => VideoCropMeta -> Word32 -> m () +setVideoCropMetaY s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 20) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoCropMetaYFieldInfo +instance AttrInfo VideoCropMetaYFieldInfo where + type AttrAllowedOps VideoCropMetaYFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoCropMetaYFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoCropMetaYFieldInfo = (~) VideoCropMeta + type AttrGetType VideoCropMetaYFieldInfo = Word32 + type AttrLabel VideoCropMetaYFieldInfo = "y" + type AttrOrigin VideoCropMetaYFieldInfo = VideoCropMeta + attrGet _ = getVideoCropMetaY + attrSet _ = setVideoCropMetaY + attrConstruct = undefined + attrClear _ = undefined + +videoCropMeta_y :: AttrLabelProxy "y" +videoCropMeta_y = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@width@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCropMeta #width +@ +-} +getVideoCropMetaWidth :: MonadIO m => VideoCropMeta -> m Word32 +getVideoCropMetaWidth s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO Word32 + return val + +{- | +Set the value of the “@width@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCropMeta [ #width 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCropMetaWidth :: MonadIO m => VideoCropMeta -> Word32 -> m () +setVideoCropMetaWidth s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoCropMetaWidthFieldInfo +instance AttrInfo VideoCropMetaWidthFieldInfo where + type AttrAllowedOps VideoCropMetaWidthFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoCropMetaWidthFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoCropMetaWidthFieldInfo = (~) VideoCropMeta + type AttrGetType VideoCropMetaWidthFieldInfo = Word32 + type AttrLabel VideoCropMetaWidthFieldInfo = "width" + type AttrOrigin VideoCropMetaWidthFieldInfo = VideoCropMeta + attrGet _ = getVideoCropMetaWidth + attrSet _ = setVideoCropMetaWidth + attrConstruct = undefined + attrClear _ = undefined + +videoCropMeta_width :: AttrLabelProxy "width" +videoCropMeta_width = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@height@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoCropMeta #height +@ +-} +getVideoCropMetaHeight :: MonadIO m => VideoCropMeta -> m Word32 +getVideoCropMetaHeight s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 28) :: IO Word32 + return val + +{- | +Set the value of the “@height@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoCropMeta [ #height 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoCropMetaHeight :: MonadIO m => VideoCropMeta -> Word32 -> m () +setVideoCropMetaHeight s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 28) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoCropMetaHeightFieldInfo +instance AttrInfo VideoCropMetaHeightFieldInfo where + type AttrAllowedOps VideoCropMetaHeightFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoCropMetaHeightFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoCropMetaHeightFieldInfo = (~) VideoCropMeta + type AttrGetType VideoCropMetaHeightFieldInfo = Word32 + type AttrLabel VideoCropMetaHeightFieldInfo = "height" + type AttrOrigin VideoCropMetaHeightFieldInfo = VideoCropMeta + attrGet _ = getVideoCropMetaHeight + attrSet _ = setVideoCropMetaHeight + attrConstruct = undefined + attrClear _ = undefined + +videoCropMeta_height :: AttrLabelProxy "height" +videoCropMeta_height = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoCropMeta +type instance O.AttributeList VideoCropMeta = VideoCropMetaAttributeList +type VideoCropMetaAttributeList = ('[ '("meta", VideoCropMetaMetaFieldInfo), '("x", VideoCropMetaXFieldInfo), '("y", VideoCropMetaYFieldInfo), '("width", VideoCropMetaWidthFieldInfo), '("height", VideoCropMetaHeightFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoCropMeta::get_info +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "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.MetaInfo) + +{- | +/No description available in the introspection data./ +-} +videoCropMetaGetInfo :: + (B.CallStack.HasCallStack, MonadIO m) => + m Gst.MetaInfo.MetaInfo +videoCropMetaGetInfo = liftIO $ do + result <- gst_video_crop_meta_get_info + checkUnexpectedReturnNULL "videoCropMetaGetInfo" result + result' <- (newPtr Gst.MetaInfo.MetaInfo) result + return result' + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoCropMetaMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoCropMetaMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoCropMetaMethod t VideoCropMeta, O.MethodInfo info VideoCropMeta p) => OL.IsLabel t (VideoCropMeta -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoCropMeta.hs-boot b/GI/GstVideo/Structs/VideoCropMeta.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoCropMeta.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoCropMeta where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoCropMeta = VideoCropMeta (ManagedPtr VideoCropMeta) +instance WrappedPtr VideoCropMeta where diff --git a/GI/GstVideo/Structs/VideoDither.hs b/GI/GstVideo/Structs/VideoDither.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoDither.hs @@ -0,0 +1,179 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +GstVideoDither provides implementations of several dithering algorithms +that can be applied to lines of video pixels to quantize and dither them. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoDither + ( + +-- * Exported types + VideoDither(..) , + noVideoDither , + + + -- * Methods +-- ** free #method:free# + +#if ENABLE_OVERLOADING + VideoDitherFreeMethodInfo , +#endif + videoDitherFree , + + +-- ** line #method:line# + +#if ENABLE_OVERLOADING + VideoDitherLineMethodInfo , +#endif + videoDitherLine , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- | Memory-managed wrapper type. +newtype VideoDither = VideoDither (ManagedPtr VideoDither) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr VideoDither where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoDither`. +noVideoDither :: Maybe VideoDither +noVideoDither = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoDither +type instance O.AttributeList VideoDither = VideoDitherAttributeList +type VideoDitherAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method VideoDither::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dither", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDither"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDither", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_dither_free" gst_video_dither_free :: + Ptr VideoDither -> -- dither : TInterface (Name {namespace = "GstVideo", name = "VideoDither"}) + IO () + +{- | +Free /@dither@/ +-} +videoDitherFree :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoDither + {- ^ /@dither@/: a 'GI.GstVideo.Structs.VideoDither.VideoDither' -} + -> m () +videoDitherFree dither = liftIO $ do + dither' <- unsafeManagedPtrGetPtr dither + gst_video_dither_free dither' + touchManagedPtr dither + return () + +#if ENABLE_OVERLOADING +data VideoDitherFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoDitherFreeMethodInfo VideoDither signature where + overloadedMethod _ = videoDitherFree + +#endif + +-- method VideoDither::line +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dither", argType = TInterface (Name {namespace = "GstVideo", name = "VideoDither"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoDither", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "pointer to the pixels of the line", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "x coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "y coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_dither_line" gst_video_dither_line :: + Ptr VideoDither -> -- dither : TInterface (Name {namespace = "GstVideo", name = "VideoDither"}) + Ptr () -> -- line : TBasicType TPtr + Word32 -> -- x : TBasicType TUInt + Word32 -> -- y : TBasicType TUInt + Word32 -> -- width : TBasicType TUInt + IO () + +{- | +Dither /@width@/ pixels starting from offset /@x@/ in /@line@/ using /@dither@/. + +/@y@/ is the line number of /@line@/ in the output image. +-} +videoDitherLine :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoDither + {- ^ /@dither@/: a 'GI.GstVideo.Structs.VideoDither.VideoDither' -} + -> Ptr () + {- ^ /@line@/: pointer to the pixels of the line -} + -> Word32 + {- ^ /@x@/: x coordinate -} + -> Word32 + {- ^ /@y@/: y coordinate -} + -> Word32 + {- ^ /@width@/: the width -} + -> m () +videoDitherLine dither line x y width = liftIO $ do + dither' <- unsafeManagedPtrGetPtr dither + gst_video_dither_line dither' line x y width + touchManagedPtr dither + return () + +#if ENABLE_OVERLOADING +data VideoDitherLineMethodInfo +instance (signature ~ (Ptr () -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m) => O.MethodInfo VideoDitherLineMethodInfo VideoDither signature where + overloadedMethod _ = videoDitherLine + +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoDitherMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoDitherMethod "free" o = VideoDitherFreeMethodInfo + ResolveVideoDitherMethod "line" o = VideoDitherLineMethodInfo + ResolveVideoDitherMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoDitherMethod t VideoDither, O.MethodInfo info VideoDither p) => OL.IsLabel t (VideoDither -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoDither.hs-boot b/GI/GstVideo/Structs/VideoDither.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoDither.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoDither where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoDither = VideoDither (ManagedPtr VideoDither) +instance WrappedPtr VideoDither where +#if ENABLE_OVERLOADING +data VideoDitherFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoDitherLineMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoFormatInfo.hs b/GI/GstVideo/Structs/VideoFormatInfo.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoFormatInfo.hs @@ -0,0 +1,949 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Information for a video format. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoFormatInfo + ( + +-- * Exported types + VideoFormatInfo(..) , + newZeroVideoFormatInfo , + noVideoFormatInfo , + + + -- * Properties +-- ** bits #attr:bits# +{- | The number of bits used to pack data items. This can be less than 8 + when multiple pixels are stored in a byte. for values > 8 multiple bytes + should be read according to the endianness flag before applying the shift + and mask. +-} + getVideoFormatInfoBits , + setVideoFormatInfoBits , +#if ENABLE_OVERLOADING + videoFormatInfo_bits , +#endif + + +-- ** description #attr:description# +{- | use readable description of the format +-} + clearVideoFormatInfoDescription , + getVideoFormatInfoDescription , + setVideoFormatInfoDescription , +#if ENABLE_OVERLOADING + videoFormatInfo_description , +#endif + + +-- ** flags #attr:flags# +{- | 'GI.GstVideo.Flags.VideoFormatFlags' +-} + getVideoFormatInfoFlags , + setVideoFormatInfoFlags , +#if ENABLE_OVERLOADING + videoFormatInfo_flags , +#endif + + +-- ** format #attr:format# +{- | 'GI.GstVideo.Enums.VideoFormat' +-} + getVideoFormatInfoFormat , + setVideoFormatInfoFormat , +#if ENABLE_OVERLOADING + videoFormatInfo_format , +#endif + + +-- ** nComponents #attr:nComponents# +{- | the number of components in the video format. +-} + getVideoFormatInfoNComponents , + setVideoFormatInfoNComponents , +#if ENABLE_OVERLOADING + videoFormatInfo_nComponents , +#endif + + +-- ** nPlanes #attr:nPlanes# +{- | the number of planes for this format. The number of planes can be + less than the amount of components when multiple components are packed into + one plane. +-} + getVideoFormatInfoNPlanes , + setVideoFormatInfoNPlanes , +#if ENABLE_OVERLOADING + videoFormatInfo_nPlanes , +#endif + + +-- ** name #attr:name# +{- | string representation of the format +-} + clearVideoFormatInfoName , + getVideoFormatInfoName , + setVideoFormatInfoName , +#if ENABLE_OVERLOADING + videoFormatInfo_name , +#endif + + +-- ** packFunc #attr:packFunc# +{- | an pack function for this format +-} + clearVideoFormatInfoPackFunc , + getVideoFormatInfoPackFunc , + setVideoFormatInfoPackFunc , +#if ENABLE_OVERLOADING + videoFormatInfo_packFunc , +#endif + + +-- ** packLines #attr:packLines# +{- | the amount of lines that will be packed +-} + getVideoFormatInfoPackLines , + setVideoFormatInfoPackLines , +#if ENABLE_OVERLOADING + videoFormatInfo_packLines , +#endif + + +-- ** tileHs #attr:tileHs# +{- | The height of a tile, in bytes, represented as a shift +-} + getVideoFormatInfoTileHs , + setVideoFormatInfoTileHs , +#if ENABLE_OVERLOADING + videoFormatInfo_tileHs , +#endif + + +-- ** tileMode #attr:tileMode# +{- | The tiling mode +-} + getVideoFormatInfoTileMode , + setVideoFormatInfoTileMode , +#if ENABLE_OVERLOADING + videoFormatInfo_tileMode , +#endif + + +-- ** tileWs #attr:tileWs# +{- | The width of a tile, in bytes, represented as a shift +-} + getVideoFormatInfoTileWs , + setVideoFormatInfoTileWs , +#if ENABLE_OVERLOADING + videoFormatInfo_tileWs , +#endif + + +-- ** unpackFormat #attr:unpackFormat# +{- | the format of the unpacked pixels. This format must have the + @/GST_VIDEO_FORMAT_FLAG_UNPACK/@ flag set. +-} + getVideoFormatInfoUnpackFormat , + setVideoFormatInfoUnpackFormat , +#if ENABLE_OVERLOADING + videoFormatInfo_unpackFormat , +#endif + + +-- ** unpackFunc #attr:unpackFunc# +{- | an unpack function for this format +-} + clearVideoFormatInfoUnpackFunc , + getVideoFormatInfoUnpackFunc , + setVideoFormatInfoUnpackFunc , +#if ENABLE_OVERLOADING + videoFormatInfo_unpackFunc , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GstVideo.Callbacks as GstVideo.Callbacks +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums +import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags + +-- | Memory-managed wrapper type. +newtype VideoFormatInfo = VideoFormatInfo (ManagedPtr VideoFormatInfo) +instance WrappedPtr VideoFormatInfo where + wrappedPtrCalloc = callocBytes 232 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 232 >=> wrapPtr VideoFormatInfo) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoFormatInfo` struct initialized to zero. +newZeroVideoFormatInfo :: MonadIO m => m VideoFormatInfo +newZeroVideoFormatInfo = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoFormatInfo + +instance tag ~ 'AttrSet => Constructible VideoFormatInfo tag where + new _ attrs = do + o <- newZeroVideoFormatInfo + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoFormatInfo`. +noVideoFormatInfo :: Maybe VideoFormatInfo +noVideoFormatInfo = Nothing + +{- | +Get the value of the “@format@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #format +@ +-} +getVideoFormatInfoFormat :: MonadIO m => VideoFormatInfo -> m GstVideo.Enums.VideoFormat +getVideoFormatInfoFormat s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@format@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #format 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoFormat :: MonadIO m => VideoFormatInfo -> GstVideo.Enums.VideoFormat -> m () +setVideoFormatInfoFormat s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoFormatInfoFormatFieldInfo +instance AttrInfo VideoFormatInfoFormatFieldInfo where + type AttrAllowedOps VideoFormatInfoFormatFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoFormatInfoFormatFieldInfo = (~) GstVideo.Enums.VideoFormat + type AttrBaseTypeConstraint VideoFormatInfoFormatFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoFormatFieldInfo = GstVideo.Enums.VideoFormat + type AttrLabel VideoFormatInfoFormatFieldInfo = "format" + type AttrOrigin VideoFormatInfoFormatFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoFormat + attrSet _ = setVideoFormatInfoFormat + attrConstruct = undefined + attrClear _ = undefined + +videoFormatInfo_format :: AttrLabelProxy "format" +videoFormatInfo_format = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@name@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #name +@ +-} +getVideoFormatInfoName :: MonadIO m => VideoFormatInfo -> m (Maybe T.Text) +getVideoFormatInfoName s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@name@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #name 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoName :: MonadIO m => VideoFormatInfo -> CString -> m () +setVideoFormatInfoName s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: CString) + +{- | +Set the value of the “@name@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #name +@ +-} +clearVideoFormatInfoName :: MonadIO m => VideoFormatInfo -> m () +clearVideoFormatInfoName s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data VideoFormatInfoNameFieldInfo +instance AttrInfo VideoFormatInfoNameFieldInfo where + type AttrAllowedOps VideoFormatInfoNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoFormatInfoNameFieldInfo = (~) CString + type AttrBaseTypeConstraint VideoFormatInfoNameFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoNameFieldInfo = Maybe T.Text + type AttrLabel VideoFormatInfoNameFieldInfo = "name" + type AttrOrigin VideoFormatInfoNameFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoName + attrSet _ = setVideoFormatInfoName + attrConstruct = undefined + attrClear _ = clearVideoFormatInfoName + +videoFormatInfo_name :: AttrLabelProxy "name" +videoFormatInfo_name = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@description@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #description +@ +-} +getVideoFormatInfoDescription :: MonadIO m => VideoFormatInfo -> m (Maybe T.Text) +getVideoFormatInfoDescription s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@description@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #description 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoDescription :: MonadIO m => VideoFormatInfo -> CString -> m () +setVideoFormatInfoDescription s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: CString) + +{- | +Set the value of the “@description@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #description +@ +-} +clearVideoFormatInfoDescription :: MonadIO m => VideoFormatInfo -> m () +clearVideoFormatInfoDescription s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data VideoFormatInfoDescriptionFieldInfo +instance AttrInfo VideoFormatInfoDescriptionFieldInfo where + type AttrAllowedOps VideoFormatInfoDescriptionFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoFormatInfoDescriptionFieldInfo = (~) CString + type AttrBaseTypeConstraint VideoFormatInfoDescriptionFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoDescriptionFieldInfo = Maybe T.Text + type AttrLabel VideoFormatInfoDescriptionFieldInfo = "description" + type AttrOrigin VideoFormatInfoDescriptionFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoDescription + attrSet _ = setVideoFormatInfoDescription + attrConstruct = undefined + attrClear _ = clearVideoFormatInfoDescription + +videoFormatInfo_description :: AttrLabelProxy "description" +videoFormatInfo_description = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@flags@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #flags +@ +-} +getVideoFormatInfoFlags :: MonadIO m => VideoFormatInfo -> m [GstVideo.Flags.VideoFormatFlags] +getVideoFormatInfoFlags s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO CUInt + let val' = wordToGFlags val + return val' + +{- | +Set the value of the “@flags@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #flags 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoFlags :: MonadIO m => VideoFormatInfo -> [GstVideo.Flags.VideoFormatFlags] -> m () +setVideoFormatInfoFlags s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = gflagsToWord val + poke (ptr `plusPtr` 24) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoFormatInfoFlagsFieldInfo +instance AttrInfo VideoFormatInfoFlagsFieldInfo where + type AttrAllowedOps VideoFormatInfoFlagsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoFormatInfoFlagsFieldInfo = (~) [GstVideo.Flags.VideoFormatFlags] + type AttrBaseTypeConstraint VideoFormatInfoFlagsFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoFlagsFieldInfo = [GstVideo.Flags.VideoFormatFlags] + type AttrLabel VideoFormatInfoFlagsFieldInfo = "flags" + type AttrOrigin VideoFormatInfoFlagsFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoFlags + attrSet _ = setVideoFormatInfoFlags + attrConstruct = undefined + attrClear _ = undefined + +videoFormatInfo_flags :: AttrLabelProxy "flags" +videoFormatInfo_flags = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@bits@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #bits +@ +-} +getVideoFormatInfoBits :: MonadIO m => VideoFormatInfo -> m Word32 +getVideoFormatInfoBits s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 28) :: IO Word32 + return val + +{- | +Set the value of the “@bits@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #bits 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoBits :: MonadIO m => VideoFormatInfo -> Word32 -> m () +setVideoFormatInfoBits s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 28) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoFormatInfoBitsFieldInfo +instance AttrInfo VideoFormatInfoBitsFieldInfo where + type AttrAllowedOps VideoFormatInfoBitsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoFormatInfoBitsFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoFormatInfoBitsFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoBitsFieldInfo = Word32 + type AttrLabel VideoFormatInfoBitsFieldInfo = "bits" + type AttrOrigin VideoFormatInfoBitsFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoBits + attrSet _ = setVideoFormatInfoBits + attrConstruct = undefined + attrClear _ = undefined + +videoFormatInfo_bits :: AttrLabelProxy "bits" +videoFormatInfo_bits = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@n_components@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #nComponents +@ +-} +getVideoFormatInfoNComponents :: MonadIO m => VideoFormatInfo -> m Word32 +getVideoFormatInfoNComponents s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Word32 + return val + +{- | +Set the value of the “@n_components@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #nComponents 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoNComponents :: MonadIO m => VideoFormatInfo -> Word32 -> m () +setVideoFormatInfoNComponents s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoFormatInfoNComponentsFieldInfo +instance AttrInfo VideoFormatInfoNComponentsFieldInfo where + type AttrAllowedOps VideoFormatInfoNComponentsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoFormatInfoNComponentsFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoFormatInfoNComponentsFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoNComponentsFieldInfo = Word32 + type AttrLabel VideoFormatInfoNComponentsFieldInfo = "n_components" + type AttrOrigin VideoFormatInfoNComponentsFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoNComponents + attrSet _ = setVideoFormatInfoNComponents + attrConstruct = undefined + attrClear _ = undefined + +videoFormatInfo_nComponents :: AttrLabelProxy "nComponents" +videoFormatInfo_nComponents = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "VideoFormatInfo:shift" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt)" +-- XXX Skipped attribute for "VideoFormatInfo:depth" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt)" +-- XXX Skipped attribute for "VideoFormatInfo:pixel_stride" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TInt)" +{- | +Get the value of the “@n_planes@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #nPlanes +@ +-} +getVideoFormatInfoNPlanes :: MonadIO m => VideoFormatInfo -> m Word32 +getVideoFormatInfoNPlanes s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 84) :: IO Word32 + return val + +{- | +Set the value of the “@n_planes@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #nPlanes 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoNPlanes :: MonadIO m => VideoFormatInfo -> Word32 -> m () +setVideoFormatInfoNPlanes s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 84) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoFormatInfoNPlanesFieldInfo +instance AttrInfo VideoFormatInfoNPlanesFieldInfo where + type AttrAllowedOps VideoFormatInfoNPlanesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoFormatInfoNPlanesFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoFormatInfoNPlanesFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoNPlanesFieldInfo = Word32 + type AttrLabel VideoFormatInfoNPlanesFieldInfo = "n_planes" + type AttrOrigin VideoFormatInfoNPlanesFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoNPlanes + attrSet _ = setVideoFormatInfoNPlanes + attrConstruct = undefined + attrClear _ = undefined + +videoFormatInfo_nPlanes :: AttrLabelProxy "nPlanes" +videoFormatInfo_nPlanes = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "VideoFormatInfo:plane" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt)" +-- XXX Skipped attribute for "VideoFormatInfo:poffset" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt)" +-- XXX Skipped attribute for "VideoFormatInfo:w_sub" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt)" +-- XXX Skipped attribute for "VideoFormatInfo:h_sub" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt)" +{- | +Get the value of the “@unpack_format@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #unpackFormat +@ +-} +getVideoFormatInfoUnpackFormat :: MonadIO m => VideoFormatInfo -> m GstVideo.Enums.VideoFormat +getVideoFormatInfoUnpackFormat s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 152) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@unpack_format@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #unpackFormat 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoUnpackFormat :: MonadIO m => VideoFormatInfo -> GstVideo.Enums.VideoFormat -> m () +setVideoFormatInfoUnpackFormat s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 152) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoFormatInfoUnpackFormatFieldInfo +instance AttrInfo VideoFormatInfoUnpackFormatFieldInfo where + type AttrAllowedOps VideoFormatInfoUnpackFormatFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoFormatInfoUnpackFormatFieldInfo = (~) GstVideo.Enums.VideoFormat + type AttrBaseTypeConstraint VideoFormatInfoUnpackFormatFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoUnpackFormatFieldInfo = GstVideo.Enums.VideoFormat + type AttrLabel VideoFormatInfoUnpackFormatFieldInfo = "unpack_format" + type AttrOrigin VideoFormatInfoUnpackFormatFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoUnpackFormat + attrSet _ = setVideoFormatInfoUnpackFormat + attrConstruct = undefined + attrClear _ = undefined + +videoFormatInfo_unpackFormat :: AttrLabelProxy "unpackFormat" +videoFormatInfo_unpackFormat = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@unpack_func@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #unpackFunc +@ +-} +getVideoFormatInfoUnpackFunc :: MonadIO m => VideoFormatInfo -> m (Maybe GstVideo.Callbacks.VideoFormatUnpack) +getVideoFormatInfoUnpackFunc s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 160) :: IO (FunPtr GstVideo.Callbacks.C_VideoFormatUnpack) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = GstVideo.Callbacks.dynamic_VideoFormatUnpack val' + return val'' + return result + +{- | +Set the value of the “@unpack_func@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #unpackFunc 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoUnpackFunc :: MonadIO m => VideoFormatInfo -> FunPtr GstVideo.Callbacks.C_VideoFormatUnpack -> m () +setVideoFormatInfoUnpackFunc s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 160) (val :: FunPtr GstVideo.Callbacks.C_VideoFormatUnpack) + +{- | +Set the value of the “@unpack_func@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #unpackFunc +@ +-} +clearVideoFormatInfoUnpackFunc :: MonadIO m => VideoFormatInfo -> m () +clearVideoFormatInfoUnpackFunc s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 160) (FP.nullFunPtr :: FunPtr GstVideo.Callbacks.C_VideoFormatUnpack) + +#if ENABLE_OVERLOADING +data VideoFormatInfoUnpackFuncFieldInfo +instance AttrInfo VideoFormatInfoUnpackFuncFieldInfo where + type AttrAllowedOps VideoFormatInfoUnpackFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoFormatInfoUnpackFuncFieldInfo = (~) (FunPtr GstVideo.Callbacks.C_VideoFormatUnpack) + type AttrBaseTypeConstraint VideoFormatInfoUnpackFuncFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoUnpackFuncFieldInfo = Maybe GstVideo.Callbacks.VideoFormatUnpack + type AttrLabel VideoFormatInfoUnpackFuncFieldInfo = "unpack_func" + type AttrOrigin VideoFormatInfoUnpackFuncFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoUnpackFunc + attrSet _ = setVideoFormatInfoUnpackFunc + attrConstruct = undefined + attrClear _ = clearVideoFormatInfoUnpackFunc + +videoFormatInfo_unpackFunc :: AttrLabelProxy "unpackFunc" +videoFormatInfo_unpackFunc = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@pack_lines@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #packLines +@ +-} +getVideoFormatInfoPackLines :: MonadIO m => VideoFormatInfo -> m Int32 +getVideoFormatInfoPackLines s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 168) :: IO Int32 + return val + +{- | +Set the value of the “@pack_lines@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #packLines 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoPackLines :: MonadIO m => VideoFormatInfo -> Int32 -> m () +setVideoFormatInfoPackLines s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 168) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoFormatInfoPackLinesFieldInfo +instance AttrInfo VideoFormatInfoPackLinesFieldInfo where + type AttrAllowedOps VideoFormatInfoPackLinesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoFormatInfoPackLinesFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoFormatInfoPackLinesFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoPackLinesFieldInfo = Int32 + type AttrLabel VideoFormatInfoPackLinesFieldInfo = "pack_lines" + type AttrOrigin VideoFormatInfoPackLinesFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoPackLines + attrSet _ = setVideoFormatInfoPackLines + attrConstruct = undefined + attrClear _ = undefined + +videoFormatInfo_packLines :: AttrLabelProxy "packLines" +videoFormatInfo_packLines = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@pack_func@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #packFunc +@ +-} +getVideoFormatInfoPackFunc :: MonadIO m => VideoFormatInfo -> m (Maybe GstVideo.Callbacks.VideoFormatPack) +getVideoFormatInfoPackFunc s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 176) :: IO (FunPtr GstVideo.Callbacks.C_VideoFormatPack) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = GstVideo.Callbacks.dynamic_VideoFormatPack val' + return val'' + return result + +{- | +Set the value of the “@pack_func@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #packFunc 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoPackFunc :: MonadIO m => VideoFormatInfo -> FunPtr GstVideo.Callbacks.C_VideoFormatPack -> m () +setVideoFormatInfoPackFunc s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 176) (val :: FunPtr GstVideo.Callbacks.C_VideoFormatPack) + +{- | +Set the value of the “@pack_func@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #packFunc +@ +-} +clearVideoFormatInfoPackFunc :: MonadIO m => VideoFormatInfo -> m () +clearVideoFormatInfoPackFunc s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 176) (FP.nullFunPtr :: FunPtr GstVideo.Callbacks.C_VideoFormatPack) + +#if ENABLE_OVERLOADING +data VideoFormatInfoPackFuncFieldInfo +instance AttrInfo VideoFormatInfoPackFuncFieldInfo where + type AttrAllowedOps VideoFormatInfoPackFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoFormatInfoPackFuncFieldInfo = (~) (FunPtr GstVideo.Callbacks.C_VideoFormatPack) + type AttrBaseTypeConstraint VideoFormatInfoPackFuncFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoPackFuncFieldInfo = Maybe GstVideo.Callbacks.VideoFormatPack + type AttrLabel VideoFormatInfoPackFuncFieldInfo = "pack_func" + type AttrOrigin VideoFormatInfoPackFuncFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoPackFunc + attrSet _ = setVideoFormatInfoPackFunc + attrConstruct = undefined + attrClear _ = clearVideoFormatInfoPackFunc + +videoFormatInfo_packFunc :: AttrLabelProxy "packFunc" +videoFormatInfo_packFunc = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@tile_mode@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #tileMode +@ +-} +getVideoFormatInfoTileMode :: MonadIO m => VideoFormatInfo -> m GstVideo.Enums.VideoTileMode +getVideoFormatInfoTileMode s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 184) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@tile_mode@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #tileMode 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoTileMode :: MonadIO m => VideoFormatInfo -> GstVideo.Enums.VideoTileMode -> m () +setVideoFormatInfoTileMode s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 184) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoFormatInfoTileModeFieldInfo +instance AttrInfo VideoFormatInfoTileModeFieldInfo where + type AttrAllowedOps VideoFormatInfoTileModeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoFormatInfoTileModeFieldInfo = (~) GstVideo.Enums.VideoTileMode + type AttrBaseTypeConstraint VideoFormatInfoTileModeFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoTileModeFieldInfo = GstVideo.Enums.VideoTileMode + type AttrLabel VideoFormatInfoTileModeFieldInfo = "tile_mode" + type AttrOrigin VideoFormatInfoTileModeFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoTileMode + attrSet _ = setVideoFormatInfoTileMode + attrConstruct = undefined + attrClear _ = undefined + +videoFormatInfo_tileMode :: AttrLabelProxy "tileMode" +videoFormatInfo_tileMode = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@tile_ws@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #tileWs +@ +-} +getVideoFormatInfoTileWs :: MonadIO m => VideoFormatInfo -> m Word32 +getVideoFormatInfoTileWs s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 188) :: IO Word32 + return val + +{- | +Set the value of the “@tile_ws@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #tileWs 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoTileWs :: MonadIO m => VideoFormatInfo -> Word32 -> m () +setVideoFormatInfoTileWs s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 188) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoFormatInfoTileWsFieldInfo +instance AttrInfo VideoFormatInfoTileWsFieldInfo where + type AttrAllowedOps VideoFormatInfoTileWsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoFormatInfoTileWsFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoFormatInfoTileWsFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoTileWsFieldInfo = Word32 + type AttrLabel VideoFormatInfoTileWsFieldInfo = "tile_ws" + type AttrOrigin VideoFormatInfoTileWsFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoTileWs + attrSet _ = setVideoFormatInfoTileWs + attrConstruct = undefined + attrClear _ = undefined + +videoFormatInfo_tileWs :: AttrLabelProxy "tileWs" +videoFormatInfo_tileWs = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@tile_hs@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFormatInfo #tileHs +@ +-} +getVideoFormatInfoTileHs :: MonadIO m => VideoFormatInfo -> m Word32 +getVideoFormatInfoTileHs s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 192) :: IO Word32 + return val + +{- | +Set the value of the “@tile_hs@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFormatInfo [ #tileHs 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFormatInfoTileHs :: MonadIO m => VideoFormatInfo -> Word32 -> m () +setVideoFormatInfoTileHs s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 192) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoFormatInfoTileHsFieldInfo +instance AttrInfo VideoFormatInfoTileHsFieldInfo where + type AttrAllowedOps VideoFormatInfoTileHsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoFormatInfoTileHsFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoFormatInfoTileHsFieldInfo = (~) VideoFormatInfo + type AttrGetType VideoFormatInfoTileHsFieldInfo = Word32 + type AttrLabel VideoFormatInfoTileHsFieldInfo = "tile_hs" + type AttrOrigin VideoFormatInfoTileHsFieldInfo = VideoFormatInfo + attrGet _ = getVideoFormatInfoTileHs + attrSet _ = setVideoFormatInfoTileHs + attrConstruct = undefined + attrClear _ = undefined + +videoFormatInfo_tileHs :: AttrLabelProxy "tileHs" +videoFormatInfo_tileHs = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoFormatInfo +type instance O.AttributeList VideoFormatInfo = VideoFormatInfoAttributeList +type VideoFormatInfoAttributeList = ('[ '("format", VideoFormatInfoFormatFieldInfo), '("name", VideoFormatInfoNameFieldInfo), '("description", VideoFormatInfoDescriptionFieldInfo), '("flags", VideoFormatInfoFlagsFieldInfo), '("bits", VideoFormatInfoBitsFieldInfo), '("nComponents", VideoFormatInfoNComponentsFieldInfo), '("nPlanes", VideoFormatInfoNPlanesFieldInfo), '("unpackFormat", VideoFormatInfoUnpackFormatFieldInfo), '("unpackFunc", VideoFormatInfoUnpackFuncFieldInfo), '("packLines", VideoFormatInfoPackLinesFieldInfo), '("packFunc", VideoFormatInfoPackFuncFieldInfo), '("tileMode", VideoFormatInfoTileModeFieldInfo), '("tileWs", VideoFormatInfoTileWsFieldInfo), '("tileHs", VideoFormatInfoTileHsFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoFormatInfoMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoFormatInfoMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoFormatInfoMethod t VideoFormatInfo, O.MethodInfo info VideoFormatInfo p) => OL.IsLabel t (VideoFormatInfo -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoFormatInfo.hs-boot b/GI/GstVideo/Structs/VideoFormatInfo.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoFormatInfo.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoFormatInfo where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoFormatInfo = VideoFormatInfo (ManagedPtr VideoFormatInfo) +instance WrappedPtr VideoFormatInfo where diff --git a/GI/GstVideo/Structs/VideoFrame.hs b/GI/GstVideo/Structs/VideoFrame.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoFrame.hs @@ -0,0 +1,708 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A video frame obtained from 'GI.GstVideo.Structs.VideoFrame.videoFrameMap' +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoFrame + ( + +-- * Exported types + VideoFrame(..) , + newZeroVideoFrame , + noVideoFrame , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + VideoFrameCopyMethodInfo , +#endif + videoFrameCopy , + + +-- ** copyPlane #method:copyPlane# + +#if ENABLE_OVERLOADING + VideoFrameCopyPlaneMethodInfo , +#endif + videoFrameCopyPlane , + + +-- ** map #method:map# + +#if ENABLE_OVERLOADING + VideoFrameMapMethodInfo , +#endif + videoFrameMap , + + +-- ** mapId #method:mapId# + +#if ENABLE_OVERLOADING + VideoFrameMapIdMethodInfo , +#endif + videoFrameMapId , + + +-- ** unmap #method:unmap# + +#if ENABLE_OVERLOADING + VideoFrameUnmapMethodInfo , +#endif + videoFrameUnmap , + + + + + -- * Properties +-- ** buffer #attr:buffer# +{- | the mapped buffer +-} + clearVideoFrameBuffer , + getVideoFrameBuffer , + setVideoFrameBuffer , +#if ENABLE_OVERLOADING + videoFrame_buffer , +#endif + + +-- ** flags #attr:flags# +{- | 'GI.GstVideo.Flags.VideoFrameFlags' for the frame +-} + getVideoFrameFlags , + setVideoFrameFlags , +#if ENABLE_OVERLOADING + videoFrame_flags , +#endif + + +-- ** id #attr:id# +{- | id of the mapped frame. the id can for example be used to + indentify the frame in case of multiview video. +-} + getVideoFrameId , + setVideoFrameId , +#if ENABLE_OVERLOADING + videoFrame_id , +#endif + + +-- ** info #attr:info# +{- | the 'GI.GstVideo.Structs.VideoInfo.VideoInfo' +-} + getVideoFrameInfo , +#if ENABLE_OVERLOADING + videoFrame_info , +#endif + + +-- ** meta #attr:meta# +{- | pointer to metadata if any +-} + clearVideoFrameMeta , + getVideoFrameMeta , + setVideoFrameMeta , +#if ENABLE_OVERLOADING + videoFrame_meta , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Flags as Gst.Flags +import qualified GI.Gst.Structs.Buffer as Gst.Buffer +import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoInfo as GstVideo.VideoInfo + +-- | Memory-managed wrapper type. +newtype VideoFrame = VideoFrame (ManagedPtr VideoFrame) +instance WrappedPtr VideoFrame where + wrappedPtrCalloc = callocBytes 632 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 632 >=> wrapPtr VideoFrame) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoFrame` struct initialized to zero. +newZeroVideoFrame :: MonadIO m => m VideoFrame +newZeroVideoFrame = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoFrame + +instance tag ~ 'AttrSet => Constructible VideoFrame tag where + new _ attrs = do + o <- newZeroVideoFrame + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoFrame`. +noVideoFrame :: Maybe VideoFrame +noVideoFrame = Nothing + +{- | +Get the value of the “@info@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFrame #info +@ +-} +getVideoFrameInfo :: MonadIO m => VideoFrame -> m GstVideo.VideoInfo.VideoInfo +getVideoFrameInfo s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr GstVideo.VideoInfo.VideoInfo) + val' <- (newBoxed GstVideo.VideoInfo.VideoInfo) val + return val' + +#if ENABLE_OVERLOADING +data VideoFrameInfoFieldInfo +instance AttrInfo VideoFrameInfoFieldInfo where + type AttrAllowedOps VideoFrameInfoFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint VideoFrameInfoFieldInfo = (~) (Ptr GstVideo.VideoInfo.VideoInfo) + type AttrBaseTypeConstraint VideoFrameInfoFieldInfo = (~) VideoFrame + type AttrGetType VideoFrameInfoFieldInfo = GstVideo.VideoInfo.VideoInfo + type AttrLabel VideoFrameInfoFieldInfo = "info" + type AttrOrigin VideoFrameInfoFieldInfo = VideoFrame + attrGet _ = getVideoFrameInfo + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +videoFrame_info :: AttrLabelProxy "info" +videoFrame_info = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@flags@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFrame #flags +@ +-} +getVideoFrameFlags :: MonadIO m => VideoFrame -> m [GstVideo.Flags.VideoFrameFlags] +getVideoFrameFlags s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 120) :: IO CUInt + let val' = wordToGFlags val + return val' + +{- | +Set the value of the “@flags@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFrame [ #flags 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFrameFlags :: MonadIO m => VideoFrame -> [GstVideo.Flags.VideoFrameFlags] -> m () +setVideoFrameFlags s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = gflagsToWord val + poke (ptr `plusPtr` 120) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoFrameFlagsFieldInfo +instance AttrInfo VideoFrameFlagsFieldInfo where + type AttrAllowedOps VideoFrameFlagsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoFrameFlagsFieldInfo = (~) [GstVideo.Flags.VideoFrameFlags] + type AttrBaseTypeConstraint VideoFrameFlagsFieldInfo = (~) VideoFrame + type AttrGetType VideoFrameFlagsFieldInfo = [GstVideo.Flags.VideoFrameFlags] + type AttrLabel VideoFrameFlagsFieldInfo = "flags" + type AttrOrigin VideoFrameFlagsFieldInfo = VideoFrame + attrGet _ = getVideoFrameFlags + attrSet _ = setVideoFrameFlags + attrConstruct = undefined + attrClear _ = undefined + +videoFrame_flags :: AttrLabelProxy "flags" +videoFrame_flags = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@buffer@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFrame #buffer +@ +-} +getVideoFrameBuffer :: MonadIO m => VideoFrame -> m (Maybe Gst.Buffer.Buffer) +getVideoFrameBuffer s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 128) :: IO (Ptr Gst.Buffer.Buffer) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed Gst.Buffer.Buffer) val' + return val'' + return result + +{- | +Set the value of the “@buffer@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFrame [ #buffer 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFrameBuffer :: MonadIO m => VideoFrame -> Ptr Gst.Buffer.Buffer -> m () +setVideoFrameBuffer s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 128) (val :: Ptr Gst.Buffer.Buffer) + +{- | +Set the value of the “@buffer@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #buffer +@ +-} +clearVideoFrameBuffer :: MonadIO m => VideoFrame -> m () +clearVideoFrameBuffer s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 128) (FP.nullPtr :: Ptr Gst.Buffer.Buffer) + +#if ENABLE_OVERLOADING +data VideoFrameBufferFieldInfo +instance AttrInfo VideoFrameBufferFieldInfo where + type AttrAllowedOps VideoFrameBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoFrameBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer) + type AttrBaseTypeConstraint VideoFrameBufferFieldInfo = (~) VideoFrame + type AttrGetType VideoFrameBufferFieldInfo = Maybe Gst.Buffer.Buffer + type AttrLabel VideoFrameBufferFieldInfo = "buffer" + type AttrOrigin VideoFrameBufferFieldInfo = VideoFrame + attrGet _ = getVideoFrameBuffer + attrSet _ = setVideoFrameBuffer + attrConstruct = undefined + attrClear _ = clearVideoFrameBuffer + +videoFrame_buffer :: AttrLabelProxy "buffer" +videoFrame_buffer = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@meta@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFrame #meta +@ +-} +getVideoFrameMeta :: MonadIO m => VideoFrame -> m (Ptr ()) +getVideoFrameMeta s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 136) :: IO (Ptr ()) + return val + +{- | +Set the value of the “@meta@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFrame [ #meta 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFrameMeta :: MonadIO m => VideoFrame -> Ptr () -> m () +setVideoFrameMeta s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 136) (val :: Ptr ()) + +{- | +Set the value of the “@meta@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #meta +@ +-} +clearVideoFrameMeta :: MonadIO m => VideoFrame -> m () +clearVideoFrameMeta s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 136) (FP.nullPtr :: Ptr ()) + +#if ENABLE_OVERLOADING +data VideoFrameMetaFieldInfo +instance AttrInfo VideoFrameMetaFieldInfo where + type AttrAllowedOps VideoFrameMetaFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoFrameMetaFieldInfo = (~) (Ptr ()) + type AttrBaseTypeConstraint VideoFrameMetaFieldInfo = (~) VideoFrame + type AttrGetType VideoFrameMetaFieldInfo = Ptr () + type AttrLabel VideoFrameMetaFieldInfo = "meta" + type AttrOrigin VideoFrameMetaFieldInfo = VideoFrame + attrGet _ = getVideoFrameMeta + attrSet _ = setVideoFrameMeta + attrConstruct = undefined + attrClear _ = clearVideoFrameMeta + +videoFrame_meta :: AttrLabelProxy "meta" +videoFrame_meta = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@id@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoFrame #id +@ +-} +getVideoFrameId :: MonadIO m => VideoFrame -> m Int32 +getVideoFrameId s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 144) :: IO Int32 + return val + +{- | +Set the value of the “@id@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoFrame [ #id 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoFrameId :: MonadIO m => VideoFrame -> Int32 -> m () +setVideoFrameId s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 144) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoFrameIdFieldInfo +instance AttrInfo VideoFrameIdFieldInfo where + type AttrAllowedOps VideoFrameIdFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoFrameIdFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoFrameIdFieldInfo = (~) VideoFrame + type AttrGetType VideoFrameIdFieldInfo = Int32 + type AttrLabel VideoFrameIdFieldInfo = "id" + type AttrOrigin VideoFrameIdFieldInfo = VideoFrame + attrGet _ = getVideoFrameId + attrSet _ = setVideoFrameId + attrConstruct = undefined + attrClear _ = undefined + +videoFrame_id :: AttrLabelProxy "id" +videoFrame_id = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "VideoFrame:data" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TPtr)" +-- XXX Skipped attribute for "VideoFrame:map" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TInterface (Name {namespace = \"Gst\", name = \"MapInfo\"}))" + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoFrame +type instance O.AttributeList VideoFrame = VideoFrameAttributeList +type VideoFrameAttributeList = ('[ '("info", VideoFrameInfoFieldInfo), '("flags", VideoFrameFlagsFieldInfo), '("buffer", VideoFrameBufferFieldInfo), '("meta", VideoFrameMetaFieldInfo), '("id", VideoFrameIdFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoFrame::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dest", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_frame_copy" gst_video_frame_copy :: + Ptr VideoFrame -> -- dest : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) + Ptr VideoFrame -> -- src : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) + IO CInt + +{- | +Copy the contents from /@src@/ to /@dest@/. +-} +videoFrameCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoFrame + {- ^ /@dest@/: a 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} + -> VideoFrame + {- ^ /@src@/: a 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} + -> m Bool + {- ^ __Returns:__ TRUE if the contents could be copied. -} +videoFrameCopy dest src = liftIO $ do + dest' <- unsafeManagedPtrGetPtr dest + src' <- unsafeManagedPtrGetPtr src + result <- gst_video_frame_copy dest' src' + let result' = (/= 0) result + touchManagedPtr dest + touchManagedPtr src + return result' + +#if ENABLE_OVERLOADING +data VideoFrameCopyMethodInfo +instance (signature ~ (VideoFrame -> m Bool), MonadIO m) => O.MethodInfo VideoFrameCopyMethodInfo VideoFrame signature where + overloadedMethod _ = videoFrameCopy + +#endif + +-- method VideoFrame::copy_plane +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dest", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a plane", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_frame_copy_plane" gst_video_frame_copy_plane :: + Ptr VideoFrame -> -- dest : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) + Ptr VideoFrame -> -- src : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) + Word32 -> -- plane : TBasicType TUInt + IO CInt + +{- | +Copy the plane with index /@plane@/ from /@src@/ to /@dest@/. +-} +videoFrameCopyPlane :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoFrame + {- ^ /@dest@/: a 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} + -> VideoFrame + {- ^ /@src@/: a 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} + -> Word32 + {- ^ /@plane@/: a plane -} + -> m Bool + {- ^ __Returns:__ TRUE if the contents could be copied. -} +videoFrameCopyPlane dest src plane = liftIO $ do + dest' <- unsafeManagedPtrGetPtr dest + src' <- unsafeManagedPtrGetPtr src + result <- gst_video_frame_copy_plane dest' src' plane + let result' = (/= 0) result + touchManagedPtr dest + touchManagedPtr src + return result' + +#if ENABLE_OVERLOADING +data VideoFrameCopyPlaneMethodInfo +instance (signature ~ (VideoFrame -> Word32 -> m Bool), MonadIO m) => O.MethodInfo VideoFrameCopyPlaneMethodInfo VideoFrame signature where + overloadedMethod _ = videoFrameCopyPlane + +#endif + +-- method VideoFrame::map +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer to #GstVideoFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer to map", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "MapFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstMapFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_frame_map" gst_video_frame_map :: + Ptr VideoFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) + Ptr GstVideo.VideoInfo.VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + CUInt -> -- flags : TInterface (Name {namespace = "Gst", name = "MapFlags"}) + IO CInt + +{- | +Use /@info@/ and /@buffer@/ to fill in the values of /@frame@/. /@frame@/ is usually +allocated on the stack, and you will pass the address to the 'GI.GstVideo.Structs.VideoFrame.VideoFrame' +structure allocated on the stack; 'GI.GstVideo.Structs.VideoFrame.videoFrameMap' will then fill in +the structures with the various video-specific information you need to access +the pixels of the video buffer. You can then use accessor macros such as +@/GST_VIDEO_FRAME_COMP_DATA()/@, @/GST_VIDEO_FRAME_PLANE_DATA()/@, +@/GST_VIDEO_FRAME_COMP_STRIDE()/@, @/GST_VIDEO_FRAME_PLANE_STRIDE()/@ etc. +to get to the pixels. + + +=== /C code/ +> +> GstVideoFrame vframe; +> ... +> // set RGB pixels to black one at a time +> if (gst_video_frame_map (&vframe, video_info, video_buffer, GST_MAP_WRITE)) { +> guint8 *pixels = GST_VIDEO_FRAME_PLANE_DATA (vframe, 0); +> guint stride = GST_VIDEO_FRAME_PLANE_STRIDE (vframe, 0); +> guint pixel_stride = GST_VIDEO_FRAME_COMP_PSTRIDE (vframe, 0); +> +> for (h = 0; h < height; ++h) { +> for (w = 0; w < width; ++w) { +> guint8 *pixel = pixels + h * stride + w * pixel_stride; +> +> memset (pixel, 0, pixel_stride); +> } +> } +> +> gst_video_frame_unmap (&vframe); +> } +> ... + + +All video planes of /@buffer@/ will be mapped and the pointers will be set in +/@frame@/->data. + +The purpose of this function is to make it easy for you to get to the video +pixels in a generic way, without you having to worry too much about details +such as whether the video data is allocated in one contiguous memory chunk +or multiple memory chunks (e.g. one for each plane); or if custom strides +and custom plane offsets are used or not (as signalled by GstVideoMeta on +each buffer). This function will just fill the 'GI.GstVideo.Structs.VideoFrame.VideoFrame' structure +with the right values and if you use the accessor macros everything will +just work and you can access the data easily. It also maps the underlying +memory chunks for you. +-} +videoFrameMap :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoFrame + {- ^ /@frame@/: pointer to 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} + -> GstVideo.VideoInfo.VideoInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> Gst.Buffer.Buffer + {- ^ /@buffer@/: the buffer to map -} + -> [Gst.Flags.MapFlags] + {- ^ /@flags@/: 'GI.Gst.Flags.MapFlags' -} + -> m Bool + {- ^ __Returns:__ 'True' on success. -} +videoFrameMap frame info buffer flags = liftIO $ do + frame' <- unsafeManagedPtrGetPtr frame + info' <- unsafeManagedPtrGetPtr info + buffer' <- unsafeManagedPtrGetPtr buffer + let flags' = gflagsToWord flags + result <- gst_video_frame_map frame' info' buffer' flags' + let result' = (/= 0) result + touchManagedPtr frame + touchManagedPtr info + touchManagedPtr buffer + return result' + +#if ENABLE_OVERLOADING +data VideoFrameMapMethodInfo +instance (signature ~ (GstVideo.VideoInfo.VideoInfo -> Gst.Buffer.Buffer -> [Gst.Flags.MapFlags] -> m Bool), MonadIO m) => O.MethodInfo VideoFrameMapMethodInfo VideoFrame signature where + overloadedMethod _ = videoFrameMap + +#endif + +-- method VideoFrame::map_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer to #GstVideoFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer to map", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the frame id to map", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "MapFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstMapFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_frame_map_id" gst_video_frame_map_id :: + Ptr VideoFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) + Ptr GstVideo.VideoInfo.VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + Ptr Gst.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "Gst", name = "Buffer"}) + Int32 -> -- id : TBasicType TInt + CUInt -> -- flags : TInterface (Name {namespace = "Gst", name = "MapFlags"}) + IO CInt + +{- | +Use /@info@/ and /@buffer@/ to fill in the values of /@frame@/ with the video frame +information of frame /@id@/. + +When /@id@/ is -1, the default frame is mapped. When /@id@/ != -1, this function +will return 'False' when there is no GstVideoMeta with that id. + +All video planes of /@buffer@/ will be mapped and the pointers will be set in +/@frame@/->data. +-} +videoFrameMapId :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoFrame + {- ^ /@frame@/: pointer to 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} + -> GstVideo.VideoInfo.VideoInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> Gst.Buffer.Buffer + {- ^ /@buffer@/: the buffer to map -} + -> Int32 + {- ^ /@id@/: the frame id to map -} + -> [Gst.Flags.MapFlags] + {- ^ /@flags@/: 'GI.Gst.Flags.MapFlags' -} + -> m Bool + {- ^ __Returns:__ 'True' on success. -} +videoFrameMapId frame info buffer id flags = liftIO $ do + frame' <- unsafeManagedPtrGetPtr frame + info' <- unsafeManagedPtrGetPtr info + buffer' <- unsafeManagedPtrGetPtr buffer + let flags' = gflagsToWord flags + result <- gst_video_frame_map_id frame' info' buffer' id flags' + let result' = (/= 0) result + touchManagedPtr frame + touchManagedPtr info + touchManagedPtr buffer + return result' + +#if ENABLE_OVERLOADING +data VideoFrameMapIdMethodInfo +instance (signature ~ (GstVideo.VideoInfo.VideoInfo -> Gst.Buffer.Buffer -> Int32 -> [Gst.Flags.MapFlags] -> m Bool), MonadIO m) => O.MethodInfo VideoFrameMapIdMethodInfo VideoFrame signature where + overloadedMethod _ = videoFrameMapId + +#endif + +-- method VideoFrame::unmap +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "frame", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFrame", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_frame_unmap" gst_video_frame_unmap :: + Ptr VideoFrame -> -- frame : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) + IO () + +{- | +Unmap the memory previously mapped with gst_video_frame_map. +-} +videoFrameUnmap :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoFrame + {- ^ /@frame@/: a 'GI.GstVideo.Structs.VideoFrame.VideoFrame' -} + -> m () +videoFrameUnmap frame = liftIO $ do + frame' <- unsafeManagedPtrGetPtr frame + gst_video_frame_unmap frame' + touchManagedPtr frame + return () + +#if ENABLE_OVERLOADING +data VideoFrameUnmapMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoFrameUnmapMethodInfo VideoFrame signature where + overloadedMethod _ = videoFrameUnmap + +#endif + +#if ENABLE_OVERLOADING +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 = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoFrameMethod t VideoFrame, O.MethodInfo info VideoFrame p) => OL.IsLabel t (VideoFrame -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoFrame.hs-boot b/GI/GstVideo/Structs/VideoFrame.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoFrame.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoFrame where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoFrame = VideoFrame (ManagedPtr VideoFrame) +instance WrappedPtr VideoFrame where +#if ENABLE_OVERLOADING +data VideoFrameCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoFrameCopyPlaneMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoFrameMapMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoFrameMapIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoFrameUnmapMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoGLTextureUploadMeta.hs b/GI/GstVideo/Structs/VideoGLTextureUploadMeta.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoGLTextureUploadMeta.hs @@ -0,0 +1,334 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Extra buffer metadata for uploading a buffer to an OpenGL texture +ID. The caller of 'GI.GstVideo.Structs.VideoGLTextureUploadMeta.videoGLTextureUploadMetaUpload' must +have OpenGL set up and call this from a thread where it is valid +to upload something to an OpenGL texture. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoGLTextureUploadMeta + ( + +-- * Exported types + VideoGLTextureUploadMeta(..) , + newZeroVideoGLTextureUploadMeta , + noVideoGLTextureUploadMeta , + + + -- * Methods +-- ** getInfo #method:getInfo# + + videoGLTextureUploadMetaGetInfo , + + +-- ** upload #method:upload# + +#if ENABLE_OVERLOADING + VideoGLTextureUploadMetaUploadMethodInfo, +#endif + videoGLTextureUploadMetaUpload , + + + + + -- * Properties +-- ** meta #attr:meta# +{- | parent 'GI.Gst.Structs.Meta.Meta' +-} + getVideoGLTextureUploadMetaMeta , +#if ENABLE_OVERLOADING + videoGLTextureUploadMeta_meta , +#endif + + +-- ** nTextures #attr:nTextures# +{- | Number of textures that are generated +-} + getVideoGLTextureUploadMetaNTextures , + setVideoGLTextureUploadMetaNTextures , +#if ENABLE_OVERLOADING + videoGLTextureUploadMeta_nTextures , +#endif + + +-- ** textureOrientation #attr:textureOrientation# +{- | Orientation of the textures +-} + getVideoGLTextureUploadMetaTextureOrientation, + setVideoGLTextureUploadMetaTextureOrientation, +#if ENABLE_OVERLOADING + videoGLTextureUploadMeta_textureOrientation, +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Structs.Meta as Gst.Meta +import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums + +-- | Memory-managed wrapper type. +newtype VideoGLTextureUploadMeta = VideoGLTextureUploadMeta (ManagedPtr VideoGLTextureUploadMeta) +instance WrappedPtr VideoGLTextureUploadMeta where + wrappedPtrCalloc = callocBytes 80 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 80 >=> wrapPtr VideoGLTextureUploadMeta) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoGLTextureUploadMeta` struct initialized to zero. +newZeroVideoGLTextureUploadMeta :: MonadIO m => m VideoGLTextureUploadMeta +newZeroVideoGLTextureUploadMeta = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoGLTextureUploadMeta + +instance tag ~ 'AttrSet => Constructible VideoGLTextureUploadMeta tag where + new _ attrs = do + o <- newZeroVideoGLTextureUploadMeta + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoGLTextureUploadMeta`. +noVideoGLTextureUploadMeta :: Maybe VideoGLTextureUploadMeta +noVideoGLTextureUploadMeta = Nothing + +{- | +Get the value of the “@meta@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoGLTextureUploadMeta #meta +@ +-} +getVideoGLTextureUploadMetaMeta :: MonadIO m => VideoGLTextureUploadMeta -> m Gst.Meta.Meta +getVideoGLTextureUploadMetaMeta s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Gst.Meta.Meta) + val' <- (newPtr Gst.Meta.Meta) val + return val' + +#if ENABLE_OVERLOADING +data VideoGLTextureUploadMetaMetaFieldInfo +instance AttrInfo VideoGLTextureUploadMetaMetaFieldInfo where + type AttrAllowedOps VideoGLTextureUploadMetaMetaFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint VideoGLTextureUploadMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta) + type AttrBaseTypeConstraint VideoGLTextureUploadMetaMetaFieldInfo = (~) VideoGLTextureUploadMeta + type AttrGetType VideoGLTextureUploadMetaMetaFieldInfo = Gst.Meta.Meta + type AttrLabel VideoGLTextureUploadMetaMetaFieldInfo = "meta" + type AttrOrigin VideoGLTextureUploadMetaMetaFieldInfo = VideoGLTextureUploadMeta + attrGet _ = getVideoGLTextureUploadMetaMeta + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +videoGLTextureUploadMeta_meta :: AttrLabelProxy "meta" +videoGLTextureUploadMeta_meta = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@texture_orientation@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoGLTextureUploadMeta #textureOrientation +@ +-} +getVideoGLTextureUploadMetaTextureOrientation :: MonadIO m => VideoGLTextureUploadMeta -> m GstVideo.Enums.VideoGLTextureOrientation +getVideoGLTextureUploadMetaTextureOrientation s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@texture_orientation@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoGLTextureUploadMeta [ #textureOrientation 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoGLTextureUploadMetaTextureOrientation :: MonadIO m => VideoGLTextureUploadMeta -> GstVideo.Enums.VideoGLTextureOrientation -> m () +setVideoGLTextureUploadMetaTextureOrientation s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 16) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoGLTextureUploadMetaTextureOrientationFieldInfo +instance AttrInfo VideoGLTextureUploadMetaTextureOrientationFieldInfo where + type AttrAllowedOps VideoGLTextureUploadMetaTextureOrientationFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoGLTextureUploadMetaTextureOrientationFieldInfo = (~) GstVideo.Enums.VideoGLTextureOrientation + type AttrBaseTypeConstraint VideoGLTextureUploadMetaTextureOrientationFieldInfo = (~) VideoGLTextureUploadMeta + type AttrGetType VideoGLTextureUploadMetaTextureOrientationFieldInfo = GstVideo.Enums.VideoGLTextureOrientation + type AttrLabel VideoGLTextureUploadMetaTextureOrientationFieldInfo = "texture_orientation" + type AttrOrigin VideoGLTextureUploadMetaTextureOrientationFieldInfo = VideoGLTextureUploadMeta + attrGet _ = getVideoGLTextureUploadMetaTextureOrientation + attrSet _ = setVideoGLTextureUploadMetaTextureOrientation + attrConstruct = undefined + attrClear _ = undefined + +videoGLTextureUploadMeta_textureOrientation :: AttrLabelProxy "textureOrientation" +videoGLTextureUploadMeta_textureOrientation = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@n_textures@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoGLTextureUploadMeta #nTextures +@ +-} +getVideoGLTextureUploadMetaNTextures :: MonadIO m => VideoGLTextureUploadMeta -> m Word32 +getVideoGLTextureUploadMetaNTextures s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 20) :: IO Word32 + return val + +{- | +Set the value of the “@n_textures@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoGLTextureUploadMeta [ #nTextures 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoGLTextureUploadMetaNTextures :: MonadIO m => VideoGLTextureUploadMeta -> Word32 -> m () +setVideoGLTextureUploadMetaNTextures s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 20) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoGLTextureUploadMetaNTexturesFieldInfo +instance AttrInfo VideoGLTextureUploadMetaNTexturesFieldInfo where + type AttrAllowedOps VideoGLTextureUploadMetaNTexturesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoGLTextureUploadMetaNTexturesFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoGLTextureUploadMetaNTexturesFieldInfo = (~) VideoGLTextureUploadMeta + type AttrGetType VideoGLTextureUploadMetaNTexturesFieldInfo = Word32 + type AttrLabel VideoGLTextureUploadMetaNTexturesFieldInfo = "n_textures" + type AttrOrigin VideoGLTextureUploadMetaNTexturesFieldInfo = VideoGLTextureUploadMeta + attrGet _ = getVideoGLTextureUploadMetaNTextures + attrSet _ = setVideoGLTextureUploadMetaNTextures + attrConstruct = undefined + attrClear _ = undefined + +videoGLTextureUploadMeta_nTextures :: AttrLabelProxy "nTextures" +videoGLTextureUploadMeta_nTextures = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "VideoGLTextureUploadMeta:texture_type" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TInterface (Name {namespace = \"GstVideo\", name = \"VideoGLTextureType\"}))" + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoGLTextureUploadMeta +type instance O.AttributeList VideoGLTextureUploadMeta = VideoGLTextureUploadMetaAttributeList +type VideoGLTextureUploadMetaAttributeList = ('[ '("meta", VideoGLTextureUploadMetaMetaFieldInfo), '("textureOrientation", VideoGLTextureUploadMetaTextureOrientationFieldInfo), '("nTextures", VideoGLTextureUploadMetaNTexturesFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoGLTextureUploadMeta::upload +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureUploadMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoGLTextureUploadMeta", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "texture_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the texture IDs to upload to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_gl_texture_upload_meta_upload" gst_video_gl_texture_upload_meta_upload :: + Ptr VideoGLTextureUploadMeta -> -- meta : TInterface (Name {namespace = "GstVideo", name = "VideoGLTextureUploadMeta"}) + Word32 -> -- texture_id : TBasicType TUInt + IO CInt + +{- | +Uploads the buffer which owns the meta to a specific texture ID. +-} +videoGLTextureUploadMetaUpload :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoGLTextureUploadMeta + {- ^ /@meta@/: a 'GI.GstVideo.Structs.VideoGLTextureUploadMeta.VideoGLTextureUploadMeta' -} + -> Word32 + {- ^ /@textureId@/: the texture IDs to upload to -} + -> m Bool + {- ^ __Returns:__ 'True' if uploading succeeded, 'False' otherwise. -} +videoGLTextureUploadMetaUpload meta textureId = liftIO $ do + meta' <- unsafeManagedPtrGetPtr meta + result <- gst_video_gl_texture_upload_meta_upload meta' textureId + let result' = (/= 0) result + touchManagedPtr meta + return result' + +#if ENABLE_OVERLOADING +data VideoGLTextureUploadMetaUploadMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m) => O.MethodInfo VideoGLTextureUploadMetaUploadMethodInfo VideoGLTextureUploadMeta signature where + overloadedMethod _ = videoGLTextureUploadMetaUpload + +#endif + +-- method VideoGLTextureUploadMeta::get_info +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "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.MetaInfo) + +{- | +/No description available in the introspection data./ +-} +videoGLTextureUploadMetaGetInfo :: + (B.CallStack.HasCallStack, MonadIO m) => + m Gst.MetaInfo.MetaInfo +videoGLTextureUploadMetaGetInfo = liftIO $ do + result <- gst_video_gl_texture_upload_meta_get_info + checkUnexpectedReturnNULL "videoGLTextureUploadMetaGetInfo" result + result' <- (newPtr Gst.MetaInfo.MetaInfo) result + return result' + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoGLTextureUploadMetaMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoGLTextureUploadMetaMethod "upload" o = VideoGLTextureUploadMetaUploadMethodInfo + ResolveVideoGLTextureUploadMetaMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoGLTextureUploadMetaMethod t VideoGLTextureUploadMeta, O.MethodInfo info VideoGLTextureUploadMeta p) => OL.IsLabel t (VideoGLTextureUploadMeta -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoGLTextureUploadMeta.hs-boot b/GI/GstVideo/Structs/VideoGLTextureUploadMeta.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoGLTextureUploadMeta.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoGLTextureUploadMeta where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoGLTextureUploadMeta = VideoGLTextureUploadMeta (ManagedPtr VideoGLTextureUploadMeta) +instance WrappedPtr VideoGLTextureUploadMeta where +#if ENABLE_OVERLOADING +data VideoGLTextureUploadMetaUploadMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoInfo.hs b/GI/GstVideo/Structs/VideoInfo.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoInfo.hs @@ -0,0 +1,1383 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Information describing image properties. This information can be filled +in from GstCaps with 'GI.GstVideo.Structs.VideoInfo.videoInfoFromCaps'. The information is also used +to store the specific video info when mapping a video frame with +'GI.GstVideo.Structs.VideoFrame.videoFrameMap'. + +Use the provided macros to access the info in this structure. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoInfo + ( + +-- * Exported types + VideoInfo(..) , + newZeroVideoInfo , + noVideoInfo , + + + -- * Methods +-- ** align #method:align# + +#if ENABLE_OVERLOADING + VideoInfoAlignMethodInfo , +#endif + videoInfoAlign , + + +-- ** convert #method:convert# + +#if ENABLE_OVERLOADING + VideoInfoConvertMethodInfo , +#endif + videoInfoConvert , + + +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + VideoInfoCopyMethodInfo , +#endif + videoInfoCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + VideoInfoFreeMethodInfo , +#endif + videoInfoFree , + + +-- ** fromCaps #method:fromCaps# + +#if ENABLE_OVERLOADING + VideoInfoFromCapsMethodInfo , +#endif + videoInfoFromCaps , + + +-- ** init #method:init# + +#if ENABLE_OVERLOADING + VideoInfoInitMethodInfo , +#endif + videoInfoInit , + + +-- ** isEqual #method:isEqual# + +#if ENABLE_OVERLOADING + VideoInfoIsEqualMethodInfo , +#endif + videoInfoIsEqual , + + +-- ** new #method:new# + + videoInfoNew , + + +-- ** setFormat #method:setFormat# + +#if ENABLE_OVERLOADING + VideoInfoSetFormatMethodInfo , +#endif + videoInfoSetFormat , + + +-- ** setInterlacedFormat #method:setInterlacedFormat# + +#if ENABLE_OVERLOADING + VideoInfoSetInterlacedFormatMethodInfo , +#endif + videoInfoSetInterlacedFormat , + + +-- ** toCaps #method:toCaps# + +#if ENABLE_OVERLOADING + VideoInfoToCapsMethodInfo , +#endif + videoInfoToCaps , + + + + + -- * Properties +-- ** chromaSite #attr:chromaSite# +{- | a 'GI.GstVideo.Flags.VideoChromaSite'. +-} + getVideoInfoChromaSite , + setVideoInfoChromaSite , +#if ENABLE_OVERLOADING + videoInfo_chromaSite , +#endif + + +-- ** colorimetry #attr:colorimetry# +{- | the colorimetry info +-} + getVideoInfoColorimetry , +#if ENABLE_OVERLOADING + videoInfo_colorimetry , +#endif + + +-- ** finfo #attr:finfo# +{- | the format info of the video +-} + clearVideoInfoFinfo , + getVideoInfoFinfo , + setVideoInfoFinfo , +#if ENABLE_OVERLOADING + videoInfo_finfo , +#endif + + +-- ** flags #attr:flags# +{- | additional video flags +-} + getVideoInfoFlags , + setVideoInfoFlags , +#if ENABLE_OVERLOADING + videoInfo_flags , +#endif + + +-- ** fpsD #attr:fpsD# +{- | the framerate demnominator +-} + getVideoInfoFpsD , + setVideoInfoFpsD , +#if ENABLE_OVERLOADING + videoInfo_fpsD , +#endif + + +-- ** fpsN #attr:fpsN# +{- | the framerate numerator +-} + getVideoInfoFpsN , + setVideoInfoFpsN , +#if ENABLE_OVERLOADING + videoInfo_fpsN , +#endif + + +-- ** height #attr:height# +{- | the height of the video +-} + getVideoInfoHeight , + setVideoInfoHeight , +#if ENABLE_OVERLOADING + videoInfo_height , +#endif + + +-- ** interlaceMode #attr:interlaceMode# +{- | the interlace mode +-} + getVideoInfoInterlaceMode , + setVideoInfoInterlaceMode , +#if ENABLE_OVERLOADING + videoInfo_interlaceMode , +#endif + + +-- ** parD #attr:parD# +{- | the pixel-aspect-ratio demnominator +-} + getVideoInfoParD , + setVideoInfoParD , +#if ENABLE_OVERLOADING + videoInfo_parD , +#endif + + +-- ** parN #attr:parN# +{- | the pixel-aspect-ratio numerator +-} + getVideoInfoParN , + setVideoInfoParN , +#if ENABLE_OVERLOADING + videoInfo_parN , +#endif + + +-- ** size #attr:size# +{- | the default size of one frame +-} + getVideoInfoSize , + setVideoInfoSize , +#if ENABLE_OVERLOADING + videoInfo_size , +#endif + + +-- ** views #attr:views# +{- | the number of views for multiview video +-} + getVideoInfoViews , + setVideoInfoViews , +#if ENABLE_OVERLOADING + videoInfo_views , +#endif + + +-- ** width #attr:width# +{- | the width of the video +-} + getVideoInfoWidth , + setVideoInfoWidth , +#if ENABLE_OVERLOADING + videoInfo_width , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Enums as Gst.Enums +import qualified GI.Gst.Structs.Caps as Gst.Caps +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums +import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoAlignment as GstVideo.VideoAlignment +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoColorimetry as GstVideo.VideoColorimetry +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoFormatInfo as GstVideo.VideoFormatInfo + +-- | Memory-managed wrapper type. +newtype VideoInfo = VideoInfo (ManagedPtr 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 + +instance tag ~ 'AttrSet => Constructible VideoInfo tag where + new _ attrs = do + o <- newZeroVideoInfo + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoInfo`. +noVideoInfo :: Maybe VideoInfo +noVideoInfo = Nothing + +{- | +Get the value of the “@finfo@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoInfo #finfo +@ +-} +getVideoInfoFinfo :: MonadIO m => VideoInfo -> m (Maybe GstVideo.VideoFormatInfo.VideoFormatInfo) +getVideoInfoFinfo s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO (Ptr GstVideo.VideoFormatInfo.VideoFormatInfo) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newPtr GstVideo.VideoFormatInfo.VideoFormatInfo) val' + return val'' + return result + +{- | +Set the value of the “@finfo@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoInfo [ #finfo 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoInfoFinfo :: MonadIO m => VideoInfo -> Ptr GstVideo.VideoFormatInfo.VideoFormatInfo -> m () +setVideoInfoFinfo s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Ptr GstVideo.VideoFormatInfo.VideoFormatInfo) + +{- | +Set the value of the “@finfo@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #finfo +@ +-} +clearVideoInfoFinfo :: MonadIO m => VideoInfo -> m () +clearVideoInfoFinfo s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr GstVideo.VideoFormatInfo.VideoFormatInfo) + +#if ENABLE_OVERLOADING +data VideoInfoFinfoFieldInfo +instance AttrInfo VideoInfoFinfoFieldInfo where + type AttrAllowedOps VideoInfoFinfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoInfoFinfoFieldInfo = (~) (Ptr GstVideo.VideoFormatInfo.VideoFormatInfo) + type AttrBaseTypeConstraint VideoInfoFinfoFieldInfo = (~) VideoInfo + type AttrGetType VideoInfoFinfoFieldInfo = Maybe GstVideo.VideoFormatInfo.VideoFormatInfo + type AttrLabel VideoInfoFinfoFieldInfo = "finfo" + type AttrOrigin VideoInfoFinfoFieldInfo = VideoInfo + attrGet _ = getVideoInfoFinfo + attrSet _ = setVideoInfoFinfo + attrConstruct = undefined + attrClear _ = clearVideoInfoFinfo + +videoInfo_finfo :: AttrLabelProxy "finfo" +videoInfo_finfo = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@interlace_mode@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoInfo #interlaceMode +@ +-} +getVideoInfoInterlaceMode :: MonadIO m => VideoInfo -> m GstVideo.Enums.VideoInterlaceMode +getVideoInfoInterlaceMode s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@interlace_mode@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoInfo [ #interlaceMode 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoInfoInterlaceMode :: MonadIO m => VideoInfo -> GstVideo.Enums.VideoInterlaceMode -> m () +setVideoInfoInterlaceMode s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 8) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoInfoInterlaceModeFieldInfo +instance AttrInfo VideoInfoInterlaceModeFieldInfo where + type AttrAllowedOps VideoInfoInterlaceModeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoInfoInterlaceModeFieldInfo = (~) GstVideo.Enums.VideoInterlaceMode + type AttrBaseTypeConstraint VideoInfoInterlaceModeFieldInfo = (~) VideoInfo + type AttrGetType VideoInfoInterlaceModeFieldInfo = GstVideo.Enums.VideoInterlaceMode + type AttrLabel VideoInfoInterlaceModeFieldInfo = "interlace_mode" + type AttrOrigin VideoInfoInterlaceModeFieldInfo = VideoInfo + attrGet _ = getVideoInfoInterlaceMode + attrSet _ = setVideoInfoInterlaceMode + attrConstruct = undefined + attrClear _ = undefined + +videoInfo_interlaceMode :: AttrLabelProxy "interlaceMode" +videoInfo_interlaceMode = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@flags@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoInfo #flags +@ +-} +getVideoInfoFlags :: MonadIO m => VideoInfo -> m [GstVideo.Flags.VideoFlags] +getVideoInfoFlags s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 12) :: IO CUInt + let val' = wordToGFlags val + return val' + +{- | +Set the value of the “@flags@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoInfo [ #flags 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoInfoFlags :: MonadIO m => VideoInfo -> [GstVideo.Flags.VideoFlags] -> m () +setVideoInfoFlags s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = gflagsToWord val + poke (ptr `plusPtr` 12) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoInfoFlagsFieldInfo +instance AttrInfo VideoInfoFlagsFieldInfo where + type AttrAllowedOps VideoInfoFlagsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoInfoFlagsFieldInfo = (~) [GstVideo.Flags.VideoFlags] + type AttrBaseTypeConstraint VideoInfoFlagsFieldInfo = (~) VideoInfo + type AttrGetType VideoInfoFlagsFieldInfo = [GstVideo.Flags.VideoFlags] + type AttrLabel VideoInfoFlagsFieldInfo = "flags" + type AttrOrigin VideoInfoFlagsFieldInfo = VideoInfo + attrGet _ = getVideoInfoFlags + attrSet _ = setVideoInfoFlags + attrConstruct = undefined + attrClear _ = undefined + +videoInfo_flags :: AttrLabelProxy "flags" +videoInfo_flags = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@width@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoInfo #width +@ +-} +getVideoInfoWidth :: MonadIO m => VideoInfo -> m Int32 +getVideoInfoWidth s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO Int32 + return val + +{- | +Set the value of the “@width@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoInfo [ #width 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoInfoWidth :: MonadIO m => VideoInfo -> Int32 -> m () +setVideoInfoWidth s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoInfoWidthFieldInfo +instance AttrInfo VideoInfoWidthFieldInfo where + type AttrAllowedOps VideoInfoWidthFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoInfoWidthFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoInfoWidthFieldInfo = (~) VideoInfo + type AttrGetType VideoInfoWidthFieldInfo = Int32 + type AttrLabel VideoInfoWidthFieldInfo = "width" + type AttrOrigin VideoInfoWidthFieldInfo = VideoInfo + attrGet _ = getVideoInfoWidth + attrSet _ = setVideoInfoWidth + attrConstruct = undefined + attrClear _ = undefined + +videoInfo_width :: AttrLabelProxy "width" +videoInfo_width = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@height@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoInfo #height +@ +-} +getVideoInfoHeight :: MonadIO m => VideoInfo -> m Int32 +getVideoInfoHeight s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 20) :: IO Int32 + return val + +{- | +Set the value of the “@height@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoInfo [ #height 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoInfoHeight :: MonadIO m => VideoInfo -> Int32 -> m () +setVideoInfoHeight s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 20) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoInfoHeightFieldInfo +instance AttrInfo VideoInfoHeightFieldInfo where + type AttrAllowedOps VideoInfoHeightFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoInfoHeightFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoInfoHeightFieldInfo = (~) VideoInfo + type AttrGetType VideoInfoHeightFieldInfo = Int32 + type AttrLabel VideoInfoHeightFieldInfo = "height" + type AttrOrigin VideoInfoHeightFieldInfo = VideoInfo + attrGet _ = getVideoInfoHeight + attrSet _ = setVideoInfoHeight + attrConstruct = undefined + attrClear _ = undefined + +videoInfo_height :: AttrLabelProxy "height" +videoInfo_height = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@size@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoInfo #size +@ +-} +getVideoInfoSize :: MonadIO m => VideoInfo -> m Word64 +getVideoInfoSize s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO Word64 + return val + +{- | +Set the value of the “@size@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoInfo [ #size 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoInfoSize :: MonadIO m => VideoInfo -> Word64 -> m () +setVideoInfoSize s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: Word64) + +#if ENABLE_OVERLOADING +data VideoInfoSizeFieldInfo +instance AttrInfo VideoInfoSizeFieldInfo where + type AttrAllowedOps VideoInfoSizeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoInfoSizeFieldInfo = (~) Word64 + type AttrBaseTypeConstraint VideoInfoSizeFieldInfo = (~) VideoInfo + type AttrGetType VideoInfoSizeFieldInfo = Word64 + type AttrLabel VideoInfoSizeFieldInfo = "size" + type AttrOrigin VideoInfoSizeFieldInfo = VideoInfo + attrGet _ = getVideoInfoSize + attrSet _ = setVideoInfoSize + attrConstruct = undefined + attrClear _ = undefined + +videoInfo_size :: AttrLabelProxy "size" +videoInfo_size = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@views@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoInfo #views +@ +-} +getVideoInfoViews :: MonadIO m => VideoInfo -> m Int32 +getVideoInfoViews s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Int32 + return val + +{- | +Set the value of the “@views@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoInfo [ #views 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoInfoViews :: MonadIO m => VideoInfo -> Int32 -> m () +setVideoInfoViews s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoInfoViewsFieldInfo +instance AttrInfo VideoInfoViewsFieldInfo where + type AttrAllowedOps VideoInfoViewsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoInfoViewsFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoInfoViewsFieldInfo = (~) VideoInfo + type AttrGetType VideoInfoViewsFieldInfo = Int32 + type AttrLabel VideoInfoViewsFieldInfo = "views" + type AttrOrigin VideoInfoViewsFieldInfo = VideoInfo + attrGet _ = getVideoInfoViews + attrSet _ = setVideoInfoViews + attrConstruct = undefined + attrClear _ = undefined + +videoInfo_views :: AttrLabelProxy "views" +videoInfo_views = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@chroma_site@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoInfo #chromaSite +@ +-} +getVideoInfoChromaSite :: MonadIO m => VideoInfo -> m [GstVideo.Flags.VideoChromaSite] +getVideoInfoChromaSite s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 36) :: IO CUInt + let val' = wordToGFlags val + return val' + +{- | +Set the value of the “@chroma_site@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoInfo [ #chromaSite 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoInfoChromaSite :: MonadIO m => VideoInfo -> [GstVideo.Flags.VideoChromaSite] -> m () +setVideoInfoChromaSite s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = gflagsToWord val + poke (ptr `plusPtr` 36) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoInfoChromaSiteFieldInfo +instance AttrInfo VideoInfoChromaSiteFieldInfo where + type AttrAllowedOps VideoInfoChromaSiteFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoInfoChromaSiteFieldInfo = (~) [GstVideo.Flags.VideoChromaSite] + type AttrBaseTypeConstraint VideoInfoChromaSiteFieldInfo = (~) VideoInfo + type AttrGetType VideoInfoChromaSiteFieldInfo = [GstVideo.Flags.VideoChromaSite] + type AttrLabel VideoInfoChromaSiteFieldInfo = "chroma_site" + type AttrOrigin VideoInfoChromaSiteFieldInfo = VideoInfo + attrGet _ = getVideoInfoChromaSite + attrSet _ = setVideoInfoChromaSite + attrConstruct = undefined + attrClear _ = undefined + +videoInfo_chromaSite :: AttrLabelProxy "chromaSite" +videoInfo_chromaSite = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@colorimetry@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoInfo #colorimetry +@ +-} +getVideoInfoColorimetry :: MonadIO m => VideoInfo -> m GstVideo.VideoColorimetry.VideoColorimetry +getVideoInfoColorimetry s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 40 :: (Ptr GstVideo.VideoColorimetry.VideoColorimetry) + val' <- (newPtr GstVideo.VideoColorimetry.VideoColorimetry) val + return val' + +#if ENABLE_OVERLOADING +data VideoInfoColorimetryFieldInfo +instance AttrInfo VideoInfoColorimetryFieldInfo where + type AttrAllowedOps VideoInfoColorimetryFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint VideoInfoColorimetryFieldInfo = (~) (Ptr GstVideo.VideoColorimetry.VideoColorimetry) + type AttrBaseTypeConstraint VideoInfoColorimetryFieldInfo = (~) VideoInfo + type AttrGetType VideoInfoColorimetryFieldInfo = GstVideo.VideoColorimetry.VideoColorimetry + type AttrLabel VideoInfoColorimetryFieldInfo = "colorimetry" + type AttrOrigin VideoInfoColorimetryFieldInfo = VideoInfo + attrGet _ = getVideoInfoColorimetry + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +videoInfo_colorimetry :: AttrLabelProxy "colorimetry" +videoInfo_colorimetry = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@par_n@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoInfo #parN +@ +-} +getVideoInfoParN :: MonadIO m => VideoInfo -> m Int32 +getVideoInfoParN s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 56) :: IO Int32 + return val + +{- | +Set the value of the “@par_n@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoInfo [ #parN 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoInfoParN :: MonadIO m => VideoInfo -> Int32 -> m () +setVideoInfoParN s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 56) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoInfoParNFieldInfo +instance AttrInfo VideoInfoParNFieldInfo where + type AttrAllowedOps VideoInfoParNFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoInfoParNFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoInfoParNFieldInfo = (~) VideoInfo + type AttrGetType VideoInfoParNFieldInfo = Int32 + type AttrLabel VideoInfoParNFieldInfo = "par_n" + type AttrOrigin VideoInfoParNFieldInfo = VideoInfo + attrGet _ = getVideoInfoParN + attrSet _ = setVideoInfoParN + attrConstruct = undefined + attrClear _ = undefined + +videoInfo_parN :: AttrLabelProxy "parN" +videoInfo_parN = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@par_d@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoInfo #parD +@ +-} +getVideoInfoParD :: MonadIO m => VideoInfo -> m Int32 +getVideoInfoParD s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 60) :: IO Int32 + return val + +{- | +Set the value of the “@par_d@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoInfo [ #parD 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoInfoParD :: MonadIO m => VideoInfo -> Int32 -> m () +setVideoInfoParD s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 60) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoInfoParDFieldInfo +instance AttrInfo VideoInfoParDFieldInfo where + type AttrAllowedOps VideoInfoParDFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoInfoParDFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoInfoParDFieldInfo = (~) VideoInfo + type AttrGetType VideoInfoParDFieldInfo = Int32 + type AttrLabel VideoInfoParDFieldInfo = "par_d" + type AttrOrigin VideoInfoParDFieldInfo = VideoInfo + attrGet _ = getVideoInfoParD + attrSet _ = setVideoInfoParD + attrConstruct = undefined + attrClear _ = undefined + +videoInfo_parD :: AttrLabelProxy "parD" +videoInfo_parD = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@fps_n@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoInfo #fpsN +@ +-} +getVideoInfoFpsN :: MonadIO m => VideoInfo -> m Int32 +getVideoInfoFpsN s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 64) :: IO Int32 + return val + +{- | +Set the value of the “@fps_n@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoInfo [ #fpsN 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoInfoFpsN :: MonadIO m => VideoInfo -> Int32 -> m () +setVideoInfoFpsN s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 64) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoInfoFpsNFieldInfo +instance AttrInfo VideoInfoFpsNFieldInfo where + type AttrAllowedOps VideoInfoFpsNFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoInfoFpsNFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoInfoFpsNFieldInfo = (~) VideoInfo + type AttrGetType VideoInfoFpsNFieldInfo = Int32 + type AttrLabel VideoInfoFpsNFieldInfo = "fps_n" + type AttrOrigin VideoInfoFpsNFieldInfo = VideoInfo + attrGet _ = getVideoInfoFpsN + attrSet _ = setVideoInfoFpsN + attrConstruct = undefined + attrClear _ = undefined + +videoInfo_fpsN :: AttrLabelProxy "fpsN" +videoInfo_fpsN = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@fps_d@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoInfo #fpsD +@ +-} +getVideoInfoFpsD :: MonadIO m => VideoInfo -> m Int32 +getVideoInfoFpsD s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 68) :: IO Int32 + return val + +{- | +Set the value of the “@fps_d@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoInfo [ #fpsD 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoInfoFpsD :: MonadIO m => VideoInfo -> Int32 -> m () +setVideoInfoFpsD s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 68) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoInfoFpsDFieldInfo +instance AttrInfo VideoInfoFpsDFieldInfo where + type AttrAllowedOps VideoInfoFpsDFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoInfoFpsDFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoInfoFpsDFieldInfo = (~) VideoInfo + type AttrGetType VideoInfoFpsDFieldInfo = Int32 + type AttrLabel VideoInfoFpsDFieldInfo = "fps_d" + type AttrOrigin VideoInfoFpsDFieldInfo = VideoInfo + attrGet _ = getVideoInfoFpsD + attrSet _ = setVideoInfoFpsD + attrConstruct = undefined + attrClear _ = undefined + +videoInfo_fpsD :: AttrLabelProxy "fpsD" +videoInfo_fpsD = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "VideoInfo:offset" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt64)" +-- XXX Skipped attribute for "VideoInfo:stride" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TInt)" + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoInfo +type instance O.AttributeList VideoInfo = VideoInfoAttributeList +type VideoInfoAttributeList = ('[ '("finfo", VideoInfoFinfoFieldInfo), '("interlaceMode", VideoInfoInterlaceModeFieldInfo), '("flags", VideoInfoFlagsFieldInfo), '("width", VideoInfoWidthFieldInfo), '("height", VideoInfoHeightFieldInfo), '("size", VideoInfoSizeFieldInfo), '("views", VideoInfoViewsFieldInfo), '("chromaSite", VideoInfoChromaSiteFieldInfo), '("colorimetry", VideoInfoColorimetryFieldInfo), '("parN", VideoInfoParNFieldInfo), '("parD", VideoInfoParDFieldInfo), '("fpsN", VideoInfoFpsNFieldInfo), '("fpsD", VideoInfoFpsDFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoInfo::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_info_new" gst_video_info_new :: + IO (Ptr VideoInfo) + +{- | +Allocate a new 'GI.GstVideo.Structs.VideoInfo.VideoInfo' that is also initialized with +'GI.GstVideo.Structs.VideoInfo.videoInfoInit'. + +/Since: 1.6/ +-} +videoInfoNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m VideoInfo + {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoInfo.VideoInfo'. free with 'GI.GstVideo.Structs.VideoInfo.videoInfoFree'. -} +videoInfoNew = liftIO $ do + result <- gst_video_info_new + checkUnexpectedReturnNULL "videoInfoNew" result + result' <- (wrapBoxed VideoInfo) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method VideoInfo::align +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "alignment parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_info_align" gst_video_info_align :: + Ptr VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + Ptr GstVideo.VideoAlignment.VideoAlignment -> -- align : TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"}) + IO CInt + +{- | +Adjust the offset and stride fields in /@info@/ so that the padding and +stride alignment in /@align@/ is respected. + +Extra padding will be added to the right side when stride alignment padding +is required and /@align@/ will be updated with the new padding values. +-} +videoInfoAlign :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> GstVideo.VideoAlignment.VideoAlignment + {- ^ /@align@/: alignment parameters -} + -> m Bool + {- ^ __Returns:__ 'False' if alignment could not be applied, e.g. because the + size of a frame can\'t be represented as a 32 bit integer (Since: 1.12) -} +videoInfoAlign info align = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + align' <- unsafeManagedPtrGetPtr align + result <- gst_video_info_align info' align' + let result' = (/= 0) result + touchManagedPtr info + touchManagedPtr align + return result' + +#if ENABLE_OVERLOADING +data VideoInfoAlignMethodInfo +instance (signature ~ (GstVideo.VideoAlignment.VideoAlignment -> m Bool), MonadIO m) => O.MethodInfo VideoInfoAlignMethodInfo VideoInfo signature where + overloadedMethod _ = videoInfoAlign + +#endif + +-- method VideoInfo::convert +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstFormat of the @src_value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "value to convert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface (Name {namespace = "Gst", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstFormat of the @dest_value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer to destination value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_info_convert" gst_video_info_convert :: + Ptr VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + CUInt -> -- src_format : TInterface (Name {namespace = "Gst", name = "Format"}) + Int64 -> -- src_value : TBasicType TInt64 + CUInt -> -- dest_format : TInterface (Name {namespace = "Gst", name = "Format"}) + Ptr Int64 -> -- dest_value : TBasicType TInt64 + IO CInt + +{- | +Converts among various 'GI.Gst.Enums.Format' types. This function handles +GST_FORMAT_BYTES, GST_FORMAT_TIME, and GST_FORMAT_DEFAULT. For +raw video, GST_FORMAT_DEFAULT corresponds to video frames. This +function can be used to handle pad queries of the type GST_QUERY_CONVERT. +-} +videoInfoConvert :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> Gst.Enums.Format + {- ^ /@srcFormat@/: 'GI.Gst.Enums.Format' of the /@srcValue@/ -} + -> Int64 + {- ^ /@srcValue@/: value to convert -} + -> Gst.Enums.Format + {- ^ /@destFormat@/: 'GI.Gst.Enums.Format' of the /@destValue@/ -} + -> m ((Bool, Int64)) + {- ^ __Returns:__ TRUE if the conversion was successful. -} +videoInfoConvert info srcFormat srcValue destFormat = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + let srcFormat' = (fromIntegral . fromEnum) srcFormat + let destFormat' = (fromIntegral . fromEnum) destFormat + destValue <- allocMem :: IO (Ptr Int64) + result <- gst_video_info_convert info' srcFormat' srcValue destFormat' destValue + let result' = (/= 0) result + destValue' <- peek destValue + touchManagedPtr info + freeMem destValue + return (result', destValue') + +#if ENABLE_OVERLOADING +data VideoInfoConvertMethodInfo +instance (signature ~ (Gst.Enums.Format -> Int64 -> Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m) => O.MethodInfo VideoInfoConvertMethodInfo VideoInfo signature where + overloadedMethod _ = videoInfoConvert + +#endif + +-- method VideoInfo::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_info_copy" gst_video_info_copy :: + Ptr VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + IO (Ptr VideoInfo) + +{- | +Copy a GstVideoInfo structure. + +/Since: 1.6/ +-} +videoInfoCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> m VideoInfo + {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoInfo.VideoInfo'. free with gst_video_info_free. -} +videoInfoCopy info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- gst_video_info_copy info' + checkUnexpectedReturnNULL "videoInfoCopy" result + result' <- (wrapBoxed VideoInfo) result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data VideoInfoCopyMethodInfo +instance (signature ~ (m VideoInfo), MonadIO m) => O.MethodInfo VideoInfoCopyMethodInfo VideoInfo signature where + overloadedMethod _ = videoInfoCopy + +#endif + +-- method VideoInfo::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_info_free" gst_video_info_free :: + Ptr VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + IO () + +{- | +Free a GstVideoInfo structure previously allocated with 'GI.GstVideo.Structs.VideoInfo.videoInfoNew' +or 'GI.GstVideo.Structs.VideoInfo.videoInfoCopy'. + +/Since: 1.6/ +-} +videoInfoFree :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> m () +videoInfoFree info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + gst_video_info_free info' + touchManagedPtr info + return () + +#if ENABLE_OVERLOADING +data VideoInfoFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoInfoFreeMethodInfo VideoInfo signature where + overloadedMethod _ = videoInfoFree + +#endif + +-- method VideoInfo::from_caps +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface (Name {namespace = "Gst", name = "Caps"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstCaps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_info_from_caps" gst_video_info_from_caps :: + Ptr VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + Ptr Gst.Caps.Caps -> -- caps : TInterface (Name {namespace = "Gst", name = "Caps"}) + IO CInt + +{- | +Parse /@caps@/ and update /@info@/. +-} +videoInfoFromCaps :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> Gst.Caps.Caps + {- ^ /@caps@/: a 'GI.Gst.Structs.Caps.Caps' -} + -> m Bool + {- ^ __Returns:__ TRUE if /@caps@/ could be parsed -} +videoInfoFromCaps info caps = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + caps' <- unsafeManagedPtrGetPtr caps + result <- gst_video_info_from_caps info' caps' + let result' = (/= 0) result + touchManagedPtr info + touchManagedPtr caps + return result' + +#if ENABLE_OVERLOADING +data VideoInfoFromCapsMethodInfo +instance (signature ~ (Gst.Caps.Caps -> m Bool), MonadIO m) => O.MethodInfo VideoInfoFromCapsMethodInfo VideoInfo signature where + overloadedMethod _ = videoInfoFromCaps + +#endif + +-- method VideoInfo::init +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_info_init" gst_video_info_init :: + Ptr VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + IO () + +{- | +Initialize /@info@/ with default values. +-} +videoInfoInit :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> m () +videoInfoInit info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + gst_video_info_init info' + touchManagedPtr info + return () + +#if ENABLE_OVERLOADING +data VideoInfoInitMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoInfoInitMethodInfo VideoInfo signature where + overloadedMethod _ = videoInfoInit + +#endif + +-- method VideoInfo::is_equal +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "other", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_info_is_equal" gst_video_info_is_equal :: + Ptr VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + Ptr VideoInfo -> -- other : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + IO CInt + +{- | +Compares two 'GI.GstVideo.Structs.VideoInfo.VideoInfo' and returns whether they are equal or not +-} +videoInfoIsEqual :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> VideoInfo + {- ^ /@other@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@info@/ and /@other@/ are equal, else 'False'. -} +videoInfoIsEqual info other = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + other' <- unsafeManagedPtrGetPtr other + result <- gst_video_info_is_equal info' other' + let result' = (/= 0) result + touchManagedPtr info + touchManagedPtr other + return result' + +#if ENABLE_OVERLOADING +data VideoInfoIsEqualMethodInfo +instance (signature ~ (VideoInfo -> m Bool), MonadIO m) => O.MethodInfo VideoInfoIsEqualMethodInfo VideoInfo signature where + overloadedMethod _ = videoInfoIsEqual + +#endif + +-- method VideoInfo::set_format +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the format", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_info_set_format" gst_video_info_set_format :: + Ptr VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + CUInt -> -- format : TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}) + Word32 -> -- width : TBasicType TUInt + Word32 -> -- height : TBasicType TUInt + IO CInt + +{- | +Set the default info for a video frame of /@format@/ and /@width@/ and /@height@/. + +Note: This initializes /@info@/ first, no values are preserved. This function +does not set the offsets correctly for interlaced vertically +subsampled formats. +-} +videoInfoSetFormat :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> GstVideo.Enums.VideoFormat + {- ^ /@format@/: the format -} + -> Word32 + {- ^ /@width@/: a width -} + -> Word32 + {- ^ /@height@/: a height -} + -> m Bool + {- ^ __Returns:__ 'False' if the returned video info is invalid, e.g. because the + size of a frame can\'t be represented as a 32 bit integer (Since: 1.12) -} +videoInfoSetFormat info format width height = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + let format' = (fromIntegral . fromEnum) format + result <- gst_video_info_set_format info' format' width height + let result' = (/= 0) result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data VideoInfoSetFormatMethodInfo +instance (signature ~ (GstVideo.Enums.VideoFormat -> Word32 -> Word32 -> m Bool), MonadIO m) => O.MethodInfo VideoInfoSetFormatMethodInfo VideoInfo signature where + overloadedMethod _ = videoInfoSetFormat + +#endif + +-- method VideoInfo::set_interlaced_format +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the format", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInterlaceMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInterlaceMode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_info_set_interlaced_format" gst_video_info_set_interlaced_format :: + Ptr VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + CUInt -> -- format : TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}) + CUInt -> -- mode : TInterface (Name {namespace = "GstVideo", name = "VideoInterlaceMode"}) + Word32 -> -- width : TBasicType TUInt + Word32 -> -- height : TBasicType TUInt + IO CInt + +{- | +Same as @/gst_video_info_set_format/@ but also allowing to set the interlaced +mode. + +/Since: 1.16/ +-} +videoInfoSetInterlacedFormat :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> GstVideo.Enums.VideoFormat + {- ^ /@format@/: the format -} + -> GstVideo.Enums.VideoInterlaceMode + {- ^ /@mode@/: a 'GI.GstVideo.Enums.VideoInterlaceMode' -} + -> Word32 + {- ^ /@width@/: a width -} + -> Word32 + {- ^ /@height@/: a height -} + -> m Bool + {- ^ __Returns:__ 'False' if the returned video info is invalid, e.g. because the + size of a frame can\'t be represented as a 32 bit integer. -} +videoInfoSetInterlacedFormat info format mode width height = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + let format' = (fromIntegral . fromEnum) format + let mode' = (fromIntegral . fromEnum) mode + result <- gst_video_info_set_interlaced_format info' format' mode' width height + let result' = (/= 0) result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data VideoInfoSetInterlacedFormatMethodInfo +instance (signature ~ (GstVideo.Enums.VideoFormat -> GstVideo.Enums.VideoInterlaceMode -> Word32 -> Word32 -> m Bool), MonadIO m) => O.MethodInfo VideoInfoSetInterlacedFormatMethodInfo VideoInfo signature where + overloadedMethod _ = videoInfoSetInterlacedFormat + +#endif + +-- method VideoInfo::to_caps +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Caps"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_info_to_caps" gst_video_info_to_caps :: + Ptr VideoInfo -> -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"}) + IO (Ptr Gst.Caps.Caps) + +{- | +Convert the values of /@info@/ into a 'GI.Gst.Structs.Caps.Caps'. +-} +videoInfoToCaps :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoInfo + {- ^ /@info@/: a 'GI.GstVideo.Structs.VideoInfo.VideoInfo' -} + -> m Gst.Caps.Caps + {- ^ __Returns:__ a new 'GI.Gst.Structs.Caps.Caps' containing the info of /@info@/. -} +videoInfoToCaps info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- gst_video_info_to_caps info' + checkUnexpectedReturnNULL "videoInfoToCaps" result + result' <- (wrapBoxed Gst.Caps.Caps) result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data VideoInfoToCapsMethodInfo +instance (signature ~ (m Gst.Caps.Caps), MonadIO m) => O.MethodInfo VideoInfoToCapsMethodInfo VideoInfo signature where + overloadedMethod _ = videoInfoToCaps + +#endif + +#if ENABLE_OVERLOADING +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 "setInterlacedFormat" o = VideoInfoSetInterlacedFormatMethodInfo + ResolveVideoInfoMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoInfoMethod t VideoInfo, O.MethodInfo info VideoInfo p) => OL.IsLabel t (VideoInfo -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoInfo.hs-boot b/GI/GstVideo/Structs/VideoInfo.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoInfo.hs-boot @@ -0,0 +1,56 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoInfo where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoInfo = VideoInfo (ManagedPtr VideoInfo) +instance BoxedObject VideoInfo where +#if ENABLE_OVERLOADING +data VideoInfoAlignMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoInfoConvertMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoInfoCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoInfoFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoInfoFromCapsMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoInfoInitMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoInfoIsEqualMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoInfoSetFormatMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoInfoSetInterlacedFormatMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoInfoToCapsMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoMeta.hs b/GI/GstVideo/Structs/VideoMeta.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoMeta.hs @@ -0,0 +1,842 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Extra buffer metadata describing image properties +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoMeta + ( + +-- * Exported types + VideoMeta(..) , + newZeroVideoMeta , + noVideoMeta , + + + -- * Methods +-- ** getInfo #method:getInfo# + + videoMetaGetInfo , + + +-- ** map #method:map# + +#if ENABLE_OVERLOADING + VideoMetaMapMethodInfo , +#endif + videoMetaMap , + + +-- ** unmap #method:unmap# + +#if ENABLE_OVERLOADING + VideoMetaUnmapMethodInfo , +#endif + videoMetaUnmap , + + + + + -- * Properties +-- ** buffer #attr:buffer# +{- | the buffer this metadata belongs to +-} + clearVideoMetaBuffer , + getVideoMetaBuffer , + setVideoMetaBuffer , +#if ENABLE_OVERLOADING + videoMeta_buffer , +#endif + + +-- ** flags #attr:flags# +{- | additional video flags +-} + getVideoMetaFlags , + setVideoMetaFlags , +#if ENABLE_OVERLOADING + videoMeta_flags , +#endif + + +-- ** format #attr:format# +{- | the video format +-} + getVideoMetaFormat , + setVideoMetaFormat , +#if ENABLE_OVERLOADING + videoMeta_format , +#endif + + +-- ** height #attr:height# +{- | the video height +-} + getVideoMetaHeight , + setVideoMetaHeight , +#if ENABLE_OVERLOADING + videoMeta_height , +#endif + + +-- ** id #attr:id# +{- | identifier of the frame +-} + getVideoMetaId , + setVideoMetaId , +#if ENABLE_OVERLOADING + videoMeta_id , +#endif + + +-- ** map #attr:map# +{- | /No description available in the introspection data./ +-} + clearVideoMetaMap , + getVideoMetaMap , + setVideoMetaMap , +#if ENABLE_OVERLOADING + videoMeta_map , +#endif + + +-- ** meta #attr:meta# +{- | parent 'GI.Gst.Structs.Meta.Meta' +-} + getVideoMetaMeta , +#if ENABLE_OVERLOADING + videoMeta_meta , +#endif + + +-- ** nPlanes #attr:nPlanes# +{- | the number of planes in the image +-} + getVideoMetaNPlanes , + setVideoMetaNPlanes , +#if ENABLE_OVERLOADING + videoMeta_nPlanes , +#endif + + +-- ** unmap #attr:unmap# +{- | /No description available in the introspection data./ +-} + clearVideoMetaUnmap , + getVideoMetaUnmap , + setVideoMetaUnmap , +#if ENABLE_OVERLOADING + videoMeta_unmap , +#endif + + +-- ** width #attr:width# +{- | the video width +-} + getVideoMetaWidth , + setVideoMetaWidth , +#if ENABLE_OVERLOADING + videoMeta_width , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Flags as Gst.Flags +import qualified GI.Gst.Structs.Buffer as Gst.Buffer +import qualified GI.Gst.Structs.MapInfo as Gst.MapInfo +import qualified GI.Gst.Structs.Meta as Gst.Meta +import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo +import qualified GI.GstVideo.Callbacks as GstVideo.Callbacks +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums +import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags + +-- | Memory-managed wrapper type. +newtype VideoMeta = VideoMeta (ManagedPtr VideoMeta) +instance WrappedPtr VideoMeta where + wrappedPtrCalloc = callocBytes 112 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 112 >=> wrapPtr VideoMeta) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoMeta` struct initialized to zero. +newZeroVideoMeta :: MonadIO m => m VideoMeta +newZeroVideoMeta = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoMeta + +instance tag ~ 'AttrSet => Constructible VideoMeta tag where + new _ attrs = do + o <- newZeroVideoMeta + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoMeta`. +noVideoMeta :: Maybe VideoMeta +noVideoMeta = Nothing + +{- | +Get the value of the “@meta@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoMeta #meta +@ +-} +getVideoMetaMeta :: MonadIO m => VideoMeta -> m Gst.Meta.Meta +getVideoMetaMeta s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Gst.Meta.Meta) + val' <- (newPtr Gst.Meta.Meta) val + return val' + +#if ENABLE_OVERLOADING +data VideoMetaMetaFieldInfo +instance AttrInfo VideoMetaMetaFieldInfo where + type AttrAllowedOps VideoMetaMetaFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint VideoMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta) + type AttrBaseTypeConstraint VideoMetaMetaFieldInfo = (~) VideoMeta + type AttrGetType VideoMetaMetaFieldInfo = Gst.Meta.Meta + type AttrLabel VideoMetaMetaFieldInfo = "meta" + type AttrOrigin VideoMetaMetaFieldInfo = VideoMeta + attrGet _ = getVideoMetaMeta + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +videoMeta_meta :: AttrLabelProxy "meta" +videoMeta_meta = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@buffer@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoMeta #buffer +@ +-} +getVideoMetaBuffer :: MonadIO m => VideoMeta -> m (Maybe Gst.Buffer.Buffer) +getVideoMetaBuffer s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO (Ptr Gst.Buffer.Buffer) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed Gst.Buffer.Buffer) val' + return val'' + return result + +{- | +Set the value of the “@buffer@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoMeta [ #buffer 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoMetaBuffer :: MonadIO m => VideoMeta -> Ptr Gst.Buffer.Buffer -> m () +setVideoMetaBuffer s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Ptr Gst.Buffer.Buffer) + +{- | +Set the value of the “@buffer@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #buffer +@ +-} +clearVideoMetaBuffer :: MonadIO m => VideoMeta -> m () +clearVideoMetaBuffer s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr Gst.Buffer.Buffer) + +#if ENABLE_OVERLOADING +data VideoMetaBufferFieldInfo +instance AttrInfo VideoMetaBufferFieldInfo where + type AttrAllowedOps VideoMetaBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoMetaBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer) + type AttrBaseTypeConstraint VideoMetaBufferFieldInfo = (~) VideoMeta + type AttrGetType VideoMetaBufferFieldInfo = Maybe Gst.Buffer.Buffer + type AttrLabel VideoMetaBufferFieldInfo = "buffer" + type AttrOrigin VideoMetaBufferFieldInfo = VideoMeta + attrGet _ = getVideoMetaBuffer + attrSet _ = setVideoMetaBuffer + attrConstruct = undefined + attrClear _ = clearVideoMetaBuffer + +videoMeta_buffer :: AttrLabelProxy "buffer" +videoMeta_buffer = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@flags@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoMeta #flags +@ +-} +getVideoMetaFlags :: MonadIO m => VideoMeta -> m [GstVideo.Flags.VideoFrameFlags] +getVideoMetaFlags s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO CUInt + let val' = wordToGFlags val + return val' + +{- | +Set the value of the “@flags@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoMeta [ #flags 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoMetaFlags :: MonadIO m => VideoMeta -> [GstVideo.Flags.VideoFrameFlags] -> m () +setVideoMetaFlags s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = gflagsToWord val + poke (ptr `plusPtr` 24) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoMetaFlagsFieldInfo +instance AttrInfo VideoMetaFlagsFieldInfo where + type AttrAllowedOps VideoMetaFlagsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoMetaFlagsFieldInfo = (~) [GstVideo.Flags.VideoFrameFlags] + type AttrBaseTypeConstraint VideoMetaFlagsFieldInfo = (~) VideoMeta + type AttrGetType VideoMetaFlagsFieldInfo = [GstVideo.Flags.VideoFrameFlags] + type AttrLabel VideoMetaFlagsFieldInfo = "flags" + type AttrOrigin VideoMetaFlagsFieldInfo = VideoMeta + attrGet _ = getVideoMetaFlags + attrSet _ = setVideoMetaFlags + attrConstruct = undefined + attrClear _ = undefined + +videoMeta_flags :: AttrLabelProxy "flags" +videoMeta_flags = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@format@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoMeta #format +@ +-} +getVideoMetaFormat :: MonadIO m => VideoMeta -> m GstVideo.Enums.VideoFormat +getVideoMetaFormat s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 28) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@format@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoMeta [ #format 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoMetaFormat :: MonadIO m => VideoMeta -> GstVideo.Enums.VideoFormat -> m () +setVideoMetaFormat s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 28) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoMetaFormatFieldInfo +instance AttrInfo VideoMetaFormatFieldInfo where + type AttrAllowedOps VideoMetaFormatFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoMetaFormatFieldInfo = (~) GstVideo.Enums.VideoFormat + type AttrBaseTypeConstraint VideoMetaFormatFieldInfo = (~) VideoMeta + type AttrGetType VideoMetaFormatFieldInfo = GstVideo.Enums.VideoFormat + type AttrLabel VideoMetaFormatFieldInfo = "format" + type AttrOrigin VideoMetaFormatFieldInfo = VideoMeta + attrGet _ = getVideoMetaFormat + attrSet _ = setVideoMetaFormat + attrConstruct = undefined + attrClear _ = undefined + +videoMeta_format :: AttrLabelProxy "format" +videoMeta_format = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@id@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoMeta #id +@ +-} +getVideoMetaId :: MonadIO m => VideoMeta -> m Int32 +getVideoMetaId s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Int32 + return val + +{- | +Set the value of the “@id@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoMeta [ #id 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoMetaId :: MonadIO m => VideoMeta -> Int32 -> m () +setVideoMetaId s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoMetaIdFieldInfo +instance AttrInfo VideoMetaIdFieldInfo where + type AttrAllowedOps VideoMetaIdFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoMetaIdFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoMetaIdFieldInfo = (~) VideoMeta + type AttrGetType VideoMetaIdFieldInfo = Int32 + type AttrLabel VideoMetaIdFieldInfo = "id" + type AttrOrigin VideoMetaIdFieldInfo = VideoMeta + attrGet _ = getVideoMetaId + attrSet _ = setVideoMetaId + attrConstruct = undefined + attrClear _ = undefined + +videoMeta_id :: AttrLabelProxy "id" +videoMeta_id = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@width@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoMeta #width +@ +-} +getVideoMetaWidth :: MonadIO m => VideoMeta -> m Word32 +getVideoMetaWidth s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 36) :: IO Word32 + return val + +{- | +Set the value of the “@width@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoMeta [ #width 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoMetaWidth :: MonadIO m => VideoMeta -> Word32 -> m () +setVideoMetaWidth s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 36) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoMetaWidthFieldInfo +instance AttrInfo VideoMetaWidthFieldInfo where + type AttrAllowedOps VideoMetaWidthFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoMetaWidthFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoMetaWidthFieldInfo = (~) VideoMeta + type AttrGetType VideoMetaWidthFieldInfo = Word32 + type AttrLabel VideoMetaWidthFieldInfo = "width" + type AttrOrigin VideoMetaWidthFieldInfo = VideoMeta + attrGet _ = getVideoMetaWidth + attrSet _ = setVideoMetaWidth + attrConstruct = undefined + attrClear _ = undefined + +videoMeta_width :: AttrLabelProxy "width" +videoMeta_width = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@height@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoMeta #height +@ +-} +getVideoMetaHeight :: MonadIO m => VideoMeta -> m Word32 +getVideoMetaHeight s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO Word32 + return val + +{- | +Set the value of the “@height@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoMeta [ #height 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoMetaHeight :: MonadIO m => VideoMeta -> Word32 -> m () +setVideoMetaHeight s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoMetaHeightFieldInfo +instance AttrInfo VideoMetaHeightFieldInfo where + type AttrAllowedOps VideoMetaHeightFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoMetaHeightFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoMetaHeightFieldInfo = (~) VideoMeta + type AttrGetType VideoMetaHeightFieldInfo = Word32 + type AttrLabel VideoMetaHeightFieldInfo = "height" + type AttrOrigin VideoMetaHeightFieldInfo = VideoMeta + attrGet _ = getVideoMetaHeight + attrSet _ = setVideoMetaHeight + attrConstruct = undefined + attrClear _ = undefined + +videoMeta_height :: AttrLabelProxy "height" +videoMeta_height = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@n_planes@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoMeta #nPlanes +@ +-} +getVideoMetaNPlanes :: MonadIO m => VideoMeta -> m Word32 +getVideoMetaNPlanes s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 44) :: IO Word32 + return val + +{- | +Set the value of the “@n_planes@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoMeta [ #nPlanes 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoMetaNPlanes :: MonadIO m => VideoMeta -> Word32 -> m () +setVideoMetaNPlanes s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 44) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoMetaNPlanesFieldInfo +instance AttrInfo VideoMetaNPlanesFieldInfo where + type AttrAllowedOps VideoMetaNPlanesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoMetaNPlanesFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoMetaNPlanesFieldInfo = (~) VideoMeta + type AttrGetType VideoMetaNPlanesFieldInfo = Word32 + type AttrLabel VideoMetaNPlanesFieldInfo = "n_planes" + type AttrOrigin VideoMetaNPlanesFieldInfo = VideoMeta + attrGet _ = getVideoMetaNPlanes + attrSet _ = setVideoMetaNPlanes + attrConstruct = undefined + attrClear _ = undefined + +videoMeta_nPlanes :: AttrLabelProxy "nPlanes" +videoMeta_nPlanes = AttrLabelProxy + +#endif + + +-- XXX Skipped attribute for "VideoMeta:offset" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt64)" +-- XXX Skipped attribute for "VideoMeta:stride" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TInt)" +{- | +Get the value of the “@map@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoMeta #map +@ +-} +getVideoMetaMap :: MonadIO m => VideoMeta -> m (Maybe GstVideo.Callbacks.VideoMetaMapFieldCallback) +getVideoMetaMap s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 96) :: IO (FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = GstVideo.Callbacks.dynamic_VideoMetaMapFieldCallback val' + return val'' + return result + +{- | +Set the value of the “@map@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoMeta [ #map 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoMetaMap :: MonadIO m => VideoMeta -> FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback -> m () +setVideoMetaMap s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 96) (val :: FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback) + +{- | +Set the value of the “@map@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #map +@ +-} +clearVideoMetaMap :: MonadIO m => VideoMeta -> m () +clearVideoMetaMap s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 96) (FP.nullFunPtr :: FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback) + +#if ENABLE_OVERLOADING +data VideoMetaMapFieldInfo +instance AttrInfo VideoMetaMapFieldInfo where + type AttrAllowedOps VideoMetaMapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoMetaMapFieldInfo = (~) (FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback) + type AttrBaseTypeConstraint VideoMetaMapFieldInfo = (~) VideoMeta + type AttrGetType VideoMetaMapFieldInfo = Maybe GstVideo.Callbacks.VideoMetaMapFieldCallback + type AttrLabel VideoMetaMapFieldInfo = "map" + type AttrOrigin VideoMetaMapFieldInfo = VideoMeta + attrGet _ = getVideoMetaMap + attrSet _ = setVideoMetaMap + attrConstruct = undefined + attrClear _ = clearVideoMetaMap + +videoMeta_map :: AttrLabelProxy "map" +videoMeta_map = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@unmap@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoMeta #unmap +@ +-} +getVideoMetaUnmap :: MonadIO m => VideoMeta -> m (Maybe GstVideo.Callbacks.VideoMetaUnmapFieldCallback) +getVideoMetaUnmap s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 104) :: IO (FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = GstVideo.Callbacks.dynamic_VideoMetaUnmapFieldCallback val' + return val'' + return result + +{- | +Set the value of the “@unmap@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoMeta [ #unmap 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoMetaUnmap :: MonadIO m => VideoMeta -> FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback -> m () +setVideoMetaUnmap s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 104) (val :: FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback) + +{- | +Set the value of the “@unmap@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #unmap +@ +-} +clearVideoMetaUnmap :: MonadIO m => VideoMeta -> m () +clearVideoMetaUnmap s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 104) (FP.nullFunPtr :: FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback) + +#if ENABLE_OVERLOADING +data VideoMetaUnmapFieldInfo +instance AttrInfo VideoMetaUnmapFieldInfo where + type AttrAllowedOps VideoMetaUnmapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoMetaUnmapFieldInfo = (~) (FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback) + type AttrBaseTypeConstraint VideoMetaUnmapFieldInfo = (~) VideoMeta + type AttrGetType VideoMetaUnmapFieldInfo = Maybe GstVideo.Callbacks.VideoMetaUnmapFieldCallback + type AttrLabel VideoMetaUnmapFieldInfo = "unmap" + type AttrOrigin VideoMetaUnmapFieldInfo = VideoMeta + attrGet _ = getVideoMetaUnmap + attrSet _ = setVideoMetaUnmap + attrConstruct = undefined + attrClear _ = clearVideoMetaUnmap + +videoMeta_unmap :: AttrLabelProxy "unmap" +videoMeta_unmap = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoMeta +type instance O.AttributeList VideoMeta = VideoMetaAttributeList +type VideoMetaAttributeList = ('[ '("meta", VideoMetaMetaFieldInfo), '("buffer", VideoMetaBufferFieldInfo), '("flags", VideoMetaFlagsFieldInfo), '("format", VideoMetaFormatFieldInfo), '("id", VideoMetaIdFieldInfo), '("width", VideoMetaWidthFieldInfo), '("height", VideoMetaHeightFieldInfo), '("nPlanes", VideoMetaNPlanesFieldInfo), '("map", VideoMetaMapFieldInfo), '("unmap", VideoMetaUnmapFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoMeta::map +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoMeta", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a plane", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gst", name = "MapInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMapInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data of @plane", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stride", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stride of @plane", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gst", name = "MapFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "@GstMapFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_meta_map" gst_video_meta_map :: + Ptr VideoMeta -> -- meta : TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}) + Word32 -> -- plane : TBasicType TUInt + Ptr Gst.MapInfo.MapInfo -> -- info : TInterface (Name {namespace = "Gst", name = "MapInfo"}) + Ptr (Ptr ()) -> -- data : TBasicType TPtr + Ptr Int32 -> -- stride : TBasicType TInt + CUInt -> -- flags : TInterface (Name {namespace = "Gst", name = "MapFlags"}) + IO CInt + +{- | +Map the video plane with index /@plane@/ in /@meta@/ and return a pointer to the +first byte of the plane and the stride of the plane. +-} +videoMetaMap :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoMeta + {- ^ /@meta@/: a 'GI.GstVideo.Structs.VideoMeta.VideoMeta' -} + -> Word32 + {- ^ /@plane@/: a plane -} + -> Gst.MapInfo.MapInfo + {- ^ /@info@/: a 'GI.Gst.Structs.MapInfo.MapInfo' -} + -> [Gst.Flags.MapFlags] + {- ^ /@flags@/: /@gstMapFlags@/ -} + -> m ((Bool, Ptr (), Int32)) + {- ^ __Returns:__ TRUE if the map operation was successful. -} +videoMetaMap meta plane info flags = liftIO $ do + meta' <- unsafeManagedPtrGetPtr meta + info' <- unsafeManagedPtrGetPtr info + data_ <- allocMem :: IO (Ptr (Ptr ())) + stride <- allocMem :: IO (Ptr Int32) + let flags' = gflagsToWord flags + result <- gst_video_meta_map meta' plane info' data_ stride flags' + let result' = (/= 0) result + data_' <- peek data_ + stride' <- peek stride + touchManagedPtr meta + touchManagedPtr info + freeMem data_ + freeMem stride + return (result', data_', stride') + +#if ENABLE_OVERLOADING +data VideoMetaMapMethodInfo +instance (signature ~ (Word32 -> Gst.MapInfo.MapInfo -> [Gst.Flags.MapFlags] -> m ((Bool, Ptr (), Int32))), MonadIO m) => O.MethodInfo VideoMetaMapMethodInfo VideoMeta signature where + overloadedMethod _ = videoMetaMap + +#endif + +-- method VideoMeta::unmap +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoMeta", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plane", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a plane", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "Gst", name = "MapInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstMapInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_meta_unmap" gst_video_meta_unmap :: + Ptr VideoMeta -> -- meta : TInterface (Name {namespace = "GstVideo", name = "VideoMeta"}) + Word32 -> -- plane : TBasicType TUInt + Ptr Gst.MapInfo.MapInfo -> -- info : TInterface (Name {namespace = "Gst", name = "MapInfo"}) + IO CInt + +{- | +Unmap a previously mapped plane with 'GI.GstVideo.Structs.VideoMeta.videoMetaMap'. +-} +videoMetaUnmap :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoMeta + {- ^ /@meta@/: a 'GI.GstVideo.Structs.VideoMeta.VideoMeta' -} + -> Word32 + {- ^ /@plane@/: a plane -} + -> Gst.MapInfo.MapInfo + {- ^ /@info@/: a 'GI.Gst.Structs.MapInfo.MapInfo' -} + -> m Bool + {- ^ __Returns:__ TRUE if the memory was successfully unmapped. -} +videoMetaUnmap meta plane info = liftIO $ do + meta' <- unsafeManagedPtrGetPtr meta + info' <- unsafeManagedPtrGetPtr info + result <- gst_video_meta_unmap meta' plane info' + let result' = (/= 0) result + touchManagedPtr meta + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data VideoMetaUnmapMethodInfo +instance (signature ~ (Word32 -> Gst.MapInfo.MapInfo -> m Bool), MonadIO m) => O.MethodInfo VideoMetaUnmapMethodInfo VideoMeta signature where + overloadedMethod _ = videoMetaUnmap + +#endif + +-- method VideoMeta::get_info +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "MetaInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_meta_get_info" gst_video_meta_get_info :: + IO (Ptr Gst.MetaInfo.MetaInfo) + +{- | +/No description available in the introspection data./ +-} +videoMetaGetInfo :: + (B.CallStack.HasCallStack, MonadIO m) => + m Gst.MetaInfo.MetaInfo +videoMetaGetInfo = liftIO $ do + result <- gst_video_meta_get_info + checkUnexpectedReturnNULL "videoMetaGetInfo" result + result' <- (newPtr Gst.MetaInfo.MetaInfo) result + return result' + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoMetaMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoMetaMethod "map" o = VideoMetaMapMethodInfo + ResolveVideoMetaMethod "unmap" o = VideoMetaUnmapMethodInfo + ResolveVideoMetaMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoMetaMethod t VideoMeta, O.MethodInfo info VideoMeta p) => OL.IsLabel t (VideoMeta -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoMeta.hs-boot b/GI/GstVideo/Structs/VideoMeta.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoMeta.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoMeta where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoMeta = VideoMeta (ManagedPtr VideoMeta) +instance WrappedPtr VideoMeta where +#if ENABLE_OVERLOADING +data VideoMetaMapMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoMetaUnmapMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoMetaTransform.hs b/GI/GstVideo/Structs/VideoMetaTransform.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoMetaTransform.hs @@ -0,0 +1,268 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Extra data passed to a video transform 'GI.Gst.Callbacks.MetaTransformFunction' such as: +\"gst-video-scale\". +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoMetaTransform + ( + +-- * Exported types + VideoMetaTransform(..) , + newZeroVideoMetaTransform , + noVideoMetaTransform , + + + -- * Methods +-- ** scaleGetQuark #method:scaleGetQuark# + + videoMetaTransformScaleGetQuark , + + + + + -- * Properties +-- ** inInfo #attr:inInfo# +{- | the input 'GI.GstVideo.Structs.VideoInfo.VideoInfo' +-} + clearVideoMetaTransformInInfo , + getVideoMetaTransformInInfo , + setVideoMetaTransformInInfo , +#if ENABLE_OVERLOADING + videoMetaTransform_inInfo , +#endif + + +-- ** outInfo #attr:outInfo# +{- | the output 'GI.GstVideo.Structs.VideoInfo.VideoInfo' +-} + clearVideoMetaTransformOutInfo , + getVideoMetaTransformOutInfo , + setVideoMetaTransformOutInfo , +#if ENABLE_OVERLOADING + videoMetaTransform_outInfo , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoInfo as GstVideo.VideoInfo + +-- | Memory-managed wrapper type. +newtype VideoMetaTransform = VideoMetaTransform (ManagedPtr VideoMetaTransform) +instance WrappedPtr VideoMetaTransform where + wrappedPtrCalloc = callocBytes 16 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 16 >=> wrapPtr VideoMetaTransform) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoMetaTransform` struct initialized to zero. +newZeroVideoMetaTransform :: MonadIO m => m VideoMetaTransform +newZeroVideoMetaTransform = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoMetaTransform + +instance tag ~ 'AttrSet => Constructible VideoMetaTransform tag where + new _ attrs = do + o <- newZeroVideoMetaTransform + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoMetaTransform`. +noVideoMetaTransform :: Maybe VideoMetaTransform +noVideoMetaTransform = Nothing + +{- | +Get the value of the “@in_info@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoMetaTransform #inInfo +@ +-} +getVideoMetaTransformInInfo :: MonadIO m => VideoMetaTransform -> m (Maybe GstVideo.VideoInfo.VideoInfo) +getVideoMetaTransformInInfo s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO (Ptr GstVideo.VideoInfo.VideoInfo) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed GstVideo.VideoInfo.VideoInfo) val' + return val'' + return result + +{- | +Set the value of the “@in_info@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoMetaTransform [ #inInfo 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoMetaTransformInInfo :: MonadIO m => VideoMetaTransform -> Ptr GstVideo.VideoInfo.VideoInfo -> m () +setVideoMetaTransformInInfo s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Ptr GstVideo.VideoInfo.VideoInfo) + +{- | +Set the value of the “@in_info@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #inInfo +@ +-} +clearVideoMetaTransformInInfo :: MonadIO m => VideoMetaTransform -> m () +clearVideoMetaTransformInInfo s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr GstVideo.VideoInfo.VideoInfo) + +#if ENABLE_OVERLOADING +data VideoMetaTransformInInfoFieldInfo +instance AttrInfo VideoMetaTransformInInfoFieldInfo where + type AttrAllowedOps VideoMetaTransformInInfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoMetaTransformInInfoFieldInfo = (~) (Ptr GstVideo.VideoInfo.VideoInfo) + type AttrBaseTypeConstraint VideoMetaTransformInInfoFieldInfo = (~) VideoMetaTransform + type AttrGetType VideoMetaTransformInInfoFieldInfo = Maybe GstVideo.VideoInfo.VideoInfo + type AttrLabel VideoMetaTransformInInfoFieldInfo = "in_info" + type AttrOrigin VideoMetaTransformInInfoFieldInfo = VideoMetaTransform + attrGet _ = getVideoMetaTransformInInfo + attrSet _ = setVideoMetaTransformInInfo + attrConstruct = undefined + attrClear _ = clearVideoMetaTransformInInfo + +videoMetaTransform_inInfo :: AttrLabelProxy "inInfo" +videoMetaTransform_inInfo = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@out_info@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoMetaTransform #outInfo +@ +-} +getVideoMetaTransformOutInfo :: MonadIO m => VideoMetaTransform -> m (Maybe GstVideo.VideoInfo.VideoInfo) +getVideoMetaTransformOutInfo s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO (Ptr GstVideo.VideoInfo.VideoInfo) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed GstVideo.VideoInfo.VideoInfo) val' + return val'' + return result + +{- | +Set the value of the “@out_info@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoMetaTransform [ #outInfo 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoMetaTransformOutInfo :: MonadIO m => VideoMetaTransform -> Ptr GstVideo.VideoInfo.VideoInfo -> m () +setVideoMetaTransformOutInfo s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: Ptr GstVideo.VideoInfo.VideoInfo) + +{- | +Set the value of the “@out_info@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #outInfo +@ +-} +clearVideoMetaTransformOutInfo :: MonadIO m => VideoMetaTransform -> m () +clearVideoMetaTransformOutInfo s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr GstVideo.VideoInfo.VideoInfo) + +#if ENABLE_OVERLOADING +data VideoMetaTransformOutInfoFieldInfo +instance AttrInfo VideoMetaTransformOutInfoFieldInfo where + type AttrAllowedOps VideoMetaTransformOutInfoFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoMetaTransformOutInfoFieldInfo = (~) (Ptr GstVideo.VideoInfo.VideoInfo) + type AttrBaseTypeConstraint VideoMetaTransformOutInfoFieldInfo = (~) VideoMetaTransform + type AttrGetType VideoMetaTransformOutInfoFieldInfo = Maybe GstVideo.VideoInfo.VideoInfo + type AttrLabel VideoMetaTransformOutInfoFieldInfo = "out_info" + type AttrOrigin VideoMetaTransformOutInfoFieldInfo = VideoMetaTransform + attrGet _ = getVideoMetaTransformOutInfo + attrSet _ = setVideoMetaTransformOutInfo + attrConstruct = undefined + attrClear _ = clearVideoMetaTransformOutInfo + +videoMetaTransform_outInfo :: AttrLabelProxy "outInfo" +videoMetaTransform_outInfo = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoMetaTransform +type instance O.AttributeList VideoMetaTransform = VideoMetaTransformAttributeList +type VideoMetaTransformAttributeList = ('[ '("inInfo", VideoMetaTransformInInfoFieldInfo), '("outInfo", VideoMetaTransformOutInfoFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoMetaTransform::scale_get_quark +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (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 + +{- | +Get the @/GQuark/@ for the \"gst-video-scale\" metadata transform operation. +-} +videoMetaTransformScaleGetQuark :: + (B.CallStack.HasCallStack, MonadIO m) => + m Word32 + {- ^ __Returns:__ a @/GQuark/@ -} +videoMetaTransformScaleGetQuark = liftIO $ do + result <- gst_video_meta_transform_scale_get_quark + return result + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoMetaTransformMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoMetaTransformMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoMetaTransformMethod t VideoMetaTransform, O.MethodInfo info VideoMetaTransform p) => OL.IsLabel t (VideoMetaTransform -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoMetaTransform.hs-boot b/GI/GstVideo/Structs/VideoMetaTransform.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoMetaTransform.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoMetaTransform where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoMetaTransform = VideoMetaTransform (ManagedPtr VideoMetaTransform) +instance WrappedPtr VideoMetaTransform where diff --git a/GI/GstVideo/Structs/VideoOverlayComposition.hs b/GI/GstVideo/Structs/VideoOverlayComposition.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoOverlayComposition.hs @@ -0,0 +1,486 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Functions to create and handle overlay compositions on video buffers. + +An overlay composition describes one or more overlay rectangles to be +blended on top of a video buffer. + +This API serves two main purposes: + +* 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. + +* 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. + +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 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' 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. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoOverlayComposition + ( + +-- * Exported types + VideoOverlayComposition(..) , + noVideoOverlayComposition , + + + -- * Methods +-- ** addRectangle #method:addRectangle# + +#if ENABLE_OVERLOADING + VideoOverlayCompositionAddRectangleMethodInfo, +#endif + videoOverlayCompositionAddRectangle , + + +-- ** blend #method:blend# + +#if ENABLE_OVERLOADING + VideoOverlayCompositionBlendMethodInfo , +#endif + videoOverlayCompositionBlend , + + +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + VideoOverlayCompositionCopyMethodInfo , +#endif + videoOverlayCompositionCopy , + + +-- ** getRectangle #method:getRectangle# + +#if ENABLE_OVERLOADING + VideoOverlayCompositionGetRectangleMethodInfo, +#endif + videoOverlayCompositionGetRectangle , + + +-- ** getSeqnum #method:getSeqnum# + +#if ENABLE_OVERLOADING + VideoOverlayCompositionGetSeqnumMethodInfo, +#endif + videoOverlayCompositionGetSeqnum , + + +-- ** makeWritable #method:makeWritable# + +#if ENABLE_OVERLOADING + VideoOverlayCompositionMakeWritableMethodInfo, +#endif + videoOverlayCompositionMakeWritable , + + +-- ** nRectangles #method:nRectangles# + +#if ENABLE_OVERLOADING + VideoOverlayCompositionNRectanglesMethodInfo, +#endif + videoOverlayCompositionNRectangles , + + +-- ** new #method:new# + + videoOverlayCompositionNew , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoFrame as GstVideo.VideoFrame +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoOverlayRectangle as GstVideo.VideoOverlayRectangle + +-- | Memory-managed wrapper type. +newtype VideoOverlayComposition = VideoOverlayComposition (ManagedPtr 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 + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoOverlayComposition`. +noVideoOverlayComposition :: Maybe VideoOverlayComposition +noVideoOverlayComposition = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoOverlayComposition +type instance O.AttributeList VideoOverlayComposition = VideoOverlayCompositionAttributeList +type VideoOverlayCompositionAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method VideoOverlayComposition::new +-- method type : Constructor +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle to add to the\n composition", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_composition_new" gst_video_overlay_composition_new :: + Ptr GstVideo.VideoOverlayRectangle.VideoOverlayRectangle -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + IO (Ptr VideoOverlayComposition) + +{- | +Creates a new video overlay composition object to hold one or more +overlay rectangles. +-} +videoOverlayCompositionNew :: + (B.CallStack.HasCallStack, MonadIO m) => + GstVideo.VideoOverlayRectangle.VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' to add to the + composition -} + -> m VideoOverlayComposition + {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition'. Unref with + @/gst_video_overlay_composition_unref()/@ when no longer needed. -} +videoOverlayCompositionNew rectangle = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + result <- gst_video_overlay_composition_new rectangle' + checkUnexpectedReturnNULL "videoOverlayCompositionNew" result + result' <- (wrapBoxed VideoOverlayComposition) result + touchManagedPtr rectangle + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method VideoOverlayComposition::add_rectangle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "comp", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayComposition", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle to add to the\n composition", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_composition_add_rectangle" gst_video_overlay_composition_add_rectangle :: + Ptr VideoOverlayComposition -> -- comp : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}) + Ptr GstVideo.VideoOverlayRectangle.VideoOverlayRectangle -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + IO () + +{- | +Adds an overlay rectangle to an existing overlay composition object. This +must be done right after creating the overlay composition. +-} +videoOverlayCompositionAddRectangle :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayComposition + {- ^ /@comp@/: a 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' -} + -> GstVideo.VideoOverlayRectangle.VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' to add to the + composition -} + -> m () +videoOverlayCompositionAddRectangle comp rectangle = liftIO $ do + comp' <- unsafeManagedPtrGetPtr comp + rectangle' <- unsafeManagedPtrGetPtr rectangle + gst_video_overlay_composition_add_rectangle comp' rectangle' + touchManagedPtr comp + touchManagedPtr rectangle + return () + +#if ENABLE_OVERLOADING +data VideoOverlayCompositionAddRectangleMethodInfo +instance (signature ~ (GstVideo.VideoOverlayRectangle.VideoOverlayRectangle -> m ()), MonadIO m) => O.MethodInfo VideoOverlayCompositionAddRectangleMethodInfo VideoOverlayComposition signature where + overloadedMethod _ = videoOverlayCompositionAddRectangle + +#endif + +-- method VideoOverlayComposition::blend +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "comp", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayComposition", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "video_buf", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFrame containing raw video data in a\n supported format. It should be mapped using GST_MAP_READWRITE", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_composition_blend" gst_video_overlay_composition_blend :: + Ptr VideoOverlayComposition -> -- comp : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}) + Ptr GstVideo.VideoFrame.VideoFrame -> -- video_buf : TInterface (Name {namespace = "GstVideo", name = "VideoFrame"}) + IO CInt + +{- | +Blends the overlay rectangles in /@comp@/ on top of the raw video data +contained in /@videoBuf@/. The data in /@videoBuf@/ must be writable and +mapped appropriately. + +Since /@videoBuf@/ data is read and will be modified, it ought be +mapped with flag GST_MAP_READWRITE. +-} +videoOverlayCompositionBlend :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayComposition + {- ^ /@comp@/: a 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' -} + -> GstVideo.VideoFrame.VideoFrame + {- ^ /@videoBuf@/: a 'GI.GstVideo.Structs.VideoFrame.VideoFrame' containing raw video data in a + supported format. It should be mapped using GST_MAP_READWRITE -} + -> m Bool +videoOverlayCompositionBlend comp videoBuf = liftIO $ do + comp' <- unsafeManagedPtrGetPtr comp + videoBuf' <- unsafeManagedPtrGetPtr videoBuf + result <- gst_video_overlay_composition_blend comp' videoBuf' + let result' = (/= 0) result + touchManagedPtr comp + touchManagedPtr videoBuf + return result' + +#if ENABLE_OVERLOADING +data VideoOverlayCompositionBlendMethodInfo +instance (signature ~ (GstVideo.VideoFrame.VideoFrame -> m Bool), MonadIO m) => O.MethodInfo VideoOverlayCompositionBlendMethodInfo VideoOverlayComposition signature where + overloadedMethod _ = videoOverlayCompositionBlend + +#endif + +-- method VideoOverlayComposition::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "comp", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayComposition to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_composition_copy" gst_video_overlay_composition_copy :: + Ptr VideoOverlayComposition -> -- comp : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}) + IO (Ptr VideoOverlayComposition) + +{- | +Makes a copy of /@comp@/ and all contained rectangles, so that it is possible +to modify the composition and contained rectangles (e.g. add additional +rectangles or change the render co-ordinates or render dimension). The +actual overlay pixel data buffers contained in the rectangles are not +copied. +-} +videoOverlayCompositionCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayComposition + {- ^ /@comp@/: a 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' to copy -} + -> m VideoOverlayComposition + {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' equivalent + to /@comp@/. -} +videoOverlayCompositionCopy comp = liftIO $ do + comp' <- unsafeManagedPtrGetPtr comp + result <- gst_video_overlay_composition_copy comp' + checkUnexpectedReturnNULL "videoOverlayCompositionCopy" result + result' <- (wrapBoxed VideoOverlayComposition) result + touchManagedPtr comp + return result' + +#if ENABLE_OVERLOADING +data VideoOverlayCompositionCopyMethodInfo +instance (signature ~ (m VideoOverlayComposition), MonadIO m) => O.MethodInfo VideoOverlayCompositionCopyMethodInfo VideoOverlayComposition signature where + overloadedMethod _ = videoOverlayCompositionCopy + +#endif + +-- method VideoOverlayComposition::get_rectangle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "comp", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayComposition", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of the rectangle to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_composition_get_rectangle" gst_video_overlay_composition_get_rectangle :: + Ptr VideoOverlayComposition -> -- comp : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}) + Word32 -> -- n : TBasicType TUInt + IO (Ptr GstVideo.VideoOverlayRectangle.VideoOverlayRectangle) + +{- | +Returns the /@n@/-th 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' contained in /@comp@/. +-} +videoOverlayCompositionGetRectangle :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayComposition + {- ^ /@comp@/: a 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' -} + -> Word32 + {- ^ /@n@/: number of the rectangle to get -} + -> m GstVideo.VideoOverlayRectangle.VideoOverlayRectangle + {- ^ __Returns:__ the /@n@/-th rectangle, or NULL if /@n@/ is out of + bounds. Will not return a new reference, the caller will need to + obtain her own reference using @/gst_video_overlay_rectangle_ref()/@ + if needed. -} +videoOverlayCompositionGetRectangle comp n = liftIO $ do + comp' <- unsafeManagedPtrGetPtr comp + result <- gst_video_overlay_composition_get_rectangle comp' n + checkUnexpectedReturnNULL "videoOverlayCompositionGetRectangle" result + result' <- (newBoxed GstVideo.VideoOverlayRectangle.VideoOverlayRectangle) result + touchManagedPtr comp + return result' + +#if ENABLE_OVERLOADING +data VideoOverlayCompositionGetRectangleMethodInfo +instance (signature ~ (Word32 -> m GstVideo.VideoOverlayRectangle.VideoOverlayRectangle), MonadIO m) => O.MethodInfo VideoOverlayCompositionGetRectangleMethodInfo VideoOverlayComposition signature where + overloadedMethod _ = videoOverlayCompositionGetRectangle + +#endif + +-- method VideoOverlayComposition::get_seqnum +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "comp", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayComposition", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_composition_get_seqnum" gst_video_overlay_composition_get_seqnum :: + Ptr VideoOverlayComposition -> -- comp : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}) + IO Word32 + +{- | +Returns the sequence number of this composition. Sequence numbers are +monotonically increasing and unique for overlay compositions and rectangles +(meaning there will never be a rectangle with the same sequence number as +a composition). +-} +videoOverlayCompositionGetSeqnum :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayComposition + {- ^ /@comp@/: a 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' -} + -> m Word32 + {- ^ __Returns:__ the sequence number of /@comp@/ -} +videoOverlayCompositionGetSeqnum comp = liftIO $ do + comp' <- unsafeManagedPtrGetPtr comp + result <- gst_video_overlay_composition_get_seqnum comp' + touchManagedPtr comp + return result + +#if ENABLE_OVERLOADING +data VideoOverlayCompositionGetSeqnumMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo VideoOverlayCompositionGetSeqnumMethodInfo VideoOverlayComposition signature where + overloadedMethod _ = videoOverlayCompositionGetSeqnum + +#endif + +-- method VideoOverlayComposition::make_writable +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "comp", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayComposition to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_composition_make_writable" gst_video_overlay_composition_make_writable :: + Ptr VideoOverlayComposition -> -- comp : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}) + IO (Ptr VideoOverlayComposition) + +{- | +Takes ownership of /@comp@/ and returns a version of /@comp@/ that is writable +(i.e. can be modified). Will either return /@comp@/ right away, or create a +new writable copy of /@comp@/ and unref /@comp@/ itself. All the contained +rectangles will also be copied, but the actual overlay pixel data buffers +contained in the rectangles are not copied. +-} +videoOverlayCompositionMakeWritable :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayComposition + {- ^ /@comp@/: a 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' to copy -} + -> m VideoOverlayComposition + {- ^ __Returns:__ a writable 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' + equivalent to /@comp@/. -} +videoOverlayCompositionMakeWritable comp = liftIO $ do + comp' <- B.ManagedPtr.disownBoxed comp + result <- gst_video_overlay_composition_make_writable comp' + checkUnexpectedReturnNULL "videoOverlayCompositionMakeWritable" result + result' <- (wrapBoxed VideoOverlayComposition) result + touchManagedPtr comp + return result' + +#if ENABLE_OVERLOADING +data VideoOverlayCompositionMakeWritableMethodInfo +instance (signature ~ (m VideoOverlayComposition), MonadIO m) => O.MethodInfo VideoOverlayCompositionMakeWritableMethodInfo VideoOverlayComposition signature where + overloadedMethod _ = videoOverlayCompositionMakeWritable + +#endif + +-- method VideoOverlayComposition::n_rectangles +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "comp", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayComposition", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_composition_n_rectangles" gst_video_overlay_composition_n_rectangles :: + Ptr VideoOverlayComposition -> -- comp : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayComposition"}) + IO Word32 + +{- | +Returns the number of 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle'\s contained in /@comp@/. +-} +videoOverlayCompositionNRectangles :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayComposition + {- ^ /@comp@/: a 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' -} + -> m Word32 + {- ^ __Returns:__ the number of rectangles -} +videoOverlayCompositionNRectangles comp = liftIO $ do + comp' <- unsafeManagedPtrGetPtr comp + result <- gst_video_overlay_composition_n_rectangles comp' + touchManagedPtr comp + return result + +#if ENABLE_OVERLOADING +data VideoOverlayCompositionNRectanglesMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo VideoOverlayCompositionNRectanglesMethodInfo VideoOverlayComposition signature where + overloadedMethod _ = videoOverlayCompositionNRectangles + +#endif + +#if ENABLE_OVERLOADING +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 = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoOverlayCompositionMethod t VideoOverlayComposition, O.MethodInfo info VideoOverlayComposition p) => OL.IsLabel t (VideoOverlayComposition -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoOverlayComposition.hs-boot b/GI/GstVideo/Structs/VideoOverlayComposition.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoOverlayComposition.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoOverlayComposition where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoOverlayComposition = VideoOverlayComposition (ManagedPtr VideoOverlayComposition) +instance BoxedObject VideoOverlayComposition where +#if ENABLE_OVERLOADING +data VideoOverlayCompositionAddRectangleMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayCompositionBlendMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayCompositionCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayCompositionGetRectangleMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayCompositionGetSeqnumMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayCompositionMakeWritableMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayCompositionNRectanglesMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoOverlayCompositionMeta.hs b/GI/GstVideo/Structs/VideoOverlayCompositionMeta.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoOverlayCompositionMeta.hs @@ -0,0 +1,242 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Extra buffer metadata describing image overlay data. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoOverlayCompositionMeta + ( + +-- * Exported types + VideoOverlayCompositionMeta(..) , + newZeroVideoOverlayCompositionMeta , + noVideoOverlayCompositionMeta , + + + -- * Methods +-- ** getInfo #method:getInfo# + + videoOverlayCompositionMetaGetInfo , + + + + + -- * Properties +-- ** meta #attr:meta# +{- | parent 'GI.Gst.Structs.Meta.Meta' +-} + getVideoOverlayCompositionMetaMeta , +#if ENABLE_OVERLOADING + videoOverlayCompositionMeta_meta , +#endif + + +-- ** overlay #attr:overlay# +{- | the attached 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' +-} + clearVideoOverlayCompositionMetaOverlay , + getVideoOverlayCompositionMetaOverlay , + setVideoOverlayCompositionMetaOverlay , +#if ENABLE_OVERLOADING + videoOverlayCompositionMeta_overlay , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Structs.Meta as Gst.Meta +import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoOverlayComposition as GstVideo.VideoOverlayComposition + +-- | Memory-managed wrapper type. +newtype VideoOverlayCompositionMeta = VideoOverlayCompositionMeta (ManagedPtr VideoOverlayCompositionMeta) +instance WrappedPtr VideoOverlayCompositionMeta where + wrappedPtrCalloc = callocBytes 24 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 24 >=> wrapPtr VideoOverlayCompositionMeta) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoOverlayCompositionMeta` struct initialized to zero. +newZeroVideoOverlayCompositionMeta :: MonadIO m => m VideoOverlayCompositionMeta +newZeroVideoOverlayCompositionMeta = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoOverlayCompositionMeta + +instance tag ~ 'AttrSet => Constructible VideoOverlayCompositionMeta tag where + new _ attrs = do + o <- newZeroVideoOverlayCompositionMeta + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoOverlayCompositionMeta`. +noVideoOverlayCompositionMeta :: Maybe VideoOverlayCompositionMeta +noVideoOverlayCompositionMeta = Nothing + +{- | +Get the value of the “@meta@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoOverlayCompositionMeta #meta +@ +-} +getVideoOverlayCompositionMetaMeta :: MonadIO m => VideoOverlayCompositionMeta -> m Gst.Meta.Meta +getVideoOverlayCompositionMetaMeta s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Gst.Meta.Meta) + val' <- (newPtr Gst.Meta.Meta) val + return val' + +#if ENABLE_OVERLOADING +data VideoOverlayCompositionMetaMetaFieldInfo +instance AttrInfo VideoOverlayCompositionMetaMetaFieldInfo where + type AttrAllowedOps VideoOverlayCompositionMetaMetaFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint VideoOverlayCompositionMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta) + type AttrBaseTypeConstraint VideoOverlayCompositionMetaMetaFieldInfo = (~) VideoOverlayCompositionMeta + type AttrGetType VideoOverlayCompositionMetaMetaFieldInfo = Gst.Meta.Meta + type AttrLabel VideoOverlayCompositionMetaMetaFieldInfo = "meta" + type AttrOrigin VideoOverlayCompositionMetaMetaFieldInfo = VideoOverlayCompositionMeta + attrGet _ = getVideoOverlayCompositionMetaMeta + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +videoOverlayCompositionMeta_meta :: AttrLabelProxy "meta" +videoOverlayCompositionMeta_meta = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@overlay@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoOverlayCompositionMeta #overlay +@ +-} +getVideoOverlayCompositionMetaOverlay :: MonadIO m => VideoOverlayCompositionMeta -> m (Maybe GstVideo.VideoOverlayComposition.VideoOverlayComposition) +getVideoOverlayCompositionMetaOverlay s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO (Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed GstVideo.VideoOverlayComposition.VideoOverlayComposition) val' + return val'' + return result + +{- | +Set the value of the “@overlay@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoOverlayCompositionMeta [ #overlay 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoOverlayCompositionMetaOverlay :: MonadIO m => VideoOverlayCompositionMeta -> Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition -> m () +setVideoOverlayCompositionMetaOverlay s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition) + +{- | +Set the value of the “@overlay@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #overlay +@ +-} +clearVideoOverlayCompositionMetaOverlay :: MonadIO m => VideoOverlayCompositionMeta -> m () +clearVideoOverlayCompositionMetaOverlay s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition) + +#if ENABLE_OVERLOADING +data VideoOverlayCompositionMetaOverlayFieldInfo +instance AttrInfo VideoOverlayCompositionMetaOverlayFieldInfo where + type AttrAllowedOps VideoOverlayCompositionMetaOverlayFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoOverlayCompositionMetaOverlayFieldInfo = (~) (Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition) + type AttrBaseTypeConstraint VideoOverlayCompositionMetaOverlayFieldInfo = (~) VideoOverlayCompositionMeta + type AttrGetType VideoOverlayCompositionMetaOverlayFieldInfo = Maybe GstVideo.VideoOverlayComposition.VideoOverlayComposition + type AttrLabel VideoOverlayCompositionMetaOverlayFieldInfo = "overlay" + type AttrOrigin VideoOverlayCompositionMetaOverlayFieldInfo = VideoOverlayCompositionMeta + attrGet _ = getVideoOverlayCompositionMetaOverlay + attrSet _ = setVideoOverlayCompositionMetaOverlay + attrConstruct = undefined + attrClear _ = clearVideoOverlayCompositionMetaOverlay + +videoOverlayCompositionMeta_overlay :: AttrLabelProxy "overlay" +videoOverlayCompositionMeta_overlay = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoOverlayCompositionMeta +type instance O.AttributeList VideoOverlayCompositionMeta = VideoOverlayCompositionMetaAttributeList +type VideoOverlayCompositionMetaAttributeList = ('[ '("meta", VideoOverlayCompositionMetaMetaFieldInfo), '("overlay", VideoOverlayCompositionMetaOverlayFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoOverlayCompositionMeta::get_info +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "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.MetaInfo) + +{- | +/No description available in the introspection data./ +-} +videoOverlayCompositionMetaGetInfo :: + (B.CallStack.HasCallStack, MonadIO m) => + m Gst.MetaInfo.MetaInfo +videoOverlayCompositionMetaGetInfo = liftIO $ do + result <- gst_video_overlay_composition_meta_get_info + checkUnexpectedReturnNULL "videoOverlayCompositionMetaGetInfo" result + result' <- (newPtr Gst.MetaInfo.MetaInfo) result + return result' + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoOverlayCompositionMetaMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoOverlayCompositionMetaMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoOverlayCompositionMetaMethod t VideoOverlayCompositionMeta, O.MethodInfo info VideoOverlayCompositionMeta p) => OL.IsLabel t (VideoOverlayCompositionMeta -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoOverlayCompositionMeta.hs-boot b/GI/GstVideo/Structs/VideoOverlayCompositionMeta.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoOverlayCompositionMeta.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoOverlayCompositionMeta where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoOverlayCompositionMeta = VideoOverlayCompositionMeta (ManagedPtr VideoOverlayCompositionMeta) +instance WrappedPtr VideoOverlayCompositionMeta where diff --git a/GI/GstVideo/Structs/VideoOverlayRectangle.hs b/GI/GstVideo/Structs/VideoOverlayRectangle.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoOverlayRectangle.hs @@ -0,0 +1,868 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +An opaque video overlay rectangle object. A rectangle contains a single +overlay rectangle which can be added to a composition. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoOverlayRectangle + ( + +-- * Exported types + VideoOverlayRectangle(..) , + noVideoOverlayRectangle , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + VideoOverlayRectangleCopyMethodInfo , +#endif + videoOverlayRectangleCopy , + + +-- ** getFlags #method:getFlags# + +#if ENABLE_OVERLOADING + VideoOverlayRectangleGetFlagsMethodInfo , +#endif + videoOverlayRectangleGetFlags , + + +-- ** getGlobalAlpha #method:getGlobalAlpha# + +#if ENABLE_OVERLOADING + VideoOverlayRectangleGetGlobalAlphaMethodInfo, +#endif + videoOverlayRectangleGetGlobalAlpha , + + +-- ** getPixelsArgb #method:getPixelsArgb# + +#if ENABLE_OVERLOADING + VideoOverlayRectangleGetPixelsArgbMethodInfo, +#endif + videoOverlayRectangleGetPixelsArgb , + + +-- ** getPixelsAyuv #method:getPixelsAyuv# + +#if ENABLE_OVERLOADING + VideoOverlayRectangleGetPixelsAyuvMethodInfo, +#endif + videoOverlayRectangleGetPixelsAyuv , + + +-- ** getPixelsRaw #method:getPixelsRaw# + +#if ENABLE_OVERLOADING + VideoOverlayRectangleGetPixelsRawMethodInfo, +#endif + videoOverlayRectangleGetPixelsRaw , + + +-- ** getPixelsUnscaledArgb #method:getPixelsUnscaledArgb# + +#if ENABLE_OVERLOADING + VideoOverlayRectangleGetPixelsUnscaledArgbMethodInfo, +#endif + videoOverlayRectangleGetPixelsUnscaledArgb, + + +-- ** getPixelsUnscaledAyuv #method:getPixelsUnscaledAyuv# + +#if ENABLE_OVERLOADING + VideoOverlayRectangleGetPixelsUnscaledAyuvMethodInfo, +#endif + videoOverlayRectangleGetPixelsUnscaledAyuv, + + +-- ** getPixelsUnscaledRaw #method:getPixelsUnscaledRaw# + +#if ENABLE_OVERLOADING + VideoOverlayRectangleGetPixelsUnscaledRawMethodInfo, +#endif + videoOverlayRectangleGetPixelsUnscaledRaw, + + +-- ** getRenderRectangle #method:getRenderRectangle# + +#if ENABLE_OVERLOADING + VideoOverlayRectangleGetRenderRectangleMethodInfo, +#endif + videoOverlayRectangleGetRenderRectangle , + + +-- ** getSeqnum #method:getSeqnum# + +#if ENABLE_OVERLOADING + VideoOverlayRectangleGetSeqnumMethodInfo, +#endif + videoOverlayRectangleGetSeqnum , + + +-- ** newRaw #method:newRaw# + + videoOverlayRectangleNewRaw , + + +-- ** setGlobalAlpha #method:setGlobalAlpha# + +#if ENABLE_OVERLOADING + VideoOverlayRectangleSetGlobalAlphaMethodInfo, +#endif + videoOverlayRectangleSetGlobalAlpha , + + +-- ** setRenderRectangle #method:setRenderRectangle# + +#if ENABLE_OVERLOADING + VideoOverlayRectangleSetRenderRectangleMethodInfo, +#endif + videoOverlayRectangleSetRenderRectangle , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Structs.Buffer as Gst.Buffer +import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags + +-- | Memory-managed wrapper type. +newtype VideoOverlayRectangle = VideoOverlayRectangle (ManagedPtr 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 + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoOverlayRectangle`. +noVideoOverlayRectangle :: Maybe VideoOverlayRectangle +noVideoOverlayRectangle = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoOverlayRectangle +type instance O.AttributeList VideoOverlayRectangle = VideoOverlayRectangleAttributeList +type VideoOverlayRectangleAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method VideoOverlayRectangle::new_raw +-- method type : Constructor +-- Args : [Arg {argCName = "pixels", argType = TInterface (Name {namespace = "Gst", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBuffer pointing to the pixel memory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the X co-ordinate on the video where the top-left corner of this\n overlay rectangle should be rendered to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the Y co-ordinate on the video where the top-left corner of this\n overlay rectangle should be rendered to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the render width of this rectangle on the video", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the render height of this rectangle on the video", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_rectangle_new_raw" gst_video_overlay_rectangle_new_raw :: + Ptr Gst.Buffer.Buffer -> -- pixels : TInterface (Name {namespace = "Gst", name = "Buffer"}) + Int32 -> -- render_x : TBasicType TInt + Int32 -> -- render_y : TBasicType TInt + Word32 -> -- render_width : TBasicType TUInt + Word32 -> -- render_height : TBasicType TUInt + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}) + IO (Ptr VideoOverlayRectangle) + +{- | +Creates a new video overlay rectangle with ARGB or AYUV pixel data. +The layout in case of ARGB of the components in memory is B-G-R-A +on little-endian platforms +(corresponding to @/GST_VIDEO_FORMAT_BGRA/@) and A-R-G-B on big-endian +platforms (corresponding to @/GST_VIDEO_FORMAT_ARGB/@). In other words, +pixels are treated as 32-bit words and the lowest 8 bits then contain +the blue component value and the highest 8 bits contain the alpha +component value. Unless specified in the flags, the RGB values are +non-premultiplied. This is the format that is used by most hardware, +and also many rendering libraries such as Cairo, for example. +The pixel data buffer must have 'GI.GstVideo.Structs.VideoMeta.VideoMeta' set. +-} +videoOverlayRectangleNewRaw :: + (B.CallStack.HasCallStack, MonadIO m) => + Gst.Buffer.Buffer + {- ^ /@pixels@/: a 'GI.Gst.Structs.Buffer.Buffer' pointing to the pixel memory -} + -> Int32 + {- ^ /@renderX@/: the X co-ordinate on the video where the top-left corner of this + overlay rectangle should be rendered to -} + -> Int32 + {- ^ /@renderY@/: the Y co-ordinate on the video where the top-left corner of this + overlay rectangle should be rendered to -} + -> Word32 + {- ^ /@renderWidth@/: the render width of this rectangle on the video -} + -> Word32 + {- ^ /@renderHeight@/: the render height of this rectangle on the video -} + -> [GstVideo.Flags.VideoOverlayFormatFlags] + {- ^ /@flags@/: flags -} + -> m VideoOverlayRectangle + {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle'. Unref with + @/gst_video_overlay_rectangle_unref()/@ when no longer needed. -} +videoOverlayRectangleNewRaw pixels renderX renderY renderWidth renderHeight flags = liftIO $ do + pixels' <- unsafeManagedPtrGetPtr pixels + let flags' = gflagsToWord flags + result <- gst_video_overlay_rectangle_new_raw pixels' renderX renderY renderWidth renderHeight flags' + checkUnexpectedReturnNULL "videoOverlayRectangleNewRaw" result + result' <- (wrapBoxed VideoOverlayRectangle) result + touchManagedPtr pixels + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method VideoOverlayRectangle::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_rectangle_copy" gst_video_overlay_rectangle_copy :: + Ptr VideoOverlayRectangle -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + IO (Ptr VideoOverlayRectangle) + +{- | +Makes a copy of /@rectangle@/, so that it is possible to modify it +(e.g. to change the render co-ordinates or render dimension). The +actual overlay pixel data buffers contained in the rectangle are not +copied. +-} +videoOverlayRectangleCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' to copy -} + -> m VideoOverlayRectangle + {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' equivalent + to /@rectangle@/. -} +videoOverlayRectangleCopy rectangle = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + result <- gst_video_overlay_rectangle_copy rectangle' + checkUnexpectedReturnNULL "videoOverlayRectangleCopy" result + result' <- (wrapBoxed VideoOverlayRectangle) result + touchManagedPtr rectangle + return result' + +#if ENABLE_OVERLOADING +data VideoOverlayRectangleCopyMethodInfo +instance (signature ~ (m VideoOverlayRectangle), MonadIO m) => O.MethodInfo VideoOverlayRectangleCopyMethodInfo VideoOverlayRectangle signature where + overloadedMethod _ = videoOverlayRectangleCopy + +#endif + +-- method VideoOverlayRectangle::get_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_rectangle_get_flags" gst_video_overlay_rectangle_get_flags :: + Ptr VideoOverlayRectangle -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + IO CUInt + +{- | +Retrieves the flags associated with a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle'. +This is useful if the caller can handle both premultiplied alpha and +non premultiplied alpha, for example. By knowing whether the rectangle +uses premultiplied or not, it can request the pixel data in the format +it is stored in, to avoid unnecessary conversion. +-} +videoOverlayRectangleGetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' -} + -> m [GstVideo.Flags.VideoOverlayFormatFlags] + {- ^ __Returns:__ the 'GI.GstVideo.Flags.VideoOverlayFormatFlags' associated with the rectangle. -} +videoOverlayRectangleGetFlags rectangle = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + result <- gst_video_overlay_rectangle_get_flags rectangle' + let result' = wordToGFlags result + touchManagedPtr rectangle + return result' + +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetFlagsMethodInfo +instance (signature ~ (m [GstVideo.Flags.VideoOverlayFormatFlags]), MonadIO m) => O.MethodInfo VideoOverlayRectangleGetFlagsMethodInfo VideoOverlayRectangle signature where + overloadedMethod _ = videoOverlayRectangleGetFlags + +#endif + +-- method VideoOverlayRectangle::get_global_alpha +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (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 -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + IO CFloat + +{- | +Retrieves the global-alpha value associated with a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle'. +-} +videoOverlayRectangleGetGlobalAlpha :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' -} + -> m Float + {- ^ __Returns:__ the global-alpha value associated with the rectangle. -} +videoOverlayRectangleGetGlobalAlpha rectangle = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + result <- gst_video_overlay_rectangle_get_global_alpha rectangle' + let result' = realToFrac result + touchManagedPtr rectangle + return result' + +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetGlobalAlphaMethodInfo +instance (signature ~ (m Float), MonadIO m) => O.MethodInfo VideoOverlayRectangleGetGlobalAlphaMethodInfo VideoOverlayRectangle signature where + overloadedMethod _ = videoOverlayRectangleGetGlobalAlpha + +#endif + +-- method VideoOverlayRectangle::get_pixels_argb +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags\n If a global_alpha value != 1 is set for the rectangle, the caller\n should set the #GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA flag\n if he wants to apply global-alpha himself. If the flag is not set\n global_alpha is applied internally before returning the pixel-data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "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 -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}) + IO (Ptr Gst.Buffer.Buffer) + +{- | +/No description available in the introspection data./ +-} +videoOverlayRectangleGetPixelsArgb :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' -} + -> [GstVideo.Flags.VideoOverlayFormatFlags] + {- ^ /@flags@/: flags + If a global_alpha value != 1 is set for the rectangle, the caller + should set the @/GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA/@ flag + if he wants to apply global-alpha himself. If the flag is not set + global_alpha is applied internally before returning the pixel-data. -} + -> m Gst.Buffer.Buffer + {- ^ __Returns:__ a 'GI.Gst.Structs.Buffer.Buffer' holding the ARGB pixel data with + width and height of the render dimensions as per + 'GI.GstVideo.Structs.VideoOverlayRectangle.videoOverlayRectangleGetRenderRectangle'. This function does + not return a reference, the caller should obtain a reference of her own + with @/gst_buffer_ref()/@ if needed. -} +videoOverlayRectangleGetPixelsArgb rectangle flags = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + let flags' = gflagsToWord flags + result <- gst_video_overlay_rectangle_get_pixels_argb rectangle' flags' + checkUnexpectedReturnNULL "videoOverlayRectangleGetPixelsArgb" result + result' <- (newBoxed Gst.Buffer.Buffer) result + touchManagedPtr rectangle + return result' + +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetPixelsArgbMethodInfo +instance (signature ~ ([GstVideo.Flags.VideoOverlayFormatFlags] -> m Gst.Buffer.Buffer), MonadIO m) => O.MethodInfo VideoOverlayRectangleGetPixelsArgbMethodInfo VideoOverlayRectangle signature where + overloadedMethod _ = videoOverlayRectangleGetPixelsArgb + +#endif + +-- method VideoOverlayRectangle::get_pixels_ayuv +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags\n If a global_alpha value != 1 is set for the rectangle, the caller\n should set the #GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA flag\n if he wants to apply global-alpha himself. If the flag is not set\n global_alpha is applied internally before returning the pixel-data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "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 -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}) + IO (Ptr Gst.Buffer.Buffer) + +{- | +/No description available in the introspection data./ +-} +videoOverlayRectangleGetPixelsAyuv :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' -} + -> [GstVideo.Flags.VideoOverlayFormatFlags] + {- ^ /@flags@/: flags + If a global_alpha value != 1 is set for the rectangle, the caller + should set the @/GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA/@ flag + if he wants to apply global-alpha himself. If the flag is not set + global_alpha is applied internally before returning the pixel-data. -} + -> m Gst.Buffer.Buffer + {- ^ __Returns:__ a 'GI.Gst.Structs.Buffer.Buffer' holding the AYUV pixel data with + width and height of the render dimensions as per + 'GI.GstVideo.Structs.VideoOverlayRectangle.videoOverlayRectangleGetRenderRectangle'. This function does + not return a reference, the caller should obtain a reference of her own + with @/gst_buffer_ref()/@ if needed. -} +videoOverlayRectangleGetPixelsAyuv rectangle flags = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + let flags' = gflagsToWord flags + result <- gst_video_overlay_rectangle_get_pixels_ayuv rectangle' flags' + checkUnexpectedReturnNULL "videoOverlayRectangleGetPixelsAyuv" result + result' <- (newBoxed Gst.Buffer.Buffer) result + touchManagedPtr rectangle + return result' + +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetPixelsAyuvMethodInfo +instance (signature ~ ([GstVideo.Flags.VideoOverlayFormatFlags] -> m Gst.Buffer.Buffer), MonadIO m) => O.MethodInfo VideoOverlayRectangleGetPixelsAyuvMethodInfo VideoOverlayRectangle signature where + overloadedMethod _ = videoOverlayRectangleGetPixelsAyuv + +#endif + +-- method VideoOverlayRectangle::get_pixels_raw +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags\n If a global_alpha value != 1 is set for the rectangle, the caller\n should set the #GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA flag\n if he wants to apply global-alpha himself. If the flag is not set\n global_alpha is applied internally before returning the pixel-data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "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 -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}) + IO (Ptr Gst.Buffer.Buffer) + +{- | +/No description available in the introspection data./ +-} +videoOverlayRectangleGetPixelsRaw :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' -} + -> [GstVideo.Flags.VideoOverlayFormatFlags] + {- ^ /@flags@/: flags + If a global_alpha value != 1 is set for the rectangle, the caller + should set the @/GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA/@ flag + if he wants to apply global-alpha himself. If the flag is not set + global_alpha is applied internally before returning the pixel-data. -} + -> m Gst.Buffer.Buffer + {- ^ __Returns:__ a 'GI.Gst.Structs.Buffer.Buffer' holding the pixel data with + format as originally provided and specified in video meta with + width and height of the render dimensions as per + 'GI.GstVideo.Structs.VideoOverlayRectangle.videoOverlayRectangleGetRenderRectangle'. This function does + not return a reference, the caller should obtain a reference of her own + with @/gst_buffer_ref()/@ if needed. -} +videoOverlayRectangleGetPixelsRaw rectangle flags = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + let flags' = gflagsToWord flags + result <- gst_video_overlay_rectangle_get_pixels_raw rectangle' flags' + checkUnexpectedReturnNULL "videoOverlayRectangleGetPixelsRaw" result + result' <- (newBoxed Gst.Buffer.Buffer) result + touchManagedPtr rectangle + return result' + +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetPixelsRawMethodInfo +instance (signature ~ ([GstVideo.Flags.VideoOverlayFormatFlags] -> m Gst.Buffer.Buffer), MonadIO m) => O.MethodInfo VideoOverlayRectangleGetPixelsRawMethodInfo VideoOverlayRectangle signature where + overloadedMethod _ = videoOverlayRectangleGetPixelsRaw + +#endif + +-- method VideoOverlayRectangle::get_pixels_unscaled_argb +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags.\n If a global_alpha value != 1 is set for the rectangle, the caller\n should set the #GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA flag\n if he wants to apply global-alpha himself. If the flag is not set\n global_alpha is applied internally before returning the pixel-data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "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 -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}) + IO (Ptr Gst.Buffer.Buffer) + +{- | +Retrieves the pixel data as it is. This is useful if the caller can +do the scaling itself when handling the overlaying. The rectangle will +need to be scaled to the render dimensions, which can be retrieved using +'GI.GstVideo.Structs.VideoOverlayRectangle.videoOverlayRectangleGetRenderRectangle'. +-} +videoOverlayRectangleGetPixelsUnscaledArgb :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' -} + -> [GstVideo.Flags.VideoOverlayFormatFlags] + {- ^ /@flags@/: flags. + If a global_alpha value != 1 is set for the rectangle, the caller + should set the @/GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA/@ flag + if he wants to apply global-alpha himself. If the flag is not set + global_alpha is applied internally before returning the pixel-data. -} + -> m Gst.Buffer.Buffer + {- ^ __Returns:__ a 'GI.Gst.Structs.Buffer.Buffer' holding the ARGB pixel data with + 'GI.GstVideo.Structs.VideoMeta.VideoMeta' set. This function does not return a reference, the caller + should obtain a reference of her own with @/gst_buffer_ref()/@ if needed. -} +videoOverlayRectangleGetPixelsUnscaledArgb rectangle flags = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + let flags' = gflagsToWord flags + result <- gst_video_overlay_rectangle_get_pixels_unscaled_argb rectangle' flags' + checkUnexpectedReturnNULL "videoOverlayRectangleGetPixelsUnscaledArgb" result + result' <- (newBoxed Gst.Buffer.Buffer) result + touchManagedPtr rectangle + return result' + +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetPixelsUnscaledArgbMethodInfo +instance (signature ~ ([GstVideo.Flags.VideoOverlayFormatFlags] -> m Gst.Buffer.Buffer), MonadIO m) => O.MethodInfo VideoOverlayRectangleGetPixelsUnscaledArgbMethodInfo VideoOverlayRectangle signature where + overloadedMethod _ = videoOverlayRectangleGetPixelsUnscaledArgb + +#endif + +-- method VideoOverlayRectangle::get_pixels_unscaled_ayuv +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags.\n If a global_alpha value != 1 is set for the rectangle, the caller\n should set the #GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA flag\n if he wants to apply global-alpha himself. If the flag is not set\n global_alpha is applied internally before returning the pixel-data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "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 -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}) + IO (Ptr Gst.Buffer.Buffer) + +{- | +Retrieves the pixel data as it is. This is useful if the caller can +do the scaling itself when handling the overlaying. The rectangle will +need to be scaled to the render dimensions, which can be retrieved using +'GI.GstVideo.Structs.VideoOverlayRectangle.videoOverlayRectangleGetRenderRectangle'. +-} +videoOverlayRectangleGetPixelsUnscaledAyuv :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' -} + -> [GstVideo.Flags.VideoOverlayFormatFlags] + {- ^ /@flags@/: flags. + If a global_alpha value != 1 is set for the rectangle, the caller + should set the @/GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA/@ flag + if he wants to apply global-alpha himself. If the flag is not set + global_alpha is applied internally before returning the pixel-data. -} + -> m Gst.Buffer.Buffer + {- ^ __Returns:__ a 'GI.Gst.Structs.Buffer.Buffer' holding the AYUV pixel data with + 'GI.GstVideo.Structs.VideoMeta.VideoMeta' set. This function does not return a reference, the caller + should obtain a reference of her own with @/gst_buffer_ref()/@ if needed. -} +videoOverlayRectangleGetPixelsUnscaledAyuv rectangle flags = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + let flags' = gflagsToWord flags + result <- gst_video_overlay_rectangle_get_pixels_unscaled_ayuv rectangle' flags' + checkUnexpectedReturnNULL "videoOverlayRectangleGetPixelsUnscaledAyuv" result + result' <- (newBoxed Gst.Buffer.Buffer) result + touchManagedPtr rectangle + return result' + +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetPixelsUnscaledAyuvMethodInfo +instance (signature ~ ([GstVideo.Flags.VideoOverlayFormatFlags] -> m Gst.Buffer.Buffer), MonadIO m) => O.MethodInfo VideoOverlayRectangleGetPixelsUnscaledAyuvMethodInfo VideoOverlayRectangle signature where + overloadedMethod _ = videoOverlayRectangleGetPixelsUnscaledAyuv + +#endif + +-- method VideoOverlayRectangle::get_pixels_unscaled_raw +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags.\n If a global_alpha value != 1 is set for the rectangle, the caller\n should set the #GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA flag\n if he wants to apply global-alpha himself. If the flag is not set\n global_alpha is applied internally before returning the pixel-data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "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 -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayFormatFlags"}) + IO (Ptr Gst.Buffer.Buffer) + +{- | +Retrieves the pixel data as it is. This is useful if the caller can +do the scaling itself when handling the overlaying. The rectangle will +need to be scaled to the render dimensions, which can be retrieved using +'GI.GstVideo.Structs.VideoOverlayRectangle.videoOverlayRectangleGetRenderRectangle'. +-} +videoOverlayRectangleGetPixelsUnscaledRaw :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' -} + -> [GstVideo.Flags.VideoOverlayFormatFlags] + {- ^ /@flags@/: flags. + If a global_alpha value != 1 is set for the rectangle, the caller + should set the @/GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA/@ flag + if he wants to apply global-alpha himself. If the flag is not set + global_alpha is applied internally before returning the pixel-data. -} + -> m Gst.Buffer.Buffer + {- ^ __Returns:__ a 'GI.Gst.Structs.Buffer.Buffer' holding the pixel data with + 'GI.GstVideo.Structs.VideoMeta.VideoMeta' set. This function does not return a reference, the caller + should obtain a reference of her own with @/gst_buffer_ref()/@ if needed. -} +videoOverlayRectangleGetPixelsUnscaledRaw rectangle flags = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + let flags' = gflagsToWord flags + result <- gst_video_overlay_rectangle_get_pixels_unscaled_raw rectangle' flags' + checkUnexpectedReturnNULL "videoOverlayRectangleGetPixelsUnscaledRaw" result + result' <- (newBoxed Gst.Buffer.Buffer) result + touchManagedPtr rectangle + return result' + +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetPixelsUnscaledRawMethodInfo +instance (signature ~ ([GstVideo.Flags.VideoOverlayFormatFlags] -> m Gst.Buffer.Buffer), MonadIO m) => O.MethodInfo VideoOverlayRectangleGetPixelsUnscaledRawMethodInfo VideoOverlayRectangle signature where + overloadedMethod _ = videoOverlayRectangleGetPixelsUnscaledRaw + +#endif + +-- method VideoOverlayRectangle::get_render_rectangle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_x", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address where to store the X render offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "render_y", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address where to store the Y render offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "render_width", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address where to store the render width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "render_height", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address where to store the render height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_rectangle_get_render_rectangle" gst_video_overlay_rectangle_get_render_rectangle :: + Ptr VideoOverlayRectangle -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + Ptr Int32 -> -- render_x : TBasicType TInt + Ptr Int32 -> -- render_y : TBasicType TInt + Ptr Word32 -> -- render_width : TBasicType TUInt + Ptr Word32 -> -- render_height : TBasicType TUInt + IO CInt + +{- | +Retrieves the render position and render dimension of the overlay +rectangle on the video. +-} +videoOverlayRectangleGetRenderRectangle :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' -} + -> m ((Bool, Int32, Int32, Word32, Word32)) + {- ^ __Returns:__ TRUE if valid render dimensions were retrieved. -} +videoOverlayRectangleGetRenderRectangle rectangle = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + 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 rectangle' renderX renderY renderWidth renderHeight + let result' = (/= 0) result + renderX' <- peek renderX + renderY' <- peek renderY + renderWidth' <- peek renderWidth + renderHeight' <- peek renderHeight + touchManagedPtr rectangle + freeMem renderX + freeMem renderY + freeMem renderWidth + freeMem renderHeight + return (result', renderX', renderY', renderWidth', renderHeight') + +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetRenderRectangleMethodInfo +instance (signature ~ (m ((Bool, Int32, Int32, Word32, Word32))), MonadIO m) => O.MethodInfo VideoOverlayRectangleGetRenderRectangleMethodInfo VideoOverlayRectangle signature where + overloadedMethod _ = videoOverlayRectangleGetRenderRectangle + +#endif + +-- method VideoOverlayRectangle::get_seqnum +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_rectangle_get_seqnum" gst_video_overlay_rectangle_get_seqnum :: + Ptr VideoOverlayRectangle -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + IO Word32 + +{- | +Returns the sequence number of this rectangle. Sequence numbers are +monotonically increasing and unique for overlay compositions and rectangles +(meaning there will never be a rectangle with the same sequence number as +a composition). + +Using the sequence number of a rectangle as an indicator for changed +pixel-data of a rectangle is dangereous. Some API calls, like e.g. +'GI.GstVideo.Structs.VideoOverlayRectangle.videoOverlayRectangleSetGlobalAlpha', automatically update +the per rectangle sequence number, which is misleading for renderers\/ +consumers, that handle global-alpha themselves. For them the +pixel-data returned by gst_video_overlay_rectangle_get_pixels_*() +wont be different for different global-alpha values. In this case a +renderer could also use the GstBuffer pointers as a hint for changed +pixel-data. +-} +videoOverlayRectangleGetSeqnum :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' -} + -> m Word32 + {- ^ __Returns:__ the sequence number of /@rectangle@/ -} +videoOverlayRectangleGetSeqnum rectangle = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + result <- gst_video_overlay_rectangle_get_seqnum rectangle' + touchManagedPtr rectangle + return result + +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetSeqnumMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo VideoOverlayRectangleGetSeqnumMethodInfo VideoOverlayRectangle signature where + overloadedMethod _ = videoOverlayRectangleGetSeqnum + +#endif + +-- method VideoOverlayRectangle::set_global_alpha +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "global_alpha", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Global alpha value (0 to 1.0)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_rectangle_set_global_alpha" gst_video_overlay_rectangle_set_global_alpha :: + Ptr VideoOverlayRectangle -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + CFloat -> -- global_alpha : TBasicType TFloat + IO () + +{- | +Sets the global alpha value associated with a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle'. Per- +pixel alpha values are multiplied with this value. Valid +values: 0 \<= global_alpha \<= 1; 1 to deactivate. + +/@rectangle@/ must be writable, meaning its refcount must be 1. You can +make the rectangles inside a 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' writable using +'GI.GstVideo.Structs.VideoOverlayComposition.videoOverlayCompositionMakeWritable' or +'GI.GstVideo.Structs.VideoOverlayComposition.videoOverlayCompositionCopy'. +-} +videoOverlayRectangleSetGlobalAlpha :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' -} + -> Float + {- ^ /@globalAlpha@/: Global alpha value (0 to 1.0) -} + -> m () +videoOverlayRectangleSetGlobalAlpha rectangle globalAlpha = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + let globalAlpha' = realToFrac globalAlpha + gst_video_overlay_rectangle_set_global_alpha rectangle' globalAlpha' + touchManagedPtr rectangle + return () + +#if ENABLE_OVERLOADING +data VideoOverlayRectangleSetGlobalAlphaMethodInfo +instance (signature ~ (Float -> m ()), MonadIO m) => O.MethodInfo VideoOverlayRectangleSetGlobalAlphaMethodInfo VideoOverlayRectangle signature where + overloadedMethod _ = videoOverlayRectangleSetGlobalAlpha + +#endif + +-- method VideoOverlayRectangle::set_render_rectangle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoOverlayRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "render X position of rectangle on video", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "render Y position of rectangle on video", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "render width of rectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "render_height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "render height of rectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_overlay_rectangle_set_render_rectangle" gst_video_overlay_rectangle_set_render_rectangle :: + Ptr VideoOverlayRectangle -> -- rectangle : TInterface (Name {namespace = "GstVideo", name = "VideoOverlayRectangle"}) + Int32 -> -- render_x : TBasicType TInt + Int32 -> -- render_y : TBasicType TInt + Word32 -> -- render_width : TBasicType TUInt + Word32 -> -- render_height : TBasicType TUInt + IO () + +{- | +Sets the render position and dimensions of the rectangle on the video. +This function is mainly for elements that modify the size of the video +in some way (e.g. through scaling or cropping) and need to adjust the +details of any overlays to match the operation that changed the size. + +/@rectangle@/ must be writable, meaning its refcount must be 1. You can +make the rectangles inside a 'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' writable using +'GI.GstVideo.Structs.VideoOverlayComposition.videoOverlayCompositionMakeWritable' or +'GI.GstVideo.Structs.VideoOverlayComposition.videoOverlayCompositionCopy'. +-} +videoOverlayRectangleSetRenderRectangle :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoOverlayRectangle + {- ^ /@rectangle@/: a 'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' -} + -> Int32 + {- ^ /@renderX@/: render X position of rectangle on video -} + -> Int32 + {- ^ /@renderY@/: render Y position of rectangle on video -} + -> Word32 + {- ^ /@renderWidth@/: render width of rectangle -} + -> Word32 + {- ^ /@renderHeight@/: render height of rectangle -} + -> m () +videoOverlayRectangleSetRenderRectangle rectangle renderX renderY renderWidth renderHeight = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + gst_video_overlay_rectangle_set_render_rectangle rectangle' renderX renderY renderWidth renderHeight + touchManagedPtr rectangle + return () + +#if ENABLE_OVERLOADING +data VideoOverlayRectangleSetRenderRectangleMethodInfo +instance (signature ~ (Int32 -> Int32 -> Word32 -> Word32 -> m ()), MonadIO m) => O.MethodInfo VideoOverlayRectangleSetRenderRectangleMethodInfo VideoOverlayRectangle signature where + overloadedMethod _ = videoOverlayRectangleSetRenderRectangle + +#endif + +#if ENABLE_OVERLOADING +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 = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoOverlayRectangleMethod t VideoOverlayRectangle, O.MethodInfo info VideoOverlayRectangle p) => OL.IsLabel t (VideoOverlayRectangle -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoOverlayRectangle.hs-boot b/GI/GstVideo/Structs/VideoOverlayRectangle.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoOverlayRectangle.hs-boot @@ -0,0 +1,65 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoOverlayRectangle where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoOverlayRectangle = VideoOverlayRectangle (ManagedPtr VideoOverlayRectangle) +instance BoxedObject VideoOverlayRectangle where +#if ENABLE_OVERLOADING +data VideoOverlayRectangleCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetGlobalAlphaMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetPixelsArgbMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetPixelsAyuvMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetPixelsRawMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetPixelsUnscaledArgbMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetPixelsUnscaledAyuvMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetPixelsUnscaledRawMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetRenderRectangleMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayRectangleGetSeqnumMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayRectangleSetGlobalAlphaMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoOverlayRectangleSetRenderRectangleMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoRectangle.hs b/GI/GstVideo/Structs/VideoRectangle.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoRectangle.hs @@ -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 (inaki@blueleaf.cc) + +Helper structure representing a rectangular area. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoRectangle + ( + +-- * Exported types + VideoRectangle(..) , + newZeroVideoRectangle , + noVideoRectangle , + + + -- * Properties +-- ** h #attr:h# +{- | height of the rectangle +-} + getVideoRectangleH , + setVideoRectangleH , +#if ENABLE_OVERLOADING + videoRectangle_h , +#endif + + +-- ** w #attr:w# +{- | width of the rectangle +-} + getVideoRectangleW , + setVideoRectangleW , +#if ENABLE_OVERLOADING + videoRectangle_w , +#endif + + +-- ** x #attr:x# +{- | X coordinate of rectangle\'s top-left point +-} + getVideoRectangleX , + setVideoRectangleX , +#if ENABLE_OVERLOADING + videoRectangle_x , +#endif + + +-- ** y #attr:y# +{- | Y coordinate of rectangle\'s top-left point +-} + getVideoRectangleY , + setVideoRectangleY , +#if ENABLE_OVERLOADING + videoRectangle_y , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- | Memory-managed wrapper type. +newtype VideoRectangle = VideoRectangle (ManagedPtr VideoRectangle) +instance WrappedPtr VideoRectangle where + wrappedPtrCalloc = callocBytes 16 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 16 >=> wrapPtr VideoRectangle) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoRectangle` struct initialized to zero. +newZeroVideoRectangle :: MonadIO m => m VideoRectangle +newZeroVideoRectangle = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoRectangle + +instance tag ~ 'AttrSet => Constructible VideoRectangle tag where + new _ attrs = do + o <- newZeroVideoRectangle + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoRectangle`. +noVideoRectangle :: Maybe VideoRectangle +noVideoRectangle = Nothing + +{- | +Get the value of the “@x@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoRectangle #x +@ +-} +getVideoRectangleX :: MonadIO m => VideoRectangle -> m Int32 +getVideoRectangleX s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Int32 + return val + +{- | +Set the value of the “@x@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoRectangle [ #x 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoRectangleX :: MonadIO m => VideoRectangle -> Int32 -> m () +setVideoRectangleX s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoRectangleXFieldInfo +instance AttrInfo VideoRectangleXFieldInfo where + type AttrAllowedOps VideoRectangleXFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoRectangleXFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoRectangleXFieldInfo = (~) VideoRectangle + type AttrGetType VideoRectangleXFieldInfo = Int32 + type AttrLabel VideoRectangleXFieldInfo = "x" + type AttrOrigin VideoRectangleXFieldInfo = VideoRectangle + attrGet _ = getVideoRectangleX + attrSet _ = setVideoRectangleX + attrConstruct = undefined + attrClear _ = undefined + +videoRectangle_x :: AttrLabelProxy "x" +videoRectangle_x = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@y@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoRectangle #y +@ +-} +getVideoRectangleY :: MonadIO m => VideoRectangle -> m Int32 +getVideoRectangleY s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 4) :: IO Int32 + return val + +{- | +Set the value of the “@y@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoRectangle [ #y 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoRectangleY :: MonadIO m => VideoRectangle -> Int32 -> m () +setVideoRectangleY s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 4) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoRectangleYFieldInfo +instance AttrInfo VideoRectangleYFieldInfo where + type AttrAllowedOps VideoRectangleYFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoRectangleYFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoRectangleYFieldInfo = (~) VideoRectangle + type AttrGetType VideoRectangleYFieldInfo = Int32 + type AttrLabel VideoRectangleYFieldInfo = "y" + type AttrOrigin VideoRectangleYFieldInfo = VideoRectangle + attrGet _ = getVideoRectangleY + attrSet _ = setVideoRectangleY + attrConstruct = undefined + attrClear _ = undefined + +videoRectangle_y :: AttrLabelProxy "y" +videoRectangle_y = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@w@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoRectangle #w +@ +-} +getVideoRectangleW :: MonadIO m => VideoRectangle -> m Int32 +getVideoRectangleW s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO Int32 + return val + +{- | +Set the value of the “@w@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoRectangle [ #w 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoRectangleW :: MonadIO m => VideoRectangle -> Int32 -> m () +setVideoRectangleW s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoRectangleWFieldInfo +instance AttrInfo VideoRectangleWFieldInfo where + type AttrAllowedOps VideoRectangleWFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoRectangleWFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoRectangleWFieldInfo = (~) VideoRectangle + type AttrGetType VideoRectangleWFieldInfo = Int32 + type AttrLabel VideoRectangleWFieldInfo = "w" + type AttrOrigin VideoRectangleWFieldInfo = VideoRectangle + attrGet _ = getVideoRectangleW + attrSet _ = setVideoRectangleW + attrConstruct = undefined + attrClear _ = undefined + +videoRectangle_w :: AttrLabelProxy "w" +videoRectangle_w = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@h@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoRectangle #h +@ +-} +getVideoRectangleH :: MonadIO m => VideoRectangle -> m Int32 +getVideoRectangleH s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 12) :: IO Int32 + return val + +{- | +Set the value of the “@h@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoRectangle [ #h 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoRectangleH :: MonadIO m => VideoRectangle -> Int32 -> m () +setVideoRectangleH s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 12) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoRectangleHFieldInfo +instance AttrInfo VideoRectangleHFieldInfo where + type AttrAllowedOps VideoRectangleHFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoRectangleHFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoRectangleHFieldInfo = (~) VideoRectangle + type AttrGetType VideoRectangleHFieldInfo = Int32 + type AttrLabel VideoRectangleHFieldInfo = "h" + type AttrOrigin VideoRectangleHFieldInfo = VideoRectangle + attrGet _ = getVideoRectangleH + attrSet _ = setVideoRectangleH + attrConstruct = undefined + attrClear _ = undefined + +videoRectangle_h :: AttrLabelProxy "h" +videoRectangle_h = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoRectangle +type instance O.AttributeList VideoRectangle = VideoRectangleAttributeList +type VideoRectangleAttributeList = ('[ '("x", VideoRectangleXFieldInfo), '("y", VideoRectangleYFieldInfo), '("w", VideoRectangleWFieldInfo), '("h", VideoRectangleHFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoRectangleMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoRectangleMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoRectangleMethod t VideoRectangle, O.MethodInfo info VideoRectangle p) => OL.IsLabel t (VideoRectangle -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoRectangle.hs-boot b/GI/GstVideo/Structs/VideoRectangle.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoRectangle.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoRectangle where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoRectangle = VideoRectangle (ManagedPtr VideoRectangle) +instance WrappedPtr VideoRectangle where diff --git a/GI/GstVideo/Structs/VideoRegionOfInterestMeta.hs b/GI/GstVideo/Structs/VideoRegionOfInterestMeta.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoRegionOfInterestMeta.hs @@ -0,0 +1,736 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Extra buffer metadata describing an image region of interest +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoRegionOfInterestMeta + ( + +-- * Exported types + VideoRegionOfInterestMeta(..) , + newZeroVideoRegionOfInterestMeta , + noVideoRegionOfInterestMeta , + + + -- * Methods +-- ** addParam #method:addParam# + +#if ENABLE_OVERLOADING + VideoRegionOfInterestMetaAddParamMethodInfo, +#endif + videoRegionOfInterestMetaAddParam , + + +-- ** getInfo #method:getInfo# + + videoRegionOfInterestMetaGetInfo , + + +-- ** getParam #method:getParam# + +#if ENABLE_OVERLOADING + VideoRegionOfInterestMetaGetParamMethodInfo, +#endif + videoRegionOfInterestMetaGetParam , + + + + + -- * Properties +-- ** h #attr:h# +{- | bounding box height +-} + getVideoRegionOfInterestMetaH , + setVideoRegionOfInterestMetaH , +#if ENABLE_OVERLOADING + videoRegionOfInterestMeta_h , +#endif + + +-- ** id #attr:id# +{- | identifier of this particular ROI +-} + getVideoRegionOfInterestMetaId , + setVideoRegionOfInterestMetaId , +#if ENABLE_OVERLOADING + videoRegionOfInterestMeta_id , +#endif + + +-- ** meta #attr:meta# +{- | parent 'GI.Gst.Structs.Meta.Meta' +-} + getVideoRegionOfInterestMetaMeta , +#if ENABLE_OVERLOADING + videoRegionOfInterestMeta_meta , +#endif + + +-- ** params #attr:params# +{- | list of 'GI.Gst.Structs.Structure.Structure' containing element-specific params for downstream, see @/gst_video_region_of_interest_meta_add_params()/@. (Since: 1.14) +-} + clearVideoRegionOfInterestMetaParams , + getVideoRegionOfInterestMetaParams , + setVideoRegionOfInterestMetaParams , +#if ENABLE_OVERLOADING + videoRegionOfInterestMeta_params , +#endif + + +-- ** parentId #attr:parentId# +{- | identifier of its parent ROI, used f.i. for ROI hierarchisation. +-} + getVideoRegionOfInterestMetaParentId , + setVideoRegionOfInterestMetaParentId , +#if ENABLE_OVERLOADING + videoRegionOfInterestMeta_parentId , +#endif + + +-- ** roiType #attr:roiType# +{- | GQuark describing the semantic of the Roi (f.i. a face, a pedestrian) +-} + getVideoRegionOfInterestMetaRoiType , + setVideoRegionOfInterestMetaRoiType , +#if ENABLE_OVERLOADING + videoRegionOfInterestMeta_roiType , +#endif + + +-- ** w #attr:w# +{- | bounding box width +-} + getVideoRegionOfInterestMetaW , + setVideoRegionOfInterestMetaW , +#if ENABLE_OVERLOADING + videoRegionOfInterestMeta_w , +#endif + + +-- ** x #attr:x# +{- | x component of upper-left corner +-} + getVideoRegionOfInterestMetaX , + setVideoRegionOfInterestMetaX , +#if ENABLE_OVERLOADING + videoRegionOfInterestMeta_x , +#endif + + +-- ** y #attr:y# +{- | y component of upper-left corner +-} + getVideoRegionOfInterestMetaY , + setVideoRegionOfInterestMetaY , +#if ENABLE_OVERLOADING + videoRegionOfInterestMeta_y , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Structs.Meta as Gst.Meta +import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo +import qualified GI.Gst.Structs.Structure as Gst.Structure + +-- | Memory-managed wrapper type. +newtype VideoRegionOfInterestMeta = VideoRegionOfInterestMeta (ManagedPtr VideoRegionOfInterestMeta) +instance WrappedPtr VideoRegionOfInterestMeta where + wrappedPtrCalloc = callocBytes 56 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 56 >=> wrapPtr VideoRegionOfInterestMeta) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoRegionOfInterestMeta` struct initialized to zero. +newZeroVideoRegionOfInterestMeta :: MonadIO m => m VideoRegionOfInterestMeta +newZeroVideoRegionOfInterestMeta = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoRegionOfInterestMeta + +instance tag ~ 'AttrSet => Constructible VideoRegionOfInterestMeta tag where + new _ attrs = do + o <- newZeroVideoRegionOfInterestMeta + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoRegionOfInterestMeta`. +noVideoRegionOfInterestMeta :: Maybe VideoRegionOfInterestMeta +noVideoRegionOfInterestMeta = Nothing + +{- | +Get the value of the “@meta@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoRegionOfInterestMeta #meta +@ +-} +getVideoRegionOfInterestMetaMeta :: MonadIO m => VideoRegionOfInterestMeta -> m Gst.Meta.Meta +getVideoRegionOfInterestMetaMeta s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Gst.Meta.Meta) + val' <- (newPtr Gst.Meta.Meta) val + return val' + +#if ENABLE_OVERLOADING +data VideoRegionOfInterestMetaMetaFieldInfo +instance AttrInfo VideoRegionOfInterestMetaMetaFieldInfo where + type AttrAllowedOps VideoRegionOfInterestMetaMetaFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint VideoRegionOfInterestMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta) + type AttrBaseTypeConstraint VideoRegionOfInterestMetaMetaFieldInfo = (~) VideoRegionOfInterestMeta + type AttrGetType VideoRegionOfInterestMetaMetaFieldInfo = Gst.Meta.Meta + type AttrLabel VideoRegionOfInterestMetaMetaFieldInfo = "meta" + type AttrOrigin VideoRegionOfInterestMetaMetaFieldInfo = VideoRegionOfInterestMeta + attrGet _ = getVideoRegionOfInterestMetaMeta + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +videoRegionOfInterestMeta_meta :: AttrLabelProxy "meta" +videoRegionOfInterestMeta_meta = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@roi_type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoRegionOfInterestMeta #roiType +@ +-} +getVideoRegionOfInterestMetaRoiType :: MonadIO m => VideoRegionOfInterestMeta -> m Word32 +getVideoRegionOfInterestMetaRoiType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO Word32 + return val + +{- | +Set the value of the “@roi_type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoRegionOfInterestMeta [ #roiType 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoRegionOfInterestMetaRoiType :: MonadIO m => VideoRegionOfInterestMeta -> Word32 -> m () +setVideoRegionOfInterestMetaRoiType s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoRegionOfInterestMetaRoiTypeFieldInfo +instance AttrInfo VideoRegionOfInterestMetaRoiTypeFieldInfo where + type AttrAllowedOps VideoRegionOfInterestMetaRoiTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoRegionOfInterestMetaRoiTypeFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoRegionOfInterestMetaRoiTypeFieldInfo = (~) VideoRegionOfInterestMeta + type AttrGetType VideoRegionOfInterestMetaRoiTypeFieldInfo = Word32 + type AttrLabel VideoRegionOfInterestMetaRoiTypeFieldInfo = "roi_type" + type AttrOrigin VideoRegionOfInterestMetaRoiTypeFieldInfo = VideoRegionOfInterestMeta + attrGet _ = getVideoRegionOfInterestMetaRoiType + attrSet _ = setVideoRegionOfInterestMetaRoiType + attrConstruct = undefined + attrClear _ = undefined + +videoRegionOfInterestMeta_roiType :: AttrLabelProxy "roiType" +videoRegionOfInterestMeta_roiType = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@id@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoRegionOfInterestMeta #id +@ +-} +getVideoRegionOfInterestMetaId :: MonadIO m => VideoRegionOfInterestMeta -> m Int32 +getVideoRegionOfInterestMetaId s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 20) :: IO Int32 + return val + +{- | +Set the value of the “@id@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoRegionOfInterestMeta [ #id 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoRegionOfInterestMetaId :: MonadIO m => VideoRegionOfInterestMeta -> Int32 -> m () +setVideoRegionOfInterestMetaId s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 20) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoRegionOfInterestMetaIdFieldInfo +instance AttrInfo VideoRegionOfInterestMetaIdFieldInfo where + type AttrAllowedOps VideoRegionOfInterestMetaIdFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoRegionOfInterestMetaIdFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoRegionOfInterestMetaIdFieldInfo = (~) VideoRegionOfInterestMeta + type AttrGetType VideoRegionOfInterestMetaIdFieldInfo = Int32 + type AttrLabel VideoRegionOfInterestMetaIdFieldInfo = "id" + type AttrOrigin VideoRegionOfInterestMetaIdFieldInfo = VideoRegionOfInterestMeta + attrGet _ = getVideoRegionOfInterestMetaId + attrSet _ = setVideoRegionOfInterestMetaId + attrConstruct = undefined + attrClear _ = undefined + +videoRegionOfInterestMeta_id :: AttrLabelProxy "id" +videoRegionOfInterestMeta_id = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@parent_id@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoRegionOfInterestMeta #parentId +@ +-} +getVideoRegionOfInterestMetaParentId :: MonadIO m => VideoRegionOfInterestMeta -> m Int32 +getVideoRegionOfInterestMetaParentId s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO Int32 + return val + +{- | +Set the value of the “@parent_id@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoRegionOfInterestMeta [ #parentId 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoRegionOfInterestMetaParentId :: MonadIO m => VideoRegionOfInterestMeta -> Int32 -> m () +setVideoRegionOfInterestMetaParentId s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoRegionOfInterestMetaParentIdFieldInfo +instance AttrInfo VideoRegionOfInterestMetaParentIdFieldInfo where + type AttrAllowedOps VideoRegionOfInterestMetaParentIdFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoRegionOfInterestMetaParentIdFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoRegionOfInterestMetaParentIdFieldInfo = (~) VideoRegionOfInterestMeta + type AttrGetType VideoRegionOfInterestMetaParentIdFieldInfo = Int32 + type AttrLabel VideoRegionOfInterestMetaParentIdFieldInfo = "parent_id" + type AttrOrigin VideoRegionOfInterestMetaParentIdFieldInfo = VideoRegionOfInterestMeta + attrGet _ = getVideoRegionOfInterestMetaParentId + attrSet _ = setVideoRegionOfInterestMetaParentId + attrConstruct = undefined + attrClear _ = undefined + +videoRegionOfInterestMeta_parentId :: AttrLabelProxy "parentId" +videoRegionOfInterestMeta_parentId = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@x@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoRegionOfInterestMeta #x +@ +-} +getVideoRegionOfInterestMetaX :: MonadIO m => VideoRegionOfInterestMeta -> m Word32 +getVideoRegionOfInterestMetaX s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 28) :: IO Word32 + return val + +{- | +Set the value of the “@x@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoRegionOfInterestMeta [ #x 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoRegionOfInterestMetaX :: MonadIO m => VideoRegionOfInterestMeta -> Word32 -> m () +setVideoRegionOfInterestMetaX s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 28) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoRegionOfInterestMetaXFieldInfo +instance AttrInfo VideoRegionOfInterestMetaXFieldInfo where + type AttrAllowedOps VideoRegionOfInterestMetaXFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoRegionOfInterestMetaXFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoRegionOfInterestMetaXFieldInfo = (~) VideoRegionOfInterestMeta + type AttrGetType VideoRegionOfInterestMetaXFieldInfo = Word32 + type AttrLabel VideoRegionOfInterestMetaXFieldInfo = "x" + type AttrOrigin VideoRegionOfInterestMetaXFieldInfo = VideoRegionOfInterestMeta + attrGet _ = getVideoRegionOfInterestMetaX + attrSet _ = setVideoRegionOfInterestMetaX + attrConstruct = undefined + attrClear _ = undefined + +videoRegionOfInterestMeta_x :: AttrLabelProxy "x" +videoRegionOfInterestMeta_x = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@y@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoRegionOfInterestMeta #y +@ +-} +getVideoRegionOfInterestMetaY :: MonadIO m => VideoRegionOfInterestMeta -> m Word32 +getVideoRegionOfInterestMetaY s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Word32 + return val + +{- | +Set the value of the “@y@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoRegionOfInterestMeta [ #y 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoRegionOfInterestMetaY :: MonadIO m => VideoRegionOfInterestMeta -> Word32 -> m () +setVideoRegionOfInterestMetaY s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoRegionOfInterestMetaYFieldInfo +instance AttrInfo VideoRegionOfInterestMetaYFieldInfo where + type AttrAllowedOps VideoRegionOfInterestMetaYFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoRegionOfInterestMetaYFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoRegionOfInterestMetaYFieldInfo = (~) VideoRegionOfInterestMeta + type AttrGetType VideoRegionOfInterestMetaYFieldInfo = Word32 + type AttrLabel VideoRegionOfInterestMetaYFieldInfo = "y" + type AttrOrigin VideoRegionOfInterestMetaYFieldInfo = VideoRegionOfInterestMeta + attrGet _ = getVideoRegionOfInterestMetaY + attrSet _ = setVideoRegionOfInterestMetaY + attrConstruct = undefined + attrClear _ = undefined + +videoRegionOfInterestMeta_y :: AttrLabelProxy "y" +videoRegionOfInterestMeta_y = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@w@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoRegionOfInterestMeta #w +@ +-} +getVideoRegionOfInterestMetaW :: MonadIO m => VideoRegionOfInterestMeta -> m Word32 +getVideoRegionOfInterestMetaW s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 36) :: IO Word32 + return val + +{- | +Set the value of the “@w@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoRegionOfInterestMeta [ #w 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoRegionOfInterestMetaW :: MonadIO m => VideoRegionOfInterestMeta -> Word32 -> m () +setVideoRegionOfInterestMetaW s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 36) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoRegionOfInterestMetaWFieldInfo +instance AttrInfo VideoRegionOfInterestMetaWFieldInfo where + type AttrAllowedOps VideoRegionOfInterestMetaWFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoRegionOfInterestMetaWFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoRegionOfInterestMetaWFieldInfo = (~) VideoRegionOfInterestMeta + type AttrGetType VideoRegionOfInterestMetaWFieldInfo = Word32 + type AttrLabel VideoRegionOfInterestMetaWFieldInfo = "w" + type AttrOrigin VideoRegionOfInterestMetaWFieldInfo = VideoRegionOfInterestMeta + attrGet _ = getVideoRegionOfInterestMetaW + attrSet _ = setVideoRegionOfInterestMetaW + attrConstruct = undefined + attrClear _ = undefined + +videoRegionOfInterestMeta_w :: AttrLabelProxy "w" +videoRegionOfInterestMeta_w = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@h@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoRegionOfInterestMeta #h +@ +-} +getVideoRegionOfInterestMetaH :: MonadIO m => VideoRegionOfInterestMeta -> m Word32 +getVideoRegionOfInterestMetaH s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO Word32 + return val + +{- | +Set the value of the “@h@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoRegionOfInterestMeta [ #h 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoRegionOfInterestMetaH :: MonadIO m => VideoRegionOfInterestMeta -> Word32 -> m () +setVideoRegionOfInterestMetaH s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoRegionOfInterestMetaHFieldInfo +instance AttrInfo VideoRegionOfInterestMetaHFieldInfo where + type AttrAllowedOps VideoRegionOfInterestMetaHFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoRegionOfInterestMetaHFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoRegionOfInterestMetaHFieldInfo = (~) VideoRegionOfInterestMeta + type AttrGetType VideoRegionOfInterestMetaHFieldInfo = Word32 + type AttrLabel VideoRegionOfInterestMetaHFieldInfo = "h" + type AttrOrigin VideoRegionOfInterestMetaHFieldInfo = VideoRegionOfInterestMeta + attrGet _ = getVideoRegionOfInterestMetaH + attrSet _ = setVideoRegionOfInterestMetaH + attrConstruct = undefined + attrClear _ = undefined + +videoRegionOfInterestMeta_h :: AttrLabelProxy "h" +videoRegionOfInterestMeta_h = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@params@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoRegionOfInterestMeta #params +@ +-} +getVideoRegionOfInterestMetaParams :: MonadIO m => VideoRegionOfInterestMeta -> m ([Ptr ()]) +getVideoRegionOfInterestMetaParams s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 48) :: IO (Ptr (GList (Ptr ()))) + val' <- unpackGList val + return val' + +{- | +Set the value of the “@params@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoRegionOfInterestMeta [ #params 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoRegionOfInterestMetaParams :: MonadIO m => VideoRegionOfInterestMeta -> Ptr (GList (Ptr ())) -> m () +setVideoRegionOfInterestMetaParams s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 48) (val :: Ptr (GList (Ptr ()))) + +{- | +Set the value of the “@params@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #params +@ +-} +clearVideoRegionOfInterestMetaParams :: MonadIO m => VideoRegionOfInterestMeta -> m () +clearVideoRegionOfInterestMetaParams s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 48) (FP.nullPtr :: Ptr (GList (Ptr ()))) + +#if ENABLE_OVERLOADING +data VideoRegionOfInterestMetaParamsFieldInfo +instance AttrInfo VideoRegionOfInterestMetaParamsFieldInfo where + type AttrAllowedOps VideoRegionOfInterestMetaParamsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoRegionOfInterestMetaParamsFieldInfo = (~) (Ptr (GList (Ptr ()))) + type AttrBaseTypeConstraint VideoRegionOfInterestMetaParamsFieldInfo = (~) VideoRegionOfInterestMeta + type AttrGetType VideoRegionOfInterestMetaParamsFieldInfo = [Ptr ()] + type AttrLabel VideoRegionOfInterestMetaParamsFieldInfo = "params" + type AttrOrigin VideoRegionOfInterestMetaParamsFieldInfo = VideoRegionOfInterestMeta + attrGet _ = getVideoRegionOfInterestMetaParams + attrSet _ = setVideoRegionOfInterestMetaParams + attrConstruct = undefined + attrClear _ = clearVideoRegionOfInterestMetaParams + +videoRegionOfInterestMeta_params :: AttrLabelProxy "params" +videoRegionOfInterestMeta_params = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoRegionOfInterestMeta +type instance O.AttributeList VideoRegionOfInterestMeta = VideoRegionOfInterestMetaAttributeList +type VideoRegionOfInterestMetaAttributeList = ('[ '("meta", VideoRegionOfInterestMetaMetaFieldInfo), '("roiType", VideoRegionOfInterestMetaRoiTypeFieldInfo), '("id", VideoRegionOfInterestMetaIdFieldInfo), '("parentId", VideoRegionOfInterestMetaParentIdFieldInfo), '("x", VideoRegionOfInterestMetaXFieldInfo), '("y", VideoRegionOfInterestMetaYFieldInfo), '("w", VideoRegionOfInterestMetaWFieldInfo), '("h", VideoRegionOfInterestMetaHFieldInfo), '("params", VideoRegionOfInterestMetaParamsFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoRegionOfInterestMeta::add_param +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoRegionOfInterestMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoRegionOfInterestMeta", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "s", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_region_of_interest_meta_add_param" gst_video_region_of_interest_meta_add_param :: + Ptr VideoRegionOfInterestMeta -> -- meta : TInterface (Name {namespace = "GstVideo", name = "VideoRegionOfInterestMeta"}) + Ptr Gst.Structure.Structure -> -- s : TInterface (Name {namespace = "Gst", name = "Structure"}) + IO () + +{- | +Attach element-specific parameters to /@meta@/ meant to be used by downstream +elements which may handle this ROI. +The name of /@s@/ is used to identify the element these parameters are meant for. + +This is typically used to tell encoders how they should encode this specific region. +For example, a structure named \"roi\/x264enc\" could be used to give the +QP offsets this encoder should use when encoding the region described in /@meta@/. +Multiple parameters can be defined for the same meta so different encoders +can be supported by cross platform applications). + +/Since: 1.14/ +-} +videoRegionOfInterestMetaAddParam :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoRegionOfInterestMeta + {- ^ /@meta@/: a 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' -} + -> Gst.Structure.Structure + {- ^ /@s@/: a 'GI.Gst.Structs.Structure.Structure' -} + -> m () +videoRegionOfInterestMetaAddParam meta s = liftIO $ do + meta' <- unsafeManagedPtrGetPtr meta + s' <- B.ManagedPtr.disownBoxed s + gst_video_region_of_interest_meta_add_param meta' s' + touchManagedPtr meta + touchManagedPtr s + return () + +#if ENABLE_OVERLOADING +data VideoRegionOfInterestMetaAddParamMethodInfo +instance (signature ~ (Gst.Structure.Structure -> m ()), MonadIO m) => O.MethodInfo VideoRegionOfInterestMetaAddParamMethodInfo VideoRegionOfInterestMeta signature where + overloadedMethod _ = videoRegionOfInterestMetaAddParam + +#endif + +-- method VideoRegionOfInterestMeta::get_param +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "meta", argType = TInterface (Name {namespace = "GstVideo", name = "VideoRegionOfInterestMeta"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoRegionOfInterestMeta", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Structure"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_region_of_interest_meta_get_param" gst_video_region_of_interest_meta_get_param :: + Ptr VideoRegionOfInterestMeta -> -- meta : TInterface (Name {namespace = "GstVideo", name = "VideoRegionOfInterestMeta"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr Gst.Structure.Structure) + +{- | +Retrieve the parameter for /@meta@/ having /@name@/ as structure name, +or 'Nothing' if there is none. + +/Since: 1.14/ +-} +videoRegionOfInterestMetaGetParam :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoRegionOfInterestMeta + {- ^ /@meta@/: a 'GI.GstVideo.Structs.VideoRegionOfInterestMeta.VideoRegionOfInterestMeta' -} + -> T.Text + {- ^ /@name@/: a name. -} + -> m (Maybe Gst.Structure.Structure) + {- ^ __Returns:__ a 'GI.Gst.Structs.Structure.Structure' -} +videoRegionOfInterestMetaGetParam meta name = liftIO $ do + meta' <- unsafeManagedPtrGetPtr meta + name' <- textToCString name + result <- gst_video_region_of_interest_meta_get_param meta' name' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Gst.Structure.Structure) result' + return result'' + touchManagedPtr meta + freeMem name' + return maybeResult + +#if ENABLE_OVERLOADING +data VideoRegionOfInterestMetaGetParamMethodInfo +instance (signature ~ (T.Text -> m (Maybe Gst.Structure.Structure)), MonadIO m) => O.MethodInfo VideoRegionOfInterestMetaGetParamMethodInfo VideoRegionOfInterestMeta signature where + overloadedMethod _ = videoRegionOfInterestMetaGetParam + +#endif + +-- method VideoRegionOfInterestMeta::get_info +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "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.MetaInfo) + +{- | +/No description available in the introspection data./ +-} +videoRegionOfInterestMetaGetInfo :: + (B.CallStack.HasCallStack, MonadIO m) => + m Gst.MetaInfo.MetaInfo +videoRegionOfInterestMetaGetInfo = liftIO $ do + result <- gst_video_region_of_interest_meta_get_info + checkUnexpectedReturnNULL "videoRegionOfInterestMetaGetInfo" result + result' <- (newPtr Gst.MetaInfo.MetaInfo) result + return result' + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoRegionOfInterestMetaMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoRegionOfInterestMetaMethod "addParam" o = VideoRegionOfInterestMetaAddParamMethodInfo + ResolveVideoRegionOfInterestMetaMethod "getParam" o = VideoRegionOfInterestMetaGetParamMethodInfo + ResolveVideoRegionOfInterestMetaMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoRegionOfInterestMetaMethod t VideoRegionOfInterestMeta, O.MethodInfo info VideoRegionOfInterestMeta p) => OL.IsLabel t (VideoRegionOfInterestMeta -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoRegionOfInterestMeta.hs-boot b/GI/GstVideo/Structs/VideoRegionOfInterestMeta.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoRegionOfInterestMeta.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoRegionOfInterestMeta where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoRegionOfInterestMeta = VideoRegionOfInterestMeta (ManagedPtr VideoRegionOfInterestMeta) +instance WrappedPtr VideoRegionOfInterestMeta where +#if ENABLE_OVERLOADING +data VideoRegionOfInterestMetaAddParamMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoRegionOfInterestMetaGetParamMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoResampler.hs b/GI/GstVideo/Structs/VideoResampler.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoResampler.hs @@ -0,0 +1,649 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +'GI.GstVideo.Structs.VideoResampler.VideoResampler' is a structure which holds the information +required to perform various kinds of resampling filtering. + +/Since: 1.6/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoResampler + ( + +-- * Exported types + VideoResampler(..) , + newZeroVideoResampler , + noVideoResampler , + + + -- * Methods +-- ** clear #method:clear# + +#if ENABLE_OVERLOADING + VideoResamplerClearMethodInfo , +#endif + videoResamplerClear , + + +-- ** init #method:init# + +#if ENABLE_OVERLOADING + VideoResamplerInitMethodInfo , +#endif + videoResamplerInit , + + + + + -- * Properties +-- ** inSize #attr:inSize# +{- | the input size +-} + getVideoResamplerInSize , + setVideoResamplerInSize , +#if ENABLE_OVERLOADING + videoResampler_inSize , +#endif + + +-- ** maxTaps #attr:maxTaps# +{- | the maximum number of taps +-} + getVideoResamplerMaxTaps , + setVideoResamplerMaxTaps , +#if ENABLE_OVERLOADING + videoResampler_maxTaps , +#endif + + +-- ** nPhases #attr:nPhases# +{- | the number of phases +-} + getVideoResamplerNPhases , + setVideoResamplerNPhases , +#if ENABLE_OVERLOADING + videoResampler_nPhases , +#endif + + +-- ** nTaps #attr:nTaps# +{- | array with new number of taps for each phase +-} + getVideoResamplerNTaps , + setVideoResamplerNTaps , +#if ENABLE_OVERLOADING + videoResampler_nTaps , +#endif + + +-- ** offset #attr:offset# +{- | array with the source offset for each output element +-} + getVideoResamplerOffset , + setVideoResamplerOffset , +#if ENABLE_OVERLOADING + videoResampler_offset , +#endif + + +-- ** outSize #attr:outSize# +{- | the output size +-} + getVideoResamplerOutSize , + setVideoResamplerOutSize , +#if ENABLE_OVERLOADING + videoResampler_outSize , +#endif + + +-- ** phase #attr:phase# +{- | array with the phase to use for each output element +-} + getVideoResamplerPhase , + setVideoResamplerPhase , +#if ENABLE_OVERLOADING + videoResampler_phase , +#endif + + +-- ** taps #attr:taps# +{- | the taps for all phases +-} + getVideoResamplerTaps , + setVideoResamplerTaps , +#if ENABLE_OVERLOADING + videoResampler_taps , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Structs.Structure as Gst.Structure +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums +import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags + +-- | Memory-managed wrapper type. +newtype VideoResampler = VideoResampler (ManagedPtr VideoResampler) +instance WrappedPtr VideoResampler where + wrappedPtrCalloc = callocBytes 80 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 80 >=> wrapPtr VideoResampler) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoResampler` struct initialized to zero. +newZeroVideoResampler :: MonadIO m => m VideoResampler +newZeroVideoResampler = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoResampler + +instance tag ~ 'AttrSet => Constructible VideoResampler tag where + new _ attrs = do + o <- newZeroVideoResampler + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoResampler`. +noVideoResampler :: Maybe VideoResampler +noVideoResampler = Nothing + +{- | +Get the value of the “@in_size@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoResampler #inSize +@ +-} +getVideoResamplerInSize :: MonadIO m => VideoResampler -> m Int32 +getVideoResamplerInSize s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Int32 + return val + +{- | +Set the value of the “@in_size@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoResampler [ #inSize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoResamplerInSize :: MonadIO m => VideoResampler -> Int32 -> m () +setVideoResamplerInSize s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoResamplerInSizeFieldInfo +instance AttrInfo VideoResamplerInSizeFieldInfo where + type AttrAllowedOps VideoResamplerInSizeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoResamplerInSizeFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoResamplerInSizeFieldInfo = (~) VideoResampler + type AttrGetType VideoResamplerInSizeFieldInfo = Int32 + type AttrLabel VideoResamplerInSizeFieldInfo = "in_size" + type AttrOrigin VideoResamplerInSizeFieldInfo = VideoResampler + attrGet _ = getVideoResamplerInSize + attrSet _ = setVideoResamplerInSize + attrConstruct = undefined + attrClear _ = undefined + +videoResampler_inSize :: AttrLabelProxy "inSize" +videoResampler_inSize = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@out_size@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoResampler #outSize +@ +-} +getVideoResamplerOutSize :: MonadIO m => VideoResampler -> m Int32 +getVideoResamplerOutSize s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 4) :: IO Int32 + return val + +{- | +Set the value of the “@out_size@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoResampler [ #outSize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoResamplerOutSize :: MonadIO m => VideoResampler -> Int32 -> m () +setVideoResamplerOutSize s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 4) (val :: Int32) + +#if ENABLE_OVERLOADING +data VideoResamplerOutSizeFieldInfo +instance AttrInfo VideoResamplerOutSizeFieldInfo where + type AttrAllowedOps VideoResamplerOutSizeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoResamplerOutSizeFieldInfo = (~) Int32 + type AttrBaseTypeConstraint VideoResamplerOutSizeFieldInfo = (~) VideoResampler + type AttrGetType VideoResamplerOutSizeFieldInfo = Int32 + type AttrLabel VideoResamplerOutSizeFieldInfo = "out_size" + type AttrOrigin VideoResamplerOutSizeFieldInfo = VideoResampler + attrGet _ = getVideoResamplerOutSize + attrSet _ = setVideoResamplerOutSize + attrConstruct = undefined + attrClear _ = undefined + +videoResampler_outSize :: AttrLabelProxy "outSize" +videoResampler_outSize = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@max_taps@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoResampler #maxTaps +@ +-} +getVideoResamplerMaxTaps :: MonadIO m => VideoResampler -> m Word32 +getVideoResamplerMaxTaps s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO Word32 + return val + +{- | +Set the value of the “@max_taps@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoResampler [ #maxTaps 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoResamplerMaxTaps :: MonadIO m => VideoResampler -> Word32 -> m () +setVideoResamplerMaxTaps s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoResamplerMaxTapsFieldInfo +instance AttrInfo VideoResamplerMaxTapsFieldInfo where + type AttrAllowedOps VideoResamplerMaxTapsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoResamplerMaxTapsFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoResamplerMaxTapsFieldInfo = (~) VideoResampler + type AttrGetType VideoResamplerMaxTapsFieldInfo = Word32 + type AttrLabel VideoResamplerMaxTapsFieldInfo = "max_taps" + type AttrOrigin VideoResamplerMaxTapsFieldInfo = VideoResampler + attrGet _ = getVideoResamplerMaxTaps + attrSet _ = setVideoResamplerMaxTaps + attrConstruct = undefined + attrClear _ = undefined + +videoResampler_maxTaps :: AttrLabelProxy "maxTaps" +videoResampler_maxTaps = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@n_phases@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoResampler #nPhases +@ +-} +getVideoResamplerNPhases :: MonadIO m => VideoResampler -> m Word32 +getVideoResamplerNPhases s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 12) :: IO Word32 + return val + +{- | +Set the value of the “@n_phases@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoResampler [ #nPhases 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoResamplerNPhases :: MonadIO m => VideoResampler -> Word32 -> m () +setVideoResamplerNPhases s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 12) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoResamplerNPhasesFieldInfo +instance AttrInfo VideoResamplerNPhasesFieldInfo where + type AttrAllowedOps VideoResamplerNPhasesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoResamplerNPhasesFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoResamplerNPhasesFieldInfo = (~) VideoResampler + type AttrGetType VideoResamplerNPhasesFieldInfo = Word32 + type AttrLabel VideoResamplerNPhasesFieldInfo = "n_phases" + type AttrOrigin VideoResamplerNPhasesFieldInfo = VideoResampler + attrGet _ = getVideoResamplerNPhases + attrSet _ = setVideoResamplerNPhases + attrConstruct = undefined + attrClear _ = undefined + +videoResampler_nPhases :: AttrLabelProxy "nPhases" +videoResampler_nPhases = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@offset@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoResampler #offset +@ +-} +getVideoResamplerOffset :: MonadIO m => VideoResampler -> m Word32 +getVideoResamplerOffset s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO Word32 + return val + +{- | +Set the value of the “@offset@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoResampler [ #offset 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoResamplerOffset :: MonadIO m => VideoResampler -> Word32 -> m () +setVideoResamplerOffset s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoResamplerOffsetFieldInfo +instance AttrInfo VideoResamplerOffsetFieldInfo where + type AttrAllowedOps VideoResamplerOffsetFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoResamplerOffsetFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoResamplerOffsetFieldInfo = (~) VideoResampler + type AttrGetType VideoResamplerOffsetFieldInfo = Word32 + type AttrLabel VideoResamplerOffsetFieldInfo = "offset" + type AttrOrigin VideoResamplerOffsetFieldInfo = VideoResampler + attrGet _ = getVideoResamplerOffset + attrSet _ = setVideoResamplerOffset + attrConstruct = undefined + attrClear _ = undefined + +videoResampler_offset :: AttrLabelProxy "offset" +videoResampler_offset = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@phase@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoResampler #phase +@ +-} +getVideoResamplerPhase :: MonadIO m => VideoResampler -> m Word32 +getVideoResamplerPhase s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO Word32 + return val + +{- | +Set the value of the “@phase@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoResampler [ #phase 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoResamplerPhase :: MonadIO m => VideoResampler -> Word32 -> m () +setVideoResamplerPhase s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoResamplerPhaseFieldInfo +instance AttrInfo VideoResamplerPhaseFieldInfo where + type AttrAllowedOps VideoResamplerPhaseFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoResamplerPhaseFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoResamplerPhaseFieldInfo = (~) VideoResampler + type AttrGetType VideoResamplerPhaseFieldInfo = Word32 + type AttrLabel VideoResamplerPhaseFieldInfo = "phase" + type AttrOrigin VideoResamplerPhaseFieldInfo = VideoResampler + attrGet _ = getVideoResamplerPhase + attrSet _ = setVideoResamplerPhase + attrConstruct = undefined + attrClear _ = undefined + +videoResampler_phase :: AttrLabelProxy "phase" +videoResampler_phase = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@n_taps@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoResampler #nTaps +@ +-} +getVideoResamplerNTaps :: MonadIO m => VideoResampler -> m Word32 +getVideoResamplerNTaps s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Word32 + return val + +{- | +Set the value of the “@n_taps@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoResampler [ #nTaps 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoResamplerNTaps :: MonadIO m => VideoResampler -> Word32 -> m () +setVideoResamplerNTaps s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoResamplerNTapsFieldInfo +instance AttrInfo VideoResamplerNTapsFieldInfo where + type AttrAllowedOps VideoResamplerNTapsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoResamplerNTapsFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoResamplerNTapsFieldInfo = (~) VideoResampler + type AttrGetType VideoResamplerNTapsFieldInfo = Word32 + type AttrLabel VideoResamplerNTapsFieldInfo = "n_taps" + type AttrOrigin VideoResamplerNTapsFieldInfo = VideoResampler + attrGet _ = getVideoResamplerNTaps + attrSet _ = setVideoResamplerNTaps + attrConstruct = undefined + attrClear _ = undefined + +videoResampler_nTaps :: AttrLabelProxy "nTaps" +videoResampler_nTaps = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@taps@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoResampler #taps +@ +-} +getVideoResamplerTaps :: MonadIO m => VideoResampler -> m Double +getVideoResamplerTaps s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@taps@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoResampler [ #taps 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoResamplerTaps :: MonadIO m => VideoResampler -> Double -> m () +setVideoResamplerTaps s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 40) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data VideoResamplerTapsFieldInfo +instance AttrInfo VideoResamplerTapsFieldInfo where + type AttrAllowedOps VideoResamplerTapsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoResamplerTapsFieldInfo = (~) Double + type AttrBaseTypeConstraint VideoResamplerTapsFieldInfo = (~) VideoResampler + type AttrGetType VideoResamplerTapsFieldInfo = Double + type AttrLabel VideoResamplerTapsFieldInfo = "taps" + type AttrOrigin VideoResamplerTapsFieldInfo = VideoResampler + attrGet _ = getVideoResamplerTaps + attrSet _ = setVideoResamplerTaps + attrConstruct = undefined + attrClear _ = undefined + +videoResampler_taps :: AttrLabelProxy "taps" +videoResampler_taps = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoResampler +type instance O.AttributeList VideoResampler = VideoResamplerAttributeList +type VideoResamplerAttributeList = ('[ '("inSize", VideoResamplerInSizeFieldInfo), '("outSize", VideoResamplerOutSizeFieldInfo), '("maxTaps", VideoResamplerMaxTapsFieldInfo), '("nPhases", VideoResamplerNPhasesFieldInfo), '("offset", VideoResamplerOffsetFieldInfo), '("phase", VideoResamplerPhaseFieldInfo), '("nTaps", VideoResamplerNTapsFieldInfo), '("taps", VideoResamplerTapsFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoResampler::clear +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "resampler", argType = TInterface (Name {namespace = "GstVideo", name = "VideoResampler"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoResampler", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_resampler_clear" gst_video_resampler_clear :: + Ptr VideoResampler -> -- resampler : TInterface (Name {namespace = "GstVideo", name = "VideoResampler"}) + IO () + +{- | +Clear a previously initialized 'GI.GstVideo.Structs.VideoResampler.VideoResampler' /@resampler@/. + +/Since: 1.6/ +-} +videoResamplerClear :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoResampler + {- ^ /@resampler@/: a 'GI.GstVideo.Structs.VideoResampler.VideoResampler' -} + -> m () +videoResamplerClear resampler = liftIO $ do + resampler' <- unsafeManagedPtrGetPtr resampler + gst_video_resampler_clear resampler' + touchManagedPtr resampler + return () + +#if ENABLE_OVERLOADING +data VideoResamplerClearMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoResamplerClearMethodInfo VideoResampler signature where + overloadedMethod _ = videoResamplerClear + +#endif + +-- method VideoResampler::init +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "resampler", argType = TInterface (Name {namespace = "GstVideo", name = "VideoResampler"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "method", argType = TInterface (Name {namespace = "GstVideo", name = "VideoResamplerMethod"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoResamplerFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_phases", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_taps", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shift", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "in_size", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_size", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_resampler_init" gst_video_resampler_init :: + Ptr VideoResampler -> -- resampler : TInterface (Name {namespace = "GstVideo", name = "VideoResampler"}) + CUInt -> -- method : TInterface (Name {namespace = "GstVideo", name = "VideoResamplerMethod"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoResamplerFlags"}) + Word32 -> -- n_phases : TBasicType TUInt + Word32 -> -- n_taps : TBasicType TUInt + CDouble -> -- shift : TBasicType TDouble + Word32 -> -- in_size : TBasicType TUInt + Word32 -> -- out_size : TBasicType TUInt + Ptr Gst.Structure.Structure -> -- options : TInterface (Name {namespace = "Gst", name = "Structure"}) + IO CInt + +{- | +/No description available in the introspection data./ +-} +videoResamplerInit :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoResampler + -> GstVideo.Enums.VideoResamplerMethod + -> [GstVideo.Flags.VideoResamplerFlags] + -> Word32 + -> Word32 + -> Double + -> Word32 + -> Word32 + -> Gst.Structure.Structure + -> m Bool +videoResamplerInit resampler method flags nPhases nTaps shift inSize outSize options = liftIO $ do + resampler' <- unsafeManagedPtrGetPtr resampler + let method' = (fromIntegral . fromEnum) method + let flags' = gflagsToWord flags + let shift' = realToFrac shift + options' <- unsafeManagedPtrGetPtr options + result <- gst_video_resampler_init resampler' method' flags' nPhases nTaps shift' inSize outSize options' + let result' = (/= 0) result + touchManagedPtr resampler + touchManagedPtr options + return result' + +#if ENABLE_OVERLOADING +data VideoResamplerInitMethodInfo +instance (signature ~ (GstVideo.Enums.VideoResamplerMethod -> [GstVideo.Flags.VideoResamplerFlags] -> Word32 -> Word32 -> Double -> Word32 -> Word32 -> Gst.Structure.Structure -> m Bool), MonadIO m) => O.MethodInfo VideoResamplerInitMethodInfo VideoResampler signature where + overloadedMethod _ = videoResamplerInit + +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoResamplerMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoResamplerMethod "clear" o = VideoResamplerClearMethodInfo + ResolveVideoResamplerMethod "init" o = VideoResamplerInitMethodInfo + ResolveVideoResamplerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoResamplerMethod t VideoResampler, O.MethodInfo info VideoResampler p) => OL.IsLabel t (VideoResampler -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoResampler.hs-boot b/GI/GstVideo/Structs/VideoResampler.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoResampler.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoResampler where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoResampler = VideoResampler (ManagedPtr VideoResampler) +instance WrappedPtr VideoResampler where +#if ENABLE_OVERLOADING +data VideoResamplerClearMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoResamplerInitMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoScaler.hs b/GI/GstVideo/Structs/VideoScaler.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoScaler.hs @@ -0,0 +1,426 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +'GI.GstVideo.Structs.VideoScaler.VideoScaler' is a utility object for rescaling and resampling +video frames using various interpolation \/ sampling methods. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoScaler + ( + +-- * Exported types + VideoScaler(..) , + noVideoScaler , + + + -- * Methods +-- ** 2d #method:2d# + +#if ENABLE_OVERLOADING + VideoScaler2dMethodInfo , +#endif + videoScaler2d , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + VideoScalerFreeMethodInfo , +#endif + videoScalerFree , + + +-- ** getCoeff #method:getCoeff# + +#if ENABLE_OVERLOADING + VideoScalerGetCoeffMethodInfo , +#endif + videoScalerGetCoeff , + + +-- ** getMaxTaps #method:getMaxTaps# + +#if ENABLE_OVERLOADING + VideoScalerGetMaxTapsMethodInfo , +#endif + videoScalerGetMaxTaps , + + +-- ** horizontal #method:horizontal# + +#if ENABLE_OVERLOADING + VideoScalerHorizontalMethodInfo , +#endif + videoScalerHorizontal , + + +-- ** vertical #method:vertical# + +#if ENABLE_OVERLOADING + VideoScalerVerticalMethodInfo , +#endif + videoScalerVertical , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums + +-- | Memory-managed wrapper type. +newtype VideoScaler = VideoScaler (ManagedPtr VideoScaler) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr VideoScaler where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoScaler`. +noVideoScaler :: Maybe VideoScaler +noVideoScaler = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoScaler +type instance O.AttributeList VideoScaler = VideoScalerAttributeList +type VideoScalerAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method VideoScaler::2d +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "hscale", argType = TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a horzontal #GstVideoScaler", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vscale", argType = TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a vertical #GstVideoScaler", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormat for @srcs and @dest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "source pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "source pixels stride", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destination pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_stride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "destination pixels stride", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the horizontal destination offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the vertical destination offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of output pixels to scale", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of output lines to scale", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_scaler_2d" gst_video_scaler_2d :: + Ptr VideoScaler -> -- hscale : TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}) + Ptr VideoScaler -> -- vscale : TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}) + CUInt -> -- format : TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}) + Ptr () -> -- src : TBasicType TPtr + Int32 -> -- src_stride : TBasicType TInt + Ptr () -> -- dest : TBasicType TPtr + Int32 -> -- dest_stride : TBasicType TInt + Word32 -> -- x : TBasicType TUInt + Word32 -> -- y : TBasicType TUInt + Word32 -> -- width : TBasicType TUInt + Word32 -> -- height : TBasicType TUInt + IO () + +{- | +Scale a rectangle of pixels in /@src@/ with /@srcStride@/ to /@dest@/ with +/@destStride@/ using the horizontal scaler /@hscaler@/ and the vertical +scaler /@vscale@/. + +One or both of /@hscale@/ and /@vscale@/ can be NULL to only perform scaling in +one dimension or do a copy without scaling. + +/@x@/ and /@y@/ are the coordinates in the destination image to process. +-} +videoScaler2d :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoScaler + {- ^ /@hscale@/: a horzontal 'GI.GstVideo.Structs.VideoScaler.VideoScaler' -} + -> VideoScaler + {- ^ /@vscale@/: a vertical 'GI.GstVideo.Structs.VideoScaler.VideoScaler' -} + -> GstVideo.Enums.VideoFormat + {- ^ /@format@/: a 'GI.GstVideo.Enums.VideoFormat' for /@srcs@/ and /@dest@/ -} + -> Ptr () + {- ^ /@src@/: source pixels -} + -> Int32 + {- ^ /@srcStride@/: source pixels stride -} + -> Ptr () + {- ^ /@dest@/: destination pixels -} + -> Int32 + {- ^ /@destStride@/: destination pixels stride -} + -> Word32 + {- ^ /@x@/: the horizontal destination offset -} + -> Word32 + {- ^ /@y@/: the vertical destination offset -} + -> Word32 + {- ^ /@width@/: the number of output pixels to scale -} + -> Word32 + {- ^ /@height@/: the number of output lines to scale -} + -> m () +videoScaler2d hscale vscale format src srcStride dest destStride x y width height = liftIO $ do + hscale' <- unsafeManagedPtrGetPtr hscale + vscale' <- unsafeManagedPtrGetPtr vscale + let format' = (fromIntegral . fromEnum) format + gst_video_scaler_2d hscale' vscale' format' src srcStride dest destStride x y width height + touchManagedPtr hscale + touchManagedPtr vscale + return () + +#if ENABLE_OVERLOADING +data VideoScaler2dMethodInfo +instance (signature ~ (VideoScaler -> GstVideo.Enums.VideoFormat -> Ptr () -> Int32 -> Ptr () -> Int32 -> Word32 -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m) => O.MethodInfo VideoScaler2dMethodInfo VideoScaler signature where + overloadedMethod _ = videoScaler2d + +#endif + +-- method VideoScaler::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "scale", argType = TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoScaler", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_scaler_free" gst_video_scaler_free :: + Ptr VideoScaler -> -- scale : TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}) + IO () + +{- | +Free a previously allocated 'GI.GstVideo.Structs.VideoScaler.VideoScaler' /@scale@/. +-} +videoScalerFree :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoScaler + {- ^ /@scale@/: a 'GI.GstVideo.Structs.VideoScaler.VideoScaler' -} + -> m () +videoScalerFree scale = liftIO $ do + scale' <- unsafeManagedPtrGetPtr scale + gst_video_scaler_free scale' + touchManagedPtr scale + return () + +#if ENABLE_OVERLOADING +data VideoScalerFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoScalerFreeMethodInfo VideoScaler signature where + overloadedMethod _ = videoScalerFree + +#endif + +-- method VideoScaler::get_coeff +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "scale", argType = TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoScaler", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_offset", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an output offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "in_offset", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "result input offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_taps", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "result n_taps", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_scaler_get_coeff" gst_video_scaler_get_coeff :: + Ptr VideoScaler -> -- scale : TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}) + Word32 -> -- out_offset : TBasicType TUInt + Word32 -> -- in_offset : TBasicType TUInt + Word32 -> -- n_taps : TBasicType TUInt + IO CDouble + +{- | +For a given pixel at /@outOffset@/, get the first required input pixel at +/@inOffset@/ and the /@nTaps@/ filter coefficients. + +Note that for interlaced content, /@inOffset@/ needs to be incremented with +2 to get the next input line. +-} +videoScalerGetCoeff :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoScaler + {- ^ /@scale@/: a 'GI.GstVideo.Structs.VideoScaler.VideoScaler' -} + -> Word32 + {- ^ /@outOffset@/: an output offset -} + -> Word32 + {- ^ /@inOffset@/: result input offset -} + -> Word32 + {- ^ /@nTaps@/: result n_taps -} + -> m Double + {- ^ __Returns:__ an array of /@nTap@/ gdouble values with filter coefficients. -} +videoScalerGetCoeff scale outOffset inOffset nTaps = liftIO $ do + scale' <- unsafeManagedPtrGetPtr scale + result <- gst_video_scaler_get_coeff scale' outOffset inOffset nTaps + let result' = realToFrac result + touchManagedPtr scale + return result' + +#if ENABLE_OVERLOADING +data VideoScalerGetCoeffMethodInfo +instance (signature ~ (Word32 -> Word32 -> Word32 -> m Double), MonadIO m) => O.MethodInfo VideoScalerGetCoeffMethodInfo VideoScaler signature where + overloadedMethod _ = videoScalerGetCoeff + +#endif + +-- method VideoScaler::get_max_taps +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "scale", argType = TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoScaler", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_scaler_get_max_taps" gst_video_scaler_get_max_taps :: + Ptr VideoScaler -> -- scale : TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}) + IO Word32 + +{- | +Get the maximum number of taps for /@scale@/. +-} +videoScalerGetMaxTaps :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoScaler + {- ^ /@scale@/: a 'GI.GstVideo.Structs.VideoScaler.VideoScaler' -} + -> m Word32 + {- ^ __Returns:__ the maximum number of taps -} +videoScalerGetMaxTaps scale = liftIO $ do + scale' <- unsafeManagedPtrGetPtr scale + result <- gst_video_scaler_get_max_taps scale' + touchManagedPtr scale + return result + +#if ENABLE_OVERLOADING +data VideoScalerGetMaxTapsMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo VideoScalerGetMaxTapsMethodInfo VideoScaler signature where + overloadedMethod _ = videoScalerGetMaxTaps + +#endif + +-- method VideoScaler::horizontal +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "scale", argType = TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoScaler", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormat for @src and @dest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "source pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destination pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_offset", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the horizontal destination offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of pixels to scale", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_scaler_horizontal" gst_video_scaler_horizontal :: + Ptr VideoScaler -> -- scale : TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}) + CUInt -> -- format : TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}) + Ptr () -> -- src : TBasicType TPtr + Ptr () -> -- dest : TBasicType TPtr + Word32 -> -- dest_offset : TBasicType TUInt + Word32 -> -- width : TBasicType TUInt + IO () + +{- | +Horizontally scale the pixels in /@src@/ to /@dest@/, starting from /@destOffset@/ +for /@width@/ samples. +-} +videoScalerHorizontal :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoScaler + {- ^ /@scale@/: a 'GI.GstVideo.Structs.VideoScaler.VideoScaler' -} + -> GstVideo.Enums.VideoFormat + {- ^ /@format@/: a 'GI.GstVideo.Enums.VideoFormat' for /@src@/ and /@dest@/ -} + -> Ptr () + {- ^ /@src@/: source pixels -} + -> Ptr () + {- ^ /@dest@/: destination pixels -} + -> Word32 + {- ^ /@destOffset@/: the horizontal destination offset -} + -> Word32 + {- ^ /@width@/: the number of pixels to scale -} + -> m () +videoScalerHorizontal scale format src dest destOffset width = liftIO $ do + scale' <- unsafeManagedPtrGetPtr scale + let format' = (fromIntegral . fromEnum) format + gst_video_scaler_horizontal scale' format' src dest destOffset width + touchManagedPtr scale + return () + +#if ENABLE_OVERLOADING +data VideoScalerHorizontalMethodInfo +instance (signature ~ (GstVideo.Enums.VideoFormat -> Ptr () -> Ptr () -> Word32 -> Word32 -> m ()), MonadIO m) => O.MethodInfo VideoScalerHorizontalMethodInfo VideoScaler signature where + overloadedMethod _ = videoScalerHorizontal + +#endif + +-- method VideoScaler::vertical +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "scale", argType = TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoScaler", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormat for @srcs and @dest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_lines", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "source pixels lines", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destination pixels", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_offset", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the vertical destination offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of pixels to scale", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_scaler_vertical" gst_video_scaler_vertical :: + Ptr VideoScaler -> -- scale : TInterface (Name {namespace = "GstVideo", name = "VideoScaler"}) + CUInt -> -- format : TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}) + Ptr () -> -- src_lines : TBasicType TPtr + Ptr () -> -- dest : TBasicType TPtr + Word32 -> -- dest_offset : TBasicType TUInt + Word32 -> -- width : TBasicType TUInt + IO () + +{- | +Vertically combine /@width@/ pixels in the lines in /@srcLines@/ to /@dest@/. +/@dest@/ is the location of the target line at /@destOffset@/ and +/@srcs@/ are the input lines for /@destOffset@/, as obtained with +@/gst_video_scaler_get_info()/@. +-} +videoScalerVertical :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoScaler + {- ^ /@scale@/: a 'GI.GstVideo.Structs.VideoScaler.VideoScaler' -} + -> GstVideo.Enums.VideoFormat + {- ^ /@format@/: a 'GI.GstVideo.Enums.VideoFormat' for /@srcs@/ and /@dest@/ -} + -> Ptr () + {- ^ /@srcLines@/: source pixels lines -} + -> Ptr () + {- ^ /@dest@/: destination pixels -} + -> Word32 + {- ^ /@destOffset@/: the vertical destination offset -} + -> Word32 + {- ^ /@width@/: the number of pixels to scale -} + -> m () +videoScalerVertical scale format srcLines dest destOffset width = liftIO $ do + scale' <- unsafeManagedPtrGetPtr scale + let format' = (fromIntegral . fromEnum) format + gst_video_scaler_vertical scale' format' srcLines dest destOffset width + touchManagedPtr scale + return () + +#if ENABLE_OVERLOADING +data VideoScalerVerticalMethodInfo +instance (signature ~ (GstVideo.Enums.VideoFormat -> Ptr () -> Ptr () -> Word32 -> Word32 -> m ()), MonadIO m) => O.MethodInfo VideoScalerVerticalMethodInfo VideoScaler signature where + overloadedMethod _ = videoScalerVertical + +#endif + +#if ENABLE_OVERLOADING +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 = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoScalerMethod t VideoScaler, O.MethodInfo info VideoScaler p) => OL.IsLabel t (VideoScaler -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoScaler.hs-boot b/GI/GstVideo/Structs/VideoScaler.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoScaler.hs-boot @@ -0,0 +1,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoScaler where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoScaler = VideoScaler (ManagedPtr VideoScaler) +instance WrappedPtr VideoScaler where +#if ENABLE_OVERLOADING +data VideoScaler2dMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoScalerFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoScalerGetCoeffMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoScalerGetMaxTapsMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoScalerHorizontalMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoScalerVerticalMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoTimeCode.hs b/GI/GstVideo/Structs/VideoTimeCode.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoTimeCode.hs @@ -0,0 +1,1476 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/@fieldCount@/ must be 0 for progressive video and 1 or 2 for interlaced. + +A representation of a SMPTE time code. + +/@hours@/ must be positive and less than 24. Will wrap around otherwise. +/@minutes@/ and /@seconds@/ must be positive and less than 60. +/@frames@/ must be less than or equal to /@config@/.fps_n \/ /@config@/.fps_d +These values are *NOT* automatically normalized. + +/Since: 1.10/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoTimeCode + ( + +-- * Exported types + VideoTimeCode(..) , + newZeroVideoTimeCode , + noVideoTimeCode , + + + -- * Methods +-- ** addFrames #method:addFrames# + +#if ENABLE_OVERLOADING + VideoTimeCodeAddFramesMethodInfo , +#endif + videoTimeCodeAddFrames , + + +-- ** addInterval #method:addInterval# + +#if ENABLE_OVERLOADING + VideoTimeCodeAddIntervalMethodInfo , +#endif + videoTimeCodeAddInterval , + + +-- ** clear #method:clear# + +#if ENABLE_OVERLOADING + VideoTimeCodeClearMethodInfo , +#endif + videoTimeCodeClear , + + +-- ** compare #method:compare# + +#if ENABLE_OVERLOADING + VideoTimeCodeCompareMethodInfo , +#endif + videoTimeCodeCompare , + + +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + VideoTimeCodeCopyMethodInfo , +#endif + videoTimeCodeCopy , + + +-- ** framesSinceDailyJam #method:framesSinceDailyJam# + +#if ENABLE_OVERLOADING + VideoTimeCodeFramesSinceDailyJamMethodInfo, +#endif + videoTimeCodeFramesSinceDailyJam , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + VideoTimeCodeFreeMethodInfo , +#endif + videoTimeCodeFree , + + +-- ** incrementFrame #method:incrementFrame# + +#if ENABLE_OVERLOADING + VideoTimeCodeIncrementFrameMethodInfo , +#endif + videoTimeCodeIncrementFrame , + + +-- ** init #method:init# + +#if ENABLE_OVERLOADING + VideoTimeCodeInitMethodInfo , +#endif + videoTimeCodeInit , + + +-- ** initFromDateTime #method:initFromDateTime# + +#if ENABLE_OVERLOADING + VideoTimeCodeInitFromDateTimeMethodInfo , +#endif + videoTimeCodeInitFromDateTime , + + +-- ** initFromDateTimeFull #method:initFromDateTimeFull# + +#if ENABLE_OVERLOADING + VideoTimeCodeInitFromDateTimeFullMethodInfo, +#endif + videoTimeCodeInitFromDateTimeFull , + + +-- ** isValid #method:isValid# + +#if ENABLE_OVERLOADING + VideoTimeCodeIsValidMethodInfo , +#endif + videoTimeCodeIsValid , + + +-- ** new #method:new# + + videoTimeCodeNew , + + +-- ** newEmpty #method:newEmpty# + + videoTimeCodeNewEmpty , + + +-- ** newFromDateTime #method:newFromDateTime# + + videoTimeCodeNewFromDateTime , + + +-- ** newFromDateTimeFull #method:newFromDateTimeFull# + + videoTimeCodeNewFromDateTimeFull , + + +-- ** newFromString #method:newFromString# + + videoTimeCodeNewFromString , + + +-- ** nsecSinceDailyJam #method:nsecSinceDailyJam# + +#if ENABLE_OVERLOADING + VideoTimeCodeNsecSinceDailyJamMethodInfo, +#endif + videoTimeCodeNsecSinceDailyJam , + + +-- ** toDateTime #method:toDateTime# + +#if ENABLE_OVERLOADING + VideoTimeCodeToDateTimeMethodInfo , +#endif + videoTimeCodeToDateTime , + + +-- ** toString #method:toString# + +#if ENABLE_OVERLOADING + VideoTimeCodeToStringMethodInfo , +#endif + videoTimeCodeToString , + + + + + -- * Properties +-- ** config #attr:config# +{- | the corresponding 'GI.GstVideo.Structs.VideoTimeCodeConfig.VideoTimeCodeConfig' +-} + getVideoTimeCodeConfig , +#if ENABLE_OVERLOADING + videoTimeCode_config , +#endif + + +-- ** fieldCount #attr:fieldCount# +{- | Interlaced video field count +-} + getVideoTimeCodeFieldCount , + setVideoTimeCodeFieldCount , +#if ENABLE_OVERLOADING + videoTimeCode_fieldCount , +#endif + + +-- ** frames #attr:frames# +{- | the frames field of 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' +-} + getVideoTimeCodeFrames , + setVideoTimeCodeFrames , +#if ENABLE_OVERLOADING + videoTimeCode_frames , +#endif + + +-- ** hours #attr:hours# +{- | the hours field of 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' +-} + getVideoTimeCodeHours , + setVideoTimeCodeHours , +#if ENABLE_OVERLOADING + videoTimeCode_hours , +#endif + + +-- ** minutes #attr:minutes# +{- | the minutes field of 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' +-} + getVideoTimeCodeMinutes , + setVideoTimeCodeMinutes , +#if ENABLE_OVERLOADING + videoTimeCode_minutes , +#endif + + +-- ** seconds #attr:seconds# +{- | the seconds field of 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' +-} + getVideoTimeCodeSeconds , + setVideoTimeCodeSeconds , +#if ENABLE_OVERLOADING + videoTimeCode_seconds , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GLib.Structs.DateTime as GLib.DateTime +import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoTimeCodeConfig as GstVideo.VideoTimeCodeConfig +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoTimeCodeInterval as GstVideo.VideoTimeCodeInterval + +-- | Memory-managed wrapper type. +newtype VideoTimeCode = VideoTimeCode (ManagedPtr VideoTimeCode) +foreign import ccall "gst_video_time_code_get_type" c_gst_video_time_code_get_type :: + IO GType + +instance BoxedObject VideoTimeCode where + boxedType _ = c_gst_video_time_code_get_type + +-- | Construct a `VideoTimeCode` struct initialized to zero. +newZeroVideoTimeCode :: MonadIO m => m VideoTimeCode +newZeroVideoTimeCode = liftIO $ callocBoxedBytes 48 >>= wrapBoxed VideoTimeCode + +instance tag ~ 'AttrSet => Constructible VideoTimeCode tag where + new _ attrs = do + o <- newZeroVideoTimeCode + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoTimeCode`. +noVideoTimeCode :: Maybe VideoTimeCode +noVideoTimeCode = Nothing + +{- | +Get the value of the “@config@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCode #config +@ +-} +getVideoTimeCodeConfig :: MonadIO m => VideoTimeCode -> m GstVideo.VideoTimeCodeConfig.VideoTimeCodeConfig +getVideoTimeCodeConfig s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr GstVideo.VideoTimeCodeConfig.VideoTimeCodeConfig) + val' <- (newPtr GstVideo.VideoTimeCodeConfig.VideoTimeCodeConfig) val + return val' + +#if ENABLE_OVERLOADING +data VideoTimeCodeConfigFieldInfo +instance AttrInfo VideoTimeCodeConfigFieldInfo where + type AttrAllowedOps VideoTimeCodeConfigFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeConfigFieldInfo = (~) (Ptr GstVideo.VideoTimeCodeConfig.VideoTimeCodeConfig) + type AttrBaseTypeConstraint VideoTimeCodeConfigFieldInfo = (~) VideoTimeCode + type AttrGetType VideoTimeCodeConfigFieldInfo = GstVideo.VideoTimeCodeConfig.VideoTimeCodeConfig + type AttrLabel VideoTimeCodeConfigFieldInfo = "config" + type AttrOrigin VideoTimeCodeConfigFieldInfo = VideoTimeCode + attrGet _ = getVideoTimeCodeConfig + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCode_config :: AttrLabelProxy "config" +videoTimeCode_config = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@hours@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCode #hours +@ +-} +getVideoTimeCodeHours :: MonadIO m => VideoTimeCode -> m Word32 +getVideoTimeCodeHours s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO Word32 + return val + +{- | +Set the value of the “@hours@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoTimeCode [ #hours 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoTimeCodeHours :: MonadIO m => VideoTimeCode -> Word32 -> m () +setVideoTimeCodeHours s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoTimeCodeHoursFieldInfo +instance AttrInfo VideoTimeCodeHoursFieldInfo where + type AttrAllowedOps VideoTimeCodeHoursFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeHoursFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoTimeCodeHoursFieldInfo = (~) VideoTimeCode + type AttrGetType VideoTimeCodeHoursFieldInfo = Word32 + type AttrLabel VideoTimeCodeHoursFieldInfo = "hours" + type AttrOrigin VideoTimeCodeHoursFieldInfo = VideoTimeCode + attrGet _ = getVideoTimeCodeHours + attrSet _ = setVideoTimeCodeHours + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCode_hours :: AttrLabelProxy "hours" +videoTimeCode_hours = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@minutes@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCode #minutes +@ +-} +getVideoTimeCodeMinutes :: MonadIO m => VideoTimeCode -> m Word32 +getVideoTimeCodeMinutes s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 28) :: IO Word32 + return val + +{- | +Set the value of the “@minutes@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoTimeCode [ #minutes 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoTimeCodeMinutes :: MonadIO m => VideoTimeCode -> Word32 -> m () +setVideoTimeCodeMinutes s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 28) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoTimeCodeMinutesFieldInfo +instance AttrInfo VideoTimeCodeMinutesFieldInfo where + type AttrAllowedOps VideoTimeCodeMinutesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeMinutesFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoTimeCodeMinutesFieldInfo = (~) VideoTimeCode + type AttrGetType VideoTimeCodeMinutesFieldInfo = Word32 + type AttrLabel VideoTimeCodeMinutesFieldInfo = "minutes" + type AttrOrigin VideoTimeCodeMinutesFieldInfo = VideoTimeCode + attrGet _ = getVideoTimeCodeMinutes + attrSet _ = setVideoTimeCodeMinutes + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCode_minutes :: AttrLabelProxy "minutes" +videoTimeCode_minutes = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@seconds@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCode #seconds +@ +-} +getVideoTimeCodeSeconds :: MonadIO m => VideoTimeCode -> m Word32 +getVideoTimeCodeSeconds s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Word32 + return val + +{- | +Set the value of the “@seconds@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoTimeCode [ #seconds 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoTimeCodeSeconds :: MonadIO m => VideoTimeCode -> Word32 -> m () +setVideoTimeCodeSeconds s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoTimeCodeSecondsFieldInfo +instance AttrInfo VideoTimeCodeSecondsFieldInfo where + type AttrAllowedOps VideoTimeCodeSecondsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeSecondsFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoTimeCodeSecondsFieldInfo = (~) VideoTimeCode + type AttrGetType VideoTimeCodeSecondsFieldInfo = Word32 + type AttrLabel VideoTimeCodeSecondsFieldInfo = "seconds" + type AttrOrigin VideoTimeCodeSecondsFieldInfo = VideoTimeCode + attrGet _ = getVideoTimeCodeSeconds + attrSet _ = setVideoTimeCodeSeconds + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCode_seconds :: AttrLabelProxy "seconds" +videoTimeCode_seconds = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@frames@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCode #frames +@ +-} +getVideoTimeCodeFrames :: MonadIO m => VideoTimeCode -> m Word32 +getVideoTimeCodeFrames s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 36) :: IO Word32 + return val + +{- | +Set the value of the “@frames@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoTimeCode [ #frames 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoTimeCodeFrames :: MonadIO m => VideoTimeCode -> Word32 -> m () +setVideoTimeCodeFrames s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 36) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoTimeCodeFramesFieldInfo +instance AttrInfo VideoTimeCodeFramesFieldInfo where + type AttrAllowedOps VideoTimeCodeFramesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeFramesFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoTimeCodeFramesFieldInfo = (~) VideoTimeCode + type AttrGetType VideoTimeCodeFramesFieldInfo = Word32 + type AttrLabel VideoTimeCodeFramesFieldInfo = "frames" + type AttrOrigin VideoTimeCodeFramesFieldInfo = VideoTimeCode + attrGet _ = getVideoTimeCodeFrames + attrSet _ = setVideoTimeCodeFrames + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCode_frames :: AttrLabelProxy "frames" +videoTimeCode_frames = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@field_count@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCode #fieldCount +@ +-} +getVideoTimeCodeFieldCount :: MonadIO m => VideoTimeCode -> m Word32 +getVideoTimeCodeFieldCount s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO Word32 + return val + +{- | +Set the value of the “@field_count@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoTimeCode [ #fieldCount 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoTimeCodeFieldCount :: MonadIO m => VideoTimeCode -> Word32 -> m () +setVideoTimeCodeFieldCount s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoTimeCodeFieldCountFieldInfo +instance AttrInfo VideoTimeCodeFieldCountFieldInfo where + type AttrAllowedOps VideoTimeCodeFieldCountFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeFieldCountFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoTimeCodeFieldCountFieldInfo = (~) VideoTimeCode + type AttrGetType VideoTimeCodeFieldCountFieldInfo = Word32 + type AttrLabel VideoTimeCodeFieldCountFieldInfo = "field_count" + type AttrOrigin VideoTimeCodeFieldCountFieldInfo = VideoTimeCode + attrGet _ = getVideoTimeCodeFieldCount + attrSet _ = setVideoTimeCodeFieldCount + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCode_fieldCount :: AttrLabelProxy "fieldCount" +videoTimeCode_fieldCount = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoTimeCode +type instance O.AttributeList VideoTimeCode = VideoTimeCodeAttributeList +type VideoTimeCodeAttributeList = ('[ '("config", VideoTimeCodeConfigFieldInfo), '("hours", VideoTimeCodeHoursFieldInfo), '("minutes", VideoTimeCodeMinutesFieldInfo), '("seconds", VideoTimeCodeSecondsFieldInfo), '("frames", VideoTimeCodeFramesFieldInfo), '("fieldCount", VideoTimeCodeFieldCountFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoTimeCode::new +-- method type : Constructor +-- Args : [Arg {argCName = "fps_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the frame rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the frame rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "latest_daily_jam", argType = TInterface (Name {namespace = "GLib", name = "DateTime"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The latest daily jam of the #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoTimeCodeFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hours", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hours field of #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minutes", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minutes field of #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seconds", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the seconds field of #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frames", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the frames field of #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Interlaced video field count", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_new" gst_video_time_code_new :: + Word32 -> -- fps_n : TBasicType TUInt + Word32 -> -- fps_d : TBasicType TUInt + Ptr GLib.DateTime.DateTime -> -- latest_daily_jam : TInterface (Name {namespace = "GLib", name = "DateTime"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}) + Word32 -> -- hours : TBasicType TUInt + Word32 -> -- minutes : TBasicType TUInt + Word32 -> -- seconds : TBasicType TUInt + Word32 -> -- frames : TBasicType TUInt + Word32 -> -- field_count : TBasicType TUInt + IO (Ptr VideoTimeCode) + +{- | +/@fieldCount@/ is 0 for progressive, 1 or 2 for interlaced. +/@latestDaiyJam@/ reference is stolen from caller. + +/Since: 1.10/ +-} +videoTimeCodeNew :: + (B.CallStack.HasCallStack, MonadIO m) => + Word32 + {- ^ /@fpsN@/: Numerator of the frame rate -} + -> Word32 + {- ^ /@fpsD@/: Denominator of the frame rate -} + -> GLib.DateTime.DateTime + {- ^ /@latestDailyJam@/: The latest daily jam of the 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> [GstVideo.Flags.VideoTimeCodeFlags] + {- ^ /@flags@/: 'GI.GstVideo.Flags.VideoTimeCodeFlags' -} + -> Word32 + {- ^ /@hours@/: the hours field of 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> Word32 + {- ^ /@minutes@/: the minutes field of 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> Word32 + {- ^ /@seconds@/: the seconds field of 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> Word32 + {- ^ /@frames@/: the frames field of 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> Word32 + {- ^ /@fieldCount@/: Interlaced video field count -} + -> m VideoTimeCode + {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' with the given values. +The values are not checked for being in a valid range. To see if your +timecode actually has valid content, use 'GI.GstVideo.Structs.VideoTimeCode.videoTimeCodeIsValid'. -} +videoTimeCodeNew fpsN fpsD latestDailyJam flags hours minutes seconds frames fieldCount = liftIO $ do + latestDailyJam' <- unsafeManagedPtrGetPtr latestDailyJam + let flags' = gflagsToWord flags + result <- gst_video_time_code_new fpsN fpsD latestDailyJam' flags' hours minutes seconds frames fieldCount + checkUnexpectedReturnNULL "videoTimeCodeNew" result + result' <- (wrapBoxed VideoTimeCode) result + touchManagedPtr latestDailyJam + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method VideoTimeCode::new_empty +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_new_empty" gst_video_time_code_new_empty :: + IO (Ptr VideoTimeCode) + +{- | +/No description available in the introspection data./ + +/Since: 1.10/ +-} +videoTimeCodeNewEmpty :: + (B.CallStack.HasCallStack, MonadIO m) => + m VideoTimeCode + {- ^ __Returns:__ a new empty, invalid 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} +videoTimeCodeNewEmpty = liftIO $ do + result <- gst_video_time_code_new_empty + checkUnexpectedReturnNULL "videoTimeCodeNewEmpty" result + result' <- (wrapBoxed VideoTimeCode) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method VideoTimeCode::new_from_date_time +-- method type : Constructor +-- Args : [Arg {argCName = "fps_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the frame rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the frame rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dt", argType = TInterface (Name {namespace = "GLib", name = "DateTime"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GDateTime to convert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoTimeCodeFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Interlaced video field count", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_new_from_date_time" gst_video_time_code_new_from_date_time :: + Word32 -> -- fps_n : TBasicType TUInt + Word32 -> -- fps_d : TBasicType TUInt + Ptr GLib.DateTime.DateTime -> -- dt : TInterface (Name {namespace = "GLib", name = "DateTime"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}) + Word32 -> -- field_count : TBasicType TUInt + IO (Ptr VideoTimeCode) + +{- | +The resulting config->latest_daily_jam is set to +midnight, and timecode is set to the given time. + +This might return a completely invalid timecode, use +'GI.GstVideo.Structs.VideoTimeCode.videoTimeCodeNewFromDateTimeFull' to ensure +that you would get 'Nothing' instead in that case. + +/Since: 1.12/ +-} +videoTimeCodeNewFromDateTime :: + (B.CallStack.HasCallStack, MonadIO m) => + Word32 + {- ^ /@fpsN@/: Numerator of the frame rate -} + -> Word32 + {- ^ /@fpsD@/: Denominator of the frame rate -} + -> GLib.DateTime.DateTime + {- ^ /@dt@/: 'GI.GLib.Structs.DateTime.DateTime' to convert -} + -> [GstVideo.Flags.VideoTimeCodeFlags] + {- ^ /@flags@/: 'GI.GstVideo.Flags.VideoTimeCodeFlags' -} + -> Word32 + {- ^ /@fieldCount@/: Interlaced video field count -} + -> m VideoTimeCode + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' representation of /@dt@/. -} +videoTimeCodeNewFromDateTime fpsN fpsD dt flags fieldCount = liftIO $ do + dt' <- unsafeManagedPtrGetPtr dt + let flags' = gflagsToWord flags + result <- gst_video_time_code_new_from_date_time fpsN fpsD dt' flags' fieldCount + checkUnexpectedReturnNULL "videoTimeCodeNewFromDateTime" result + result' <- (wrapBoxed VideoTimeCode) result + touchManagedPtr dt + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method VideoTimeCode::new_from_date_time_full +-- method type : Constructor +-- Args : [Arg {argCName = "fps_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the frame rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the frame rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dt", argType = TInterface (Name {namespace = "GLib", name = "DateTime"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GDateTime to convert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoTimeCodeFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Interlaced video field count", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_new_from_date_time_full" gst_video_time_code_new_from_date_time_full :: + Word32 -> -- fps_n : TBasicType TUInt + Word32 -> -- fps_d : TBasicType TUInt + Ptr GLib.DateTime.DateTime -> -- dt : TInterface (Name {namespace = "GLib", name = "DateTime"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}) + Word32 -> -- field_count : TBasicType TUInt + IO (Ptr VideoTimeCode) + +{- | +The resulting config->latest_daily_jam is set to +midnight, and timecode is set to the given time. + +/Since: 1.16/ +-} +videoTimeCodeNewFromDateTimeFull :: + (B.CallStack.HasCallStack, MonadIO m) => + Word32 + {- ^ /@fpsN@/: Numerator of the frame rate -} + -> Word32 + {- ^ /@fpsD@/: Denominator of the frame rate -} + -> GLib.DateTime.DateTime + {- ^ /@dt@/: 'GI.GLib.Structs.DateTime.DateTime' to convert -} + -> [GstVideo.Flags.VideoTimeCodeFlags] + {- ^ /@flags@/: 'GI.GstVideo.Flags.VideoTimeCodeFlags' -} + -> Word32 + {- ^ /@fieldCount@/: Interlaced video field count -} + -> m VideoTimeCode + {- ^ __Returns:__ the 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' representation of /@dt@/, or 'Nothing' if + no valid timecode could be created. -} +videoTimeCodeNewFromDateTimeFull fpsN fpsD dt flags fieldCount = liftIO $ do + dt' <- unsafeManagedPtrGetPtr dt + let flags' = gflagsToWord flags + result <- gst_video_time_code_new_from_date_time_full fpsN fpsD dt' flags' fieldCount + checkUnexpectedReturnNULL "videoTimeCodeNewFromDateTimeFull" result + result' <- (wrapBoxed VideoTimeCode) result + touchManagedPtr dt + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method VideoTimeCode::new_from_string +-- method type : Constructor +-- Args : [Arg {argCName = "tc_str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The string that represents the #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_new_from_string" gst_video_time_code_new_from_string :: + CString -> -- tc_str : TBasicType TUTF8 + IO (Ptr VideoTimeCode) + +{- | +/No description available in the introspection data./ + +/Since: 1.12/ +-} +videoTimeCodeNewFromString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@tcStr@/: The string that represents the 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> m (Maybe VideoTimeCode) + {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' from the given string or 'Nothing' + if the string could not be passed. -} +videoTimeCodeNewFromString tcStr = liftIO $ do + tcStr' <- textToCString tcStr + result <- gst_video_time_code_new_from_string tcStr' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed VideoTimeCode) result' + return result'' + freeMem tcStr' + return maybeResult + +#if ENABLE_OVERLOADING +#endif + +-- method VideoTimeCode::add_frames +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a valid #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frames", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "How many frames to add or subtract", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_add_frames" gst_video_time_code_add_frames :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + Int64 -> -- frames : TBasicType TInt64 + IO () + +{- | +Adds or subtracts /@frames@/ amount of frames to /@tc@/. tc needs to +contain valid data, as verified by 'GI.GstVideo.Structs.VideoTimeCode.videoTimeCodeIsValid'. + +/Since: 1.10/ +-} +videoTimeCodeAddFrames :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: a valid 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> Int64 + {- ^ /@frames@/: How many frames to add or subtract -} + -> m () +videoTimeCodeAddFrames tc frames = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + gst_video_time_code_add_frames tc' frames + touchManagedPtr tc + return () + +#if ENABLE_OVERLOADING +data VideoTimeCodeAddFramesMethodInfo +instance (signature ~ (Int64 -> m ()), MonadIO m) => O.MethodInfo VideoTimeCodeAddFramesMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeAddFrames + +#endif + +-- method VideoTimeCode::add_interval +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GstVideoTimeCode where the diff should be added. This\nmust contain valid timecode values.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tc_inter", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GstVideoTimeCodeInterval to add to @tc.\nThe interval must contain valid values, except that for drop-frame\ntimecode, it may also contain timecodes which would normally\nbe dropped. These are then corrected to the next reasonable timecode.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_add_interval" gst_video_time_code_add_interval :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + Ptr GstVideo.VideoTimeCodeInterval.VideoTimeCodeInterval -> -- tc_inter : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}) + IO (Ptr VideoTimeCode) + +{- | +This makes a component-wise addition of /@tcInter@/ to /@tc@/. For example, +adding (\"01:02:03:04\", \"00:01:00:00\") will return \"01:03:03:04\". +When it comes to drop-frame timecodes, +adding (\"00:00:00;00\", \"00:01:00:00\") will return \"00:01:00;02\" +because of drop-frame oddities. However, +adding (\"00:09:00;02\", \"00:01:00:00\") will return \"00:10:00;00\" +because this time we can have an exact minute. + +/Since: 1.12/ +-} +videoTimeCodeAddInterval :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: The 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' where the diff should be added. This +must contain valid timecode values. -} + -> GstVideo.VideoTimeCodeInterval.VideoTimeCodeInterval + {- ^ /@tcInter@/: The 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' to add to /@tc@/. +The interval must contain valid values, except that for drop-frame +timecode, it may also contain timecodes which would normally +be dropped. These are then corrected to the next reasonable timecode. -} + -> m (Maybe VideoTimeCode) + {- ^ __Returns:__ A new 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' with /@tcInter@/ added or 'Nothing' + if the interval can\'t be added. -} +videoTimeCodeAddInterval tc tcInter = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + tcInter' <- unsafeManagedPtrGetPtr tcInter + result <- gst_video_time_code_add_interval tc' tcInter' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed VideoTimeCode) result' + return result'' + touchManagedPtr tc + touchManagedPtr tcInter + return maybeResult + +#if ENABLE_OVERLOADING +data VideoTimeCodeAddIntervalMethodInfo +instance (signature ~ (GstVideo.VideoTimeCodeInterval.VideoTimeCodeInterval -> m (Maybe VideoTimeCode)), MonadIO m) => O.MethodInfo VideoTimeCodeAddIntervalMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeAddInterval + +#endif + +-- method VideoTimeCode::clear +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_clear" gst_video_time_code_clear :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + IO () + +{- | +Initializes /@tc@/ with empty\/zero\/NULL values and frees any memory +it might currently use. + +/Since: 1.10/ +-} +videoTimeCodeClear :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> m () +videoTimeCodeClear tc = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + gst_video_time_code_clear tc' + touchManagedPtr tc + return () + +#if ENABLE_OVERLOADING +data VideoTimeCodeClearMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoTimeCodeClearMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeClear + +#endif + +-- method VideoTimeCode::compare +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc1", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a valid #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tc2", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "another valid #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_compare" gst_video_time_code_compare :: + Ptr VideoTimeCode -> -- tc1 : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + Ptr VideoTimeCode -> -- tc2 : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + IO Int32 + +{- | +Compares /@tc1@/ and /@tc2@/. If both have latest daily jam information, it is +taken into account. Otherwise, it is assumed that the daily jam of both +/@tc1@/ and /@tc2@/ was at the same time. Both time codes must be valid. + +/Since: 1.10/ +-} +videoTimeCodeCompare :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc1@/: a valid 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> VideoTimeCode + {- ^ /@tc2@/: another valid 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> m Int32 + {- ^ __Returns:__ 1 if /@tc1@/ is after /@tc2@/, -1 if /@tc1@/ is before /@tc2@/, 0 otherwise. -} +videoTimeCodeCompare tc1 tc2 = liftIO $ do + tc1' <- unsafeManagedPtrGetPtr tc1 + tc2' <- unsafeManagedPtrGetPtr tc2 + result <- gst_video_time_code_compare tc1' tc2' + touchManagedPtr tc1 + touchManagedPtr tc2 + return result + +#if ENABLE_OVERLOADING +data VideoTimeCodeCompareMethodInfo +instance (signature ~ (VideoTimeCode -> m Int32), MonadIO m) => O.MethodInfo VideoTimeCodeCompareMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeCompare + +#endif + +-- method VideoTimeCode::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_copy" gst_video_time_code_copy :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + IO (Ptr VideoTimeCode) + +{- | +/No description available in the introspection data./ + +/Since: 1.10/ +-} +videoTimeCodeCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> m VideoTimeCode + {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' with the same values as /@tc@/. -} +videoTimeCodeCopy tc = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + result <- gst_video_time_code_copy tc' + checkUnexpectedReturnNULL "videoTimeCodeCopy" result + result' <- (wrapBoxed VideoTimeCode) result + touchManagedPtr tc + return result' + +#if ENABLE_OVERLOADING +data VideoTimeCodeCopyMethodInfo +instance (signature ~ (m VideoTimeCode), MonadIO m) => O.MethodInfo VideoTimeCodeCopyMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeCopy + +#endif + +-- method VideoTimeCode::frames_since_daily_jam +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a valid #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_frames_since_daily_jam" gst_video_time_code_frames_since_daily_jam :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + IO Word64 + +{- | +/No description available in the introspection data./ + +/Since: 1.10/ +-} +videoTimeCodeFramesSinceDailyJam :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: a valid 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> m Word64 + {- ^ __Returns:__ how many frames have passed since the daily jam of /@tc@/. -} +videoTimeCodeFramesSinceDailyJam tc = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + result <- gst_video_time_code_frames_since_daily_jam tc' + touchManagedPtr tc + return result + +#if ENABLE_OVERLOADING +data VideoTimeCodeFramesSinceDailyJamMethodInfo +instance (signature ~ (m Word64), MonadIO m) => O.MethodInfo VideoTimeCodeFramesSinceDailyJamMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeFramesSinceDailyJam + +#endif + +-- method VideoTimeCode::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_free" gst_video_time_code_free :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + IO () + +{- | +Frees /@tc@/. + +/Since: 1.10/ +-} +videoTimeCodeFree :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> m () +videoTimeCodeFree tc = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + gst_video_time_code_free tc' + touchManagedPtr tc + return () + +#if ENABLE_OVERLOADING +data VideoTimeCodeFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoTimeCodeFreeMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeFree + +#endif + +-- method VideoTimeCode::increment_frame +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a valid #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_increment_frame" gst_video_time_code_increment_frame :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + IO () + +{- | +Adds one frame to /@tc@/. + +/Since: 1.10/ +-} +videoTimeCodeIncrementFrame :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: a valid 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> m () +videoTimeCodeIncrementFrame tc = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + gst_video_time_code_increment_frame tc' + touchManagedPtr tc + return () + +#if ENABLE_OVERLOADING +data VideoTimeCodeIncrementFrameMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoTimeCodeIncrementFrameMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeIncrementFrame + +#endif + +-- method VideoTimeCode::init +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the frame rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the frame rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "latest_daily_jam", argType = TInterface (Name {namespace = "GLib", name = "DateTime"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The latest daily jam of the #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoTimeCodeFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hours", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hours field of #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minutes", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minutes field of #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seconds", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the seconds field of #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frames", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the frames field of #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Interlaced video field count", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_init" gst_video_time_code_init :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + Word32 -> -- fps_n : TBasicType TUInt + Word32 -> -- fps_d : TBasicType TUInt + Ptr GLib.DateTime.DateTime -> -- latest_daily_jam : TInterface (Name {namespace = "GLib", name = "DateTime"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}) + Word32 -> -- hours : TBasicType TUInt + Word32 -> -- minutes : TBasicType TUInt + Word32 -> -- seconds : TBasicType TUInt + Word32 -> -- frames : TBasicType TUInt + Word32 -> -- field_count : TBasicType TUInt + IO () + +{- | +/@fieldCount@/ is 0 for progressive, 1 or 2 for interlaced. +/@latestDaiyJam@/ reference is stolen from caller. + +Initializes /@tc@/ with the given values. +The values are not checked for being in a valid range. To see if your +timecode actually has valid content, use 'GI.GstVideo.Structs.VideoTimeCode.videoTimeCodeIsValid'. + +/Since: 1.10/ +-} +videoTimeCodeInit :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> Word32 + {- ^ /@fpsN@/: Numerator of the frame rate -} + -> Word32 + {- ^ /@fpsD@/: Denominator of the frame rate -} + -> GLib.DateTime.DateTime + {- ^ /@latestDailyJam@/: The latest daily jam of the 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> [GstVideo.Flags.VideoTimeCodeFlags] + {- ^ /@flags@/: 'GI.GstVideo.Flags.VideoTimeCodeFlags' -} + -> Word32 + {- ^ /@hours@/: the hours field of 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> Word32 + {- ^ /@minutes@/: the minutes field of 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> Word32 + {- ^ /@seconds@/: the seconds field of 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> Word32 + {- ^ /@frames@/: the frames field of 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> Word32 + {- ^ /@fieldCount@/: Interlaced video field count -} + -> m () +videoTimeCodeInit tc fpsN fpsD latestDailyJam flags hours minutes seconds frames fieldCount = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + latestDailyJam' <- unsafeManagedPtrGetPtr latestDailyJam + let flags' = gflagsToWord flags + gst_video_time_code_init tc' fpsN fpsD latestDailyJam' flags' hours minutes seconds frames fieldCount + touchManagedPtr tc + touchManagedPtr latestDailyJam + return () + +#if ENABLE_OVERLOADING +data VideoTimeCodeInitMethodInfo +instance (signature ~ (Word32 -> Word32 -> GLib.DateTime.DateTime -> [GstVideo.Flags.VideoTimeCodeFlags] -> Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m) => O.MethodInfo VideoTimeCodeInitMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeInit + +#endif + +-- method VideoTimeCode::init_from_date_time +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an uninitialized #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the frame rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the frame rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dt", argType = TInterface (Name {namespace = "GLib", name = "DateTime"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GDateTime to convert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoTimeCodeFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Interlaced video field count", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_init_from_date_time" gst_video_time_code_init_from_date_time :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + Word32 -> -- fps_n : TBasicType TUInt + Word32 -> -- fps_d : TBasicType TUInt + Ptr GLib.DateTime.DateTime -> -- dt : TInterface (Name {namespace = "GLib", name = "DateTime"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}) + Word32 -> -- field_count : TBasicType TUInt + IO () + +{- | +The resulting config->latest_daily_jam is set to midnight, and timecode is +set to the given time. + +Will assert on invalid parameters, use 'GI.GstVideo.Structs.VideoTimeCode.videoTimeCodeInitFromDateTimeFull' +for being able to handle invalid parameters. + +/Since: 1.12/ +-} +videoTimeCodeInitFromDateTime :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: an uninitialized 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> Word32 + {- ^ /@fpsN@/: Numerator of the frame rate -} + -> Word32 + {- ^ /@fpsD@/: Denominator of the frame rate -} + -> GLib.DateTime.DateTime + {- ^ /@dt@/: 'GI.GLib.Structs.DateTime.DateTime' to convert -} + -> [GstVideo.Flags.VideoTimeCodeFlags] + {- ^ /@flags@/: 'GI.GstVideo.Flags.VideoTimeCodeFlags' -} + -> Word32 + {- ^ /@fieldCount@/: Interlaced video field count -} + -> m () +videoTimeCodeInitFromDateTime tc fpsN fpsD dt flags fieldCount = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + dt' <- unsafeManagedPtrGetPtr dt + let flags' = gflagsToWord flags + gst_video_time_code_init_from_date_time tc' fpsN fpsD dt' flags' fieldCount + touchManagedPtr tc + touchManagedPtr dt + return () + +#if ENABLE_OVERLOADING +data VideoTimeCodeInitFromDateTimeMethodInfo +instance (signature ~ (Word32 -> Word32 -> GLib.DateTime.DateTime -> [GstVideo.Flags.VideoTimeCodeFlags] -> Word32 -> m ()), MonadIO m) => O.MethodInfo VideoTimeCodeInitFromDateTimeMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeInitFromDateTime + +#endif + +-- method VideoTimeCode::init_from_date_time_full +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_n", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Numerator of the frame rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fps_d", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Denominator of the frame rate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dt", argType = TInterface (Name {namespace = "GLib", name = "DateTime"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GDateTime to convert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoTimeCodeFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Interlaced video field count", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_init_from_date_time_full" gst_video_time_code_init_from_date_time_full :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + Word32 -> -- fps_n : TBasicType TUInt + Word32 -> -- fps_d : TBasicType TUInt + Ptr GLib.DateTime.DateTime -> -- dt : TInterface (Name {namespace = "GLib", name = "DateTime"}) + CUInt -> -- flags : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeFlags"}) + Word32 -> -- field_count : TBasicType TUInt + IO CInt + +{- | +The resulting config->latest_daily_jam is set to +midnight, and timecode is set to the given time. + +/Since: 1.16/ +-} +videoTimeCodeInitFromDateTimeFull :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> Word32 + {- ^ /@fpsN@/: Numerator of the frame rate -} + -> Word32 + {- ^ /@fpsD@/: Denominator of the frame rate -} + -> GLib.DateTime.DateTime + {- ^ /@dt@/: 'GI.GLib.Structs.DateTime.DateTime' to convert -} + -> [GstVideo.Flags.VideoTimeCodeFlags] + {- ^ /@flags@/: 'GI.GstVideo.Flags.VideoTimeCodeFlags' -} + -> Word32 + {- ^ /@fieldCount@/: Interlaced video field count -} + -> m Bool + {- ^ __Returns:__ 'True' if /@tc@/ could be correctly initialized to a valid timecode -} +videoTimeCodeInitFromDateTimeFull tc fpsN fpsD dt flags fieldCount = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + dt' <- unsafeManagedPtrGetPtr dt + let flags' = gflagsToWord flags + result <- gst_video_time_code_init_from_date_time_full tc' fpsN fpsD dt' flags' fieldCount + let result' = (/= 0) result + touchManagedPtr tc + touchManagedPtr dt + return result' + +#if ENABLE_OVERLOADING +data VideoTimeCodeInitFromDateTimeFullMethodInfo +instance (signature ~ (Word32 -> Word32 -> GLib.DateTime.DateTime -> [GstVideo.Flags.VideoTimeCodeFlags] -> Word32 -> m Bool), MonadIO m) => O.MethodInfo VideoTimeCodeInitFromDateTimeFullMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeInitFromDateTimeFull + +#endif + +-- method VideoTimeCode::is_valid +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GstVideoTimeCode to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_is_valid" gst_video_time_code_is_valid :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 1.10/ +-} +videoTimeCodeIsValid :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' to check -} + -> m Bool + {- ^ __Returns:__ whether /@tc@/ is a valid timecode (supported frame rate, +hours\/minutes\/seconds\/frames not overflowing) -} +videoTimeCodeIsValid tc = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + result <- gst_video_time_code_is_valid tc' + let result' = (/= 0) result + touchManagedPtr tc + return result' + +#if ENABLE_OVERLOADING +data VideoTimeCodeIsValidMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo VideoTimeCodeIsValidMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeIsValid + +#endif + +-- method VideoTimeCode::nsec_since_daily_jam +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a valid #GstVideoTimeCode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_nsec_since_daily_jam" gst_video_time_code_nsec_since_daily_jam :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + IO Word64 + +{- | +/No description available in the introspection data./ + +/Since: 1.10/ +-} +videoTimeCodeNsecSinceDailyJam :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: a valid 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' -} + -> m Word64 + {- ^ __Returns:__ how many nsec have passed since the daily jam of /@tc@/. -} +videoTimeCodeNsecSinceDailyJam tc = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + result <- gst_video_time_code_nsec_since_daily_jam tc' + touchManagedPtr tc + return result + +#if ENABLE_OVERLOADING +data VideoTimeCodeNsecSinceDailyJamMethodInfo +instance (signature ~ (m Word64), MonadIO m) => O.MethodInfo VideoTimeCodeNsecSinceDailyJamMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeNsecSinceDailyJam + +#endif + +-- method VideoTimeCode::to_date_time +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid #GstVideoTimeCode to convert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "DateTime"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_to_date_time" gst_video_time_code_to_date_time :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + IO (Ptr GLib.DateTime.DateTime) + +{- | +The /@tc@/.config->latest_daily_jam is required to be non-NULL. + +/Since: 1.10/ +-} +videoTimeCodeToDateTime :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: A valid 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' to convert -} + -> m (Maybe GLib.DateTime.DateTime) + {- ^ __Returns:__ the 'GI.GLib.Structs.DateTime.DateTime' representation of /@tc@/ or 'Nothing' if /@tc@/ + has no daily jam. -} +videoTimeCodeToDateTime tc = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + result <- gst_video_time_code_to_date_time tc' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed GLib.DateTime.DateTime) result' + return result'' + touchManagedPtr tc + return maybeResult + +#if ENABLE_OVERLOADING +data VideoTimeCodeToDateTimeMethodInfo +instance (signature ~ (m (Maybe GLib.DateTime.DateTime)), MonadIO m) => O.MethodInfo VideoTimeCodeToDateTimeMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeToDateTime + +#endif + +-- method VideoTimeCode::to_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstVideoTimeCode to convert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_to_string" gst_video_time_code_to_string :: + Ptr VideoTimeCode -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCode"}) + IO CString + +{- | +/No description available in the introspection data./ + +/Since: 1.10/ +-} +videoTimeCodeToString :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCode + {- ^ /@tc@/: A 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' to convert -} + -> m T.Text + {- ^ __Returns:__ the SMPTE ST 2059-1:2015 string representation of /@tc@/. That will +take the form hh:mm:ss:ff. The last separator (between seconds and frames) +may vary: + +\';\' for drop-frame, non-interlaced content and for drop-frame interlaced +field 2 +\',\' for drop-frame interlaced field 1 +\':\' for non-drop-frame, non-interlaced content and for non-drop-frame +interlaced field 2 +\'.\' for non-drop-frame interlaced field 1 -} +videoTimeCodeToString tc = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + result <- gst_video_time_code_to_string tc' + checkUnexpectedReturnNULL "videoTimeCodeToString" result + result' <- cstringToText result + freeMem result + touchManagedPtr tc + return result' + +#if ENABLE_OVERLOADING +data VideoTimeCodeToStringMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo VideoTimeCodeToStringMethodInfo VideoTimeCode signature where + overloadedMethod _ = videoTimeCodeToString + +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoTimeCodeMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoTimeCodeMethod "addFrames" o = VideoTimeCodeAddFramesMethodInfo + ResolveVideoTimeCodeMethod "addInterval" o = VideoTimeCodeAddIntervalMethodInfo + ResolveVideoTimeCodeMethod "clear" o = VideoTimeCodeClearMethodInfo + ResolveVideoTimeCodeMethod "compare" o = VideoTimeCodeCompareMethodInfo + ResolveVideoTimeCodeMethod "copy" o = VideoTimeCodeCopyMethodInfo + ResolveVideoTimeCodeMethod "framesSinceDailyJam" o = VideoTimeCodeFramesSinceDailyJamMethodInfo + ResolveVideoTimeCodeMethod "free" o = VideoTimeCodeFreeMethodInfo + ResolveVideoTimeCodeMethod "incrementFrame" o = VideoTimeCodeIncrementFrameMethodInfo + ResolveVideoTimeCodeMethod "init" o = VideoTimeCodeInitMethodInfo + ResolveVideoTimeCodeMethod "initFromDateTime" o = VideoTimeCodeInitFromDateTimeMethodInfo + ResolveVideoTimeCodeMethod "initFromDateTimeFull" o = VideoTimeCodeInitFromDateTimeFullMethodInfo + ResolveVideoTimeCodeMethod "isValid" o = VideoTimeCodeIsValidMethodInfo + ResolveVideoTimeCodeMethod "nsecSinceDailyJam" o = VideoTimeCodeNsecSinceDailyJamMethodInfo + ResolveVideoTimeCodeMethod "toDateTime" o = VideoTimeCodeToDateTimeMethodInfo + ResolveVideoTimeCodeMethod "toString" o = VideoTimeCodeToStringMethodInfo + ResolveVideoTimeCodeMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoTimeCodeMethod t VideoTimeCode, O.MethodInfo info VideoTimeCode p) => OL.IsLabel t (VideoTimeCode -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoTimeCode.hs-boot b/GI/GstVideo/Structs/VideoTimeCode.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoTimeCode.hs-boot @@ -0,0 +1,71 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoTimeCode where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoTimeCode = VideoTimeCode (ManagedPtr VideoTimeCode) +instance BoxedObject VideoTimeCode where +#if ENABLE_OVERLOADING +data VideoTimeCodeAddFramesMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeAddIntervalMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeClearMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeCompareMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeFramesSinceDailyJamMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeIncrementFrameMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeInitMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeInitFromDateTimeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeInitFromDateTimeFullMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeIsValidMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeNsecSinceDailyJamMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeToDateTimeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeToStringMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoTimeCodeConfig.hs b/GI/GstVideo/Structs/VideoTimeCodeConfig.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoTimeCodeConfig.hs @@ -0,0 +1,336 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Supported frame rates: 30000\/1001, 60000\/1001 (both with and without drop +frame), and integer frame rates e.g. 25\/1, 30\/1, 50\/1, 60\/1. + +The configuration of the time code. + +/Since: 1.10/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoTimeCodeConfig + ( + +-- * Exported types + VideoTimeCodeConfig(..) , + newZeroVideoTimeCodeConfig , + noVideoTimeCodeConfig , + + + -- * Properties +-- ** flags #attr:flags# +{- | the corresponding 'GI.GstVideo.Flags.VideoTimeCodeFlags' +-} + getVideoTimeCodeConfigFlags , + setVideoTimeCodeConfigFlags , +#if ENABLE_OVERLOADING + videoTimeCodeConfig_flags , +#endif + + +-- ** fpsD #attr:fpsD# +{- | Denominator of the frame rate +-} + getVideoTimeCodeConfigFpsD , + setVideoTimeCodeConfigFpsD , +#if ENABLE_OVERLOADING + videoTimeCodeConfig_fpsD , +#endif + + +-- ** fpsN #attr:fpsN# +{- | Numerator of the frame rate +-} + getVideoTimeCodeConfigFpsN , + setVideoTimeCodeConfigFpsN , +#if ENABLE_OVERLOADING + videoTimeCodeConfig_fpsN , +#endif + + +-- ** latestDailyJam #attr:latestDailyJam# +{- | The latest daily jam information, if present, or NULL +-} + clearVideoTimeCodeConfigLatestDailyJam , + getVideoTimeCodeConfigLatestDailyJam , + setVideoTimeCodeConfigLatestDailyJam , +#if ENABLE_OVERLOADING + videoTimeCodeConfig_latestDailyJam , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GLib.Structs.DateTime as GLib.DateTime +import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags + +-- | Memory-managed wrapper type. +newtype VideoTimeCodeConfig = VideoTimeCodeConfig (ManagedPtr VideoTimeCodeConfig) +instance WrappedPtr VideoTimeCodeConfig where + wrappedPtrCalloc = callocBytes 24 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 24 >=> wrapPtr VideoTimeCodeConfig) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoTimeCodeConfig` struct initialized to zero. +newZeroVideoTimeCodeConfig :: MonadIO m => m VideoTimeCodeConfig +newZeroVideoTimeCodeConfig = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoTimeCodeConfig + +instance tag ~ 'AttrSet => Constructible VideoTimeCodeConfig tag where + new _ attrs = do + o <- newZeroVideoTimeCodeConfig + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoTimeCodeConfig`. +noVideoTimeCodeConfig :: Maybe VideoTimeCodeConfig +noVideoTimeCodeConfig = Nothing + +{- | +Get the value of the “@fps_n@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCodeConfig #fpsN +@ +-} +getVideoTimeCodeConfigFpsN :: MonadIO m => VideoTimeCodeConfig -> m Word32 +getVideoTimeCodeConfigFpsN s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word32 + return val + +{- | +Set the value of the “@fps_n@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoTimeCodeConfig [ #fpsN 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoTimeCodeConfigFpsN :: MonadIO m => VideoTimeCodeConfig -> Word32 -> m () +setVideoTimeCodeConfigFpsN s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoTimeCodeConfigFpsNFieldInfo +instance AttrInfo VideoTimeCodeConfigFpsNFieldInfo where + type AttrAllowedOps VideoTimeCodeConfigFpsNFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeConfigFpsNFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoTimeCodeConfigFpsNFieldInfo = (~) VideoTimeCodeConfig + type AttrGetType VideoTimeCodeConfigFpsNFieldInfo = Word32 + type AttrLabel VideoTimeCodeConfigFpsNFieldInfo = "fps_n" + type AttrOrigin VideoTimeCodeConfigFpsNFieldInfo = VideoTimeCodeConfig + attrGet _ = getVideoTimeCodeConfigFpsN + attrSet _ = setVideoTimeCodeConfigFpsN + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCodeConfig_fpsN :: AttrLabelProxy "fpsN" +videoTimeCodeConfig_fpsN = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@fps_d@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCodeConfig #fpsD +@ +-} +getVideoTimeCodeConfigFpsD :: MonadIO m => VideoTimeCodeConfig -> m Word32 +getVideoTimeCodeConfigFpsD s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 4) :: IO Word32 + return val + +{- | +Set the value of the “@fps_d@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoTimeCodeConfig [ #fpsD 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoTimeCodeConfigFpsD :: MonadIO m => VideoTimeCodeConfig -> Word32 -> m () +setVideoTimeCodeConfigFpsD s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 4) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoTimeCodeConfigFpsDFieldInfo +instance AttrInfo VideoTimeCodeConfigFpsDFieldInfo where + type AttrAllowedOps VideoTimeCodeConfigFpsDFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeConfigFpsDFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoTimeCodeConfigFpsDFieldInfo = (~) VideoTimeCodeConfig + type AttrGetType VideoTimeCodeConfigFpsDFieldInfo = Word32 + type AttrLabel VideoTimeCodeConfigFpsDFieldInfo = "fps_d" + type AttrOrigin VideoTimeCodeConfigFpsDFieldInfo = VideoTimeCodeConfig + attrGet _ = getVideoTimeCodeConfigFpsD + attrSet _ = setVideoTimeCodeConfigFpsD + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCodeConfig_fpsD :: AttrLabelProxy "fpsD" +videoTimeCodeConfig_fpsD = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@flags@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCodeConfig #flags +@ +-} +getVideoTimeCodeConfigFlags :: MonadIO m => VideoTimeCodeConfig -> m [GstVideo.Flags.VideoTimeCodeFlags] +getVideoTimeCodeConfigFlags s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CUInt + let val' = wordToGFlags val + return val' + +{- | +Set the value of the “@flags@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoTimeCodeConfig [ #flags 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoTimeCodeConfigFlags :: MonadIO m => VideoTimeCodeConfig -> [GstVideo.Flags.VideoTimeCodeFlags] -> m () +setVideoTimeCodeConfigFlags s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = gflagsToWord val + poke (ptr `plusPtr` 8) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data VideoTimeCodeConfigFlagsFieldInfo +instance AttrInfo VideoTimeCodeConfigFlagsFieldInfo where + type AttrAllowedOps VideoTimeCodeConfigFlagsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeConfigFlagsFieldInfo = (~) [GstVideo.Flags.VideoTimeCodeFlags] + type AttrBaseTypeConstraint VideoTimeCodeConfigFlagsFieldInfo = (~) VideoTimeCodeConfig + type AttrGetType VideoTimeCodeConfigFlagsFieldInfo = [GstVideo.Flags.VideoTimeCodeFlags] + type AttrLabel VideoTimeCodeConfigFlagsFieldInfo = "flags" + type AttrOrigin VideoTimeCodeConfigFlagsFieldInfo = VideoTimeCodeConfig + attrGet _ = getVideoTimeCodeConfigFlags + attrSet _ = setVideoTimeCodeConfigFlags + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCodeConfig_flags :: AttrLabelProxy "flags" +videoTimeCodeConfig_flags = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@latest_daily_jam@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCodeConfig #latestDailyJam +@ +-} +getVideoTimeCodeConfigLatestDailyJam :: MonadIO m => VideoTimeCodeConfig -> m (Maybe GLib.DateTime.DateTime) +getVideoTimeCodeConfigLatestDailyJam s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO (Ptr GLib.DateTime.DateTime) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed GLib.DateTime.DateTime) val' + return val'' + return result + +{- | +Set the value of the “@latest_daily_jam@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoTimeCodeConfig [ #latestDailyJam 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoTimeCodeConfigLatestDailyJam :: MonadIO m => VideoTimeCodeConfig -> Ptr GLib.DateTime.DateTime -> m () +setVideoTimeCodeConfigLatestDailyJam s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Ptr GLib.DateTime.DateTime) + +{- | +Set the value of the “@latest_daily_jam@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #latestDailyJam +@ +-} +clearVideoTimeCodeConfigLatestDailyJam :: MonadIO m => VideoTimeCodeConfig -> m () +clearVideoTimeCodeConfigLatestDailyJam s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr GLib.DateTime.DateTime) + +#if ENABLE_OVERLOADING +data VideoTimeCodeConfigLatestDailyJamFieldInfo +instance AttrInfo VideoTimeCodeConfigLatestDailyJamFieldInfo where + type AttrAllowedOps VideoTimeCodeConfigLatestDailyJamFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint VideoTimeCodeConfigLatestDailyJamFieldInfo = (~) (Ptr GLib.DateTime.DateTime) + type AttrBaseTypeConstraint VideoTimeCodeConfigLatestDailyJamFieldInfo = (~) VideoTimeCodeConfig + type AttrGetType VideoTimeCodeConfigLatestDailyJamFieldInfo = Maybe GLib.DateTime.DateTime + type AttrLabel VideoTimeCodeConfigLatestDailyJamFieldInfo = "latest_daily_jam" + type AttrOrigin VideoTimeCodeConfigLatestDailyJamFieldInfo = VideoTimeCodeConfig + attrGet _ = getVideoTimeCodeConfigLatestDailyJam + attrSet _ = setVideoTimeCodeConfigLatestDailyJam + attrConstruct = undefined + attrClear _ = clearVideoTimeCodeConfigLatestDailyJam + +videoTimeCodeConfig_latestDailyJam :: AttrLabelProxy "latestDailyJam" +videoTimeCodeConfig_latestDailyJam = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoTimeCodeConfig +type instance O.AttributeList VideoTimeCodeConfig = VideoTimeCodeConfigAttributeList +type VideoTimeCodeConfigAttributeList = ('[ '("fpsN", VideoTimeCodeConfigFpsNFieldInfo), '("fpsD", VideoTimeCodeConfigFpsDFieldInfo), '("flags", VideoTimeCodeConfigFlagsFieldInfo), '("latestDailyJam", VideoTimeCodeConfigLatestDailyJamFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoTimeCodeConfigMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoTimeCodeConfigMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoTimeCodeConfigMethod t VideoTimeCodeConfig, O.MethodInfo info VideoTimeCodeConfig p) => OL.IsLabel t (VideoTimeCodeConfig -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoTimeCodeConfig.hs-boot b/GI/GstVideo/Structs/VideoTimeCodeConfig.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoTimeCodeConfig.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoTimeCodeConfig where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoTimeCodeConfig = VideoTimeCodeConfig (ManagedPtr VideoTimeCodeConfig) +instance WrappedPtr VideoTimeCodeConfig where diff --git a/GI/GstVideo/Structs/VideoTimeCodeInterval.hs b/GI/GstVideo/Structs/VideoTimeCodeInterval.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoTimeCodeInterval.hs @@ -0,0 +1,596 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A representation of a difference between two 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' instances. +Will not necessarily correspond to a real timecode (e.g. 00:00:10;00) + +/Since: 1.12/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoTimeCodeInterval + ( + +-- * Exported types + VideoTimeCodeInterval(..) , + newZeroVideoTimeCodeInterval , + noVideoTimeCodeInterval , + + + -- * Methods +-- ** clear #method:clear# + +#if ENABLE_OVERLOADING + VideoTimeCodeIntervalClearMethodInfo , +#endif + videoTimeCodeIntervalClear , + + +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + VideoTimeCodeIntervalCopyMethodInfo , +#endif + videoTimeCodeIntervalCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + VideoTimeCodeIntervalFreeMethodInfo , +#endif + videoTimeCodeIntervalFree , + + +-- ** init #method:init# + +#if ENABLE_OVERLOADING + VideoTimeCodeIntervalInitMethodInfo , +#endif + videoTimeCodeIntervalInit , + + +-- ** new #method:new# + + videoTimeCodeIntervalNew , + + +-- ** newFromString #method:newFromString# + + videoTimeCodeIntervalNewFromString , + + + + + -- * Properties +-- ** frames #attr:frames# +{- | the frames field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' +-} + getVideoTimeCodeIntervalFrames , + setVideoTimeCodeIntervalFrames , +#if ENABLE_OVERLOADING + videoTimeCodeInterval_frames , +#endif + + +-- ** hours #attr:hours# +{- | the hours field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' +-} + getVideoTimeCodeIntervalHours , + setVideoTimeCodeIntervalHours , +#if ENABLE_OVERLOADING + videoTimeCodeInterval_hours , +#endif + + +-- ** minutes #attr:minutes# +{- | the minutes field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' +-} + getVideoTimeCodeIntervalMinutes , + setVideoTimeCodeIntervalMinutes , +#if ENABLE_OVERLOADING + videoTimeCodeInterval_minutes , +#endif + + +-- ** seconds #attr:seconds# +{- | the seconds field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' +-} + getVideoTimeCodeIntervalSeconds , + setVideoTimeCodeIntervalSeconds , +#if ENABLE_OVERLOADING + videoTimeCodeInterval_seconds , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- | Memory-managed wrapper type. +newtype VideoTimeCodeInterval = VideoTimeCodeInterval (ManagedPtr VideoTimeCodeInterval) +foreign import ccall "gst_video_time_code_interval_get_type" c_gst_video_time_code_interval_get_type :: + IO GType + +instance BoxedObject VideoTimeCodeInterval where + boxedType _ = c_gst_video_time_code_interval_get_type + +-- | Construct a `VideoTimeCodeInterval` struct initialized to zero. +newZeroVideoTimeCodeInterval :: MonadIO m => m VideoTimeCodeInterval +newZeroVideoTimeCodeInterval = liftIO $ callocBoxedBytes 16 >>= wrapBoxed VideoTimeCodeInterval + +instance tag ~ 'AttrSet => Constructible VideoTimeCodeInterval tag where + new _ attrs = do + o <- newZeroVideoTimeCodeInterval + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoTimeCodeInterval`. +noVideoTimeCodeInterval :: Maybe VideoTimeCodeInterval +noVideoTimeCodeInterval = Nothing + +{- | +Get the value of the “@hours@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCodeInterval #hours +@ +-} +getVideoTimeCodeIntervalHours :: MonadIO m => VideoTimeCodeInterval -> m Word32 +getVideoTimeCodeIntervalHours s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word32 + return val + +{- | +Set the value of the “@hours@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoTimeCodeInterval [ #hours 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoTimeCodeIntervalHours :: MonadIO m => VideoTimeCodeInterval -> Word32 -> m () +setVideoTimeCodeIntervalHours s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoTimeCodeIntervalHoursFieldInfo +instance AttrInfo VideoTimeCodeIntervalHoursFieldInfo where + type AttrAllowedOps VideoTimeCodeIntervalHoursFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeIntervalHoursFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoTimeCodeIntervalHoursFieldInfo = (~) VideoTimeCodeInterval + type AttrGetType VideoTimeCodeIntervalHoursFieldInfo = Word32 + type AttrLabel VideoTimeCodeIntervalHoursFieldInfo = "hours" + type AttrOrigin VideoTimeCodeIntervalHoursFieldInfo = VideoTimeCodeInterval + attrGet _ = getVideoTimeCodeIntervalHours + attrSet _ = setVideoTimeCodeIntervalHours + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCodeInterval_hours :: AttrLabelProxy "hours" +videoTimeCodeInterval_hours = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@minutes@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCodeInterval #minutes +@ +-} +getVideoTimeCodeIntervalMinutes :: MonadIO m => VideoTimeCodeInterval -> m Word32 +getVideoTimeCodeIntervalMinutes s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 4) :: IO Word32 + return val + +{- | +Set the value of the “@minutes@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoTimeCodeInterval [ #minutes 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoTimeCodeIntervalMinutes :: MonadIO m => VideoTimeCodeInterval -> Word32 -> m () +setVideoTimeCodeIntervalMinutes s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 4) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoTimeCodeIntervalMinutesFieldInfo +instance AttrInfo VideoTimeCodeIntervalMinutesFieldInfo where + type AttrAllowedOps VideoTimeCodeIntervalMinutesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeIntervalMinutesFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoTimeCodeIntervalMinutesFieldInfo = (~) VideoTimeCodeInterval + type AttrGetType VideoTimeCodeIntervalMinutesFieldInfo = Word32 + type AttrLabel VideoTimeCodeIntervalMinutesFieldInfo = "minutes" + type AttrOrigin VideoTimeCodeIntervalMinutesFieldInfo = VideoTimeCodeInterval + attrGet _ = getVideoTimeCodeIntervalMinutes + attrSet _ = setVideoTimeCodeIntervalMinutes + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCodeInterval_minutes :: AttrLabelProxy "minutes" +videoTimeCodeInterval_minutes = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@seconds@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCodeInterval #seconds +@ +-} +getVideoTimeCodeIntervalSeconds :: MonadIO m => VideoTimeCodeInterval -> m Word32 +getVideoTimeCodeIntervalSeconds s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO Word32 + return val + +{- | +Set the value of the “@seconds@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoTimeCodeInterval [ #seconds 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoTimeCodeIntervalSeconds :: MonadIO m => VideoTimeCodeInterval -> Word32 -> m () +setVideoTimeCodeIntervalSeconds s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoTimeCodeIntervalSecondsFieldInfo +instance AttrInfo VideoTimeCodeIntervalSecondsFieldInfo where + type AttrAllowedOps VideoTimeCodeIntervalSecondsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeIntervalSecondsFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoTimeCodeIntervalSecondsFieldInfo = (~) VideoTimeCodeInterval + type AttrGetType VideoTimeCodeIntervalSecondsFieldInfo = Word32 + type AttrLabel VideoTimeCodeIntervalSecondsFieldInfo = "seconds" + type AttrOrigin VideoTimeCodeIntervalSecondsFieldInfo = VideoTimeCodeInterval + attrGet _ = getVideoTimeCodeIntervalSeconds + attrSet _ = setVideoTimeCodeIntervalSeconds + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCodeInterval_seconds :: AttrLabelProxy "seconds" +videoTimeCodeInterval_seconds = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@frames@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCodeInterval #frames +@ +-} +getVideoTimeCodeIntervalFrames :: MonadIO m => VideoTimeCodeInterval -> m Word32 +getVideoTimeCodeIntervalFrames s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 12) :: IO Word32 + return val + +{- | +Set the value of the “@frames@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' videoTimeCodeInterval [ #frames 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setVideoTimeCodeIntervalFrames :: MonadIO m => VideoTimeCodeInterval -> Word32 -> m () +setVideoTimeCodeIntervalFrames s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 12) (val :: Word32) + +#if ENABLE_OVERLOADING +data VideoTimeCodeIntervalFramesFieldInfo +instance AttrInfo VideoTimeCodeIntervalFramesFieldInfo where + type AttrAllowedOps VideoTimeCodeIntervalFramesFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeIntervalFramesFieldInfo = (~) Word32 + type AttrBaseTypeConstraint VideoTimeCodeIntervalFramesFieldInfo = (~) VideoTimeCodeInterval + type AttrGetType VideoTimeCodeIntervalFramesFieldInfo = Word32 + type AttrLabel VideoTimeCodeIntervalFramesFieldInfo = "frames" + type AttrOrigin VideoTimeCodeIntervalFramesFieldInfo = VideoTimeCodeInterval + attrGet _ = getVideoTimeCodeIntervalFrames + attrSet _ = setVideoTimeCodeIntervalFrames + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCodeInterval_frames :: AttrLabelProxy "frames" +videoTimeCodeInterval_frames = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoTimeCodeInterval +type instance O.AttributeList VideoTimeCodeInterval = VideoTimeCodeIntervalAttributeList +type VideoTimeCodeIntervalAttributeList = ('[ '("hours", VideoTimeCodeIntervalHoursFieldInfo), '("minutes", VideoTimeCodeIntervalMinutesFieldInfo), '("seconds", VideoTimeCodeIntervalSecondsFieldInfo), '("frames", VideoTimeCodeIntervalFramesFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoTimeCodeInterval::new +-- method type : Constructor +-- Args : [Arg {argCName = "hours", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hours field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minutes", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minutes field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seconds", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the seconds field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frames", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the frames field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_interval_new" gst_video_time_code_interval_new :: + Word32 -> -- hours : TBasicType TUInt + Word32 -> -- minutes : TBasicType TUInt + Word32 -> -- seconds : TBasicType TUInt + Word32 -> -- frames : TBasicType TUInt + IO (Ptr VideoTimeCodeInterval) + +{- | +/No description available in the introspection data./ + +/Since: 1.12/ +-} +videoTimeCodeIntervalNew :: + (B.CallStack.HasCallStack, MonadIO m) => + Word32 + {- ^ /@hours@/: the hours field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -} + -> Word32 + {- ^ /@minutes@/: the minutes field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -} + -> Word32 + {- ^ /@seconds@/: the seconds field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -} + -> Word32 + {- ^ /@frames@/: the frames field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -} + -> m VideoTimeCodeInterval + {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' with the given values. -} +videoTimeCodeIntervalNew hours minutes seconds frames = liftIO $ do + result <- gst_video_time_code_interval_new hours minutes seconds frames + checkUnexpectedReturnNULL "videoTimeCodeIntervalNew" result + result' <- (wrapBoxed VideoTimeCodeInterval) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method VideoTimeCodeInterval::new_from_string +-- method type : Constructor +-- Args : [Arg {argCName = "tc_inter_str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The string that represents the #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_interval_new_from_string" gst_video_time_code_interval_new_from_string :: + CString -> -- tc_inter_str : TBasicType TUTF8 + IO (Ptr VideoTimeCodeInterval) + +{- | +/@tcInterStr@/ must only have \":\" as separators. + +/Since: 1.12/ +-} +videoTimeCodeIntervalNewFromString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@tcInterStr@/: The string that represents the 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -} + -> m (Maybe VideoTimeCodeInterval) + {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' from the given string + or 'Nothing' if the string could not be passed. -} +videoTimeCodeIntervalNewFromString tcInterStr = liftIO $ do + tcInterStr' <- textToCString tcInterStr + result <- gst_video_time_code_interval_new_from_string tcInterStr' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed VideoTimeCodeInterval) result' + return result'' + freeMem tcInterStr' + return maybeResult + +#if ENABLE_OVERLOADING +#endif + +-- method VideoTimeCodeInterval::clear +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_interval_clear" gst_video_time_code_interval_clear :: + Ptr VideoTimeCodeInterval -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}) + IO () + +{- | +Initializes /@tc@/ with empty\/zero\/NULL values. + +/Since: 1.12/ +-} +videoTimeCodeIntervalClear :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCodeInterval + {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -} + -> m () +videoTimeCodeIntervalClear tc = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + gst_video_time_code_interval_clear tc' + touchManagedPtr tc + return () + +#if ENABLE_OVERLOADING +data VideoTimeCodeIntervalClearMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoTimeCodeIntervalClearMethodInfo VideoTimeCodeInterval signature where + overloadedMethod _ = videoTimeCodeIntervalClear + +#endif + +-- method VideoTimeCodeInterval::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_interval_copy" gst_video_time_code_interval_copy :: + Ptr VideoTimeCodeInterval -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}) + IO (Ptr VideoTimeCodeInterval) + +{- | +/No description available in the introspection data./ + +/Since: 1.12/ +-} +videoTimeCodeIntervalCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCodeInterval + {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -} + -> m VideoTimeCodeInterval + {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' with the same values as /@tc@/. -} +videoTimeCodeIntervalCopy tc = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + result <- gst_video_time_code_interval_copy tc' + checkUnexpectedReturnNULL "videoTimeCodeIntervalCopy" result + result' <- (wrapBoxed VideoTimeCodeInterval) result + touchManagedPtr tc + return result' + +#if ENABLE_OVERLOADING +data VideoTimeCodeIntervalCopyMethodInfo +instance (signature ~ (m VideoTimeCodeInterval), MonadIO m) => O.MethodInfo VideoTimeCodeIntervalCopyMethodInfo VideoTimeCodeInterval signature where + overloadedMethod _ = videoTimeCodeIntervalCopy + +#endif + +-- method VideoTimeCodeInterval::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_interval_free" gst_video_time_code_interval_free :: + Ptr VideoTimeCodeInterval -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}) + IO () + +{- | +Frees /@tc@/. + +/Since: 1.12/ +-} +videoTimeCodeIntervalFree :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCodeInterval + {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -} + -> m () +videoTimeCodeIntervalFree tc = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + gst_video_time_code_interval_free tc' + touchManagedPtr tc + return () + +#if ENABLE_OVERLOADING +data VideoTimeCodeIntervalFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoTimeCodeIntervalFreeMethodInfo VideoTimeCodeInterval signature where + overloadedMethod _ = videoTimeCodeIntervalFree + +#endif + +-- method VideoTimeCodeInterval::init +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hours", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hours field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minutes", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minutes field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seconds", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the seconds field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frames", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the frames field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_interval_init" gst_video_time_code_interval_init :: + Ptr VideoTimeCodeInterval -> -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}) + Word32 -> -- hours : TBasicType TUInt + Word32 -> -- minutes : TBasicType TUInt + Word32 -> -- seconds : TBasicType TUInt + Word32 -> -- frames : TBasicType TUInt + IO () + +{- | +Initializes /@tc@/ with the given values. + +/Since: 1.12/ +-} +videoTimeCodeIntervalInit :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoTimeCodeInterval + {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -} + -> Word32 + {- ^ /@hours@/: the hours field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -} + -> Word32 + {- ^ /@minutes@/: the minutes field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -} + -> Word32 + {- ^ /@seconds@/: the seconds field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -} + -> Word32 + {- ^ /@frames@/: the frames field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -} + -> m () +videoTimeCodeIntervalInit tc hours minutes seconds frames = liftIO $ do + tc' <- unsafeManagedPtrGetPtr tc + gst_video_time_code_interval_init tc' hours minutes seconds frames + touchManagedPtr tc + return () + +#if ENABLE_OVERLOADING +data VideoTimeCodeIntervalInitMethodInfo +instance (signature ~ (Word32 -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m) => O.MethodInfo VideoTimeCodeIntervalInitMethodInfo VideoTimeCodeInterval signature where + overloadedMethod _ = videoTimeCodeIntervalInit + +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoTimeCodeIntervalMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoTimeCodeIntervalMethod "clear" o = VideoTimeCodeIntervalClearMethodInfo + ResolveVideoTimeCodeIntervalMethod "copy" o = VideoTimeCodeIntervalCopyMethodInfo + ResolveVideoTimeCodeIntervalMethod "free" o = VideoTimeCodeIntervalFreeMethodInfo + ResolveVideoTimeCodeIntervalMethod "init" o = VideoTimeCodeIntervalInitMethodInfo + ResolveVideoTimeCodeIntervalMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoTimeCodeIntervalMethod t VideoTimeCodeInterval, O.MethodInfo info VideoTimeCodeInterval p) => OL.IsLabel t (VideoTimeCodeInterval -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoTimeCodeInterval.hs-boot b/GI/GstVideo/Structs/VideoTimeCodeInterval.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoTimeCodeInterval.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoTimeCodeInterval where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoTimeCodeInterval = VideoTimeCodeInterval (ManagedPtr VideoTimeCodeInterval) +instance BoxedObject VideoTimeCodeInterval where +#if ENABLE_OVERLOADING +data VideoTimeCodeIntervalClearMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeIntervalCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeIntervalFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoTimeCodeIntervalInitMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoTimeCodeMeta.hs b/GI/GstVideo/Structs/VideoTimeCodeMeta.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoTimeCodeMeta.hs @@ -0,0 +1,219 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Extra buffer metadata describing the GstVideoTimeCode of the frame. + +Each frame is assumed to have its own timecode, i.e. they are not +automatically incremented\/interpolated. + +/Since: 1.10/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoTimeCodeMeta + ( + +-- * Exported types + VideoTimeCodeMeta(..) , + newZeroVideoTimeCodeMeta , + noVideoTimeCodeMeta , + + + -- * Methods +-- ** getInfo #method:getInfo# + + videoTimeCodeMetaGetInfo , + + + + + -- * Properties +-- ** meta #attr:meta# +{- | parent 'GI.Gst.Structs.Meta.Meta' +-} + getVideoTimeCodeMetaMeta , +#if ENABLE_OVERLOADING + videoTimeCodeMeta_meta , +#endif + + +-- ** tc #attr:tc# +{- | the GstVideoTimeCode to attach +-} + getVideoTimeCodeMetaTc , +#if ENABLE_OVERLOADING + videoTimeCodeMeta_tc , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Gst.Structs.Meta as Gst.Meta +import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoTimeCode as GstVideo.VideoTimeCode + +-- | Memory-managed wrapper type. +newtype VideoTimeCodeMeta = VideoTimeCodeMeta (ManagedPtr VideoTimeCodeMeta) +instance WrappedPtr VideoTimeCodeMeta where + wrappedPtrCalloc = callocBytes 64 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 64 >=> wrapPtr VideoTimeCodeMeta) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `VideoTimeCodeMeta` struct initialized to zero. +newZeroVideoTimeCodeMeta :: MonadIO m => m VideoTimeCodeMeta +newZeroVideoTimeCodeMeta = liftIO $ wrappedPtrCalloc >>= wrapPtr VideoTimeCodeMeta + +instance tag ~ 'AttrSet => Constructible VideoTimeCodeMeta tag where + new _ attrs = do + o <- newZeroVideoTimeCodeMeta + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoTimeCodeMeta`. +noVideoTimeCodeMeta :: Maybe VideoTimeCodeMeta +noVideoTimeCodeMeta = Nothing + +{- | +Get the value of the “@meta@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCodeMeta #meta +@ +-} +getVideoTimeCodeMetaMeta :: MonadIO m => VideoTimeCodeMeta -> m Gst.Meta.Meta +getVideoTimeCodeMetaMeta s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Gst.Meta.Meta) + val' <- (newPtr Gst.Meta.Meta) val + return val' + +#if ENABLE_OVERLOADING +data VideoTimeCodeMetaMetaFieldInfo +instance AttrInfo VideoTimeCodeMetaMetaFieldInfo where + type AttrAllowedOps VideoTimeCodeMetaMetaFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta) + type AttrBaseTypeConstraint VideoTimeCodeMetaMetaFieldInfo = (~) VideoTimeCodeMeta + type AttrGetType VideoTimeCodeMetaMetaFieldInfo = Gst.Meta.Meta + type AttrLabel VideoTimeCodeMetaMetaFieldInfo = "meta" + type AttrOrigin VideoTimeCodeMetaMetaFieldInfo = VideoTimeCodeMeta + attrGet _ = getVideoTimeCodeMetaMeta + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCodeMeta_meta :: AttrLabelProxy "meta" +videoTimeCodeMeta_meta = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@tc@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' videoTimeCodeMeta #tc +@ +-} +getVideoTimeCodeMetaTc :: MonadIO m => VideoTimeCodeMeta -> m GstVideo.VideoTimeCode.VideoTimeCode +getVideoTimeCodeMetaTc s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 16 :: (Ptr GstVideo.VideoTimeCode.VideoTimeCode) + val' <- (newBoxed GstVideo.VideoTimeCode.VideoTimeCode) val + return val' + +#if ENABLE_OVERLOADING +data VideoTimeCodeMetaTcFieldInfo +instance AttrInfo VideoTimeCodeMetaTcFieldInfo where + type AttrAllowedOps VideoTimeCodeMetaTcFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint VideoTimeCodeMetaTcFieldInfo = (~) (Ptr GstVideo.VideoTimeCode.VideoTimeCode) + type AttrBaseTypeConstraint VideoTimeCodeMetaTcFieldInfo = (~) VideoTimeCodeMeta + type AttrGetType VideoTimeCodeMetaTcFieldInfo = GstVideo.VideoTimeCode.VideoTimeCode + type AttrLabel VideoTimeCodeMetaTcFieldInfo = "tc" + type AttrOrigin VideoTimeCodeMetaTcFieldInfo = VideoTimeCodeMeta + attrGet _ = getVideoTimeCodeMetaTc + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +videoTimeCodeMeta_tc :: AttrLabelProxy "tc" +videoTimeCodeMeta_tc = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoTimeCodeMeta +type instance O.AttributeList VideoTimeCodeMeta = VideoTimeCodeMetaAttributeList +type VideoTimeCodeMetaAttributeList = ('[ '("meta", VideoTimeCodeMetaMetaFieldInfo), '("tc", VideoTimeCodeMetaTcFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method VideoTimeCodeMeta::get_info +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gst", name = "MetaInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_time_code_meta_get_info" gst_video_time_code_meta_get_info :: + IO (Ptr Gst.MetaInfo.MetaInfo) + +{- | +/No description available in the introspection data./ +-} +videoTimeCodeMetaGetInfo :: + (B.CallStack.HasCallStack, MonadIO m) => + m Gst.MetaInfo.MetaInfo +videoTimeCodeMetaGetInfo = liftIO $ do + result <- gst_video_time_code_meta_get_info + checkUnexpectedReturnNULL "videoTimeCodeMetaGetInfo" result + result' <- (newPtr Gst.MetaInfo.MetaInfo) result + return result' + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoTimeCodeMetaMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoTimeCodeMetaMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoTimeCodeMetaMethod t VideoTimeCodeMeta, O.MethodInfo info VideoTimeCodeMeta p) => OL.IsLabel t (VideoTimeCodeMeta -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoTimeCodeMeta.hs-boot b/GI/GstVideo/Structs/VideoTimeCodeMeta.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoTimeCodeMeta.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoTimeCodeMeta where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoTimeCodeMeta = VideoTimeCodeMeta (ManagedPtr VideoTimeCodeMeta) +instance WrappedPtr VideoTimeCodeMeta where diff --git a/GI/GstVideo/Structs/VideoVBIEncoder.hs b/GI/GstVideo/Structs/VideoVBIEncoder.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoVBIEncoder.hs @@ -0,0 +1,325 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +An encoder for writing ancillary data to the +Vertical Blanking Interval lines of component signals. + +/Since: 1.16/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoVBIEncoder + ( + +-- * Exported types + VideoVBIEncoder(..) , + noVideoVBIEncoder , + + + -- * Methods +-- ** addAncillary #method:addAncillary# + +#if ENABLE_OVERLOADING + VideoVBIEncoderAddAncillaryMethodInfo , +#endif + videoVBIEncoderAddAncillary , + + +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + VideoVBIEncoderCopyMethodInfo , +#endif + videoVBIEncoderCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + VideoVBIEncoderFreeMethodInfo , +#endif + videoVBIEncoderFree , + + +-- ** new #method:new# + + videoVBIEncoderNew , + + +-- ** writeLine #method:writeLine# + +#if ENABLE_OVERLOADING + VideoVBIEncoderWriteLineMethodInfo , +#endif + videoVBIEncoderWriteLine , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums + +-- | Memory-managed wrapper type. +newtype VideoVBIEncoder = VideoVBIEncoder (ManagedPtr VideoVBIEncoder) +foreign import ccall "gst_video_vbi_encoder_get_type" c_gst_video_vbi_encoder_get_type :: + IO GType + +instance BoxedObject VideoVBIEncoder where + boxedType _ = c_gst_video_vbi_encoder_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoVBIEncoder`. +noVideoVBIEncoder :: Maybe VideoVBIEncoder +noVideoVBIEncoder = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoVBIEncoder +type instance O.AttributeList VideoVBIEncoder = VideoVBIEncoderAttributeList +type VideoVBIEncoderAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method VideoVBIEncoder::new +-- method type : Constructor +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pixel_width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The width in pixel to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoVBIEncoder"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_vbi_encoder_new" gst_video_vbi_encoder_new :: + CUInt -> -- format : TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}) + Word32 -> -- pixel_width : TBasicType TUInt32 + IO (Ptr VideoVBIEncoder) + +{- | +Create a new 'GI.GstVideo.Structs.VideoVBIEncoder.VideoVBIEncoder' for the specified /@format@/ and /@pixelWidth@/. + +/Since: 1.16/ +-} +videoVBIEncoderNew :: + (B.CallStack.HasCallStack, MonadIO m) => + GstVideo.Enums.VideoFormat + {- ^ /@format@/: a 'GI.GstVideo.Enums.VideoFormat' -} + -> Word32 + {- ^ /@pixelWidth@/: The width in pixel to use -} + -> m VideoVBIEncoder + {- ^ __Returns:__ The new 'GI.GstVideo.Structs.VideoVBIEncoder.VideoVBIEncoder' or 'Nothing' if the /@format@/ and\/or /@pixelWidth@/ +is not supported. -} +videoVBIEncoderNew format pixelWidth = liftIO $ do + let format' = (fromIntegral . fromEnum) format + result <- gst_video_vbi_encoder_new format' pixelWidth + checkUnexpectedReturnNULL "videoVBIEncoderNew" result + result' <- (wrapBoxed VideoVBIEncoder) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method VideoVBIEncoder::add_ancillary +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoVBIEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoVBIEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "composite", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if composite ADF should be created, component otherwise", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "DID", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The Data Identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "SDID_block_number", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The Secondary Data Identifier (if type 2) or the Data\n Block Number (if type 1)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 5 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The user data content of the Ancillary packet.\n Does not contain the ADF, DID, SDID nor CS.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The amount of data (in bytes) in @data (max 255 bytes)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "data_count", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The amount of data (in bytes) in @data (max 255 bytes)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_vbi_encoder_add_ancillary" gst_video_vbi_encoder_add_ancillary :: + Ptr VideoVBIEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoVBIEncoder"}) + CInt -> -- composite : TBasicType TBoolean + Word8 -> -- DID : TBasicType TUInt8 + Word8 -> -- SDID_block_number : TBasicType TUInt8 + Ptr Word8 -> -- data : TCArray False (-1) 5 (TBasicType TUInt8) + Word32 -> -- data_count : TBasicType TUInt + IO CInt + +{- | +Stores Video Ancillary data, according to SMPTE-291M specification. + +Note that the contents of the data are always read as 8bit data (i.e. do not contain +the parity check bits). + +/Since: 1.16/ +-} +videoVBIEncoderAddAncillary :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoVBIEncoder + {- ^ /@encoder@/: a 'GI.GstVideo.Structs.VideoVBIEncoder.VideoVBIEncoder' -} + -> Bool + {- ^ /@composite@/: 'True' if composite ADF should be created, component otherwise -} + -> Word8 + {- ^ /@dID@/: The Data Identifier -} + -> Word8 + {- ^ /@sDIDBlockNumber@/: The Secondary Data Identifier (if type 2) or the Data + Block Number (if type 1) -} + -> ByteString + {- ^ /@data@/: The user data content of the Ancillary packet. + Does not contain the ADF, DID, SDID nor CS. -} + -> m Bool + {- ^ __Returns:__ 'True' if enough space was left in the current line, 'False' + otherwise. -} +videoVBIEncoderAddAncillary encoder composite dID sDIDBlockNumber data_ = liftIO $ do + let dataCount = fromIntegral $ B.length data_ + encoder' <- unsafeManagedPtrGetPtr encoder + let composite' = (fromIntegral . fromEnum) composite + data_' <- packByteString data_ + result <- gst_video_vbi_encoder_add_ancillary encoder' composite' dID sDIDBlockNumber data_' dataCount + let result' = (/= 0) result + touchManagedPtr encoder + freeMem data_' + return result' + +#if ENABLE_OVERLOADING +data VideoVBIEncoderAddAncillaryMethodInfo +instance (signature ~ (Bool -> Word8 -> Word8 -> ByteString -> m Bool), MonadIO m) => O.MethodInfo VideoVBIEncoderAddAncillaryMethodInfo VideoVBIEncoder signature where + overloadedMethod _ = videoVBIEncoderAddAncillary + +#endif + +-- method VideoVBIEncoder::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoVBIEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoVBIEncoder"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_vbi_encoder_copy" gst_video_vbi_encoder_copy :: + Ptr VideoVBIEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoVBIEncoder"}) + IO (Ptr VideoVBIEncoder) + +{- | +/No description available in the introspection data./ +-} +videoVBIEncoderCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoVBIEncoder + -> m VideoVBIEncoder +videoVBIEncoderCopy encoder = liftIO $ do + encoder' <- unsafeManagedPtrGetPtr encoder + result <- gst_video_vbi_encoder_copy encoder' + checkUnexpectedReturnNULL "videoVBIEncoderCopy" result + result' <- (wrapBoxed VideoVBIEncoder) result + touchManagedPtr encoder + return result' + +#if ENABLE_OVERLOADING +data VideoVBIEncoderCopyMethodInfo +instance (signature ~ (m VideoVBIEncoder), MonadIO m) => O.MethodInfo VideoVBIEncoderCopyMethodInfo VideoVBIEncoder signature where + overloadedMethod _ = videoVBIEncoderCopy + +#endif + +-- method VideoVBIEncoder::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoVBIEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoVBIEncoder", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_vbi_encoder_free" gst_video_vbi_encoder_free :: + Ptr VideoVBIEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoVBIEncoder"}) + IO () + +{- | +Frees the /@encoder@/. + +/Since: 1.16/ +-} +videoVBIEncoderFree :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoVBIEncoder + {- ^ /@encoder@/: a 'GI.GstVideo.Structs.VideoVBIEncoder.VideoVBIEncoder' -} + -> m () +videoVBIEncoderFree encoder = liftIO $ do + encoder' <- unsafeManagedPtrGetPtr encoder + gst_video_vbi_encoder_free encoder' + touchManagedPtr encoder + return () + +#if ENABLE_OVERLOADING +data VideoVBIEncoderFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoVBIEncoderFreeMethodInfo VideoVBIEncoder signature where + overloadedMethod _ = videoVBIEncoderFree + +#endif + +-- method VideoVBIEncoder::write_line +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "encoder", argType = TInterface (Name {namespace = "GstVideo", name = "VideoVBIEncoder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_vbi_encoder_write_line" gst_video_vbi_encoder_write_line :: + Ptr VideoVBIEncoder -> -- encoder : TInterface (Name {namespace = "GstVideo", name = "VideoVBIEncoder"}) + Word8 -> -- data : TBasicType TUInt8 + IO () + +{- | +/No description available in the introspection data./ +-} +videoVBIEncoderWriteLine :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoVBIEncoder + -> Word8 + -> m () +videoVBIEncoderWriteLine encoder data_ = liftIO $ do + encoder' <- unsafeManagedPtrGetPtr encoder + gst_video_vbi_encoder_write_line encoder' data_ + touchManagedPtr encoder + return () + +#if ENABLE_OVERLOADING +data VideoVBIEncoderWriteLineMethodInfo +instance (signature ~ (Word8 -> m ()), MonadIO m) => O.MethodInfo VideoVBIEncoderWriteLineMethodInfo VideoVBIEncoder signature where + overloadedMethod _ = videoVBIEncoderWriteLine + +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoVBIEncoderMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoVBIEncoderMethod "addAncillary" o = VideoVBIEncoderAddAncillaryMethodInfo + ResolveVideoVBIEncoderMethod "copy" o = VideoVBIEncoderCopyMethodInfo + ResolveVideoVBIEncoderMethod "free" o = VideoVBIEncoderFreeMethodInfo + ResolveVideoVBIEncoderMethod "writeLine" o = VideoVBIEncoderWriteLineMethodInfo + ResolveVideoVBIEncoderMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoVBIEncoderMethod t VideoVBIEncoder, O.MethodInfo info VideoVBIEncoder p) => OL.IsLabel t (VideoVBIEncoder -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoVBIEncoder.hs-boot b/GI/GstVideo/Structs/VideoVBIEncoder.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoVBIEncoder.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoVBIEncoder where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoVBIEncoder = VideoVBIEncoder (ManagedPtr VideoVBIEncoder) +instance BoxedObject VideoVBIEncoder where +#if ENABLE_OVERLOADING +data VideoVBIEncoderAddAncillaryMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoVBIEncoderCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoVBIEncoderFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoVBIEncoderWriteLineMethodInfo +#endif diff --git a/GI/GstVideo/Structs/VideoVBIParser.hs b/GI/GstVideo/Structs/VideoVBIParser.hs new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoVBIParser.hs @@ -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 (inaki@blueleaf.cc) + +A parser for detecting and extracting /@gstVideoAncillary@/ data from +Vertical Blanking Interval lines of component signals. + +/Since: 1.16/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GstVideo.Structs.VideoVBIParser + ( + +-- * Exported types + VideoVBIParser(..) , + noVideoVBIParser , + + + -- * Methods +-- ** addLine #method:addLine# + +#if ENABLE_OVERLOADING + VideoVBIParserAddLineMethodInfo , +#endif + videoVBIParserAddLine , + + +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + VideoVBIParserCopyMethodInfo , +#endif + videoVBIParserCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + VideoVBIParserFreeMethodInfo , +#endif + videoVBIParserFree , + + +-- ** getAncillary #method:getAncillary# + +#if ENABLE_OVERLOADING + VideoVBIParserGetAncillaryMethodInfo , +#endif + videoVBIParserGetAncillary , + + +-- ** new #method:new# + + videoVBIParserNew , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums +import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoAncillary as GstVideo.VideoAncillary + +-- | Memory-managed wrapper type. +newtype VideoVBIParser = VideoVBIParser (ManagedPtr VideoVBIParser) +foreign import ccall "gst_video_vbi_parser_get_type" c_gst_video_vbi_parser_get_type :: + IO GType + +instance BoxedObject VideoVBIParser where + boxedType _ = c_gst_video_vbi_parser_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `VideoVBIParser`. +noVideoVBIParser :: Maybe VideoVBIParser +noVideoVBIParser = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList VideoVBIParser +type instance O.AttributeList VideoVBIParser = VideoVBIParserAttributeList +type VideoVBIParserAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method VideoVBIParser::new +-- method type : Constructor +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pixel_width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The width in pixel to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoVBIParser"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_vbi_parser_new" gst_video_vbi_parser_new :: + CUInt -> -- format : TInterface (Name {namespace = "GstVideo", name = "VideoFormat"}) + Word32 -> -- pixel_width : TBasicType TUInt32 + IO (Ptr VideoVBIParser) + +{- | +Create a new 'GI.GstVideo.Structs.VideoVBIParser.VideoVBIParser' for the specified /@format@/ and /@pixelWidth@/. + +/Since: 1.16/ +-} +videoVBIParserNew :: + (B.CallStack.HasCallStack, MonadIO m) => + GstVideo.Enums.VideoFormat + {- ^ /@format@/: a 'GI.GstVideo.Enums.VideoFormat' -} + -> Word32 + {- ^ /@pixelWidth@/: The width in pixel to use -} + -> m VideoVBIParser + {- ^ __Returns:__ The new 'GI.GstVideo.Structs.VideoVBIParser.VideoVBIParser' or 'Nothing' if the /@format@/ and\/or /@pixelWidth@/ +is not supported. -} +videoVBIParserNew format pixelWidth = liftIO $ do + let format' = (fromIntegral . fromEnum) format + result <- gst_video_vbi_parser_new format' pixelWidth + checkUnexpectedReturnNULL "videoVBIParserNew" result + result' <- (wrapBoxed VideoVBIParser) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method VideoVBIParser::add_line +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "parser", argType = TInterface (Name {namespace = "GstVideo", name = "VideoVBIParser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoVBIParser", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) (-1) (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The line of data to parse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_vbi_parser_add_line" gst_video_vbi_parser_add_line :: + Ptr VideoVBIParser -> -- parser : TInterface (Name {namespace = "GstVideo", name = "VideoVBIParser"}) + Ptr Word8 -> -- data : TCArray False (-1) (-1) (TBasicType TUInt8) + IO () + +{- | +Provide a new line of data to the /@parser@/. Call 'GI.GstVideo.Structs.VideoVBIParser.videoVBIParserGetAncillary' +to get the Ancillary data that might be present on that line. + +/Since: 1.16/ +-} +videoVBIParserAddLine :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoVBIParser + {- ^ /@parser@/: a 'GI.GstVideo.Structs.VideoVBIParser.VideoVBIParser' -} + -> Ptr Word8 + {- ^ /@data@/: The line of data to parse -} + -> m () +videoVBIParserAddLine parser data_ = liftIO $ do + parser' <- unsafeManagedPtrGetPtr parser + gst_video_vbi_parser_add_line parser' data_ + touchManagedPtr parser + return () + +#if ENABLE_OVERLOADING +data VideoVBIParserAddLineMethodInfo +instance (signature ~ (Ptr Word8 -> m ()), MonadIO m) => O.MethodInfo VideoVBIParserAddLineMethodInfo VideoVBIParser signature where + overloadedMethod _ = videoVBIParserAddLine + +#endif + +-- method VideoVBIParser::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "parser", argType = TInterface (Name {namespace = "GstVideo", name = "VideoVBIParser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoVBIParser"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_vbi_parser_copy" gst_video_vbi_parser_copy :: + Ptr VideoVBIParser -> -- parser : TInterface (Name {namespace = "GstVideo", name = "VideoVBIParser"}) + IO (Ptr VideoVBIParser) + +{- | +/No description available in the introspection data./ +-} +videoVBIParserCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoVBIParser + -> m VideoVBIParser +videoVBIParserCopy parser = liftIO $ do + parser' <- unsafeManagedPtrGetPtr parser + result <- gst_video_vbi_parser_copy parser' + checkUnexpectedReturnNULL "videoVBIParserCopy" result + result' <- (wrapBoxed VideoVBIParser) result + touchManagedPtr parser + return result' + +#if ENABLE_OVERLOADING +data VideoVBIParserCopyMethodInfo +instance (signature ~ (m VideoVBIParser), MonadIO m) => O.MethodInfo VideoVBIParserCopyMethodInfo VideoVBIParser signature where + overloadedMethod _ = videoVBIParserCopy + +#endif + +-- method VideoVBIParser::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "parser", argType = TInterface (Name {namespace = "GstVideo", name = "VideoVBIParser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoVBIParser", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_vbi_parser_free" gst_video_vbi_parser_free :: + Ptr VideoVBIParser -> -- parser : TInterface (Name {namespace = "GstVideo", name = "VideoVBIParser"}) + IO () + +{- | +Frees the /@parser@/. + +/Since: 1.16/ +-} +videoVBIParserFree :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoVBIParser + {- ^ /@parser@/: a 'GI.GstVideo.Structs.VideoVBIParser.VideoVBIParser' -} + -> m () +videoVBIParserFree parser = liftIO $ do + parser' <- unsafeManagedPtrGetPtr parser + gst_video_vbi_parser_free parser' + touchManagedPtr parser + return () + +#if ENABLE_OVERLOADING +data VideoVBIParserFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoVBIParserFreeMethodInfo VideoVBIParser signature where + overloadedMethod _ = videoVBIParserFree + +#endif + +-- method VideoVBIParser::get_ancillary +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "parser", argType = TInterface (Name {namespace = "GstVideo", name = "VideoVBIParser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoVBIParser", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "anc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoAncillary"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoAncillary to start the eventual ancillary data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoVBIParserResult"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gst_video_vbi_parser_get_ancillary" gst_video_vbi_parser_get_ancillary :: + Ptr VideoVBIParser -> -- parser : TInterface (Name {namespace = "GstVideo", name = "VideoVBIParser"}) + Ptr GstVideo.VideoAncillary.VideoAncillary -> -- anc : TInterface (Name {namespace = "GstVideo", name = "VideoAncillary"}) + IO CUInt + +{- | +Parse the line provided previously by 'GI.GstVideo.Structs.VideoVBIParser.videoVBIParserAddLine'. + +/Since: 1.16/ +-} +videoVBIParserGetAncillary :: + (B.CallStack.HasCallStack, MonadIO m) => + VideoVBIParser + {- ^ /@parser@/: a 'GI.GstVideo.Structs.VideoVBIParser.VideoVBIParser' -} + -> m ((GstVideo.Enums.VideoVBIParserResult, GstVideo.VideoAncillary.VideoAncillary)) + {- ^ __Returns:__ 'GI.GstVideo.Enums.VideoVBIParserResultOk' if ancillary data was found and +/@anc@/ was filled. 'GI.GstVideo.Enums.VideoVBIParserResultDone' if there wasn\'t any +data. -} +videoVBIParserGetAncillary parser = liftIO $ do + parser' <- unsafeManagedPtrGetPtr parser + anc <- callocBytes 48 :: IO (Ptr GstVideo.VideoAncillary.VideoAncillary) + result <- gst_video_vbi_parser_get_ancillary parser' anc + let result' = (toEnum . fromIntegral) result + anc' <- (wrapPtr GstVideo.VideoAncillary.VideoAncillary) anc + touchManagedPtr parser + return (result', anc') + +#if ENABLE_OVERLOADING +data VideoVBIParserGetAncillaryMethodInfo +instance (signature ~ (m ((GstVideo.Enums.VideoVBIParserResult, GstVideo.VideoAncillary.VideoAncillary))), MonadIO m) => O.MethodInfo VideoVBIParserGetAncillaryMethodInfo VideoVBIParser signature where + overloadedMethod _ = videoVBIParserGetAncillary + +#endif + +#if ENABLE_OVERLOADING +type family ResolveVideoVBIParserMethod (t :: Symbol) (o :: *) :: * where + ResolveVideoVBIParserMethod "addLine" o = VideoVBIParserAddLineMethodInfo + ResolveVideoVBIParserMethod "copy" o = VideoVBIParserCopyMethodInfo + ResolveVideoVBIParserMethod "free" o = VideoVBIParserFreeMethodInfo + ResolveVideoVBIParserMethod "getAncillary" o = VideoVBIParserGetAncillaryMethodInfo + ResolveVideoVBIParserMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveVideoVBIParserMethod t VideoVBIParser, O.MethodInfo info VideoVBIParser p) => OL.IsLabel t (VideoVBIParser -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + diff --git a/GI/GstVideo/Structs/VideoVBIParser.hs-boot b/GI/GstVideo/Structs/VideoVBIParser.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GstVideo/Structs/VideoVBIParser.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GstVideo.Structs.VideoVBIParser where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype VideoVBIParser = VideoVBIParser (ManagedPtr VideoVBIParser) +instance BoxedObject VideoVBIParser where +#if ENABLE_OVERLOADING +data VideoVBIParserAddLineMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoVBIParserCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoVBIParserFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data VideoVBIParserGetAncillaryMethodInfo +#endif diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,17 @@ +The gi-gstvideo library and included works are provided under the terms of the +GNU Library General Public License (LGPL) version 2.1 with the following +exception: + +Static linking of applications or any other source to the gi-gstvideo library +does not constitute a modified or derivative work and does not require +the author(s) to provide source code for said work, to link against the +shared gi-gstvideo libraries, or to link their applications against a +user-supplied version of gi-gstvideo. If you link applications to a modified +version of gi-gstvideo, then the changes to gi-gstvideo must be provided under the +terms of the LGPL. + +---------------------------------------------------------------------------- + GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-gstvideo-1.0.16/docs/GI-GstVideo.html](https://hackage.haskell.org/package/gi-gstvideo-1.0.16/docs/GI-GstVideo.html) +[https://hackage.haskell.org/package/gi-gstvideo-1.0.18/docs/GI-GstVideo.html](https://hackage.haskell.org/package/gi-gstvideo-1.0.18/docs/GI-GstVideo.html) For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki). diff --git a/gi-gstvideo.cabal b/gi-gstvideo.cabal --- a/gi-gstvideo.cabal +++ b/gi-gstvideo.cabal @@ -1,12 +1,12 @@ name: gi-gstvideo -version: 1.0.16 +version: 1.0.18 synopsis: GStreamerVideo bindings description: Bindings for GStreamerVideo, 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) +maintainer: Iñaki García Etxebarria (inaki@blueleaf.cc) category: Bindings build-type: Custom cabal-version: 1.24 @@ -14,20 +14,20 @@ extra-source-files: README.md ChangeLog.md stack.yaml GstVideo.overrides custom-setup - setup-depends: base >= 4.7 && < 5, + setup-depends: base >= 4.9 && < 5, Cabal >= 1.24, - haskell-gi >= 0.21.1 && < 0.22 + haskell-gi >= 0.21.0 && < 0.23 library default-language: Haskell2010 - default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts + default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts, UndecidableSuperClasses other-extensions: PatternSynonyms, ViewPatterns ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations pkgconfig-depends: gstreamer-video-1.0 build-depends: base >= 4.8 && <5, - haskell-gi-base == 0.21.*, - haskell-gi >= 0.21.1 && < 0.22, + haskell-gi-base >= 0.21.0 && < 0.23, + haskell-gi >= 0.21.0 && < 0.23, haskell-gi-overloading < 1.1, gi-gstbase == 1.0.*, gi-gst == 1.0.*, @@ -42,3 +42,59 @@ -- see https://ghc.haskell.org/trac/ghc/ticket/14382 if impl(ghc == 8.2.*) build-depends: haskell-gi-overloading == 0.0 + + exposed-modules: 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.VideoDirection, + GI.GstVideo.Interfaces.VideoOrientation, + GI.GstVideo.Interfaces.VideoOverlay, + GI.GstVideo.Objects, + GI.GstVideo.Objects.ColorBalanceChannel, + GI.GstVideo.Objects.VideoAggregator, + GI.GstVideo.Objects.VideoAggregatorConvertPad, + GI.GstVideo.Objects.VideoAggregatorPad, + GI.GstVideo.Objects.VideoBufferPool, + GI.GstVideo.Objects.VideoDecoder, + GI.GstVideo.Objects.VideoEncoder, + GI.GstVideo.Objects.VideoFilter, + GI.GstVideo.Objects.VideoMultiviewFlagsSet, + GI.GstVideo.Objects.VideoSink, + GI.GstVideo.Structs, + GI.GstVideo.Structs.VideoAffineTransformationMeta, + GI.GstVideo.Structs.VideoAlignment, + GI.GstVideo.Structs.VideoAncillary, + GI.GstVideo.Structs.VideoCaptionMeta, + 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, + GI.GstVideo.Structs.VideoTimeCode, + GI.GstVideo.Structs.VideoTimeCodeConfig, + GI.GstVideo.Structs.VideoTimeCodeInterval, + GI.GstVideo.Structs.VideoTimeCodeMeta, + GI.GstVideo.Structs.VideoVBIEncoder, + GI.GstVideo.Structs.VideoVBIParser diff --git a/stack.yaml b/stack.yaml --- a/stack.yaml +++ b/stack.yaml @@ -1,3 +1,3 @@ packages: - '.' -resolver: lts-9.21 +resolver: lts-13.7