{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- 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 t'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.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.GstVideo.Structs.VideoOverlayComposition
    ( 

-- * Exported types
    VideoOverlayComposition(..)             ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addRectangle]("GI.GstVideo.Structs.VideoOverlayComposition#g:method:addRectangle"), [blend]("GI.GstVideo.Structs.VideoOverlayComposition#g:method:blend"), [copy]("GI.GstVideo.Structs.VideoOverlayComposition#g:method:copy"), [makeWritable]("GI.GstVideo.Structs.VideoOverlayComposition#g:method:makeWritable"), [nRectangles]("GI.GstVideo.Structs.VideoOverlayComposition#g:method:nRectangles").
-- 
-- ==== Getters
-- [getRectangle]("GI.GstVideo.Structs.VideoOverlayComposition#g:method:getRectangle"), [getSeqnum]("GI.GstVideo.Structs.VideoOverlayComposition#g:method:getSeqnum").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveVideoOverlayCompositionMethod    ,
#endif

-- ** addRectangle #method:addRectangle#

#if defined(ENABLE_OVERLOADING)
    VideoOverlayCompositionAddRectangleMethodInfo,
#endif
    videoOverlayCompositionAddRectangle     ,


-- ** blend #method:blend#

#if defined(ENABLE_OVERLOADING)
    VideoOverlayCompositionBlendMethodInfo  ,
#endif
    videoOverlayCompositionBlend            ,


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    VideoOverlayCompositionCopyMethodInfo   ,
#endif
    videoOverlayCompositionCopy             ,


-- ** getRectangle #method:getRectangle#

#if defined(ENABLE_OVERLOADING)
    VideoOverlayCompositionGetRectangleMethodInfo,
#endif
    videoOverlayCompositionGetRectangle     ,


-- ** getSeqnum #method:getSeqnum#

#if defined(ENABLE_OVERLOADING)
    VideoOverlayCompositionGetSeqnumMethodInfo,
#endif
    videoOverlayCompositionGetSeqnum        ,


-- ** makeWritable #method:makeWritable#

#if defined(ENABLE_OVERLOADING)
    VideoOverlayCompositionMakeWritableMethodInfo,
#endif
    videoOverlayCompositionMakeWritable     ,


-- ** nRectangles #method:nRectangles#

#if defined(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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

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 (SP.ManagedPtr VideoOverlayComposition)
    deriving (VideoOverlayComposition -> VideoOverlayComposition -> Bool
(VideoOverlayComposition -> VideoOverlayComposition -> Bool)
-> (VideoOverlayComposition -> VideoOverlayComposition -> Bool)
-> Eq VideoOverlayComposition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoOverlayComposition -> VideoOverlayComposition -> Bool
== :: VideoOverlayComposition -> VideoOverlayComposition -> Bool
$c/= :: VideoOverlayComposition -> VideoOverlayComposition -> Bool
/= :: VideoOverlayComposition -> VideoOverlayComposition -> Bool
Eq)

instance SP.ManagedPtrNewtype VideoOverlayComposition where
    toManagedPtr :: VideoOverlayComposition -> ManagedPtr VideoOverlayComposition
toManagedPtr (VideoOverlayComposition ManagedPtr VideoOverlayComposition
p) = ManagedPtr VideoOverlayComposition
p

foreign import ccall "gst_video_overlay_composition_get_type" c_gst_video_overlay_composition_get_type :: 
    IO GType

type instance O.ParentTypes VideoOverlayComposition = '[]
instance O.HasParentTypes VideoOverlayComposition

instance B.Types.TypedObject VideoOverlayComposition where
    glibType :: IO GType
glibType = IO GType
c_gst_video_overlay_composition_get_type

instance B.Types.GBoxed VideoOverlayComposition

-- | Convert 'VideoOverlayComposition' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe VideoOverlayComposition) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_video_overlay_composition_get_type
    gvalueSet_ :: Ptr GValue -> Maybe VideoOverlayComposition -> IO ()
gvalueSet_ Ptr GValue
gv Maybe VideoOverlayComposition
P.Nothing = Ptr GValue -> Ptr VideoOverlayComposition -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr VideoOverlayComposition
forall a. Ptr a
FP.nullPtr :: FP.Ptr VideoOverlayComposition)
    gvalueSet_ Ptr GValue
