{-# 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
-- 
-- This meta can also be used by downstream elements to specifiy their
-- buffer layout requirements for upstream. Upstream should try to
-- fit those requirements, if possible, in order to prevent buffer copies.
-- 
-- This is done by passing a custom t'GI.Gst.Structs.Structure.Structure' to
-- 'GI.Gst.Structs.Query.queryAddAllocationMeta' when handling the ALLOCATION query.
-- This structure should be named \'video-meta\' and can have the following
-- fields:
-- 
-- * padding-top (uint): extra pixels on the top
-- * padding-bottom (uint): extra pixels on the bottom
-- * padding-left (uint): extra pixels on the left side
-- * padding-right (uint): extra pixels on the right side
-- 
-- The padding fields have the same semantic as t'GI.GstVideo.Structs.VideoMeta.VideoMeta'.@/alignment/@
-- and so represent the paddings requested on produced video buffers.

#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                        ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [map]("GI.GstVideo.Structs.VideoMeta#g:method:map"), [unmap]("GI.GstVideo.Structs.VideoMeta#g:method:unmap").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- [setAlignment]("GI.GstVideo.Structs.VideoMeta#g:method:setAlignment").

#if defined(ENABLE_OVERLOADING)
    ResolveVideoMetaMethod                  ,
#endif

-- ** getInfo #method:getInfo#

    videoMetaGetInfo                        ,


-- ** map #method:map#

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


-- ** setAlignment #method:setAlignment#

#if defined(ENABLE_OVERLOADING)
    VideoMetaSetAlignmentMethodInfo         ,
#endif
    videoMetaSetAlignment                   ,


-- ** unmap #method:unmap#

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




 -- * Properties


-- ** alignment #attr:alignment#
-- | the paddings and alignment constraints of the video buffer.
-- It is up to the caller of @gst_buffer_add_video_meta_full()@ to set it
-- using 'GI.GstVideo.Structs.VideoMeta.videoMetaSetAlignment', if they did not it defaults
-- to no padding and no alignment. Since: 1.18

    getVideoMetaAlignment                   ,
#if defined(ENABLE_OVERLOADING)
    videoMeta_alignment                     ,
#endif


-- ** 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.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.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 GHC.Records as R

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
import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoAlignment as GstVideo.VideoAlignment

-- | Memory-managed wrapper type.
newtype VideoMeta = VideoMeta (SP.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 SP.ManagedPtrNewtype VideoMeta where
    toManagedPtr :: VideoMeta -> ManagedPtr VideoMeta
toManagedPtr (VideoMeta ManagedPtr VideoMeta
p) = ManagedPtr VideoMeta
p

instance BoxedPtr VideoMeta where
    boxedPtrCopy :: VideoMeta -> IO VideoMeta
boxedPtrCopy = \VideoMeta
p -> VideoMeta -> (Ptr VideoMeta -> IO VideoMeta) -> IO VideoMeta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VideoMeta
p (Int -> Ptr VideoMeta -> IO (Ptr VideoMeta)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
144 (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, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr VideoMeta -> VideoMeta
VideoMeta)
    boxedPtrFree :: VideoMeta -> IO ()
boxedPtrFree = \VideoMeta
x -> VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr VideoMeta
x Ptr VideoMeta -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr VideoMeta where
    boxedPtrCalloc :: IO (Ptr VideoMeta)
boxedPtrCalloc = Int -> IO (Ptr VideoMeta)
forall a. Int -> IO (Ptr a)
callocBytes Int
144


-- | Construct a `VideoMeta` struct initialized to zero.
newZeroVideoMeta :: MonadIO m => m VideoMeta
newZeroVideoMeta :: forall (m :: * -> *). MonadIO m => 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. CallocPtr a => IO (Ptr a)
boxedPtrCalloc 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, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr VideoMeta -> VideoMeta
VideoMeta

instance tag ~ 'AttrSet => Constructible VideoMeta tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr VideoMeta -> VideoMeta)
-> [AttrOp VideoMeta tag] -> m VideoMeta
new ManagedPtr VideoMeta -> VideoMeta
_ [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


-- | 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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> m Meta
getVideoMetaMeta 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 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` 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 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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> m (Maybe Buffer)
getVideoMetaBuffer 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 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` 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 (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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> Ptr Buffer -> m ()
setVideoMetaBuffer VideoMeta
s 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 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` 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
-- @
clearVideoMetaBuffer :: MonadIO m => VideoMeta -> m ()
clearVideoMetaBuffer :: forall (m :: * -> *). MonadIO m => VideoMeta -> m ()
clearVideoMetaBuffer 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> m [VideoFrameFlags]
getVideoMetaFlags 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 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` Int
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 :: forall (m :: * -> *).
MonadIO m =>
VideoMeta -> [VideoFrameFlags] -> m ()
setVideoMetaFlags VideoMeta
s [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 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` Int
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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> m VideoFormat
getVideoMetaFormat 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> VideoFormat -> m ()
setVideoMetaFormat VideoMeta
s 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> m Int32
getVideoMetaId 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> Int32 -> m ()
setVideoMetaId VideoMeta
s 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> m Word32
getVideoMetaWidth 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> Word32 -> m ()
setVideoMetaWidth VideoMeta
s 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> m Word32
getVideoMetaHeight 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> Word32 -> m ()
setVideoMetaHeight VideoMeta
s 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> m Word32
getVideoMetaNPlanes 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> Word32 -> m ()
setVideoMetaNPlanes VideoMeta
s 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 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` Int
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 :: forall (m :: * -> *).
MonadIO m =>
VideoMeta -> m (Maybe VideoMetaMapFieldCallback)
getVideoMetaMap 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 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` Int
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
$ \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 :: forall (m :: * -> *).
MonadIO m =>
VideoMeta -> FunPtr C_VideoMetaMapFieldCallback -> m ()
setVideoMetaMap VideoMeta
s 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> m ()
clearVideoMetaMap 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 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` Int
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 :: forall (m :: * -> *).
MonadIO m =>
VideoMeta -> m (Maybe VideoMetaUnmapFieldCallback)
getVideoMetaUnmap 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 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` Int
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
$ \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 :: forall (m :: * -> *).
MonadIO m =>
VideoMeta -> FunPtr C_VideoMetaUnmapFieldCallback -> m ()
setVideoMetaUnmap VideoMeta
s 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 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` Int
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 :: forall (m :: * -> *). MonadIO m => VideoMeta -> m ()
clearVideoMetaUnmap 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 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` Int
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


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

#if defined(ENABLE_OVERLOADING)
data VideoMetaAlignmentFieldInfo
instance AttrInfo VideoMetaAlignmentFieldInfo where
    type AttrBaseTypeConstraint VideoMetaAlignmentFieldInfo = (~) VideoMeta
    type AttrAllowedOps VideoMetaAlignmentFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint VideoMetaAlignmentFieldInfo = (~) (Ptr GstVideo.VideoAlignment.VideoAlignment)
    type AttrTransferTypeConstraint VideoMetaAlignmentFieldInfo = (~)(Ptr GstVideo.VideoAlignment.VideoAlignment)
    type AttrTransferType VideoMetaAlignmentFieldInfo = (Ptr GstVideo.VideoAlignment.VideoAlignment)
    type AttrGetType VideoMetaAlignmentFieldInfo = GstVideo.VideoAlignment.VideoAlignment
    type AttrLabel VideoMetaAlignmentFieldInfo = "alignment"
    type AttrOrigin VideoMetaAlignmentFieldInfo = VideoMeta
    attrGet = getVideoMetaAlignment
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

videoMeta_alignment :: AttrLabelProxy "alignment"
videoMeta_alignment = 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), '("alignment", VideoMetaAlignmentFieldInfo)] :: [(Symbol, *)])
#endif

-- XXX Could not generate method VideoMeta::get_plane_height
-- Not implemented: Don't know how to allocate "plane_height" of type TCArray False 4 (-1) (TBasicType TUInt)
-- XXX Could not generate method VideoMeta::get_plane_size
-- Not implemented: Don't know how to allocate "plane_size" of type TCArray False 4 (-1) (TBasicType TUInt64)
-- 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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoMeta
-> Word32 -> MapInfo -> [MapFlags] -> m (Bool, Ptr (), Int32)
videoMetaMap VideoMeta
meta Word32
plane MapInfo
info [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)
callocMem :: 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
/= CInt
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.OverloadedMethod VideoMetaMapMethodInfo VideoMeta signature where
    overloadedMethod = videoMetaMap

instance O.OverloadedMethodInfo VideoMetaMapMethodInfo VideoMeta where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GstVideo.Structs.VideoMeta.videoMetaMap",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.24/docs/GI-GstVideo-Structs-VideoMeta.html#v:videoMetaMap"
        }


#endif

-- method VideoMeta::set_alignment
-- 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 = "alignment"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoAlignment" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoAlignment"
--                 , 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_set_alignment" gst_video_meta_set_alignment :: 
    Ptr VideoMeta ->                        -- meta : TInterface (Name {namespace = "GstVideo", name = "VideoMeta"})
    Ptr GstVideo.VideoAlignment.VideoAlignment -> -- alignment : TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"})
    IO CInt

-- | Set the alignment of /@meta@/ to /@alignment@/. This function checks that
-- the paddings defined in /@alignment@/ are compatible with the strides
-- defined in /@meta@/ and will fail to update if they are not.
-- 
-- /Since: 1.18/
videoMetaSetAlignment ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoMeta
    -- ^ /@meta@/: a t'GI.GstVideo.Structs.VideoMeta.VideoMeta'
    -> GstVideo.VideoAlignment.VideoAlignment
    -- ^ /@alignment@/: a t'GI.GstVideo.Structs.VideoAlignment.VideoAlignment'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@alignment@/\'s meta has been updated, 'P.False' if not
videoMetaSetAlignment :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoMeta -> VideoAlignment -> m Bool
videoMetaSetAlignment VideoMeta
meta VideoAlignment
alignment = 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 VideoAlignment
alignment' <- VideoAlignment -> IO (Ptr VideoAlignment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoAlignment
alignment
    CInt
result <- Ptr VideoMeta -> Ptr VideoAlignment -> IO CInt
gst_video_meta_set_alignment Ptr VideoMeta
meta' Ptr VideoAlignment
alignment'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    VideoMeta -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoMeta
meta
    VideoAlignment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoAlignment
alignment
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data VideoMetaSetAlignmentMethodInfo
instance (signature ~ (GstVideo.VideoAlignment.VideoAlignment -> m Bool), MonadIO m) => O.OverloadedMethod VideoMetaSetAlignmentMethodInfo VideoMeta signature where
    overloadedMethod = videoMetaSetAlignment

instance O.OverloadedMethodInfo VideoMetaSetAlignmentMethodInfo VideoMeta where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GstVideo.Structs.VideoMeta.videoMetaSetAlignment",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.24/docs/GI-GstVideo-Structs-VideoMeta.html#v:videoMetaSetAlignment"
        }


#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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoMeta -> Word32 -> MapInfo -> m Bool
videoMetaUnmap VideoMeta
meta Word32
plane 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
/= CInt
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.OverloadedMethod VideoMetaUnmapMethodInfo VideoMeta signature where
    overloadedMethod = videoMetaUnmap

instance O.OverloadedMethodInfo VideoMetaUnmapMethodInfo VideoMeta where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.GstVideo.Structs.VideoMeta.videoMetaUnmap",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.24/docs/GI-GstVideo-Structs-VideoMeta.html#v: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 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => 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 Text
"videoMetaGetInfo" 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 ResolveVideoMetaMethod (t :: Symbol) (o :: *) :: * where
    ResolveVideoMetaMethod "map" o = VideoMetaMapMethodInfo
    ResolveVideoMetaMethod "unmap" o = VideoMetaUnmapMethodInfo
    ResolveVideoMetaMethod "setAlignment" o = VideoMetaSetAlignmentMethodInfo
    ResolveVideoMetaMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveVideoMetaMethod t VideoMeta, O.OverloadedMethod 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

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

#endif

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

#endif