{-# 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 properties

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

module GI.GstVideo.Structs.VideoMeta
    ( 

-- * Exported types
    VideoMeta(..)                           ,
    newZeroVideoMeta                        ,
    noVideoMeta                             ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveVideoMetaMethod                  ,
#endif


-- ** getInfo #method:getInfo#

    videoMetaGetInfo                        ,


-- ** map #method:map#

#if defined(ENABLE_OVERLOADING)
    VideoMetaMapMethodInfo                  ,
#endif
    videoMetaMap                            ,


-- ** unmap #method:unmap#

#if defined(ENABLE_OVERLOADING)
    VideoMetaUnmapMethodInfo                ,
#endif
    videoMetaUnmap                          ,




 -- * Properties
-- ** buffer #attr:buffer#
-- | the buffer this metadata belongs to

    clearVideoMetaBuffer                    ,
    getVideoMetaBuffer                      ,
    setVideoMetaBuffer                      ,
#if defined(ENABLE_OVERLOADING)
    videoMeta_buffer                        ,
#endif


-- ** flags #attr:flags#
-- | additional video flags

    getVideoMetaFlags                       ,
    setVideoMetaFlags                       ,
#if defined(ENABLE_OVERLOADING)
    videoMeta_flags                         ,
#endif


-- ** format #attr:format#
-- | the video format

    getVideoMetaFormat                      ,
    setVideoMetaFormat                      ,
#if defined(ENABLE_OVERLOADING)
    videoMeta_format                        ,
#endif


-- ** height #attr:height#
-- | the video height

    getVideoMetaHeight                      ,
    setVideoMetaHeight                      ,
#if defined(ENABLE_OVERLOADING)
    videoMeta_height                        ,
#endif


-- ** id #attr:id#
-- | identifier of the frame

    getVideoMetaId                          ,
    setVideoMetaId                          ,
#if defined(ENABLE_OVERLOADING)
    videoMeta_id                            ,
#endif


-- ** map #attr:map#
-- | /No description available in the introspection data./

    clearVideoMetaMap                       ,
    getVideoMetaMap                         ,
    setVideoMetaMap                         ,
#if defined(ENABLE_OVERLOADING)
    videoMeta_map                           ,
#endif


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

    getVideoMetaMeta                        ,
#if defined(ENABLE_OVERLOADING)
    videoMeta_meta                          ,
#endif


-- ** nPlanes #attr:nPlanes#
-- | the number of planes in the image

    getVideoMetaNPlanes                     ,
    setVideoMetaNPlanes                     ,
#if defined(ENABLE_OVERLOADING)
    videoMeta_nPlanes                       ,
#endif


-- ** unmap #attr:unmap#
-- | /No description available in the introspection data./

    clearVideoMetaUnmap                     ,
    getVideoMetaUnmap                       ,
    setVideoMetaUnmap                       ,
#if defined(ENABLE_OVERLOADING)
    videoMeta_unmap                         ,
#endif


-- ** width #attr:width#
-- | the video width

    getVideoMetaWidth                       ,
    setVideoMetaWidth                       ,
#if defined(ENABLE_OVERLOADING)
    videoMeta_width                         ,
#endif




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.Gst.Flags as Gst.Flags
import qualified GI.Gst.Structs.Buffer as Gst.Buffer
import qualified GI.Gst.Structs.MapInfo as Gst.MapInfo
import qualified GI.Gst.Structs.Meta as Gst.Meta
import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo
import qualified GI.GstVideo.Callbacks as GstVideo.Callbacks
import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums
import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags

-- | Memory-managed wrapper type.
newtype VideoMeta = VideoMeta (ManagedPtr VideoMeta)
    deriving (VideoMeta -> VideoMeta -> Bool
(VideoMeta -> VideoMeta -> Bool)
-> (VideoMeta -> VideoMeta -> Bool) -> Eq VideoMeta
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoMeta -> VideoMeta -> Bool
$c/= :: VideoMeta -> VideoMeta -> Bool
== :: VideoMeta -> VideoMeta -> Bool
$c== :: VideoMeta -> VideoMeta -> Bool
Eq)
instance WrappedPtr VideoMeta where
    wrappedPtrCalloc :: IO (Ptr VideoMeta)
wrappedPtrCalloc = Int -> IO (Ptr VideoMeta)
forall a. Int -> IO (Ptr a)
callocBytes 112
    wrappedPtrCopy :: VideoMeta -> IO VideoMeta
wrappedPtrCopy = \p :: VideoMeta
p -> VideoMeta -> (Ptr VideoMeta -> IO VideoMeta) -> IO VideoMeta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
p (Int -> Ptr VideoMeta -> IO (Ptr VideoMeta)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 112 (Ptr VideoMeta -> IO (Ptr VideoMeta))
-> (Ptr VideoMeta -> IO VideoMeta) -> Ptr VideoMeta -> IO VideoMeta
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr VideoMeta -> VideoMeta)
-> Ptr VideoMeta -> IO VideoMeta
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr VideoMeta -> VideoMeta
VideoMeta)
    wrappedPtrFree :: Maybe (GDestroyNotify VideoMeta)
wrappedPtrFree = GDestroyNotify VideoMeta -> Maybe (GDestroyNotify VideoMeta)
forall a. a -> Maybe a
Just GDestroyNotify VideoMeta
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `VideoMeta` struct initialized to zero.
newZeroVideoMeta :: MonadIO m => m VideoMeta
newZeroVideoMeta :: m VideoMeta
newZeroVideoMeta = IO VideoMeta -> m VideoMeta
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoMeta -> m VideoMeta) -> IO VideoMeta -> m VideoMeta
forall a b. (a -> b) -> a -> b
$ IO (Ptr VideoMeta)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr VideoMeta)
-> (Ptr VideoMeta -> IO VideoMeta) -> IO VideoMeta
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr VideoMeta -> VideoMeta)
-> Ptr VideoMeta -> IO VideoMeta
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr VideoMeta -> VideoMeta
VideoMeta

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


-- | A convenience alias for `Nothing` :: `Maybe` `VideoMeta`.
noVideoMeta :: Maybe VideoMeta
noVideoMeta :: Maybe VideoMeta
noVideoMeta = Maybe VideoMeta
forall a. Maybe a
Nothing

-- | 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' videoMeta #meta
-- @
getVideoMetaMeta :: MonadIO m => VideoMeta -> m Gst.Meta.Meta
getVideoMetaMeta :: VideoMeta -> m Meta
getVideoMetaMeta s :: VideoMeta
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
$ VideoMeta -> (Ptr VideoMeta -> IO Meta) -> IO Meta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO Meta) -> IO Meta)
-> (Ptr VideoMeta -> IO Meta) -> IO Meta
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    let val :: Ptr Meta
val = Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Meta
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0 :: (Ptr Gst.Meta.Meta)
    Meta
val' <- ((ManagedPtr Meta -> Meta) -> Ptr Meta -> IO Meta
forall a.
(HasCallStack, WrappedPtr 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 VideoMetaMetaFieldInfo
instance AttrInfo VideoMetaMetaFieldInfo where
    type AttrBaseTypeConstraint VideoMetaMetaFieldInfo = (~) VideoMeta
    type AttrAllowedOps VideoMetaMetaFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint VideoMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta)
    type AttrTransferTypeConstraint VideoMetaMetaFieldInfo = (~)(Ptr Gst.Meta.Meta)
    type AttrTransferType VideoMetaMetaFieldInfo = (Ptr Gst.Meta.Meta)
    type AttrGetType VideoMetaMetaFieldInfo = Gst.Meta.Meta
    type AttrLabel VideoMetaMetaFieldInfo = "meta"
    type AttrOrigin VideoMetaMetaFieldInfo = VideoMeta
    attrGet = getVideoMetaMeta
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

videoMeta_meta :: AttrLabelProxy "meta"
videoMeta_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' videoMeta #buffer
-- @
getVideoMetaBuffer :: MonadIO m => VideoMeta -> m (Maybe Gst.Buffer.Buffer)
getVideoMetaBuffer :: VideoMeta -> m (Maybe Buffer)
getVideoMetaBuffer s :: VideoMeta
s = IO (Maybe Buffer) -> m (Maybe Buffer)
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
$ VideoMeta
-> (Ptr VideoMeta -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO (Maybe Buffer)) -> IO (Maybe Buffer))
-> (Ptr VideoMeta -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    Ptr Buffer
val <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 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
$ \val' :: Ptr Buffer
val' -> do
        Buffer
val'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
val'
        Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
val''
    Maybe Buffer -> IO (Maybe Buffer)
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' videoMeta [ #buffer 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoMetaBuffer :: MonadIO m => VideoMeta -> Ptr Gst.Buffer.Buffer -> m ()
setVideoMetaBuffer :: VideoMeta -> Ptr Buffer -> m ()
setVideoMetaBuffer s :: VideoMeta
s val :: Ptr Buffer
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 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
-- @
clearVideoMetaBuffer :: MonadIO m => VideoMeta -> m ()
clearVideoMetaBuffer :: VideoMeta -> m ()
clearVideoMetaBuffer s :: VideoMeta
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (Ptr Buffer
forall a. Ptr a
FP.nullPtr :: Ptr Gst.Buffer.Buffer)

#if defined(ENABLE_OVERLOADING)
data VideoMetaBufferFieldInfo
instance AttrInfo VideoMetaBufferFieldInfo where
    type AttrBaseTypeConstraint VideoMetaBufferFieldInfo = (~) VideoMeta
    type AttrAllowedOps VideoMetaBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint VideoMetaBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer)
    type AttrTransferTypeConstraint VideoMetaBufferFieldInfo = (~)(Ptr Gst.Buffer.Buffer)
    type AttrTransferType VideoMetaBufferFieldInfo = (Ptr Gst.Buffer.Buffer)
    type AttrGetType VideoMetaBufferFieldInfo = Maybe Gst.Buffer.Buffer
    type AttrLabel VideoMetaBufferFieldInfo = "buffer"
    type AttrOrigin VideoMetaBufferFieldInfo = VideoMeta
    attrGet = getVideoMetaBuffer
    attrSet = setVideoMetaBuffer
    attrConstruct = undefined
    attrClear = clearVideoMetaBuffer
    attrTransfer _ v = do
        return v

videoMeta_buffer :: AttrLabelProxy "buffer"
videoMeta_buffer = AttrLabelProxy

#endif


-- | Get the value of the “@flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoMeta #flags
-- @
getVideoMetaFlags :: MonadIO m => VideoMeta -> m [GstVideo.Flags.VideoFrameFlags]
getVideoMetaFlags :: VideoMeta -> m [VideoFrameFlags]
getVideoMetaFlags s :: VideoMeta
s = IO [VideoFrameFlags] -> m [VideoFrameFlags]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [VideoFrameFlags] -> m [VideoFrameFlags])
-> IO [VideoFrameFlags] -> m [VideoFrameFlags]
forall a b. (a -> b) -> a -> b
$ VideoMeta
-> (Ptr VideoMeta -> IO [VideoFrameFlags]) -> IO [VideoFrameFlags]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO [VideoFrameFlags]) -> IO [VideoFrameFlags])
-> (Ptr VideoMeta -> IO [VideoFrameFlags]) -> IO [VideoFrameFlags]
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) :: IO CUInt
    let val' :: [VideoFrameFlags]
val' = CUInt -> [VideoFrameFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
    [VideoFrameFlags] -> IO [VideoFrameFlags]
forall (m :: * -> *) a. Monad m => a -> m a
return [VideoFrameFlags]
val'

-- | Set the value of the “@flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoMeta [ #flags 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoMetaFlags :: MonadIO m => VideoMeta -> [GstVideo.Flags.VideoFrameFlags] -> m ()
setVideoMetaFlags :: VideoMeta -> [VideoFrameFlags] -> m ()
setVideoMetaFlags s :: VideoMeta
s val :: [VideoFrameFlags]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    let val' :: CUInt
val' = [VideoFrameFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [VideoFrameFlags]
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data VideoMetaFlagsFieldInfo
instance AttrInfo VideoMetaFlagsFieldInfo where
    type AttrBaseTypeConstraint VideoMetaFlagsFieldInfo = (~) VideoMeta
    type AttrAllowedOps VideoMetaFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoMetaFlagsFieldInfo = (~) [GstVideo.Flags.VideoFrameFlags]
    type AttrTransferTypeConstraint VideoMetaFlagsFieldInfo = (~)[GstVideo.Flags.VideoFrameFlags]
    type AttrTransferType VideoMetaFlagsFieldInfo = [GstVideo.Flags.VideoFrameFlags]
    type AttrGetType VideoMetaFlagsFieldInfo = [GstVideo.Flags.VideoFrameFlags]
    type AttrLabel VideoMetaFlagsFieldInfo = "flags"
    type AttrOrigin VideoMetaFlagsFieldInfo = VideoMeta
    attrGet = getVideoMetaFlags
    attrSet = setVideoMetaFlags
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoMeta_flags :: AttrLabelProxy "flags"
videoMeta_flags = AttrLabelProxy

#endif


-- | Get the value of the “@format@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoMeta #format
-- @
getVideoMetaFormat :: MonadIO m => VideoMeta -> m GstVideo.Enums.VideoFormat
getVideoMetaFormat :: VideoMeta -> m VideoFormat
getVideoMetaFormat s :: VideoMeta
s = IO VideoFormat -> m VideoFormat
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoFormat -> m VideoFormat)
-> IO VideoFormat -> m VideoFormat
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO VideoFormat) -> IO VideoFormat
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO VideoFormat) -> IO VideoFormat)
-> (Ptr VideoMeta -> IO VideoFormat) -> IO VideoFormat
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 28) :: IO CUInt
    let val' :: VideoFormat
val' = (Int -> VideoFormat
forall a. Enum a => Int -> a
toEnum (Int -> VideoFormat) -> (CUInt -> Int) -> CUInt -> VideoFormat
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    VideoFormat -> IO VideoFormat
forall (m :: * -> *) a. Monad m => a -> m a
return VideoFormat
val'

-- | Set the value of the “@format@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoMeta [ #format 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoMetaFormat :: MonadIO m => VideoMeta -> GstVideo.Enums.VideoFormat -> m ()
setVideoMetaFormat :: VideoMeta -> VideoFormat -> m ()
setVideoMetaFormat s :: VideoMeta
s val :: VideoFormat
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (VideoFormat -> Int) -> VideoFormat -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VideoFormat -> Int
forall a. Enum a => a -> Int
fromEnum) VideoFormat
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 28) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data VideoMetaFormatFieldInfo
instance AttrInfo VideoMetaFormatFieldInfo where
    type AttrBaseTypeConstraint VideoMetaFormatFieldInfo = (~) VideoMeta
    type AttrAllowedOps VideoMetaFormatFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoMetaFormatFieldInfo = (~) GstVideo.Enums.VideoFormat
    type AttrTransferTypeConstraint VideoMetaFormatFieldInfo = (~)GstVideo.Enums.VideoFormat
    type AttrTransferType VideoMetaFormatFieldInfo = GstVideo.Enums.VideoFormat
    type AttrGetType VideoMetaFormatFieldInfo = GstVideo.Enums.VideoFormat
    type AttrLabel VideoMetaFormatFieldInfo = "format"
    type AttrOrigin VideoMetaFormatFieldInfo = VideoMeta
    attrGet = getVideoMetaFormat
    attrSet = setVideoMetaFormat
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoMeta_format :: AttrLabelProxy "format"
videoMeta_format = AttrLabelProxy

#endif


-- | Get the value of the “@id@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoMeta #id
-- @
getVideoMetaId :: MonadIO m => VideoMeta -> m Int32
getVideoMetaId :: VideoMeta -> m Int32
getVideoMetaId s :: VideoMeta
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO Int32) -> IO Int32)
-> (Ptr VideoMeta -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

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

#if defined(ENABLE_OVERLOADING)
data VideoMetaIdFieldInfo
instance AttrInfo VideoMetaIdFieldInfo where
    type AttrBaseTypeConstraint VideoMetaIdFieldInfo = (~) VideoMeta
    type AttrAllowedOps VideoMetaIdFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoMetaIdFieldInfo = (~) Int32
    type AttrTransferTypeConstraint VideoMetaIdFieldInfo = (~)Int32
    type AttrTransferType VideoMetaIdFieldInfo = Int32
    type AttrGetType VideoMetaIdFieldInfo = Int32
    type AttrLabel VideoMetaIdFieldInfo = "id"
    type AttrOrigin VideoMetaIdFieldInfo = VideoMeta
    attrGet = getVideoMetaId
    attrSet = setVideoMetaId
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoMeta_id :: AttrLabelProxy "id"
videoMeta_id = AttrLabelProxy

#endif


-- | Get the value of the “@width@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoMeta #width
-- @
getVideoMetaWidth :: MonadIO m => VideoMeta -> m Word32
getVideoMetaWidth :: VideoMeta -> m Word32
getVideoMetaWidth s :: VideoMeta
s = IO Word32 -> m Word32
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
$ VideoMeta -> (Ptr VideoMeta -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO Word32) -> IO Word32)
-> (Ptr VideoMeta -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 36) :: IO Word32
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

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

#if defined(ENABLE_OVERLOADING)
data VideoMetaWidthFieldInfo
instance AttrInfo VideoMetaWidthFieldInfo where
    type AttrBaseTypeConstraint VideoMetaWidthFieldInfo = (~) VideoMeta
    type AttrAllowedOps VideoMetaWidthFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoMetaWidthFieldInfo = (~) Word32
    type AttrTransferTypeConstraint VideoMetaWidthFieldInfo = (~)Word32
    type AttrTransferType VideoMetaWidthFieldInfo = Word32
    type AttrGetType VideoMetaWidthFieldInfo = Word32
    type AttrLabel VideoMetaWidthFieldInfo = "width"
    type AttrOrigin VideoMetaWidthFieldInfo = VideoMeta
    attrGet = getVideoMetaWidth
    attrSet = setVideoMetaWidth
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoMeta_width :: AttrLabelProxy "width"
videoMeta_width = AttrLabelProxy

#endif


-- | Get the value of the “@height@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoMeta #height
-- @
getVideoMetaHeight :: MonadIO m => VideoMeta -> m Word32
getVideoMetaHeight :: VideoMeta -> m Word32
getVideoMetaHeight s :: VideoMeta
s = IO Word32 -> m Word32
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
$ VideoMeta -> (Ptr VideoMeta -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO Word32) -> IO Word32)
-> (Ptr VideoMeta -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) :: IO Word32
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

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

#if defined(ENABLE_OVERLOADING)
data VideoMetaHeightFieldInfo
instance AttrInfo VideoMetaHeightFieldInfo where
    type AttrBaseTypeConstraint VideoMetaHeightFieldInfo = (~) VideoMeta
    type AttrAllowedOps VideoMetaHeightFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoMetaHeightFieldInfo = (~) Word32
    type AttrTransferTypeConstraint VideoMetaHeightFieldInfo = (~)Word32
    type AttrTransferType VideoMetaHeightFieldInfo = Word32
    type AttrGetType VideoMetaHeightFieldInfo = Word32
    type AttrLabel VideoMetaHeightFieldInfo = "height"
    type AttrOrigin VideoMetaHeightFieldInfo = VideoMeta
    attrGet = getVideoMetaHeight
    attrSet = setVideoMetaHeight
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoMeta_height :: AttrLabelProxy "height"
videoMeta_height = AttrLabelProxy

#endif


-- | Get the value of the “@n_planes@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoMeta #nPlanes
-- @
getVideoMetaNPlanes :: MonadIO m => VideoMeta -> m Word32
getVideoMetaNPlanes :: VideoMeta -> m Word32
getVideoMetaNPlanes s :: VideoMeta
s = IO Word32 -> m Word32
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
$ VideoMeta -> (Ptr VideoMeta -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO Word32) -> IO Word32)
-> (Ptr VideoMeta -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 44) :: IO Word32
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

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

#if defined(ENABLE_OVERLOADING)
data VideoMetaNPlanesFieldInfo
instance AttrInfo VideoMetaNPlanesFieldInfo where
    type AttrBaseTypeConstraint VideoMetaNPlanesFieldInfo = (~) VideoMeta
    type AttrAllowedOps VideoMetaNPlanesFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoMetaNPlanesFieldInfo = (~) Word32
    type AttrTransferTypeConstraint VideoMetaNPlanesFieldInfo = (~)Word32
    type AttrTransferType VideoMetaNPlanesFieldInfo = Word32
    type AttrGetType VideoMetaNPlanesFieldInfo = Word32
    type AttrLabel VideoMetaNPlanesFieldInfo = "n_planes"
    type AttrOrigin VideoMetaNPlanesFieldInfo = VideoMeta
    attrGet = getVideoMetaNPlanes
    attrSet = setVideoMetaNPlanes
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

videoMeta_nPlanes :: AttrLabelProxy "nPlanes"
videoMeta_nPlanes = AttrLabelProxy

#endif


-- XXX Skipped attribute for "VideoMeta:offset" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt64)"
-- XXX Skipped attribute for "VideoMeta:stride" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TInt)"
-- | Get the value of the “@map@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoMeta #map
-- @
getVideoMetaMap :: MonadIO m => VideoMeta -> m (Maybe GstVideo.Callbacks.VideoMetaMapFieldCallback)
getVideoMetaMap :: VideoMeta -> m (Maybe VideoMetaMapFieldCallback)
getVideoMetaMap s :: VideoMeta
s = IO (Maybe VideoMetaMapFieldCallback)
-> m (Maybe VideoMetaMapFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VideoMetaMapFieldCallback)
 -> m (Maybe VideoMetaMapFieldCallback))
-> IO (Maybe VideoMetaMapFieldCallback)
-> m (Maybe VideoMetaMapFieldCallback)
forall a b. (a -> b) -> a -> b
$ VideoMeta
-> (Ptr VideoMeta -> IO (Maybe VideoMetaMapFieldCallback))
-> IO (Maybe VideoMetaMapFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO (Maybe VideoMetaMapFieldCallback))
 -> IO (Maybe VideoMetaMapFieldCallback))
-> (Ptr VideoMeta -> IO (Maybe VideoMetaMapFieldCallback))
-> IO (Maybe VideoMetaMapFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    FunPtr C_VideoMetaMapFieldCallback
val <- Ptr (FunPtr C_VideoMetaMapFieldCallback)
-> IO (FunPtr C_VideoMetaMapFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (FunPtr C_VideoMetaMapFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 96) :: IO (FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback)
    Maybe VideoMetaMapFieldCallback
result <- FunPtr C_VideoMetaMapFieldCallback
-> (FunPtr C_VideoMetaMapFieldCallback
    -> IO VideoMetaMapFieldCallback)
-> IO (Maybe VideoMetaMapFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_VideoMetaMapFieldCallback
val ((FunPtr C_VideoMetaMapFieldCallback
  -> IO VideoMetaMapFieldCallback)
 -> IO (Maybe VideoMetaMapFieldCallback))
-> (FunPtr C_VideoMetaMapFieldCallback
    -> IO VideoMetaMapFieldCallback)
-> IO (Maybe VideoMetaMapFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_VideoMetaMapFieldCallback
val' -> do
        let val'' :: VideoMetaMapFieldCallback
val'' = FunPtr C_VideoMetaMapFieldCallback -> VideoMetaMapFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_VideoMetaMapFieldCallback
-> VideoMeta
-> Word32
-> MapInfo
-> Ptr ()
-> Int32
-> [MapFlags]
-> m Bool
GstVideo.Callbacks.dynamic_VideoMetaMapFieldCallback FunPtr C_VideoMetaMapFieldCallback
val'
        VideoMetaMapFieldCallback -> IO VideoMetaMapFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return VideoMetaMapFieldCallback
val''
    Maybe VideoMetaMapFieldCallback
-> IO (Maybe VideoMetaMapFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoMetaMapFieldCallback
result

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

-- | Set the value of the “@map@” 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' #map
-- @
clearVideoMetaMap :: MonadIO m => VideoMeta -> m ()
clearVideoMetaMap :: VideoMeta -> m ()
clearVideoMetaMap s :: VideoMeta
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    Ptr (FunPtr C_VideoMetaMapFieldCallback)
-> FunPtr C_VideoMetaMapFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (FunPtr C_VideoMetaMapFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 96) (FunPtr C_VideoMetaMapFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback)

#if defined(ENABLE_OVERLOADING)
data VideoMetaMapFieldInfo
instance AttrInfo VideoMetaMapFieldInfo where
    type AttrBaseTypeConstraint VideoMetaMapFieldInfo = (~) VideoMeta
    type AttrAllowedOps VideoMetaMapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint VideoMetaMapFieldInfo = (~) (FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback)
    type AttrTransferTypeConstraint VideoMetaMapFieldInfo = (~)GstVideo.Callbacks.VideoMetaMapFieldCallback
    type AttrTransferType VideoMetaMapFieldInfo = (FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback)
    type AttrGetType VideoMetaMapFieldInfo = Maybe GstVideo.Callbacks.VideoMetaMapFieldCallback
    type AttrLabel VideoMetaMapFieldInfo = "map"
    type AttrOrigin VideoMetaMapFieldInfo = VideoMeta
    attrGet = getVideoMetaMap
    attrSet = setVideoMetaMap
    attrConstruct = undefined
    attrClear = clearVideoMetaMap
    attrTransfer _ v = do
        GstVideo.Callbacks.mk_VideoMetaMapFieldCallback (GstVideo.Callbacks.wrap_VideoMetaMapFieldCallback Nothing v)

videoMeta_map :: AttrLabelProxy "map"
videoMeta_map = AttrLabelProxy

#endif


-- | Get the value of the “@unmap@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoMeta #unmap
-- @
getVideoMetaUnmap :: MonadIO m => VideoMeta -> m (Maybe GstVideo.Callbacks.VideoMetaUnmapFieldCallback)
getVideoMetaUnmap :: VideoMeta -> m (Maybe VideoMetaUnmapFieldCallback)
getVideoMetaUnmap s :: VideoMeta
s = IO (Maybe VideoMetaUnmapFieldCallback)
-> m (Maybe VideoMetaUnmapFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VideoMetaUnmapFieldCallback)
 -> m (Maybe VideoMetaUnmapFieldCallback))
-> IO (Maybe VideoMetaUnmapFieldCallback)
-> m (Maybe VideoMetaUnmapFieldCallback)
forall a b. (a -> b) -> a -> b
$ VideoMeta
-> (Ptr VideoMeta -> IO (Maybe VideoMetaUnmapFieldCallback))
-> IO (Maybe VideoMetaUnmapFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO (Maybe VideoMetaUnmapFieldCallback))
 -> IO (Maybe VideoMetaUnmapFieldCallback))
-> (Ptr VideoMeta -> IO (Maybe VideoMetaUnmapFieldCallback))
-> IO (Maybe VideoMetaUnmapFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    FunPtr C_VideoMetaUnmapFieldCallback
val <- Ptr (FunPtr C_VideoMetaUnmapFieldCallback)
-> IO (FunPtr C_VideoMetaUnmapFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (FunPtr C_VideoMetaUnmapFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 104) :: IO (FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback)
    Maybe VideoMetaUnmapFieldCallback
result <- FunPtr C_VideoMetaUnmapFieldCallback
-> (FunPtr C_VideoMetaUnmapFieldCallback
    -> IO VideoMetaUnmapFieldCallback)
-> IO (Maybe VideoMetaUnmapFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_VideoMetaUnmapFieldCallback
val ((FunPtr C_VideoMetaUnmapFieldCallback
  -> IO VideoMetaUnmapFieldCallback)
 -> IO (Maybe VideoMetaUnmapFieldCallback))
-> (FunPtr C_VideoMetaUnmapFieldCallback
    -> IO VideoMetaUnmapFieldCallback)
-> IO (Maybe VideoMetaUnmapFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_VideoMetaUnmapFieldCallback
val' -> do
        let val'' :: VideoMetaUnmapFieldCallback
val'' = FunPtr C_VideoMetaUnmapFieldCallback -> VideoMetaUnmapFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_VideoMetaUnmapFieldCallback
-> VideoMeta -> Word32 -> MapInfo -> m Bool
GstVideo.Callbacks.dynamic_VideoMetaUnmapFieldCallback FunPtr C_VideoMetaUnmapFieldCallback
val'
        VideoMetaUnmapFieldCallback -> IO VideoMetaUnmapFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return VideoMetaUnmapFieldCallback
val''
    Maybe VideoMetaUnmapFieldCallback
-> IO (Maybe VideoMetaUnmapFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoMetaUnmapFieldCallback
result

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

-- | Set the value of the “@unmap@” 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' #unmap
-- @
clearVideoMetaUnmap :: MonadIO m => VideoMeta -> m ()
clearVideoMetaUnmap :: VideoMeta -> m ()
clearVideoMetaUnmap s :: VideoMeta
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr VideoMeta
ptr -> do
    Ptr (FunPtr C_VideoMetaUnmapFieldCallback)
-> FunPtr C_VideoMetaUnmapFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (FunPtr C_VideoMetaUnmapFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 104) (FunPtr C_VideoMetaUnmapFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback)

#if defined(ENABLE_OVERLOADING)
data VideoMetaUnmapFieldInfo
instance AttrInfo VideoMetaUnmapFieldInfo where
    type AttrBaseTypeConstraint VideoMetaUnmapFieldInfo = (~) VideoMeta
    type AttrAllowedOps VideoMetaUnmapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint VideoMetaUnmapFieldInfo = (~) (FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback)
    type AttrTransferTypeConstraint VideoMetaUnmapFieldInfo = (~)GstVideo.Callbacks.VideoMetaUnmapFieldCallback
    type AttrTransferType VideoMetaUnmapFieldInfo = (FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback)
    type AttrGetType VideoMetaUnmapFieldInfo = Maybe GstVideo.Callbacks.VideoMetaUnmapFieldCallback
    type AttrLabel VideoMetaUnmapFieldInfo = "unmap"
    type AttrOrigin VideoMetaUnmapFieldInfo = VideoMeta
    attrGet = getVideoMetaUnmap
    attrSet = setVideoMetaUnmap
    attrConstruct = undefined
    attrClear = clearVideoMetaUnmap
    attrTransfer _ v = do
        GstVideo.Callbacks.mk_VideoMetaUnmapFieldCallback (GstVideo.Callbacks.wrap_VideoMetaUnmapFieldCallback Nothing v)

videoMeta_unmap :: AttrLabelProxy "unmap"
videoMeta_unmap = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoMeta
type instance O.AttributeList VideoMeta = VideoMetaAttributeList
type VideoMetaAttributeList = ('[ '("meta", VideoMetaMetaFieldInfo), '("buffer", VideoMetaBufferFieldInfo), '("flags", VideoMetaFlagsFieldInfo), '("format", VideoMetaFormatFieldInfo), '("id", VideoMetaIdFieldInfo), '("width", VideoMetaWidthFieldInfo), '("height", VideoMetaHeightFieldInfo), '("nPlanes", VideoMetaNPlanesFieldInfo), '("map", VideoMetaMapFieldInfo), '("unmap", VideoMetaUnmapFieldInfo)] :: [(Symbol, *)])
#endif

-- method VideoMeta::map
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "meta"
--           , argType =
--               TInterface Name { namespace = "GstVideo" , name = "VideoMeta" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoMeta" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "plane"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a plane" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "MapInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstMapInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data of @plane" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "stride"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the stride of @plane"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "MapFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "@GstMapFlags" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_meta_map" gst_video_meta_map :: 
    Ptr VideoMeta ->                        -- meta : TInterface (Name {namespace = "GstVideo", name = "VideoMeta"})
    Word32 ->                               -- plane : TBasicType TUInt
    Ptr Gst.MapInfo.MapInfo ->              -- info : TInterface (Name {namespace = "Gst", name = "MapInfo"})
    Ptr (Ptr ()) ->                         -- data : TBasicType TPtr
    Ptr Int32 ->                            -- stride : TBasicType TInt
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gst", name = "MapFlags"})
    IO CInt

-- | Map the video plane with index /@plane@/ in /@meta@/ and return a pointer to the
-- first byte of the plane and the stride of the plane.
videoMetaMap ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoMeta
    -- ^ /@meta@/: a t'GI.GstVideo.Structs.VideoMeta.VideoMeta'
    -> Word32
    -- ^ /@plane@/: a plane
    -> Gst.MapInfo.MapInfo
    -- ^ /@info@/: a t'GI.Gst.Structs.MapInfo.MapInfo'
    -> [Gst.Flags.MapFlags]
    -- ^ /@flags@/: /@gstMapFlags@/
    -> m ((Bool, Ptr (), Int32))
    -- ^ __Returns:__ TRUE if the map operation was successful.
videoMetaMap :: VideoMeta
-> Word32 -> MapInfo -> [MapFlags] -> m (Bool, Ptr (), Int32)
videoMetaMap meta :: VideoMeta
meta plane :: Word32
plane info :: MapInfo
info flags :: [MapFlags]
flags = IO (Bool, Ptr (), Int32) -> m (Bool, Ptr (), Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Ptr (), Int32) -> m (Bool, Ptr (), Int32))
-> IO (Bool, Ptr (), Int32) -> m (Bool, Ptr (), Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoMeta
meta' <- VideoMeta -> IO (Ptr VideoMeta)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoMeta
meta
    Ptr MapInfo
info' <- MapInfo -> IO (Ptr MapInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MapInfo
info
    Ptr (Ptr ())
data_ <- IO (Ptr (Ptr ()))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr ()))
    Ptr Int32
stride <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    let flags' :: CUInt
flags' = [MapFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MapFlags]
flags
    CInt
result <- Ptr VideoMeta
-> Word32
-> Ptr MapInfo
-> Ptr (Ptr ())
-> Ptr Int32
-> CUInt
-> IO CInt
gst_video_meta_map Ptr VideoMeta
meta' Word32
plane Ptr MapInfo
info' Ptr (Ptr ())
data_ Ptr Int32
stride CUInt
flags'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    Ptr ()
data_' <- Ptr (Ptr ()) -> IO (Ptr ())
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr ())
data_
    Int32
stride' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
stride
    VideoMeta -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoMeta
meta
    MapInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MapInfo
info
    Ptr (Ptr ()) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr ())
data_
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
stride
    (Bool, Ptr (), Int32) -> IO (Bool, Ptr (), Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Ptr ()
data_', Int32
stride')

#if defined(ENABLE_OVERLOADING)
data VideoMetaMapMethodInfo
instance (signature ~ (Word32 -> Gst.MapInfo.MapInfo -> [Gst.Flags.MapFlags] -> m ((Bool, Ptr (), Int32))), MonadIO m) => O.MethodInfo VideoMetaMapMethodInfo VideoMeta signature where
    overloadedMethod = videoMetaMap

#endif

-- method VideoMeta::unmap
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "meta"
--           , argType =
--               TInterface Name { namespace = "GstVideo" , name = "VideoMeta" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoMeta" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "plane"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a plane" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "MapInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstMapInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_meta_unmap" gst_video_meta_unmap :: 
    Ptr VideoMeta ->                        -- meta : TInterface (Name {namespace = "GstVideo", name = "VideoMeta"})
    Word32 ->                               -- plane : TBasicType TUInt
    Ptr Gst.MapInfo.MapInfo ->              -- info : TInterface (Name {namespace = "Gst", name = "MapInfo"})
    IO CInt

-- | Unmap a previously mapped plane with 'GI.GstVideo.Structs.VideoMeta.videoMetaMap'.
videoMetaUnmap ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoMeta
    -- ^ /@meta@/: a t'GI.GstVideo.Structs.VideoMeta.VideoMeta'
    -> Word32
    -- ^ /@plane@/: a plane
    -> Gst.MapInfo.MapInfo
    -- ^ /@info@/: a t'GI.Gst.Structs.MapInfo.MapInfo'
    -> m Bool
    -- ^ __Returns:__ TRUE if the memory was successfully unmapped.
videoMetaUnmap :: VideoMeta -> Word32 -> MapInfo -> m Bool
videoMetaUnmap meta :: VideoMeta
meta plane :: Word32
plane info :: MapInfo
info = IO Bool -> m Bool
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 VideoMeta
meta' <- VideoMeta -> IO (Ptr VideoMeta)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoMeta
meta
    Ptr MapInfo
info' <- MapInfo -> IO (Ptr MapInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MapInfo
info
    CInt
result <- C_VideoMetaUnmapFieldCallback
gst_video_meta_unmap Ptr VideoMeta
meta' Word32
plane Ptr MapInfo
info'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    VideoMeta -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoMeta
meta
    MapInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MapInfo
info
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data VideoMetaUnmapMethodInfo
instance (signature ~ (Word32 -> Gst.MapInfo.MapInfo -> m Bool), MonadIO m) => O.MethodInfo VideoMetaUnmapMethodInfo VideoMeta signature where
    overloadedMethod = videoMetaUnmap

#endif

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

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

-- | /No description available in the introspection data./
videoMetaGetInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Gst.MetaInfo.MetaInfo
videoMetaGetInfo :: m MetaInfo
videoMetaGetInfo  = 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_meta_get_info
    Text -> Ptr MetaInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "videoMetaGetInfo" Ptr MetaInfo
result
    MetaInfo
result' <- ((ManagedPtr MetaInfo -> MetaInfo) -> Ptr MetaInfo -> IO MetaInfo
forall a.
(HasCallStack, WrappedPtr 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 ResolveVideoMetaMethod (t :: Symbol) (o :: *) :: * where
    ResolveVideoMetaMethod "map" o = VideoMetaMapMethodInfo
    ResolveVideoMetaMethod "unmap" o = VideoMetaUnmapMethodInfo
    ResolveVideoMetaMethod l o = O.MethodResolutionFailed l o

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

#endif