{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Active Format Description (AFD)
-- 
-- For details, see Table 6.14 Active Format in:
-- 
-- ATSC Digital Television Standard:
-- Part 4 – MPEG-2 Video System Characteristics
-- 
-- https:\/\/www.atsc.org\/wp-content\/uploads\/2015\/03\/a_53-Part-4-2009.pdf
-- 
-- and Active Format Description in Complete list of AFD codes
-- 
-- https:\/\/en.wikipedia.org\/wiki\/Active_Format_Description@/Complete_list_of_AFD_codes/@
-- 
-- and SMPTE ST2016-1
-- 
-- /Since: 1.18/

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

module GI.GstVideo.Structs.VideoAFDMeta
    ( 

-- * Exported types
    VideoAFDMeta(..)                        ,
    newZeroVideoAFDMeta                     ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveVideoAFDMetaMethod               ,
#endif

-- ** getInfo #method:getInfo#

    videoAFDMetaGetInfo                     ,




 -- * Properties


-- ** afd #attr:afd#
-- | t'GI.GstVideo.Enums.VideoAFDValue' AFD value

    getVideoAFDMetaAfd                      ,
    setVideoAFDMetaAfd                      ,
#if defined(ENABLE_OVERLOADING)
    videoAFDMeta_afd                        ,
#endif


-- ** field #attr:field#
-- | 0 for progressive or field 1 and 1 for field 2

    getVideoAFDMetaField                    ,
    setVideoAFDMetaField                    ,
#if defined(ENABLE_OVERLOADING)
    videoAFDMeta_field                      ,
#endif


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

    getVideoAFDMetaMeta                     ,
#if defined(ENABLE_OVERLOADING)
    videoAFDMeta_meta                       ,
#endif


-- ** spec #attr:spec#
-- | t'GI.GstVideo.Enums.VideoAFDSpec' that applies to /@afd@/

    getVideoAFDMetaSpec                     ,
    setVideoAFDMetaSpec                     ,
#if defined(ENABLE_OVERLOADING)
    videoAFDMeta_spec                       ,
#endif




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

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

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

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

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


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

instance tag ~ 'AttrSet => Constructible VideoAFDMeta tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr VideoAFDMeta -> VideoAFDMeta)
-> [AttrOp VideoAFDMeta tag] -> m VideoAFDMeta
new ManagedPtr VideoAFDMeta -> VideoAFDMeta
_ [AttrOp VideoAFDMeta tag]
attrs = do
        VideoAFDMeta
o <- m VideoAFDMeta
forall (m :: * -> *). MonadIO m => m VideoAFDMeta
newZeroVideoAFDMeta
        VideoAFDMeta -> [AttrOp VideoAFDMeta 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set VideoAFDMeta
o [AttrOp VideoAFDMeta tag]
[AttrOp VideoAFDMeta 'AttrSet]
attrs
        VideoAFDMeta -> m VideoAFDMeta
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoAFDMeta
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' videoAFDMeta #meta
-- @
getVideoAFDMetaMeta :: MonadIO m => VideoAFDMeta -> m Gst.Meta.Meta
getVideoAFDMetaMeta :: forall (m :: * -> *). MonadIO m => VideoAFDMeta -> m Meta
getVideoAFDMetaMeta VideoAFDMeta
s = IO Meta -> m Meta
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Meta -> m Meta) -> IO Meta -> m Meta
forall a b. (a -> b) -> a -> b
$ VideoAFDMeta -> (Ptr VideoAFDMeta -> IO Meta) -> IO Meta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoAFDMeta
s ((Ptr VideoAFDMeta -> IO Meta) -> IO Meta)
-> (Ptr VideoAFDMeta -> IO Meta) -> IO Meta
forall a b. (a -> b) -> a -> b
$ \Ptr VideoAFDMeta
ptr -> do
    let val :: Ptr Meta
val = Ptr VideoAFDMeta
ptr Ptr VideoAFDMeta -> Int -> Ptr Meta
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Gst.Meta.Meta)
    Meta
val' <- ((ManagedPtr Meta -> Meta) -> Ptr Meta -> IO Meta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Meta -> Meta
Gst.Meta.Meta) Ptr Meta
val
    Meta -> IO Meta
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Meta
val'

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

videoAFDMeta_meta :: AttrLabelProxy "meta"
videoAFDMeta_meta = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data VideoAFDMetaFieldFieldInfo
instance AttrInfo VideoAFDMetaFieldFieldInfo where
    type AttrBaseTypeConstraint VideoAFDMetaFieldFieldInfo = (~) VideoAFDMeta
    type AttrAllowedOps VideoAFDMetaFieldFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoAFDMetaFieldFieldInfo = (~) Word8
    type AttrTransferTypeConstraint VideoAFDMetaFieldFieldInfo = (~)Word8
    type AttrTransferType VideoAFDMetaFieldFieldInfo = Word8
    type AttrGetType VideoAFDMetaFieldFieldInfo = Word8
    type AttrLabel VideoAFDMetaFieldFieldInfo = "field"
    type AttrOrigin VideoAFDMetaFieldFieldInfo = VideoAFDMeta
    attrGet = getVideoAFDMetaField
    attrSet = setVideoAFDMetaField
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoAFDMeta.field"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoAFDMeta.html#g:attr:field"
        })

videoAFDMeta_field :: AttrLabelProxy "field"
videoAFDMeta_field = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data VideoAFDMetaSpecFieldInfo
instance AttrInfo VideoAFDMetaSpecFieldInfo where
    type AttrBaseTypeConstraint VideoAFDMetaSpecFieldInfo = (~) VideoAFDMeta
    type AttrAllowedOps VideoAFDMetaSpecFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoAFDMetaSpecFieldInfo = (~) GstVideo.Enums.VideoAFDSpec
    type AttrTransferTypeConstraint VideoAFDMetaSpecFieldInfo = (~)GstVideo.Enums.VideoAFDSpec
    type AttrTransferType VideoAFDMetaSpecFieldInfo = GstVideo.Enums.VideoAFDSpec
    type AttrGetType VideoAFDMetaSpecFieldInfo = GstVideo.Enums.VideoAFDSpec
    type AttrLabel VideoAFDMetaSpecFieldInfo = "spec"
    type AttrOrigin VideoAFDMetaSpecFieldInfo = VideoAFDMeta
    attrGet = getVideoAFDMetaSpec
    attrSet = setVideoAFDMetaSpec
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoAFDMeta.spec"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoAFDMeta.html#g:attr:spec"
        })

videoAFDMeta_spec :: AttrLabelProxy "spec"
videoAFDMeta_spec = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data VideoAFDMetaAfdFieldInfo
instance AttrInfo VideoAFDMetaAfdFieldInfo where
    type AttrBaseTypeConstraint VideoAFDMetaAfdFieldInfo = (~) VideoAFDMeta
    type AttrAllowedOps VideoAFDMetaAfdFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoAFDMetaAfdFieldInfo = (~) GstVideo.Enums.VideoAFDValue
    type AttrTransferTypeConstraint VideoAFDMetaAfdFieldInfo = (~)GstVideo.Enums.VideoAFDValue
    type AttrTransferType VideoAFDMetaAfdFieldInfo = GstVideo.Enums.VideoAFDValue
    type AttrGetType VideoAFDMetaAfdFieldInfo = GstVideo.Enums.VideoAFDValue
    type AttrLabel VideoAFDMetaAfdFieldInfo = "afd"
    type AttrOrigin VideoAFDMetaAfdFieldInfo = VideoAFDMeta
    attrGet = getVideoAFDMetaAfd
    attrSet = setVideoAFDMetaAfd
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoAFDMeta.afd"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoAFDMeta.html#g:attr:afd"
        })

videoAFDMeta_afd :: AttrLabelProxy "afd"
videoAFDMeta_afd = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoAFDMeta
type instance O.AttributeList VideoAFDMeta = VideoAFDMetaAttributeList
type VideoAFDMetaAttributeList = ('[ '("meta", VideoAFDMetaMetaFieldInfo), '("field", VideoAFDMetaFieldFieldInfo), '("spec", VideoAFDMetaSpecFieldInfo), '("afd", VideoAFDMetaAfdFieldInfo)] :: [(Symbol, DK.Type)])
#endif

-- method VideoAFDMeta::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_afd_meta_get_info" gst_video_afd_meta_get_info :: 
    IO (Ptr Gst.MetaInfo.MetaInfo)

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

#if defined(ENABLE_OVERLOADING)
#endif

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

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

#endif

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

#endif