{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- This meta is primarily for internal use in GStreamer elements to support
-- VP8\/VP9 transparent video stored into WebM or Matroska containers, or
-- transparent static AV1 images. Nothing prevents you from using this meta
-- for custom purposes, but it generally can\'t be used to easily to add support
-- for alpha channels to CODECs or formats that don\'t support that out of the
-- box.
-- 
-- /Since: 1.20/

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

module GI.GstVideo.Structs.VideoCodecAlphaMeta
    ( 

-- * Exported types
    VideoCodecAlphaMeta(..)                 ,
    newZeroVideoCodecAlphaMeta              ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveVideoCodecAlphaMetaMethod        ,
#endif

-- ** getInfo #method:getInfo#

    videoCodecAlphaMetaGetInfo              ,




 -- * Properties


-- ** buffer #attr:buffer#
-- | the encoded alpha frame

    clearVideoCodecAlphaMetaBuffer          ,
    getVideoCodecAlphaMetaBuffer            ,
    setVideoCodecAlphaMetaBuffer            ,
#if defined(ENABLE_OVERLOADING)
    videoCodecAlphaMeta_buffer              ,
#endif


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

    getVideoCodecAlphaMetaMeta              ,
#if defined(ENABLE_OVERLOADING)
    videoCodecAlphaMeta_meta                ,
#endif




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.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 qualified GI.Gst.Structs.Buffer as Gst.Buffer
import qualified GI.Gst.Structs.Meta as Gst.Meta
import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo

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

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

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


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

instance tag ~ 'AttrSet => Constructible VideoCodecAlphaMeta tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr VideoCodecAlphaMeta -> VideoCodecAlphaMeta)
-> [AttrOp VideoCodecAlphaMeta tag] -> m VideoCodecAlphaMeta
new ManagedPtr VideoCodecAlphaMeta -> VideoCodecAlphaMeta
_ [AttrOp VideoCodecAlphaMeta tag]
attrs = do
        VideoCodecAlphaMeta
o <- m VideoCodecAlphaMeta
forall (m :: * -> *). MonadIO m => m VideoCodecAlphaMeta
newZeroVideoCodecAlphaMeta
        VideoCodecAlphaMeta
-> [AttrOp VideoCodecAlphaMeta 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set VideoCodecAlphaMeta
o [AttrOp VideoCodecAlphaMeta tag]
[AttrOp VideoCodecAlphaMeta 'AttrSet]
attrs
        VideoCodecAlphaMeta -> m VideoCodecAlphaMeta
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoCodecAlphaMeta
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' videoCodecAlphaMeta #meta
-- @
getVideoCodecAlphaMetaMeta :: MonadIO m => VideoCodecAlphaMeta -> m Gst.Meta.Meta
getVideoCodecAlphaMetaMeta :: forall (m :: * -> *). MonadIO m => VideoCodecAlphaMeta -> m Meta
getVideoCodecAlphaMetaMeta VideoCodecAlphaMeta
s = IO Meta -> m Meta
forall a. IO a -> m a
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
$ VideoCodecAlphaMeta
-> (Ptr VideoCodecAlphaMeta -> IO Meta) -> IO Meta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecAlphaMeta
s ((Ptr VideoCodecAlphaMeta -> IO Meta) -> IO Meta)
-> (Ptr VideoCodecAlphaMeta -> IO Meta) -> IO Meta
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecAlphaMeta
ptr -> do
    let val :: Ptr Meta
val = Ptr VideoCodecAlphaMeta
ptr Ptr VideoCodecAlphaMeta -> 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Meta
val'

#if defined(ENABLE_OVERLOADING)
data VideoCodecAlphaMetaMetaFieldInfo
instance AttrInfo VideoCodecAlphaMetaMetaFieldInfo where
    type AttrBaseTypeConstraint VideoCodecAlphaMetaMetaFieldInfo = (~) VideoCodecAlphaMeta
    type AttrAllowedOps VideoCodecAlphaMetaMetaFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint VideoCodecAlphaMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta)
    type AttrTransferTypeConstraint VideoCodecAlphaMetaMetaFieldInfo = (~)(Ptr Gst.Meta.Meta)
    type AttrTransferType VideoCodecAlphaMetaMetaFieldInfo = (Ptr Gst.Meta.Meta)
    type AttrGetType VideoCodecAlphaMetaMetaFieldInfo = Gst.Meta.Meta
    type AttrLabel VideoCodecAlphaMetaMetaFieldInfo = "meta"
    type AttrOrigin VideoCodecAlphaMetaMetaFieldInfo = VideoCodecAlphaMeta
    attrGet = getVideoCodecAlphaMetaMeta
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoCodecAlphaMeta.meta"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoCodecAlphaMeta.html#g:attr:meta"
        })

videoCodecAlphaMeta_meta :: AttrLabelProxy "meta"
videoCodecAlphaMeta_meta = AttrLabelProxy

#endif


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

-- | Set the value of the “@buffer@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoCodecAlphaMeta [ #buffer 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoCodecAlphaMetaBuffer :: MonadIO m => VideoCodecAlphaMeta -> Ptr Gst.Buffer.Buffer -> m ()
setVideoCodecAlphaMetaBuffer :: forall (m :: * -> *).
MonadIO m =>
VideoCodecAlphaMeta -> Ptr Buffer -> m ()
setVideoCodecAlphaMetaBuffer VideoCodecAlphaMeta
s Ptr Buffer
val = 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
$ VideoCodecAlphaMeta -> (Ptr VideoCodecAlphaMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecAlphaMeta
s ((Ptr VideoCodecAlphaMeta -> IO ()) -> IO ())
-> (Ptr VideoCodecAlphaMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecAlphaMeta
ptr -> do
    Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecAlphaMeta
ptr Ptr VideoCodecAlphaMeta -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Buffer
val :: Ptr Gst.Buffer.Buffer)

-- | Set the value of the “@buffer@” 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' #buffer
-- @
clearVideoCodecAlphaMetaBuffer :: MonadIO m => VideoCodecAlphaMeta -> m ()
clearVideoCodecAlphaMetaBuffer :: forall (m :: * -> *). MonadIO m => VideoCodecAlphaMeta -> m ()
clearVideoCodecAlphaMetaBuffer VideoCodecAlphaMeta
s = 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
$ VideoCodecAlphaMeta -> (Ptr VideoCodecAlphaMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoCodecAlphaMeta
s ((Ptr VideoCodecAlphaMeta -> IO ()) -> IO ())
-> (Ptr VideoCodecAlphaMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoCodecAlphaMeta
ptr -> do
    Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoCodecAlphaMeta
ptr Ptr VideoCodecAlphaMeta -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Buffer
forall a. Ptr a
FP.nullPtr :: Ptr Gst.Buffer.Buffer)

#if defined(ENABLE_OVERLOADING)
data VideoCodecAlphaMetaBufferFieldInfo
instance AttrInfo VideoCodecAlphaMetaBufferFieldInfo where
    type AttrBaseTypeConstraint VideoCodecAlphaMetaBufferFieldInfo = (~) VideoCodecAlphaMeta
    type AttrAllowedOps VideoCodecAlphaMetaBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint VideoCodecAlphaMetaBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer)
    type AttrTransferTypeConstraint VideoCodecAlphaMetaBufferFieldInfo = (~)(Ptr Gst.Buffer.Buffer)
    type AttrTransferType VideoCodecAlphaMetaBufferFieldInfo = (Ptr Gst.Buffer.Buffer)
    type AttrGetType VideoCodecAlphaMetaBufferFieldInfo = Maybe Gst.Buffer.Buffer
    type AttrLabel VideoCodecAlphaMetaBufferFieldInfo = "buffer"
    type AttrOrigin VideoCodecAlphaMetaBufferFieldInfo = VideoCodecAlphaMeta
    attrGet = getVideoCodecAlphaMetaBuffer
    attrSet = setVideoCodecAlphaMetaBuffer
    attrConstruct = undefined
    attrClear = clearVideoCodecAlphaMetaBuffer
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoCodecAlphaMeta.buffer"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoCodecAlphaMeta.html#g:attr:buffer"
        })

videoCodecAlphaMeta_buffer :: AttrLabelProxy "buffer"
videoCodecAlphaMeta_buffer = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoCodecAlphaMeta
type instance O.AttributeList VideoCodecAlphaMeta = VideoCodecAlphaMetaAttributeList
type VideoCodecAlphaMetaAttributeList = ('[ '("meta", VideoCodecAlphaMetaMetaFieldInfo), '("buffer", VideoCodecAlphaMetaBufferFieldInfo)] :: [(Symbol, DK.Type)])
#endif

-- method VideoCodecAlphaMeta::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_codec_alpha_meta_get_info" gst_video_codec_alpha_meta_get_info :: 
    IO (Ptr Gst.MetaInfo.MetaInfo)

-- | /No description available in the introspection data./
-- 
-- /Since: 1.20/
videoCodecAlphaMetaGetInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Gst.MetaInfo.MetaInfo
    -- ^ __Returns:__ t'GI.Gst.Structs.MetaInfo.MetaInfo' pointer that describes t'GI.GstVideo.Structs.VideoCodecAlphaMeta.VideoCodecAlphaMeta'.
videoCodecAlphaMetaGetInfo :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m MetaInfo
videoCodecAlphaMetaGetInfo  = IO MetaInfo -> m MetaInfo
forall a. IO a -> m a
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_codec_alpha_meta_get_info
    Text -> Ptr MetaInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoCodecAlphaMetaGetInfo" 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MetaInfo
result'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveVideoCodecAlphaMetaMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveVideoCodecAlphaMetaMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveVideoCodecAlphaMetaMethod t VideoCodecAlphaMeta, O.OverloadedMethod info VideoCodecAlphaMeta p) => OL.IsLabel t (VideoCodecAlphaMeta -> 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 ~ ResolveVideoCodecAlphaMetaMethod t VideoCodecAlphaMeta, O.OverloadedMethod info VideoCodecAlphaMeta p, R.HasField t VideoCodecAlphaMeta p) => R.HasField t VideoCodecAlphaMeta p where
    getField = O.overloadedMethod @info

#endif

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

#endif