gv (P.Just VideoOverlayComposition
obj) = VideoOverlayComposition
-> (Ptr VideoOverlayComposition -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VideoOverlayComposition
obj (Ptr GValue -> Ptr VideoOverlayComposition -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe VideoOverlayComposition)
gvalueGet_ Ptr GValue
gv = do
        Ptr VideoOverlayComposition
ptr <- Ptr GValue -> IO (Ptr VideoOverlayComposition)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr VideoOverlayComposition)
        if Ptr VideoOverlayComposition
ptr Ptr VideoOverlayComposition -> Ptr VideoOverlayComposition -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr VideoOverlayComposition
forall a. Ptr a
FP.nullPtr
        then VideoOverlayComposition -> Maybe VideoOverlayComposition
forall a. a -> Maybe a
P.Just (VideoOverlayComposition -> Maybe VideoOverlayComposition)
-> IO VideoOverlayComposition -> IO (Maybe VideoOverlayComposition)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr VideoOverlayComposition -> VideoOverlayComposition)
-> Ptr VideoOverlayComposition -> IO VideoOverlayComposition
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr VideoOverlayComposition -> VideoOverlayComposition
VideoOverlayComposition Ptr VideoOverlayComposition
ptr
        else Maybe VideoOverlayComposition -> IO (Maybe VideoOverlayComposition)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoOverlayComposition
forall a. Maybe a
P.Nothing
        
    


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoOverlayComposition
type instance O.AttributeList VideoOverlayComposition = VideoOverlayCompositionAttributeList
type VideoOverlayCompositionAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif

-- method VideoOverlayComposition::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "rectangle"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoOverlayRectangle" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , 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.
-- 
-- Note that since 1.20 this allows to pass 'P.Nothing' for /@rectangle@/.
videoOverlayCompositionNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (GstVideo.VideoOverlayRectangle.VideoOverlayRectangle)
    -- ^ /@rectangle@/: a t'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' to add to the
    --     composition
    -> m VideoOverlayComposition
    -- ^ __Returns:__ a new t'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition'. Unref with
    --     @/gst_video_overlay_composition_unref()/@ when no longer needed.
videoOverlayCompositionNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe VideoOverlayRectangle -> m VideoOverlayComposition
videoOverlayCompositionNew Maybe VideoOverlayRectangle
rectangle = IO VideoOverlayComposition -> m VideoOverlayComposition
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoOverlayComposition -> m VideoOverlayComposition)
-> IO VideoOverlayComposition -> m VideoOverlayComposition
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoOverlayRectangle
maybeRectangle <- case Maybe VideoOverlayRectangle
rectangle of
        Maybe VideoOverlayRectangle
Nothing -> Ptr VideoOverlayRectangle -> IO (Ptr VideoOverlayRectangle)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VideoOverlayRectangle
forall a. Ptr a
nullPtr
        Just VideoOverlayRectangle
jRectangle -> do
            Ptr VideoOverlayRectangle
jRectangle' <- VideoOverlayRectangle -> IO (Ptr VideoOverlayRectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoOverlayRectangle
jRectangle
            Ptr VideoOverlayRectangle -> IO (Ptr VideoOverlayRectangle)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VideoOverlayRectangle
jRectangle'
    Ptr VideoOverlayComposition
result <- Ptr VideoOverlayRectangle -> IO (Ptr VideoOverlayComposition)
gst_video_overlay_composition_new Ptr VideoOverlayRectangle
maybeRectangle
    Text -> Ptr VideoOverlayComposition -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoOverlayCompositionNew" Ptr VideoOverlayComposition
result
    VideoOverlayComposition
result' <- ((ManagedPtr VideoOverlayComposition -> VideoOverlayComposition)
-> Ptr VideoOverlayComposition -> IO VideoOverlayComposition
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoOverlayComposition -> VideoOverlayComposition
VideoOverlayComposition) Ptr VideoOverlayComposition
result
    Maybe VideoOverlayRectangle
-> (VideoOverlayRectangle -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe VideoOverlayRectangle
rectangle VideoOverlayRectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    VideoOverlayComposition -> IO VideoOverlayComposition
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoOverlayComposition
result'

#if defined(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 t'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition'
    -> GstVideo.VideoOverlayRectangle.VideoOverlayRectangle
    -- ^ /@rectangle@/: a t'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' to add to the
    --     composition
    -> m ()
videoOverlayCompositionAddRectangle :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoOverlayComposition -> VideoOverlayRectangle -> m ()
videoOverlayCompositionAddRectangle VideoOverlayComposition
comp VideoOverlayRectangle
rectangle = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoOverlayComposition
comp' <- VideoOverlayComposition -> IO (Ptr VideoOverlayComposition)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoOverlayComposition
comp
    Ptr VideoOverlayRectangle
rectangle' <- VideoOverlayRectangle -> IO (Ptr VideoOverlayRectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoOverlayRectangle
rectangle
    Ptr VideoOverlayComposition -> Ptr VideoOverlayRectangle -> IO ()
gst_video_overlay_composition_add_rectangle Ptr VideoOverlayComposition
comp' Ptr VideoOverlayRectangle
rectangle'
    VideoOverlayComposition -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoOverlayComposition
comp
    VideoOverlayRectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoOverlayRectangle
rectangle
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VideoOverlayCompositionAddRectangleMethodInfo
instance (signature ~ (GstVideo.VideoOverlayRectangle.VideoOverlayRectangle -> m ()), MonadIO m) => O.OverloadedMethod VideoOverlayCompositionAddRectangleMethodInfo VideoOverlayComposition signature where
    overloadedMethod = videoOverlayCompositionAddRectangle

instance O.OverloadedMethodInfo VideoOverlayCompositionAddRectangleMethodInfo VideoOverlayComposition where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoOverlayComposition.videoOverlayCompositionAddRectangle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoOverlayComposition.html#v: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 t'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition'
    -> GstVideo.VideoFrame.VideoFrame
    -- ^ /@videoBuf@/: a t'GI.GstVideo.Structs.VideoFrame.VideoFrame' containing raw video data in a
    --             supported format. It should be mapped using GST_MAP_READWRITE
    -> m Bool
videoOverlayCompositionBlend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoOverlayComposition -> VideoFrame -> m Bool
videoOverlayCompositionBlend VideoOverlayComposition
comp VideoFrame
videoBuf = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoOverlayComposition
comp' <- VideoOverlayComposition -> IO (Ptr VideoOverlayComposition)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoOverlayComposition
comp
    Ptr VideoFrame
videoBuf' <- VideoFrame -> IO (Ptr VideoFrame)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoFrame
videoBuf
    CInt
result <- Ptr VideoOverlayComposition -> Ptr VideoFrame -> IO CInt
gst_video_overlay_composition_blend Ptr VideoOverlayComposition
comp' Ptr VideoFrame
videoBuf'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    VideoOverlayComposition -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoOverlayComposition
comp
    VideoFrame -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoFrame
videoBuf
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data VideoOverlayCompositionBlendMethodInfo
instance (signature ~ (GstVideo.VideoFrame.VideoFrame -> m Bool), MonadIO m) => O.OverloadedMethod VideoOverlayCompositionBlendMethodInfo VideoOverlayComposition signature where
    overloadedMethod = videoOverlayCompositionBlend

instance O.OverloadedMethodInfo VideoOverlayCompositionBlendMethodInfo VideoOverlayComposition where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoOverlayComposition.videoOverlayCompositionBlend",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoOverlayComposition.html#v: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 t'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' to copy
    -> m VideoOverlayComposition
    -- ^ __Returns:__ a new t'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' equivalent
    --     to /@comp@/.
videoOverlayCompositionCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoOverlayComposition -> m VideoOverlayComposition
videoOverlayCompositionCopy VideoOverlayComposition
comp = IO VideoOverlayComposition -> m VideoOverlayComposition
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoOverlayComposition -> m VideoOverlayComposition)
-> IO VideoOverlayComposition -> m VideoOverlayComposition
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoOverlayComposition
comp' <- VideoOverlayComposition -> IO (Ptr VideoOverlayComposition)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoOverlayComposition
comp
    Ptr VideoOverlayComposition
result <- Ptr VideoOverlayComposition -> IO (Ptr VideoOverlayComposition)
gst_video_overlay_composition_copy Ptr VideoOverlayComposition
comp'
    Text -> Ptr VideoOverlayComposition -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoOverlayCompositionCopy" Ptr VideoOverlayComposition
result
    VideoOverlayComposition
result' <- ((ManagedPtr VideoOverlayComposition -> VideoOverlayComposition)
-> Ptr VideoOverlayComposition -> IO VideoOverlayComposition
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoOverlayComposition -> VideoOverlayComposition
VideoOverlayComposition) Ptr VideoOverlayComposition
result
    VideoOverlayComposition -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoOverlayComposition
comp
    VideoOverlayComposition -> IO VideoOverlayComposition
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoOverlayComposition
result'

#if defined(ENABLE_OVERLOADING)
data VideoOverlayCompositionCopyMethodInfo
instance (signature ~ (m VideoOverlayComposition), MonadIO m) => O.OverloadedMethod VideoOverlayCompositionCopyMethodInfo VideoOverlayComposition signature where
    overloadedMethod = videoOverlayCompositionCopy

instance O.OverloadedMethodInfo VideoOverlayCompositionCopyMethodInfo VideoOverlayComposition where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoOverlayComposition.videoOverlayCompositionCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoOverlayComposition.html#v: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 t'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle' contained in /@comp@/.
videoOverlayCompositionGetRectangle ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoOverlayComposition
    -- ^ /@comp@/: a t'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition'
    -> Word32
    -- ^ /@n@/: number of the rectangle to get
    -> m (Maybe 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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoOverlayComposition
-> Word32 -> m (Maybe VideoOverlayRectangle)
videoOverlayCompositionGetRectangle VideoOverlayComposition
comp Word32
n = IO (Maybe VideoOverlayRectangle) -> m (Maybe VideoOverlayRectangle)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VideoOverlayRectangle)
 -> m (Maybe VideoOverlayRectangle))
-> IO (Maybe VideoOverlayRectangle)
-> m (Maybe VideoOverlayRectangle)
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoOverlayComposition
comp' <- VideoOverlayComposition -> IO (Ptr VideoOverlayComposition)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoOverlayComposition
comp
    Ptr VideoOverlayRectangle
result <- Ptr VideoOverlayComposition
-> Word32 -> IO (Ptr VideoOverlayRectangle)
gst_video_overlay_composition_get_rectangle Ptr VideoOverlayComposition
comp' Word32
n
    Maybe VideoOverlayRectangle
maybeResult <- Ptr VideoOverlayRectangle
-> (Ptr VideoOverlayRectangle -> IO VideoOverlayRectangle)
-> IO (Maybe VideoOverlayRectangle)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr VideoOverlayRectangle
result ((Ptr VideoOverlayRectangle -> IO VideoOverlayRectangle)
 -> IO (Maybe VideoOverlayRectangle))
-> (Ptr VideoOverlayRectangle -> IO VideoOverlayRectangle)
-> IO (Maybe VideoOverlayRectangle)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoOverlayRectangle
result' -> do
        VideoOverlayRectangle
result'' <- ((ManagedPtr VideoOverlayRectangle -> VideoOverlayRectangle)
-> Ptr VideoOverlayRectangle -> IO VideoOverlayRectangle
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr VideoOverlayRectangle -> VideoOverlayRectangle
GstVideo.VideoOverlayRectangle.VideoOverlayRectangle) Ptr VideoOverlayRectangle
result'
        VideoOverlayRectangle -> IO VideoOverlayRectangle
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoOverlayRectangle
result''
    VideoOverlayComposition -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoOverlayComposition
comp
    Maybe VideoOverlayRectangle -> IO (Maybe VideoOverlayRectangle)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoOverlayRectangle
maybeResult

#if defined(ENABLE_OVERLOADING)
data VideoOverlayCompositionGetRectangleMethodInfo
instance (signature ~ (Word32 -> m (Maybe GstVideo.VideoOverlayRectangle.VideoOverlayRectangle)), MonadIO m) => O.OverloadedMethod VideoOverlayCompositionGetRectangleMethodInfo VideoOverlayComposition signature where
    overloadedMethod = videoOverlayCompositionGetRectangle

instance O.OverloadedMethodInfo VideoOverlayCompositionGetRectangleMethodInfo VideoOverlayComposition where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoOverlayComposition.videoOverlayCompositionGetRectangle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoOverlayComposition.html#v: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 t'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition'
    -> m Word32
    -- ^ __Returns:__ the sequence number of /@comp@/
videoOverlayCompositionGetSeqnum :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoOverlayComposition -> m Word32
videoOverlayCompositionGetSeqnum VideoOverlayComposition
comp = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoOverlayComposition
comp' <- VideoOverlayComposition -> IO (Ptr VideoOverlayComposition)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoOverlayComposition
comp
    Word32
result <- Ptr VideoOverlayComposition -> IO Word32
gst_video_overlay_composition_get_seqnum Ptr VideoOverlayComposition
comp'
    VideoOverlayComposition -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoOverlayComposition
comp
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data VideoOverlayCompositionGetSeqnumMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod VideoOverlayCompositionGetSeqnumMethodInfo VideoOverlayComposition signature where
    overloadedMethod = videoOverlayCompositionGetSeqnum

instance O.OverloadedMethodInfo VideoOverlayCompositionGetSeqnumMethodInfo VideoOverlayComposition where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoOverlayComposition.videoOverlayCompositionGetSeqnum",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoOverlayComposition.html#v: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 t'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition' to copy
    -> m VideoOverlayComposition
    -- ^ __Returns:__ a writable t'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition'
    --     equivalent to /@comp@/.
videoOverlayCompositionMakeWritable :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoOverlayComposition -> m VideoOverlayComposition
videoOverlayCompositionMakeWritable VideoOverlayComposition
comp = IO VideoOverlayComposition -> m VideoOverlayComposition
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoOverlayComposition -> m VideoOverlayComposition)
-> IO VideoOverlayComposition -> m VideoOverlayComposition
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoOverlayComposition
comp' <- VideoOverlayComposition -> IO (Ptr VideoOverlayComposition)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed VideoOverlayComposition
comp
    Ptr VideoOverlayComposition
result <- Ptr VideoOverlayComposition -> IO (Ptr VideoOverlayComposition)
gst_video_overlay_composition_make_writable Ptr VideoOverlayComposition
comp'
    Text -> Ptr VideoOverlayComposition -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoOverlayCompositionMakeWritable" Ptr VideoOverlayComposition
result
    VideoOverlayComposition
result' <- ((ManagedPtr VideoOverlayComposition -> VideoOverlayComposition)
-> Ptr VideoOverlayComposition -> IO VideoOverlayComposition
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoOverlayComposition -> VideoOverlayComposition
VideoOverlayComposition) Ptr VideoOverlayComposition
result
    VideoOverlayComposition -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoOverlayComposition
comp
    VideoOverlayComposition -> IO VideoOverlayComposition
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoOverlayComposition
result'

#if defined(ENABLE_OVERLOADING)
data VideoOverlayCompositionMakeWritableMethodInfo
instance (signature ~ (m VideoOverlayComposition), MonadIO m) => O.OverloadedMethod VideoOverlayCompositionMakeWritableMethodInfo VideoOverlayComposition signature where
    overloadedMethod = videoOverlayCompositionMakeWritable

instance O.OverloadedMethodInfo VideoOverlayCompositionMakeWritableMethodInfo VideoOverlayComposition where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoOverlayComposition.videoOverlayCompositionMakeWritable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoOverlayComposition.html#v: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 t'GI.GstVideo.Structs.VideoOverlayRectangle.VideoOverlayRectangle's contained in /@comp@/.
videoOverlayCompositionNRectangles ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoOverlayComposition
    -- ^ /@comp@/: a t'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition'
    -> m Word32
    -- ^ __Returns:__ the number of rectangles
videoOverlayCompositionNRectangles :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoOverlayComposition -> m Word32
videoOverlayCompositionNRectangles VideoOverlayComposition
comp = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoOverlayComposition
comp' <- VideoOverlayComposition -> IO (Ptr VideoOverlayComposition)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoOverlayComposition
comp
    Word32
result <- Ptr VideoOverlayComposition -> IO Word32
gst_video_overlay_composition_n_rectangles Ptr VideoOverlayComposition
comp'
    VideoOverlayComposition -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoOverlayComposition
comp
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data VideoOverlayCompositionNRectanglesMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod VideoOverlayCompositionNRectanglesMethodInfo VideoOverlayComposition signature where
    overloadedMethod = videoOverlayCompositionNRectangles

instance O.OverloadedMethodInfo VideoOverlayCompositionNRectanglesMethodInfo VideoOverlayComposition where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoOverlayComposition.videoOverlayCompositionNRectangles",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoOverlayComposition.html#v:videoOverlayCompositionNRectangles"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveVideoOverlayCompositionMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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.OverloadedMethod info VideoOverlayComposition p) => OL.IsLabel t (VideoOverlayComposition -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveVideoOverlayCompositionMethod t VideoOverlayComposition, O.OverloadedMethod info VideoOverlayComposition p, R.HasField t VideoOverlayComposition p) => R.HasField t VideoOverlayComposition p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveVideoOverlayCompositionMethod t VideoOverlayComposition, O.OverloadedMethodInfo info VideoOverlayComposition) => OL.IsLabel t (O.MethodProxy info VideoOverlayComposition) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif