{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Gst.Structs.Meta.Meta' for carrying SMPTE-291M Ancillary data. Note that all the ADF fields
--    (/@dID@/ to /@checksum@/) are 10bit values with parity\/non-parity high-bits set.
-- 
-- /Since: 1.24/

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

module GI.GstVideo.Structs.AncillaryMeta
    ( 

-- * Exported types
    AncillaryMeta(..)                       ,
    newZeroAncillaryMeta                    ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveAncillaryMetaMethod              ,
#endif

-- ** getInfo #method:getInfo#

    ancillaryMetaGetInfo                    ,




 -- * Properties


-- ** cNotYChannel #attr:cNotYChannel#
-- | Which channel (luminance or chrominance) the ancillary
--    data is located. 0 if content is SD or stored in the luminance channel
--    (default). 1 if HD and stored in the chrominance channel.

#if defined(ENABLE_OVERLOADING)
    ancillaryMeta_cNotYChannel              ,
#endif
    getAncillaryMetaCNotYChannel            ,
    setAncillaryMetaCNotYChannel            ,


-- ** checksum #attr:checksum#
-- | The checksum of the ADF

#if defined(ENABLE_OVERLOADING)
    ancillaryMeta_checksum                  ,
#endif
    getAncillaryMetaChecksum                ,
    setAncillaryMetaChecksum                ,


-- ** dID #attr:dID#
-- | Data Identified

#if defined(ENABLE_OVERLOADING)
    ancillaryMeta_dID                       ,
#endif
    getAncillaryMetaDID                     ,
    setAncillaryMetaDID                     ,


-- ** data #attr:data#
-- | The User data

#if defined(ENABLE_OVERLOADING)
    ancillaryMeta_data                      ,
#endif
    getAncillaryMetaData                    ,
    setAncillaryMetaData                    ,


-- ** dataCount #attr:dataCount#
-- | The amount of user data

#if defined(ENABLE_OVERLOADING)
    ancillaryMeta_dataCount                 ,
#endif
    getAncillaryMetaDataCount               ,
    setAncillaryMetaDataCount               ,


-- ** field #attr:field#
-- | The field where the ancillary data is located

#if defined(ENABLE_OVERLOADING)
    ancillaryMeta_field                     ,
#endif
    getAncillaryMetaField                   ,
    setAncillaryMetaField                   ,


-- ** line #attr:line#
-- | The line on which the ancillary data is located (max 11bit). There
--    are two special values: 0x7ff if no line is specified (default), 0x7fe
--    to specify the ancillary data is on any valid line before active video

#if defined(ENABLE_OVERLOADING)
    ancillaryMeta_line                      ,
#endif
    getAncillaryMetaLine                    ,
    setAncillaryMetaLine                    ,


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

#if defined(ENABLE_OVERLOADING)
    ancillaryMeta_meta                      ,
#endif
    getAncillaryMetaMeta                    ,


-- ** offset #attr:offset#
-- | The location of the ancillary data packet in a SDI raster relative
--    to the start of active video (max 12bits). A value of 0 means the ADF of
--    the ancillary packet starts immediately following SAV. There are 3
--    special values: 0xfff: No specified location (default), 0xffe: within
--    HANC data space, 0xffd: within the ancillary data space located between
--    SAV and EAV

#if defined(ENABLE_OVERLOADING)
    ancillaryMeta_offset                    ,
#endif
    getAncillaryMetaOffset                  ,
    setAncillaryMetaOffset                  ,


-- ** sDIDBlockNumber #attr:sDIDBlockNumber#
-- | Secondary Data identification (if type 2) or Data block
--    number (if type 1)

#if defined(ENABLE_OVERLOADING)
    ancillaryMeta_sDIDBlockNumber           ,
#endif
    getAncillaryMetaSDIDBlockNumber         ,
    setAncillaryMetaSDIDBlockNumber         ,




    ) 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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
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

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

#endif

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

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

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


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

instance tag ~ 'AttrSet => Constructible AncillaryMeta tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr AncillaryMeta -> AncillaryMeta)
-> [AttrOp AncillaryMeta tag] -> m AncillaryMeta
new ManagedPtr AncillaryMeta -> AncillaryMeta
_ [AttrOp AncillaryMeta tag]
attrs = do
        AncillaryMeta
o <- m AncillaryMeta
forall (m :: * -> *). MonadIO m => m AncillaryMeta
newZeroAncillaryMeta
        AncillaryMeta -> [AttrOp AncillaryMeta 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set AncillaryMeta
o [AttrOp AncillaryMeta tag]
[AttrOp AncillaryMeta 'AttrSet]
attrs
        AncillaryMeta -> m AncillaryMeta
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return AncillaryMeta
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' ancillaryMeta #meta
-- @
getAncillaryMetaMeta :: MonadIO m => AncillaryMeta -> m Gst.Meta.Meta
getAncillaryMetaMeta :: forall (m :: * -> *). MonadIO m => AncillaryMeta -> m Meta
getAncillaryMetaMeta AncillaryMeta
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
$ AncillaryMeta -> (Ptr AncillaryMeta -> IO Meta) -> IO Meta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AncillaryMeta
s ((Ptr AncillaryMeta -> IO Meta) -> IO Meta)
-> (Ptr AncillaryMeta -> IO Meta) -> IO Meta
forall a b. (a -> b) -> a -> b
$ \Ptr AncillaryMeta
ptr -> do
    let val :: Ptr Meta
val = Ptr AncillaryMeta
ptr Ptr AncillaryMeta -> 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 AncillaryMetaMetaFieldInfo
instance AttrInfo AncillaryMetaMetaFieldInfo where
    type AttrBaseTypeConstraint AncillaryMetaMetaFieldInfo = (~) AncillaryMeta
    type AttrAllowedOps AncillaryMetaMetaFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint AncillaryMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta)
    type AttrTransferTypeConstraint AncillaryMetaMetaFieldInfo = (~)(Ptr Gst.Meta.Meta)
    type AttrTransferType AncillaryMetaMetaFieldInfo = (Ptr Gst.Meta.Meta)
    type AttrGetType AncillaryMetaMetaFieldInfo = Gst.Meta.Meta
    type AttrLabel AncillaryMetaMetaFieldInfo = "meta"
    type AttrOrigin AncillaryMetaMetaFieldInfo = AncillaryMeta
    attrGet = getAncillaryMetaMeta
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.AncillaryMeta.meta"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.29/docs/GI-GstVideo-Structs-AncillaryMeta.html#g:attr:meta"
        })

ancillaryMeta_meta :: AttrLabelProxy "meta"
ancillaryMeta_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' ancillaryMeta #field
-- @
getAncillaryMetaField :: MonadIO m => AncillaryMeta -> m GstVideo.Enums.AncillaryMetaField
getAncillaryMetaField :: forall (m :: * -> *).
MonadIO m =>
AncillaryMeta -> m AncillaryMetaField
getAncillaryMetaField AncillaryMeta
s = IO AncillaryMetaField -> m AncillaryMetaField
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AncillaryMetaField -> m AncillaryMetaField)
-> IO AncillaryMetaField -> m AncillaryMetaField
forall a b. (a -> b) -> a -> b
$ AncillaryMeta
-> (Ptr AncillaryMeta -> IO AncillaryMetaField)
-> IO AncillaryMetaField
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AncillaryMeta
s ((Ptr AncillaryMeta -> IO AncillaryMetaField)
 -> IO AncillaryMetaField)
-> (Ptr AncillaryMeta -> IO AncillaryMetaField)
-> IO AncillaryMetaField
forall a b. (a -> b) -> a -> b
$ \Ptr AncillaryMeta
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr AncillaryMeta
ptr Ptr AncillaryMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CUInt
    let val' :: AncillaryMetaField
val' = (Int -> AncillaryMetaField
forall a. Enum a => Int -> a
toEnum (Int -> AncillaryMetaField)
-> (CUInt -> Int) -> CUInt -> AncillaryMetaField
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    AncillaryMetaField -> IO AncillaryMetaField
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return AncillaryMetaField
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' ancillaryMeta [ #field 'Data.GI.Base.Attributes.:=' value ]
-- @
setAncillaryMetaField :: MonadIO m => AncillaryMeta -> GstVideo.Enums.AncillaryMetaField -> m ()
setAncillaryMetaField :: forall (m :: * -> *).
MonadIO m =>
AncillaryMeta -> AncillaryMetaField -> m ()
setAncillaryMetaField AncillaryMeta
s AncillaryMetaField
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
$ AncillaryMeta -> (Ptr AncillaryMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AncillaryMeta
s ((Ptr AncillaryMeta -> IO ()) -> IO ())
-> (Ptr AncillaryMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AncillaryMeta
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (AncillaryMetaField -> Int) -> AncillaryMetaField -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AncillaryMetaField -> Int
forall a. Enum a => a -> Int
fromEnum) AncillaryMetaField
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AncillaryMeta
ptr Ptr AncillaryMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CUInt
val' :: CUInt)

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

ancillaryMeta_field :: AttrLabelProxy "field"
ancillaryMeta_field = AttrLabelProxy

#endif


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

-- | Set the value of the “@c_not_y_channel@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' ancillaryMeta [ #cNotYChannel 'Data.GI.Base.Attributes.:=' value ]
-- @
setAncillaryMetaCNotYChannel :: MonadIO m => AncillaryMeta -> Bool -> m ()
setAncillaryMetaCNotYChannel :: forall (m :: * -> *). MonadIO m => AncillaryMeta -> Bool -> m ()
setAncillaryMetaCNotYChannel AncillaryMeta
s Bool
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
$ AncillaryMeta -> (Ptr AncillaryMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AncillaryMeta
s ((Ptr AncillaryMeta -> IO ()) -> IO ())
-> (Ptr AncillaryMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AncillaryMeta
ptr -> do
    let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
val
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AncillaryMeta
ptr Ptr AncillaryMeta -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (CInt
val' :: CInt)

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

ancillaryMeta_cNotYChannel :: AttrLabelProxy "cNotYChannel"
ancillaryMeta_cNotYChannel = AttrLabelProxy

#endif


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

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

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

ancillaryMeta_line :: AttrLabelProxy "line"
ancillaryMeta_line = AttrLabelProxy

#endif


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

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

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

ancillaryMeta_offset :: AttrLabelProxy "offset"
ancillaryMeta_offset = AttrLabelProxy

#endif


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

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

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

ancillaryMeta_dID :: AttrLabelProxy "dID"
ancillaryMeta_dID = AttrLabelProxy

#endif


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

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

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

ancillaryMeta_sDIDBlockNumber :: AttrLabelProxy "sDIDBlockNumber"
ancillaryMeta_sDIDBlockNumber = AttrLabelProxy

#endif


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

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

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

ancillaryMeta_dataCount :: AttrLabelProxy "dataCount"
ancillaryMeta_dataCount = AttrLabelProxy

#endif


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

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

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

ancillaryMeta_data :: AttrLabelProxy "data"
ancillaryMeta_data = AttrLabelProxy

#endif


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

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

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

ancillaryMeta_checksum :: AttrLabelProxy "checksum"
ancillaryMeta_checksum = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList AncillaryMeta
type instance O.AttributeList AncillaryMeta = AncillaryMetaAttributeList
type AncillaryMetaAttributeList = ('[ '("meta", AncillaryMetaMetaFieldInfo), '("field", AncillaryMetaFieldFieldInfo), '("cNotYChannel", AncillaryMetaCNotYChannelFieldInfo), '("line", AncillaryMetaLineFieldInfo), '("offset", AncillaryMetaOffsetFieldInfo), '("dID", AncillaryMetaDIDFieldInfo), '("sDIDBlockNumber", AncillaryMetaSDIDBlockNumberFieldInfo), '("dataCount", AncillaryMetaDataCountFieldInfo), '("data", AncillaryMetaDataFieldInfo), '("checksum", AncillaryMetaChecksumFieldInfo)] :: [(Symbol, DK.Type)])
#endif

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

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

-- | /No description available in the introspection data./
ancillaryMetaGetInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Gst.MetaInfo.MetaInfo
ancillaryMetaGetInfo :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m MetaInfo
ancillaryMetaGetInfo  = 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_ancillary_meta_get_info
    Text -> Ptr MetaInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"ancillaryMetaGetInfo" 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 ResolveAncillaryMetaMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveAncillaryMetaMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif