gi-gstvideo-1.0.18: GI/GstVideo/Structs/VideoOverlayRectangle.hs
{- |
Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
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