{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Extra buffer metadata describing image overlay data.

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

module GI.GstVideo.Structs.VideoOverlayCompositionMeta
    ( 

-- * Exported types
    VideoOverlayCompositionMeta(..)         ,
    newZeroVideoOverlayCompositionMeta      ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveVideoOverlayCompositionMetaMethod,
#endif


-- ** getInfo #method:getInfo#

    videoOverlayCompositionMetaGetInfo      ,




 -- * Properties
-- ** meta #attr:meta#
-- | parent t'GI.Gst.Structs.Meta.Meta'

    getVideoOverlayCompositionMetaMeta      ,
#if defined(ENABLE_OVERLOADING)
    videoOverlayCompositionMeta_meta        ,
#endif


-- ** overlay #attr:overlay#
-- | the attached t'GI.GstVideo.Structs.VideoOverlayComposition.VideoOverlayComposition'

    clearVideoOverlayCompositionMetaOverlay ,
    getVideoOverlayCompositionMetaOverlay   ,
    setVideoOverlayCompositionMetaOverlay   ,
#if defined(ENABLE_OVERLOADING)
    videoOverlayCompositionMeta_overlay     ,
#endif




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.Gst.Structs.Meta as Gst.Meta
import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo
import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoOverlayComposition as GstVideo.VideoOverlayComposition

-- | Memory-managed wrapper type.
newtype VideoOverlayCompositionMeta = VideoOverlayCompositionMeta (SP.ManagedPtr VideoOverlayCompositionMeta)
    deriving (VideoOverlayCompositionMeta -> VideoOverlayCompositionMeta -> Bool
(VideoOverlayCompositionMeta
 -> VideoOverlayCompositionMeta -> Bool)
-> (VideoOverlayCompositionMeta
    -> VideoOverlayCompositionMeta -> Bool)
-> Eq VideoOverlayCompositionMeta
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoOverlayCompositionMeta -> VideoOverlayCompositionMeta -> Bool
$c/= :: VideoOverlayCompositionMeta -> VideoOverlayCompositionMeta -> Bool
== :: VideoOverlayCompositionMeta -> VideoOverlayCompositionMeta -> Bool
$c== :: VideoOverlayCompositionMeta -> VideoOverlayCompositionMeta -> Bool
Eq)

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

instance BoxedPtr VideoOverlayCompositionMeta where
    boxedPtrCopy :: VideoOverlayCompositionMeta -> IO VideoOverlayCompositionMeta
boxedPtrCopy = \VideoOverlayCompositionMeta
p -> VideoOverlayCompositionMeta
-> (Ptr VideoOverlayCompositionMeta
    -> IO VideoOverlayCompositionMeta)
-> IO VideoOverlayCompositionMeta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VideoOverlayCompositionMeta
p (Int
-> Ptr VideoOverlayCompositionMeta
-> IO (Ptr VideoOverlayCompositionMeta)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
24 (Ptr VideoOverlayCompositionMeta
 -> IO (Ptr VideoOverlayCompositionMeta))
-> (Ptr VideoOverlayCompositionMeta
    -> IO VideoOverlayCompositionMeta)
-> Ptr VideoOverlayCompositionMeta
-> IO VideoOverlayCompositionMeta
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr VideoOverlayCompositionMeta
 -> VideoOverlayCompositionMeta)
-> Ptr VideoOverlayCompositionMeta
-> IO VideoOverlayCompositionMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr VideoOverlayCompositionMeta
-> VideoOverlayCompositionMeta
VideoOverlayCompositionMeta)
    boxedPtrFree :: VideoOverlayCompositionMeta -> IO ()
boxedPtrFree = \VideoOverlayCompositionMeta
x -> VideoOverlayCompositionMeta
-> (Ptr VideoOverlayCompositionMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr VideoOverlayCompositionMeta
x Ptr VideoOverlayCompositionMeta -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr VideoOverlayCompositionMeta where
    boxedPtrCalloc :: IO (Ptr VideoOverlayCompositionMeta)
boxedPtrCalloc = Int -> IO (Ptr VideoOverlayCompositionMeta)
forall a. Int -> IO (Ptr a)
callocBytes Int
24


-- | Construct a `VideoOverlayCompositionMeta` struct initialized to zero.
newZeroVideoOverlayCompositionMeta :: MonadIO m => m VideoOverlayCompositionMeta
newZeroVideoOverlayCompositionMeta :: m VideoOverlayCompositionMeta
newZeroVideoOverlayCompositionMeta = IO VideoOverlayCompositionMeta -> m VideoOverlayCompositionMeta
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoOverlayCompositionMeta -> m VideoOverlayCompositionMeta)
-> IO VideoOverlayCompositionMeta -> m VideoOverlayCompositionMeta
forall a b. (a -> b) -> a -> b
$ IO (Ptr VideoOverlayCompositionMeta)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr VideoOverlayCompositionMeta)
-> (Ptr VideoOverlayCompositionMeta
    -> IO VideoOverlayCompositionMeta)
-> IO VideoOverlayCompositionMeta
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr VideoOverlayCompositionMeta
 -> VideoOverlayCompositionMeta)
-> Ptr VideoOverlayCompositionMeta
-> IO VideoOverlayCompositionMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr VideoOverlayCompositionMeta
-> VideoOverlayCompositionMeta
VideoOverlayCompositionMeta

instance tag ~ 'AttrSet => Constructible VideoOverlayCompositionMeta tag where
    new :: (ManagedPtr VideoOverlayCompositionMeta
 -> VideoOverlayCompositionMeta)
-> [AttrOp VideoOverlayCompositionMeta tag]
-> m VideoOverlayCompositionMeta
new ManagedPtr VideoOverlayCompositionMeta
-> VideoOverlayCompositionMeta
_ [AttrOp VideoOverlayCompositionMeta tag]
attrs = do
        VideoOverlayCompositionMeta
o <- m VideoOverlayCompositionMeta
forall (m :: * -> *). MonadIO m => m VideoOverlayCompositionMeta
newZeroVideoOverlayCompositionMeta
        VideoOverlayCompositionMeta
-> [AttrOp VideoOverlayCompositionMeta 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set VideoOverlayCompositionMeta
o [AttrOp VideoOverlayCompositionMeta tag]
[AttrOp VideoOverlayCompositionMeta 'AttrSet]
attrs
        VideoOverlayCompositionMeta -> m VideoOverlayCompositionMeta
forall (m :: * -> *) a. Monad m => a -> m a
return VideoOverlayCompositionMeta
o


-- | Get the value of the “@meta@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoOverlayCompositionMeta #meta
-- @
getVideoOverlayCompositionMetaMeta :: MonadIO m => VideoOverlayCompositionMeta -> m Gst.Meta.Meta
getVideoOverlayCompositionMetaMeta :: VideoOverlayCompositionMeta -> m Meta
getVideoOverlayCompositionMetaMeta VideoOverlayCompositionMeta
s = IO Meta -> m Meta
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Meta -> m Meta) -> IO Meta -> m Meta
forall a b. (a -> b) -> a -> b
$ VideoOverlayCompositionMeta
-> (Ptr VideoOverlayCompositionMeta -> IO Meta) -> IO Meta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoOverlayCompositionMeta
s ((Ptr VideoOverlayCompositionMeta -> IO Meta) -> IO Meta)
-> (Ptr VideoOverlayCompositionMeta -> IO Meta) -> IO Meta
forall a b. (a -> b) -> a -> b
$ \Ptr VideoOverlayCompositionMeta
ptr -> do
    let val :: Ptr Meta
val = Ptr VideoOverlayCompositionMeta
ptr Ptr VideoOverlayCompositionMeta -> Int -> Ptr Meta
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Gst.Meta.Meta)
    Meta
val' <- ((ManagedPtr Meta -> Meta) -> Ptr Meta -> IO Meta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Meta -> Meta
Gst.Meta.Meta) Ptr Meta
val
    Meta -> IO Meta
forall (m :: * -> *) a. Monad m => a -> m a
return Meta
val'

#if defined(ENABLE_OVERLOADING)
data VideoOverlayCompositionMetaMetaFieldInfo
instance AttrInfo VideoOverlayCompositionMetaMetaFieldInfo where
    type AttrBaseTypeConstraint VideoOverlayCompositionMetaMetaFieldInfo = (~) VideoOverlayCompositionMeta
    type AttrAllowedOps VideoOverlayCompositionMetaMetaFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint VideoOverlayCompositionMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta)
    type AttrTransferTypeConstraint VideoOverlayCompositionMetaMetaFieldInfo = (~)(Ptr Gst.Meta.Meta)
    type AttrTransferType VideoOverlayCompositionMetaMetaFieldInfo = (Ptr Gst.Meta.Meta)
    type AttrGetType VideoOverlayCompositionMetaMetaFieldInfo = Gst.Meta.Meta
    type AttrLabel VideoOverlayCompositionMetaMetaFieldInfo = "meta"
    type AttrOrigin VideoOverlayCompositionMetaMetaFieldInfo = VideoOverlayCompositionMeta
    attrGet = getVideoOverlayCompositionMetaMeta
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

videoOverlayCompositionMeta_meta :: AttrLabelProxy "meta"
videoOverlayCompositionMeta_meta = AttrLabelProxy

#endif


-- | Get the value of the “@overlay@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoOverlayCompositionMeta #overlay
-- @
getVideoOverlayCompositionMetaOverlay :: MonadIO m => VideoOverlayCompositionMeta -> m (Maybe GstVideo.VideoOverlayComposition.VideoOverlayComposition)
getVideoOverlayCompositionMetaOverlay :: VideoOverlayCompositionMeta -> m (Maybe VideoOverlayComposition)
getVideoOverlayCompositionMetaOverlay VideoOverlayCompositionMeta
s = IO (Maybe VideoOverlayComposition)
-> m (Maybe VideoOverlayComposition)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VideoOverlayComposition)
 -> m (Maybe VideoOverlayComposition))
-> IO (Maybe VideoOverlayComposition)
-> m (Maybe VideoOverlayComposition)
forall a b. (a -> b) -> a -> b
$ VideoOverlayCompositionMeta
-> (Ptr VideoOverlayCompositionMeta
    -> IO (Maybe VideoOverlayComposition))
-> IO (Maybe VideoOverlayComposition)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoOverlayCompositionMeta
s ((Ptr VideoOverlayCompositionMeta
  -> IO (Maybe VideoOverlayComposition))
 -> IO (Maybe VideoOverlayComposition))
-> (Ptr VideoOverlayCompositionMeta
    -> IO (Maybe VideoOverlayComposition))
-> IO (Maybe VideoOverlayComposition)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoOverlayCompositionMeta
ptr -> do
    Ptr VideoOverlayComposition
val <- Ptr (Ptr VideoOverlayComposition)
-> IO (Ptr VideoOverlayComposition)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoOverlayCompositionMeta
ptr Ptr VideoOverlayCompositionMeta
-> Int -> Ptr (Ptr VideoOverlayComposition)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition)
    Maybe VideoOverlayComposition
result <- Ptr VideoOverlayComposition
-> (Ptr VideoOverlayComposition -> IO VideoOverlayComposition)
-> IO (Maybe VideoOverlayComposition)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr VideoOverlayComposition
val ((Ptr VideoOverlayComposition -> IO VideoOverlayComposition)
 -> IO (Maybe VideoOverlayComposition))
-> (Ptr VideoOverlayComposition -> IO VideoOverlayComposition)
-> IO (Maybe VideoOverlayComposition)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoOverlayComposition
val' -> do
        VideoOverlayComposition
val'' <- ((ManagedPtr VideoOverlayComposition -> VideoOverlayComposition)
-> Ptr VideoOverlayComposition -> IO VideoOverlayComposition
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr VideoOverlayComposition -> VideoOverlayComposition
GstVideo.VideoOverlayComposition.VideoOverlayComposition) Ptr VideoOverlayComposition
val'
        VideoOverlayComposition -> IO VideoOverlayComposition
forall (m :: * -> *) a. Monad m => a -> m a
return VideoOverlayComposition
val''
    Maybe VideoOverlayComposition -> IO (Maybe VideoOverlayComposition)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoOverlayComposition
result

-- | Set the value of the “@overlay@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoOverlayCompositionMeta [ #overlay 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoOverlayCompositionMetaOverlay :: MonadIO m => VideoOverlayCompositionMeta -> Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition -> m ()
setVideoOverlayCompositionMetaOverlay :: VideoOverlayCompositionMeta -> Ptr VideoOverlayComposition -> m ()
setVideoOverlayCompositionMetaOverlay VideoOverlayCompositionMeta
s Ptr VideoOverlayComposition
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoOverlayCompositionMeta
-> (Ptr VideoOverlayCompositionMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoOverlayCompositionMeta
s ((Ptr VideoOverlayCompositionMeta -> IO ()) -> IO ())
-> (Ptr VideoOverlayCompositionMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoOverlayCompositionMeta
ptr -> do
    Ptr (Ptr VideoOverlayComposition)
-> Ptr VideoOverlayComposition -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoOverlayCompositionMeta
ptr Ptr VideoOverlayCompositionMeta
-> Int -> Ptr (Ptr VideoOverlayComposition)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr VideoOverlayComposition
val :: Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition)

-- | Set the value of the “@overlay@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #overlay
-- @
clearVideoOverlayCompositionMetaOverlay :: MonadIO m => VideoOverlayCompositionMeta -> m ()
clearVideoOverlayCompositionMetaOverlay :: VideoOverlayCompositionMeta -> m ()
clearVideoOverlayCompositionMetaOverlay VideoOverlayCompositionMeta
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoOverlayCompositionMeta
-> (Ptr VideoOverlayCompositionMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoOverlayCompositionMeta
s ((Ptr VideoOverlayCompositionMeta -> IO ()) -> IO ())
-> (Ptr VideoOverlayCompositionMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoOverlayCompositionMeta
ptr -> do
    Ptr (Ptr VideoOverlayComposition)
-> Ptr VideoOverlayComposition -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoOverlayCompositionMeta
ptr Ptr VideoOverlayCompositionMeta
-> Int -> Ptr (Ptr VideoOverlayComposition)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr VideoOverlayComposition
forall a. Ptr a
FP.nullPtr :: Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition)

#if defined(ENABLE_OVERLOADING)
data VideoOverlayCompositionMetaOverlayFieldInfo
instance AttrInfo VideoOverlayCompositionMetaOverlayFieldInfo where
    type AttrBaseTypeConstraint VideoOverlayCompositionMetaOverlayFieldInfo = (~) VideoOverlayCompositionMeta
    type AttrAllowedOps VideoOverlayCompositionMetaOverlayFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint VideoOverlayCompositionMetaOverlayFieldInfo = (~) (Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition)
    type AttrTransferTypeConstraint VideoOverlayCompositionMetaOverlayFieldInfo = (~)(Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition)
    type AttrTransferType VideoOverlayCompositionMetaOverlayFieldInfo = (Ptr GstVideo.VideoOverlayComposition.VideoOverlayComposition)
    type AttrGetType VideoOverlayCompositionMetaOverlayFieldInfo = Maybe GstVideo.VideoOverlayComposition.VideoOverlayComposition
    type AttrLabel VideoOverlayCompositionMetaOverlayFieldInfo = "overlay"
    type AttrOrigin VideoOverlayCompositionMetaOverlayFieldInfo = VideoOverlayCompositionMeta
    attrGet = getVideoOverlayCompositionMetaOverlay
    attrSet = setVideoOverlayCompositionMetaOverlay
    attrConstruct = undefined
    attrClear = clearVideoOverlayCompositionMetaOverlay
    attrTransfer _ v = do
        return v

videoOverlayCompositionMeta_overlay :: AttrLabelProxy "overlay"
videoOverlayCompositionMeta_overlay = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoOverlayCompositionMeta
type instance O.AttributeList VideoOverlayCompositionMeta = VideoOverlayCompositionMetaAttributeList
type VideoOverlayCompositionMetaAttributeList = ('[ '("meta", VideoOverlayCompositionMetaMetaFieldInfo), '("overlay", VideoOverlayCompositionMetaOverlayFieldInfo)] :: [(Symbol, *)])
#endif

-- method VideoOverlayCompositionMeta::get_info
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "MetaInfo" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_overlay_composition_meta_get_info" gst_video_overlay_composition_meta_get_info :: 
    IO (Ptr Gst.MetaInfo.MetaInfo)

-- | /No description available in the introspection data./
videoOverlayCompositionMetaGetInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Gst.MetaInfo.MetaInfo
videoOverlayCompositionMetaGetInfo :: m MetaInfo
videoOverlayCompositionMetaGetInfo  = IO MetaInfo -> m MetaInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MetaInfo -> m MetaInfo) -> IO MetaInfo -> m MetaInfo
forall a b. (a -> b) -> a -> b
$ do
    Ptr MetaInfo
result <- IO (Ptr MetaInfo)
gst_video_overlay_composition_meta_get_info
    Text -> Ptr MetaInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoOverlayCompositionMetaGetInfo" Ptr MetaInfo
result
    MetaInfo
result' <- ((ManagedPtr MetaInfo -> MetaInfo) -> Ptr MetaInfo -> IO MetaInfo
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr MetaInfo -> MetaInfo
Gst.MetaInfo.MetaInfo) Ptr MetaInfo
result
    MetaInfo -> IO MetaInfo
forall (m :: * -> *) a. Monad m => a -> m a
return MetaInfo
result'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveVideoOverlayCompositionMetaMethod (t :: Symbol) (o :: *) :: * where
    ResolveVideoOverlayCompositionMetaMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveVideoOverlayCompositionMetaMethod t VideoOverlayCompositionMeta, O.MethodInfo info VideoOverlayCompositionMeta p) => OL.IsLabel t (VideoOverlayCompositionMeta -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif