{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Information describing a DMABuf image properties. It wraps t'GI.GstVideo.Structs.VideoInfo.VideoInfo' and
-- adds DRM information such as drm-fourcc and drm-modifier, required for
-- negotiation and mapping.
-- 
-- /Since: 1.24/

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

module GI.GstVideo.Structs.VideoInfoDmaDrm
    ( 

-- * Exported types
    VideoInfoDmaDrm(..)                     ,
    newZeroVideoInfoDmaDrm                  ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveVideoInfoDmaDrmMethod            ,
#endif

-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    VideoInfoDmaDrmFreeMethodInfo           ,
#endif
    videoInfoDmaDrmFree                     ,


-- ** fromCaps #method:fromCaps#

    videoInfoDmaDrmFromCaps                 ,


-- ** fromVideoInfo #method:fromVideoInfo#

    videoInfoDmaDrmFromVideoInfo            ,


-- ** init #method:init#

    videoInfoDmaDrmInit                     ,


-- ** new #method:new#

    videoInfoDmaDrmNew                      ,


-- ** newFromCaps #method:newFromCaps#

    videoInfoDmaDrmNewFromCaps              ,


-- ** toCaps #method:toCaps#

#if defined(ENABLE_OVERLOADING)
    VideoInfoDmaDrmToCapsMethodInfo         ,
#endif
    videoInfoDmaDrmToCaps                   ,


-- ** toVideoInfo #method:toVideoInfo#

#if defined(ENABLE_OVERLOADING)
    VideoInfoDmaDrmToVideoInfoMethodInfo    ,
#endif
    videoInfoDmaDrmToVideoInfo              ,




 -- * Properties


-- ** drmFourcc #attr:drmFourcc#
-- | the fourcc defined by drm

    getVideoInfoDmaDrmDrmFourcc             ,
    setVideoInfoDmaDrmDrmFourcc             ,
#if defined(ENABLE_OVERLOADING)
    videoInfoDmaDrm_drmFourcc               ,
#endif


-- ** drmModifier #attr:drmModifier#
-- | the drm modifier

    getVideoInfoDmaDrmDrmModifier           ,
    setVideoInfoDmaDrmDrmModifier           ,
#if defined(ENABLE_OVERLOADING)
    videoInfoDmaDrm_drmModifier             ,
#endif


-- ** vinfo #attr:vinfo#
-- | the associated t'GI.GstVideo.Structs.VideoInfo.VideoInfo'

    getVideoInfoDmaDrmVinfo                 ,
#if defined(ENABLE_OVERLOADING)
    videoInfoDmaDrm_vinfo                   ,
#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 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.Enums as Gst.Enums
import qualified GI.Gst.Structs.Caps as Gst.Caps
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
import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoColorimetry as GstVideo.VideoColorimetry
import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoFormatInfo as GstVideo.VideoFormatInfo
import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoInfo as GstVideo.VideoInfo

#else
import qualified GI.Gst.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoInfo as GstVideo.VideoInfo

#endif

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

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

foreign import ccall "gst_video_info_dma_drm_get_type" c_gst_video_info_dma_drm_get_type :: 
    IO GType

type instance O.ParentTypes VideoInfoDmaDrm = '[]
instance O.HasParentTypes VideoInfoDmaDrm

instance B.Types.TypedObject VideoInfoDmaDrm where
    glibType :: IO GType
glibType = IO GType
c_gst_video_info_dma_drm_get_type

instance B.Types.GBoxed VideoInfoDmaDrm

-- | Convert 'VideoInfoDmaDrm' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe VideoInfoDmaDrm) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_video_info_dma_drm_get_type
    gvalueSet_ :: Ptr GValue -> Maybe VideoInfoDmaDrm -> IO ()
gvalueSet_ Ptr GValue
gv Maybe VideoInfoDmaDrm
P.Nothing = Ptr GValue -> Ptr VideoInfoDmaDrm -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr VideoInfoDmaDrm
forall a. Ptr a
FP.nullPtr :: FP.Ptr VideoInfoDmaDrm)
    gvalueSet_ Ptr GValue
gv (P.Just VideoInfoDmaDrm
obj) = VideoInfoDmaDrm -> (Ptr VideoInfoDmaDrm -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VideoInfoDmaDrm
obj (Ptr GValue -> Ptr VideoInfoDmaDrm -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe VideoInfoDmaDrm)
gvalueGet_ Ptr GValue
gv = do
        Ptr VideoInfoDmaDrm
ptr <- Ptr GValue -> IO (Ptr VideoInfoDmaDrm)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr VideoInfoDmaDrm)
        if Ptr VideoInfoDmaDrm
ptr Ptr VideoInfoDmaDrm -> Ptr VideoInfoDmaDrm -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr VideoInfoDmaDrm
forall a. Ptr a
FP.nullPtr
        then VideoInfoDmaDrm -> Maybe VideoInfoDmaDrm
forall a. a -> Maybe a
P.Just (VideoInfoDmaDrm -> Maybe VideoInfoDmaDrm)
-> IO VideoInfoDmaDrm -> IO (Maybe VideoInfoDmaDrm)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm)
-> Ptr VideoInfoDmaDrm -> IO VideoInfoDmaDrm
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm
VideoInfoDmaDrm Ptr VideoInfoDmaDrm
ptr
        else Maybe VideoInfoDmaDrm -> IO (Maybe VideoInfoDmaDrm)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoInfoDmaDrm
forall a. Maybe a
P.Nothing
        
    

-- | Construct a `VideoInfoDmaDrm` struct initialized to zero.
newZeroVideoInfoDmaDrm :: MonadIO m => m VideoInfoDmaDrm
newZeroVideoInfoDmaDrm :: forall (m :: * -> *). MonadIO m => m VideoInfoDmaDrm
newZeroVideoInfoDmaDrm = IO VideoInfoDmaDrm -> m VideoInfoDmaDrm
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoInfoDmaDrm -> m VideoInfoDmaDrm)
-> IO VideoInfoDmaDrm -> m VideoInfoDmaDrm
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr VideoInfoDmaDrm)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
216 IO (Ptr VideoInfoDmaDrm)
-> (Ptr VideoInfoDmaDrm -> IO VideoInfoDmaDrm)
-> IO VideoInfoDmaDrm
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm)
-> Ptr VideoInfoDmaDrm -> IO VideoInfoDmaDrm
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm
VideoInfoDmaDrm

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


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

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

videoInfoDmaDrm_vinfo :: AttrLabelProxy "vinfo"
videoInfoDmaDrm_vinfo = AttrLabelProxy

#endif


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

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

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

videoInfoDmaDrm_drmFourcc :: AttrLabelProxy "drmFourcc"
videoInfoDmaDrm_drmFourcc = AttrLabelProxy

#endif


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

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

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

videoInfoDmaDrm_drmModifier :: AttrLabelProxy "drmModifier"
videoInfoDmaDrm_drmModifier = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoInfoDmaDrm
type instance O.AttributeList VideoInfoDmaDrm = VideoInfoDmaDrmAttributeList
type VideoInfoDmaDrmAttributeList = ('[ '("vinfo", VideoInfoDmaDrmVinfoFieldInfo), '("drmFourcc", VideoInfoDmaDrmDrmFourccFieldInfo), '("drmModifier", VideoInfoDmaDrmDrmModifierFieldInfo)] :: [(Symbol, DK.Type)])
#endif

-- method VideoInfoDmaDrm::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GstVideo" , name = "VideoInfoDmaDrm" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_info_dma_drm_new" gst_video_info_dma_drm_new :: 
    IO (Ptr VideoInfoDmaDrm)

-- | Allocate a new t'GI.GstVideo.Structs.VideoInfoDmaDrm.VideoInfoDmaDrm' that is also initialized with
-- 'GI.GstVideo.Functions.videoInfoDmaDrmInit'.
-- 
-- /Since: 1.24/
videoInfoDmaDrmNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m VideoInfoDmaDrm
    -- ^ __Returns:__ a new t'GI.GstVideo.Structs.VideoInfoDmaDrm.VideoInfoDmaDrm'.
    -- Free it with 'GI.GstVideo.Structs.VideoInfoDmaDrm.videoInfoDmaDrmFree'.
videoInfoDmaDrmNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m VideoInfoDmaDrm
videoInfoDmaDrmNew  = IO VideoInfoDmaDrm -> m VideoInfoDmaDrm
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoInfoDmaDrm -> m VideoInfoDmaDrm)
-> IO VideoInfoDmaDrm -> m VideoInfoDmaDrm
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoInfoDmaDrm
result <- IO (Ptr VideoInfoDmaDrm)
gst_video_info_dma_drm_new
    Text -> Ptr VideoInfoDmaDrm -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoInfoDmaDrmNew" Ptr VideoInfoDmaDrm
result
    VideoInfoDmaDrm
result' <- ((ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm)
-> Ptr VideoInfoDmaDrm -> IO VideoInfoDmaDrm
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm
VideoInfoDmaDrm) Ptr VideoInfoDmaDrm
result
    VideoInfoDmaDrm -> IO VideoInfoDmaDrm
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoInfoDmaDrm
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method VideoInfoDmaDrm::new_from_caps
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "caps"
--           , argType = TInterface Name { namespace = "Gst" , name = "Caps" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstCaps" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GstVideo" , name = "VideoInfoDmaDrm" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_info_dma_drm_new_from_caps" gst_video_info_dma_drm_new_from_caps :: 
    Ptr Gst.Caps.Caps ->                    -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
    IO (Ptr VideoInfoDmaDrm)

-- | Parse /@caps@/ to generate a t'GI.GstVideo.Structs.VideoInfoDmaDrm.VideoInfoDmaDrm'. Please note that the
-- /@caps@/ should be a dma drm caps. The 'GI.GstVideo.Functions.videoIsDmaDrmCaps' can
-- be used to verify it before calling this function.
-- 
-- /Since: 1.24/
videoInfoDmaDrmNewFromCaps ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gst.Caps.Caps
    -- ^ /@caps@/: a t'GI.Gst.Structs.Caps.Caps'
    -> m (Maybe VideoInfoDmaDrm)
    -- ^ __Returns:__ A t'GI.GstVideo.Structs.VideoInfoDmaDrm.VideoInfoDmaDrm',
    --   or 'P.Nothing' if /@caps@/ couldn\'t be parsed.
videoInfoDmaDrmNewFromCaps :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Caps -> m (Maybe VideoInfoDmaDrm)
videoInfoDmaDrmNewFromCaps Caps
caps = IO (Maybe VideoInfoDmaDrm) -> m (Maybe VideoInfoDmaDrm)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VideoInfoDmaDrm) -> m (Maybe VideoInfoDmaDrm))
-> IO (Maybe VideoInfoDmaDrm) -> m (Maybe VideoInfoDmaDrm)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Caps
caps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
    Ptr VideoInfoDmaDrm
result <- Ptr Caps -> IO (Ptr VideoInfoDmaDrm)
gst_video_info_dma_drm_new_from_caps Ptr Caps
caps'
    Maybe VideoInfoDmaDrm
maybeResult <- Ptr VideoInfoDmaDrm
-> (Ptr VideoInfoDmaDrm -> IO VideoInfoDmaDrm)
-> IO (Maybe VideoInfoDmaDrm)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr VideoInfoDmaDrm
result ((Ptr VideoInfoDmaDrm -> IO VideoInfoDmaDrm)
 -> IO (Maybe VideoInfoDmaDrm))
-> (Ptr VideoInfoDmaDrm -> IO VideoInfoDmaDrm)
-> IO (Maybe VideoInfoDmaDrm)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoInfoDmaDrm
result' -> do
        VideoInfoDmaDrm
result'' <- ((ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm)
-> Ptr VideoInfoDmaDrm -> IO VideoInfoDmaDrm
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm
VideoInfoDmaDrm) Ptr VideoInfoDmaDrm
result'
        VideoInfoDmaDrm -> IO VideoInfoDmaDrm
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoInfoDmaDrm
result''
    Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
    Maybe VideoInfoDmaDrm -> IO (Maybe VideoInfoDmaDrm)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoInfoDmaDrm
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

-- method VideoInfoDmaDrm::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "drm_info"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoInfoDmaDrm" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoInfoDmaDrm"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_info_dma_drm_free" gst_video_info_dma_drm_free :: 
    Ptr VideoInfoDmaDrm ->                  -- drm_info : TInterface (Name {namespace = "GstVideo", name = "VideoInfoDmaDrm"})
    IO ()

-- | Free a t'GI.GstVideo.Structs.VideoInfoDmaDrm.VideoInfoDmaDrm' structure previously allocated with
-- 'GI.GstVideo.Structs.VideoInfoDmaDrm.videoInfoDmaDrmNew'
-- 
-- /Since: 1.24/
videoInfoDmaDrmFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoInfoDmaDrm
    -- ^ /@drmInfo@/: a t'GI.GstVideo.Structs.VideoInfoDmaDrm.VideoInfoDmaDrm'
    -> m ()
videoInfoDmaDrmFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoInfoDmaDrm -> m ()
videoInfoDmaDrmFree VideoInfoDmaDrm
drmInfo = 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
$ do
    Ptr VideoInfoDmaDrm
drmInfo' <- VideoInfoDmaDrm -> IO (Ptr VideoInfoDmaDrm)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoInfoDmaDrm
drmInfo
    Ptr VideoInfoDmaDrm -> IO ()
gst_video_info_dma_drm_free Ptr VideoInfoDmaDrm
drmInfo'
    VideoInfoDmaDrm -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoInfoDmaDrm
drmInfo
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VideoInfoDmaDrmFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod VideoInfoDmaDrmFreeMethodInfo VideoInfoDmaDrm signature where
    overloadedMethod = videoInfoDmaDrmFree

instance O.OverloadedMethodInfo VideoInfoDmaDrmFreeMethodInfo VideoInfoDmaDrm where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoInfoDmaDrm.videoInfoDmaDrmFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.29/docs/GI-GstVideo-Structs-VideoInfoDmaDrm.html#v:videoInfoDmaDrmFree"
        })


#endif

-- method VideoInfoDmaDrm::to_caps
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "drm_info"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoInfoDmaDrm" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoInfoDmaDrm"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Caps" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_info_dma_drm_to_caps" gst_video_info_dma_drm_to_caps :: 
    Ptr VideoInfoDmaDrm ->                  -- drm_info : TInterface (Name {namespace = "GstVideo", name = "VideoInfoDmaDrm"})
    IO (Ptr Gst.Caps.Caps)

-- | Convert the values of /@drmInfo@/ into a t'GI.Gst.Structs.Caps.Caps'. Please note that the
-- /@caps@/ returned will be a dma drm caps which sets format field to DMA_DRM,
-- and contains a new drm-format field. The value of drm-format field is
-- composed of a drm fourcc and a modifier, such as NV12:0x0100000000000002.
-- 
-- /Since: 1.24/
videoInfoDmaDrmToCaps ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoInfoDmaDrm
    -- ^ /@drmInfo@/: a t'GI.GstVideo.Structs.VideoInfoDmaDrm.VideoInfoDmaDrm'
    -> m (Maybe Gst.Caps.Caps)
    -- ^ __Returns:__ a new t'GI.Gst.Structs.Caps.Caps' containing the
    -- info in /@drmInfo@/.
videoInfoDmaDrmToCaps :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoInfoDmaDrm -> m (Maybe Caps)
videoInfoDmaDrmToCaps VideoInfoDmaDrm
drmInfo = IO (Maybe Caps) -> m (Maybe Caps)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Caps) -> m (Maybe Caps))
-> IO (Maybe Caps) -> m (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoInfoDmaDrm
drmInfo' <- VideoInfoDmaDrm -> IO (Ptr VideoInfoDmaDrm)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoInfoDmaDrm
drmInfo
    Ptr Caps
result <- Ptr VideoInfoDmaDrm -> IO (Ptr Caps)
gst_video_info_dma_drm_to_caps Ptr VideoInfoDmaDrm
drmInfo'
    Maybe Caps
maybeResult <- Ptr Caps -> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Caps
result ((Ptr Caps -> IO Caps) -> IO (Maybe Caps))
-> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ \Ptr Caps
result' -> do
        Caps
result'' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result'
        Caps -> IO Caps
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result''
    VideoInfoDmaDrm -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoInfoDmaDrm
drmInfo
    Maybe Caps -> IO (Maybe Caps)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Caps
maybeResult

#if defined(ENABLE_OVERLOADING)
data VideoInfoDmaDrmToCapsMethodInfo
instance (signature ~ (m (Maybe Gst.Caps.Caps)), MonadIO m) => O.OverloadedMethod VideoInfoDmaDrmToCapsMethodInfo VideoInfoDmaDrm signature where
    overloadedMethod = videoInfoDmaDrmToCaps

instance O.OverloadedMethodInfo VideoInfoDmaDrmToCapsMethodInfo VideoInfoDmaDrm where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoInfoDmaDrm.videoInfoDmaDrmToCaps",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.29/docs/GI-GstVideo-Structs-VideoInfoDmaDrm.html#v:videoInfoDmaDrmToCaps"
        })


#endif

-- method VideoInfoDmaDrm::to_video_info
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "drm_info"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoInfoDmaDrm" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoInfoDmaDrm"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "GstVideo" , name = "VideoInfo" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GstVideoInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_info_dma_drm_to_video_info" gst_video_info_dma_drm_to_video_info :: 
    Ptr VideoInfoDmaDrm ->                  -- drm_info : TInterface (Name {namespace = "GstVideo", name = "VideoInfoDmaDrm"})
    Ptr GstVideo.VideoInfo.VideoInfo ->     -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"})
    IO CInt

-- | Convert the t'GI.GstVideo.Structs.VideoInfoDmaDrm.VideoInfoDmaDrm' into a traditional t'GI.GstVideo.Structs.VideoInfo.VideoInfo' with
-- recognized video format. For DMA kind memory, the non linear DMA format
-- should be recognized as @/GST_VIDEO_FORMAT_DMA_DRM/@. This helper function
-- sets /@info@/\'s video format into the default value according to /@drmInfo@/\'s
-- drm_fourcc field.
-- 
-- /Since: 1.24/
videoInfoDmaDrmToVideoInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoInfoDmaDrm
    -- ^ /@drmInfo@/: a t'GI.GstVideo.Structs.VideoInfoDmaDrm.VideoInfoDmaDrm'
    -> m ((Bool, GstVideo.VideoInfo.VideoInfo))
    -- ^ __Returns:__ 'P.True' if /@info@/ is converted correctly.
videoInfoDmaDrmToVideoInfo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoInfoDmaDrm -> m (Bool, VideoInfo)
videoInfoDmaDrmToVideoInfo VideoInfoDmaDrm
drmInfo = IO (Bool, VideoInfo) -> m (Bool, VideoInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, VideoInfo) -> m (Bool, VideoInfo))
-> IO (Bool, VideoInfo) -> m (Bool, VideoInfo)
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoInfoDmaDrm
drmInfo' <- VideoInfoDmaDrm -> IO (Ptr VideoInfoDmaDrm)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoInfoDmaDrm
drmInfo
    Ptr VideoInfo
info <- Int -> IO (Ptr VideoInfo)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
120 :: IO (Ptr GstVideo.VideoInfo.VideoInfo)
    CInt
result <- Ptr VideoInfoDmaDrm -> Ptr VideoInfo -> IO CInt
gst_video_info_dma_drm_to_video_info Ptr VideoInfoDmaDrm
drmInfo' Ptr VideoInfo
info
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    VideoInfo
info' <- ((ManagedPtr VideoInfo -> VideoInfo)
-> Ptr VideoInfo -> IO VideoInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoInfo -> VideoInfo
GstVideo.VideoInfo.VideoInfo) Ptr VideoInfo
info
    VideoInfoDmaDrm -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoInfoDmaDrm
drmInfo
    (Bool, VideoInfo) -> IO (Bool, VideoInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', VideoInfo
info')

#if defined(ENABLE_OVERLOADING)
data VideoInfoDmaDrmToVideoInfoMethodInfo
instance (signature ~ (m ((Bool, GstVideo.VideoInfo.VideoInfo))), MonadIO m) => O.OverloadedMethod VideoInfoDmaDrmToVideoInfoMethodInfo VideoInfoDmaDrm signature where
    overloadedMethod = videoInfoDmaDrmToVideoInfo

instance O.OverloadedMethodInfo VideoInfoDmaDrmToVideoInfoMethodInfo VideoInfoDmaDrm where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoInfoDmaDrm.videoInfoDmaDrmToVideoInfo",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.29/docs/GI-GstVideo-Structs-VideoInfoDmaDrm.html#v:videoInfoDmaDrmToVideoInfo"
        })


#endif

-- method VideoInfoDmaDrm::from_caps
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "drm_info"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoInfoDmaDrm" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GstVideoInfoDmaDrm"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "caps"
--           , argType = TInterface Name { namespace = "Gst" , name = "Caps" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstCaps" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_info_dma_drm_from_caps" gst_video_info_dma_drm_from_caps :: 
    Ptr VideoInfoDmaDrm ->                  -- drm_info : TInterface (Name {namespace = "GstVideo", name = "VideoInfoDmaDrm"})
    Ptr Gst.Caps.Caps ->                    -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
    IO CInt

-- | Parse /@caps@/ and update /@info@/. Please note that the /@caps@/ should be
-- a dma drm caps. The 'GI.GstVideo.Functions.videoIsDmaDrmCaps' can be used to verify
-- it before calling this function.
-- 
-- /Since: 1.24/
videoInfoDmaDrmFromCaps ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gst.Caps.Caps
    -- ^ /@caps@/: a t'GI.Gst.Structs.Caps.Caps'
    -> m ((Bool, VideoInfoDmaDrm))
    -- ^ __Returns:__ TRUE if /@caps@/ could be parsed
videoInfoDmaDrmFromCaps :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Caps -> m (Bool, VideoInfoDmaDrm)
videoInfoDmaDrmFromCaps Caps
caps = IO (Bool, VideoInfoDmaDrm) -> m (Bool, VideoInfoDmaDrm)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, VideoInfoDmaDrm) -> m (Bool, VideoInfoDmaDrm))
-> IO (Bool, VideoInfoDmaDrm) -> m (Bool, VideoInfoDmaDrm)
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoInfoDmaDrm
drmInfo <- Int -> IO (Ptr VideoInfoDmaDrm)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
216 :: IO (Ptr VideoInfoDmaDrm)
    Ptr Caps
caps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
    CInt
result <- Ptr VideoInfoDmaDrm -> Ptr Caps -> IO CInt
gst_video_info_dma_drm_from_caps Ptr VideoInfoDmaDrm
drmInfo Ptr Caps
caps'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    VideoInfoDmaDrm
drmInfo' <- ((ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm)
-> Ptr VideoInfoDmaDrm -> IO VideoInfoDmaDrm
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm
VideoInfoDmaDrm) Ptr VideoInfoDmaDrm
drmInfo
    Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
    (Bool, VideoInfoDmaDrm) -> IO (Bool, VideoInfoDmaDrm)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', VideoInfoDmaDrm
drmInfo')

#if defined(ENABLE_OVERLOADING)
#endif

-- method VideoInfoDmaDrm::from_video_info
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "drm_info"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoInfoDmaDrm" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GstVideoInfoDmaDrm"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "info"
--           , argType =
--               TInterface Name { namespace = "GstVideo" , name = "VideoInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoInfo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modifier"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the associated modifier value."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_info_dma_drm_from_video_info" gst_video_info_dma_drm_from_video_info :: 
    Ptr VideoInfoDmaDrm ->                  -- drm_info : TInterface (Name {namespace = "GstVideo", name = "VideoInfoDmaDrm"})
    Ptr GstVideo.VideoInfo.VideoInfo ->     -- info : TInterface (Name {namespace = "GstVideo", name = "VideoInfo"})
    Word64 ->                               -- modifier : TBasicType TUInt64
    IO CInt

-- | Fills /@drmInfo@/ if /@info@/\'s format has a valid drm format and /@modifier@/ is also
-- valid
-- 
-- /Since: 1.24/
videoInfoDmaDrmFromVideoInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GstVideo.VideoInfo.VideoInfo
    -- ^ /@info@/: a t'GI.GstVideo.Structs.VideoInfo.VideoInfo'
    -> Word64
    -- ^ /@modifier@/: the associated modifier value.
    -> m ((Bool, VideoInfoDmaDrm))
    -- ^ __Returns:__ 'P.True' if /@drmInfo@/ is filled correctly.
videoInfoDmaDrmFromVideoInfo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoInfo -> Word64 -> m (Bool, VideoInfoDmaDrm)
videoInfoDmaDrmFromVideoInfo VideoInfo
info Word64
modifier = IO (Bool, VideoInfoDmaDrm) -> m (Bool, VideoInfoDmaDrm)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, VideoInfoDmaDrm) -> m (Bool, VideoInfoDmaDrm))
-> IO (Bool, VideoInfoDmaDrm) -> m (Bool, VideoInfoDmaDrm)
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoInfoDmaDrm
drmInfo <- Int -> IO (Ptr VideoInfoDmaDrm)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
216 :: IO (Ptr VideoInfoDmaDrm)
    Ptr VideoInfo
info' <- VideoInfo -> IO (Ptr VideoInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoInfo
info
    CInt
result <- Ptr VideoInfoDmaDrm -> Ptr VideoInfo -> Word64 -> IO CInt
gst_video_info_dma_drm_from_video_info Ptr VideoInfoDmaDrm
drmInfo Ptr VideoInfo
info' Word64
modifier
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    VideoInfoDmaDrm
drmInfo' <- ((ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm)
-> Ptr VideoInfoDmaDrm -> IO VideoInfoDmaDrm
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm
VideoInfoDmaDrm) Ptr VideoInfoDmaDrm
drmInfo
    VideoInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoInfo
info
    (Bool, VideoInfoDmaDrm) -> IO (Bool, VideoInfoDmaDrm)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', VideoInfoDmaDrm
drmInfo')

#if defined(ENABLE_OVERLOADING)
#endif

-- method VideoInfoDmaDrm::init
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "drm_info"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoInfoDmaDrm" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoInfoDmaDrm"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_info_dma_drm_init" gst_video_info_dma_drm_init :: 
    Ptr VideoInfoDmaDrm ->                  -- drm_info : TInterface (Name {namespace = "GstVideo", name = "VideoInfoDmaDrm"})
    IO ()

-- | Initialize /@drmInfo@/ with default values.
-- 
-- /Since: 1.24/
videoInfoDmaDrmInit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m (VideoInfoDmaDrm)
videoInfoDmaDrmInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m VideoInfoDmaDrm
videoInfoDmaDrmInit  = IO VideoInfoDmaDrm -> m VideoInfoDmaDrm
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoInfoDmaDrm -> m VideoInfoDmaDrm)
-> IO VideoInfoDmaDrm -> m VideoInfoDmaDrm
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoInfoDmaDrm
drmInfo <- Int -> IO (Ptr VideoInfoDmaDrm)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
216 :: IO (Ptr VideoInfoDmaDrm)
    Ptr VideoInfoDmaDrm -> IO ()
gst_video_info_dma_drm_init Ptr VideoInfoDmaDrm
drmInfo
    VideoInfoDmaDrm
drmInfo' <- ((ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm)
-> Ptr VideoInfoDmaDrm -> IO VideoInfoDmaDrm
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoInfoDmaDrm -> VideoInfoDmaDrm
VideoInfoDmaDrm) Ptr VideoInfoDmaDrm
drmInfo
    VideoInfoDmaDrm -> IO VideoInfoDmaDrm
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoInfoDmaDrm
drmInfo'

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveVideoInfoDmaDrmMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveVideoInfoDmaDrmMethod "free" o = VideoInfoDmaDrmFreeMethodInfo
    ResolveVideoInfoDmaDrmMethod "toCaps" o = VideoInfoDmaDrmToCapsMethodInfo
    ResolveVideoInfoDmaDrmMethod "toVideoInfo" o = VideoInfoDmaDrmToVideoInfoMethodInfo
    ResolveVideoInfoDmaDrmMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif