{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstVideo.Structs.VideoMeta
(
VideoMeta(..) ,
newZeroVideoMeta ,
#if defined(ENABLE_OVERLOADING)
ResolveVideoMetaMethod ,
#endif
videoMetaGetInfo ,
#if defined(ENABLE_OVERLOADING)
VideoMetaMapMethodInfo ,
#endif
videoMetaMap ,
#if defined(ENABLE_OVERLOADING)
VideoMetaSetAlignmentMethodInfo ,
#endif
videoMetaSetAlignment ,
#if defined(ENABLE_OVERLOADING)
VideoMetaUnmapMethodInfo ,
#endif
videoMetaUnmap ,
getVideoMetaAlignment ,
#if defined(ENABLE_OVERLOADING)
videoMeta_alignment ,
#endif
clearVideoMetaBuffer ,
getVideoMetaBuffer ,
setVideoMetaBuffer ,
#if defined(ENABLE_OVERLOADING)
videoMeta_buffer ,
#endif
getVideoMetaFlags ,
setVideoMetaFlags ,
#if defined(ENABLE_OVERLOADING)
videoMeta_flags ,
#endif
getVideoMetaFormat ,
setVideoMetaFormat ,
#if defined(ENABLE_OVERLOADING)
videoMeta_format ,
#endif
getVideoMetaHeight ,
setVideoMetaHeight ,
#if defined(ENABLE_OVERLOADING)
videoMeta_height ,
#endif
getVideoMetaId ,
setVideoMetaId ,
#if defined(ENABLE_OVERLOADING)
videoMeta_id ,
#endif
clearVideoMetaMap ,
getVideoMetaMap ,
setVideoMetaMap ,
#if defined(ENABLE_OVERLOADING)
videoMeta_map ,
#endif
getVideoMetaMeta ,
#if defined(ENABLE_OVERLOADING)
videoMeta_meta ,
#endif
getVideoMetaNPlanes ,
setVideoMetaNPlanes ,
#if defined(ENABLE_OVERLOADING)
videoMeta_nPlanes ,
#endif
clearVideoMetaUnmap ,
getVideoMetaUnmap ,
setVideoMetaUnmap ,
#if defined(ENABLE_OVERLOADING)
videoMeta_unmap ,
#endif
getVideoMetaWidth ,
setVideoMetaWidth ,
#if defined(ENABLE_OVERLOADING)
videoMeta_width ,
#endif
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.Gst.Flags as Gst.Flags
import qualified GI.Gst.Structs.Buffer as Gst.Buffer
import qualified GI.Gst.Structs.MapInfo as Gst.MapInfo
import qualified GI.Gst.Structs.Meta as Gst.Meta
import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo
import qualified GI.GstVideo.Callbacks as GstVideo.Callbacks
import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums
import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags
import {-# SOURCE #-} qualified GI.GstVideo.Structs.VideoAlignment as GstVideo.VideoAlignment
newtype VideoMeta = VideoMeta (SP.ManagedPtr VideoMeta)
deriving (VideoMeta -> VideoMeta -> Bool
(VideoMeta -> VideoMeta -> Bool)
-> (VideoMeta -> VideoMeta -> Bool) -> Eq VideoMeta
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoMeta -> VideoMeta -> Bool
$c/= :: VideoMeta -> VideoMeta -> Bool
== :: VideoMeta -> VideoMeta -> Bool
$c== :: VideoMeta -> VideoMeta -> Bool
Eq)
instance SP.ManagedPtrNewtype VideoMeta where
toManagedPtr :: VideoMeta -> ManagedPtr VideoMeta
toManagedPtr (VideoMeta ManagedPtr VideoMeta
p) = ManagedPtr VideoMeta
p
instance BoxedPtr VideoMeta where
boxedPtrCopy :: VideoMeta -> IO VideoMeta
boxedPtrCopy = \VideoMeta
p -> VideoMeta -> (Ptr VideoMeta -> IO VideoMeta) -> IO VideoMeta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VideoMeta
p (Int -> Ptr VideoMeta -> IO (Ptr VideoMeta)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
144 (Ptr VideoMeta -> IO (Ptr VideoMeta))
-> (Ptr VideoMeta -> IO VideoMeta) -> Ptr VideoMeta -> IO VideoMeta
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr VideoMeta -> VideoMeta)
-> Ptr VideoMeta -> IO VideoMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr VideoMeta -> VideoMeta
VideoMeta)
boxedPtrFree :: VideoMeta -> IO ()
boxedPtrFree = \VideoMeta
x -> VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr VideoMeta
x Ptr VideoMeta -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr VideoMeta where
boxedPtrCalloc :: IO (Ptr VideoMeta)
boxedPtrCalloc = Int -> IO (Ptr VideoMeta)
forall a. Int -> IO (Ptr a)
callocBytes Int
144
newZeroVideoMeta :: MonadIO m => m VideoMeta
newZeroVideoMeta :: forall (m :: * -> *). MonadIO m => m VideoMeta
newZeroVideoMeta = IO VideoMeta -> m VideoMeta
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoMeta -> m VideoMeta) -> IO VideoMeta -> m VideoMeta
forall a b. (a -> b) -> a -> b
$ IO (Ptr VideoMeta)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr VideoMeta)
-> (Ptr VideoMeta -> IO VideoMeta) -> IO VideoMeta
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr VideoMeta -> VideoMeta)
-> Ptr VideoMeta -> IO VideoMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr VideoMeta -> VideoMeta
VideoMeta
instance tag ~ 'AttrSet => Constructible VideoMeta tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr VideoMeta -> VideoMeta)
-> [AttrOp VideoMeta tag] -> m VideoMeta
new ManagedPtr VideoMeta -> VideoMeta
_ [AttrOp VideoMeta tag]
attrs = do
VideoMeta
o <- m VideoMeta
forall (m :: * -> *). MonadIO m => m VideoMeta
newZeroVideoMeta
VideoMeta -> [AttrOp VideoMeta 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set VideoMeta
o [AttrOp VideoMeta tag]
[AttrOp VideoMeta 'AttrSet]
attrs
VideoMeta -> m VideoMeta
forall (m :: * -> *) a. Monad m => a -> m a
return VideoMeta
o
getVideoMetaMeta :: MonadIO m => VideoMeta -> m Gst.Meta.Meta
getVideoMetaMeta :: forall (m :: * -> *). MonadIO m => VideoMeta -> m Meta
getVideoMetaMeta VideoMeta
s = IO Meta -> m Meta
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Meta -> m Meta) -> IO Meta -> m Meta
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO Meta) -> IO Meta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO Meta) -> IO Meta)
-> (Ptr VideoMeta -> IO Meta) -> IO Meta
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
let val :: Ptr Meta
val = Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Meta
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Gst.Meta.Meta)
Meta
val' <- ((ManagedPtr Meta -> Meta) -> Ptr Meta -> IO Meta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Meta -> Meta
Gst.Meta.Meta) Ptr Meta
val
Meta -> IO Meta
forall (m :: * -> *) a. Monad m => a -> m a
return Meta
val'
#if defined(ENABLE_OVERLOADING)
data VideoMetaMetaFieldInfo
instance AttrInfo VideoMetaMetaFieldInfo where
type AttrBaseTypeConstraint VideoMetaMetaFieldInfo = (~) VideoMeta
type AttrAllowedOps VideoMetaMetaFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint VideoMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta)
type AttrTransferTypeConstraint VideoMetaMetaFieldInfo = (~)(Ptr Gst.Meta.Meta)
type AttrTransferType VideoMetaMetaFieldInfo = (Ptr Gst.Meta.Meta)
type AttrGetType VideoMetaMetaFieldInfo = Gst.Meta.Meta
type AttrLabel VideoMetaMetaFieldInfo = "meta"
type AttrOrigin VideoMetaMetaFieldInfo = VideoMeta
attrGet = getVideoMetaMeta
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
videoMeta_meta :: AttrLabelProxy "meta"
videoMeta_meta = AttrLabelProxy
#endif
getVideoMetaBuffer :: MonadIO m => VideoMeta -> m (Maybe Gst.Buffer.Buffer)
getVideoMetaBuffer :: forall (m :: * -> *). MonadIO m => VideoMeta -> m (Maybe Buffer)
getVideoMetaBuffer VideoMeta
s = IO (Maybe Buffer) -> m (Maybe Buffer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Buffer) -> m (Maybe Buffer))
-> IO (Maybe Buffer) -> m (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ VideoMeta
-> (Ptr VideoMeta -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO (Maybe Buffer)) -> IO (Maybe Buffer))
-> (Ptr VideoMeta -> IO (Maybe Buffer)) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Ptr Buffer
val <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr Gst.Buffer.Buffer)
Maybe Buffer
result <- Ptr Buffer -> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Buffer
val ((Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer))
-> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
val' -> do
Buffer
val'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
val'
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
val''
Maybe Buffer -> IO (Maybe Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
result
setVideoMetaBuffer :: MonadIO m => VideoMeta -> Ptr Gst.Buffer.Buffer -> m ()
setVideoMetaBuffer :: forall (m :: * -> *). MonadIO m => VideoMeta -> Ptr Buffer -> m ()
setVideoMetaBuffer VideoMeta
s Ptr Buffer
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Buffer
val :: Ptr Gst.Buffer.Buffer)
clearVideoMetaBuffer :: MonadIO m => VideoMeta -> m ()
clearVideoMetaBuffer :: forall (m :: * -> *). MonadIO m => VideoMeta -> m ()
clearVideoMetaBuffer VideoMeta
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Ptr (Ptr Buffer) -> Ptr Buffer -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (Ptr Buffer)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Buffer
forall a. Ptr a
FP.nullPtr :: Ptr Gst.Buffer.Buffer)
#if defined(ENABLE_OVERLOADING)
data VideoMetaBufferFieldInfo
instance AttrInfo VideoMetaBufferFieldInfo where
type AttrBaseTypeConstraint VideoMetaBufferFieldInfo = (~) VideoMeta
type AttrAllowedOps VideoMetaBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint VideoMetaBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer)
type AttrTransferTypeConstraint VideoMetaBufferFieldInfo = (~)(Ptr Gst.Buffer.Buffer)
type AttrTransferType VideoMetaBufferFieldInfo = (Ptr Gst.Buffer.Buffer)
type AttrGetType VideoMetaBufferFieldInfo = Maybe Gst.Buffer.Buffer
type AttrLabel VideoMetaBufferFieldInfo = "buffer"
type AttrOrigin VideoMetaBufferFieldInfo = VideoMeta
attrGet = getVideoMetaBuffer
attrSet = setVideoMetaBuffer
attrConstruct = undefined
attrClear = clearVideoMetaBuffer
attrTransfer _ v = do
return v
videoMeta_buffer :: AttrLabelProxy "buffer"
videoMeta_buffer = AttrLabelProxy
#endif
getVideoMetaFlags :: MonadIO m => VideoMeta -> m [GstVideo.Flags.VideoFrameFlags]
getVideoMetaFlags :: forall (m :: * -> *). MonadIO m => VideoMeta -> m [VideoFrameFlags]
getVideoMetaFlags VideoMeta
s = IO [VideoFrameFlags] -> m [VideoFrameFlags]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [VideoFrameFlags] -> m [VideoFrameFlags])
-> IO [VideoFrameFlags] -> m [VideoFrameFlags]
forall a b. (a -> b) -> a -> b
$ VideoMeta
-> (Ptr VideoMeta -> IO [VideoFrameFlags]) -> IO [VideoFrameFlags]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO [VideoFrameFlags]) -> IO [VideoFrameFlags])
-> (Ptr VideoMeta -> IO [VideoFrameFlags]) -> IO [VideoFrameFlags]
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CUInt
let val' :: [VideoFrameFlags]
val' = CUInt -> [VideoFrameFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
[VideoFrameFlags] -> IO [VideoFrameFlags]
forall (m :: * -> *) a. Monad m => a -> m a
return [VideoFrameFlags]
val'
setVideoMetaFlags :: MonadIO m => VideoMeta -> [GstVideo.Flags.VideoFrameFlags] -> m ()
setVideoMetaFlags :: forall (m :: * -> *).
MonadIO m =>
VideoMeta -> [VideoFrameFlags] -> m ()
setVideoMetaFlags VideoMeta
s [VideoFrameFlags]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
let val' :: CUInt
val' = [VideoFrameFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [VideoFrameFlags]
val
Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data VideoMetaFlagsFieldInfo
instance AttrInfo VideoMetaFlagsFieldInfo where
type AttrBaseTypeConstraint VideoMetaFlagsFieldInfo = (~) VideoMeta
type AttrAllowedOps VideoMetaFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint VideoMetaFlagsFieldInfo = (~) [GstVideo.Flags.VideoFrameFlags]
type AttrTransferTypeConstraint VideoMetaFlagsFieldInfo = (~)[GstVideo.Flags.VideoFrameFlags]
type AttrTransferType VideoMetaFlagsFieldInfo = [GstVideo.Flags.VideoFrameFlags]
type AttrGetType VideoMetaFlagsFieldInfo = [GstVideo.Flags.VideoFrameFlags]
type AttrLabel VideoMetaFlagsFieldInfo = "flags"
type AttrOrigin VideoMetaFlagsFieldInfo = VideoMeta
attrGet = getVideoMetaFlags
attrSet = setVideoMetaFlags
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
videoMeta_flags :: AttrLabelProxy "flags"
videoMeta_flags = AttrLabelProxy
#endif
getVideoMetaFormat :: MonadIO m => VideoMeta -> m GstVideo.Enums.VideoFormat
getVideoMetaFormat :: forall (m :: * -> *). MonadIO m => VideoMeta -> m VideoFormat
getVideoMetaFormat VideoMeta
s = IO VideoFormat -> m VideoFormat
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoFormat -> m VideoFormat)
-> IO VideoFormat -> m VideoFormat
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO VideoFormat) -> IO VideoFormat
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO VideoFormat) -> IO VideoFormat)
-> (Ptr VideoMeta -> IO VideoFormat) -> IO VideoFormat
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) :: IO CUInt
let val' :: VideoFormat
val' = (Int -> VideoFormat
forall a. Enum a => Int -> a
toEnum (Int -> VideoFormat) -> (CUInt -> Int) -> CUInt -> VideoFormat
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
VideoFormat -> IO VideoFormat
forall (m :: * -> *) a. Monad m => a -> m a
return VideoFormat
val'
setVideoMetaFormat :: MonadIO m => VideoMeta -> GstVideo.Enums.VideoFormat -> m ()
setVideoMetaFormat :: forall (m :: * -> *). MonadIO m => VideoMeta -> VideoFormat -> m ()
setVideoMetaFormat VideoMeta
s VideoFormat
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (VideoFormat -> Int) -> VideoFormat -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VideoFormat -> Int
forall a. Enum a => a -> Int
fromEnum) VideoFormat
val
Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data VideoMetaFormatFieldInfo
instance AttrInfo VideoMetaFormatFieldInfo where
type AttrBaseTypeConstraint VideoMetaFormatFieldInfo = (~) VideoMeta
type AttrAllowedOps VideoMetaFormatFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint VideoMetaFormatFieldInfo = (~) GstVideo.Enums.VideoFormat
type AttrTransferTypeConstraint VideoMetaFormatFieldInfo = (~)GstVideo.Enums.VideoFormat
type AttrTransferType VideoMetaFormatFieldInfo = GstVideo.Enums.VideoFormat
type AttrGetType VideoMetaFormatFieldInfo = GstVideo.Enums.VideoFormat
type AttrLabel VideoMetaFormatFieldInfo = "format"
type AttrOrigin VideoMetaFormatFieldInfo = VideoMeta
attrGet = getVideoMetaFormat
attrSet = setVideoMetaFormat
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
videoMeta_format :: AttrLabelProxy "format"
videoMeta_format = AttrLabelProxy
#endif
getVideoMetaId :: MonadIO m => VideoMeta -> m Int32
getVideoMetaId :: forall (m :: * -> *). MonadIO m => VideoMeta -> m Int32
getVideoMetaId VideoMeta
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO Int32) -> IO Int32)
-> (Ptr VideoMeta -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setVideoMetaId :: MonadIO m => VideoMeta -> Int32 -> m ()
setVideoMetaId :: forall (m :: * -> *). MonadIO m => VideoMeta -> Int32 -> m ()
setVideoMetaId VideoMeta
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data VideoMetaIdFieldInfo
instance AttrInfo VideoMetaIdFieldInfo where
type AttrBaseTypeConstraint VideoMetaIdFieldInfo = (~) VideoMeta
type AttrAllowedOps VideoMetaIdFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint VideoMetaIdFieldInfo = (~) Int32
type AttrTransferTypeConstraint VideoMetaIdFieldInfo = (~)Int32
type AttrTransferType VideoMetaIdFieldInfo = Int32
type AttrGetType VideoMetaIdFieldInfo = Int32
type AttrLabel VideoMetaIdFieldInfo = "id"
type AttrOrigin VideoMetaIdFieldInfo = VideoMeta
attrGet = getVideoMetaId
attrSet = setVideoMetaId
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
videoMeta_id :: AttrLabelProxy "id"
videoMeta_id = AttrLabelProxy
#endif
getVideoMetaWidth :: MonadIO m => VideoMeta -> m Word32
getVideoMetaWidth :: forall (m :: * -> *). MonadIO m => VideoMeta -> m Word32
getVideoMetaWidth VideoMeta
s = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO Word32) -> IO Word32)
-> (Ptr VideoMeta -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) :: IO Word32
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setVideoMetaWidth :: MonadIO m => VideoMeta -> Word32 -> m ()
setVideoMetaWidth :: forall (m :: * -> *). MonadIO m => VideoMeta -> Word32 -> m ()
setVideoMetaWidth VideoMeta
s Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data VideoMetaWidthFieldInfo
instance AttrInfo VideoMetaWidthFieldInfo where
type AttrBaseTypeConstraint VideoMetaWidthFieldInfo = (~) VideoMeta
type AttrAllowedOps VideoMetaWidthFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint VideoMetaWidthFieldInfo = (~) Word32
type AttrTransferTypeConstraint VideoMetaWidthFieldInfo = (~)Word32
type AttrTransferType VideoMetaWidthFieldInfo = Word32
type AttrGetType VideoMetaWidthFieldInfo = Word32
type AttrLabel VideoMetaWidthFieldInfo = "width"
type AttrOrigin VideoMetaWidthFieldInfo = VideoMeta
attrGet = getVideoMetaWidth
attrSet = setVideoMetaWidth
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
videoMeta_width :: AttrLabelProxy "width"
videoMeta_width = AttrLabelProxy
#endif
getVideoMetaHeight :: MonadIO m => VideoMeta -> m Word32
getVideoMetaHeight :: forall (m :: * -> *). MonadIO m => VideoMeta -> m Word32
getVideoMetaHeight VideoMeta
s = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO Word32) -> IO Word32)
-> (Ptr VideoMeta -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO Word32
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setVideoMetaHeight :: MonadIO m => VideoMeta -> Word32 -> m ()
setVideoMetaHeight :: forall (m :: * -> *). MonadIO m => VideoMeta -> Word32 -> m ()
setVideoMetaHeight VideoMeta
s Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data VideoMetaHeightFieldInfo
instance AttrInfo VideoMetaHeightFieldInfo where
type AttrBaseTypeConstraint VideoMetaHeightFieldInfo = (~) VideoMeta
type AttrAllowedOps VideoMetaHeightFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint VideoMetaHeightFieldInfo = (~) Word32
type AttrTransferTypeConstraint VideoMetaHeightFieldInfo = (~)Word32
type AttrTransferType VideoMetaHeightFieldInfo = Word32
type AttrGetType VideoMetaHeightFieldInfo = Word32
type AttrLabel VideoMetaHeightFieldInfo = "height"
type AttrOrigin VideoMetaHeightFieldInfo = VideoMeta
attrGet = getVideoMetaHeight
attrSet = setVideoMetaHeight
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
videoMeta_height :: AttrLabelProxy "height"
videoMeta_height = AttrLabelProxy
#endif
getVideoMetaNPlanes :: MonadIO m => VideoMeta -> m Word32
getVideoMetaNPlanes :: forall (m :: * -> *). MonadIO m => VideoMeta -> m Word32
getVideoMetaNPlanes VideoMeta
s = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO Word32) -> IO Word32)
-> (Ptr VideoMeta -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44) :: IO Word32
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setVideoMetaNPlanes :: MonadIO m => VideoMeta -> Word32 -> m ()
setVideoMetaNPlanes :: forall (m :: * -> *). MonadIO m => VideoMeta -> Word32 -> m ()
setVideoMetaNPlanes VideoMeta
s Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data VideoMetaNPlanesFieldInfo
instance AttrInfo VideoMetaNPlanesFieldInfo where
type AttrBaseTypeConstraint VideoMetaNPlanesFieldInfo = (~) VideoMeta
type AttrAllowedOps VideoMetaNPlanesFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint VideoMetaNPlanesFieldInfo = (~) Word32
type AttrTransferTypeConstraint VideoMetaNPlanesFieldInfo = (~)Word32
type AttrTransferType VideoMetaNPlanesFieldInfo = Word32
type AttrGetType VideoMetaNPlanesFieldInfo = Word32
type AttrLabel VideoMetaNPlanesFieldInfo = "n_planes"
type AttrOrigin VideoMetaNPlanesFieldInfo = VideoMeta
attrGet = getVideoMetaNPlanes
attrSet = setVideoMetaNPlanes
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
videoMeta_nPlanes :: AttrLabelProxy "nPlanes"
videoMeta_nPlanes = AttrLabelProxy
#endif
getVideoMetaMap :: MonadIO m => VideoMeta -> m (Maybe GstVideo.Callbacks.VideoMetaMapFieldCallback)
getVideoMetaMap :: forall (m :: * -> *).
MonadIO m =>
VideoMeta -> m (Maybe VideoMetaMapFieldCallback)
getVideoMetaMap VideoMeta
s = IO (Maybe VideoMetaMapFieldCallback)
-> m (Maybe VideoMetaMapFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VideoMetaMapFieldCallback)
-> m (Maybe VideoMetaMapFieldCallback))
-> IO (Maybe VideoMetaMapFieldCallback)
-> m (Maybe VideoMetaMapFieldCallback)
forall a b. (a -> b) -> a -> b
$ VideoMeta
-> (Ptr VideoMeta -> IO (Maybe VideoMetaMapFieldCallback))
-> IO (Maybe VideoMetaMapFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO (Maybe VideoMetaMapFieldCallback))
-> IO (Maybe VideoMetaMapFieldCallback))
-> (Ptr VideoMeta -> IO (Maybe VideoMetaMapFieldCallback))
-> IO (Maybe VideoMetaMapFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
FunPtr C_VideoMetaMapFieldCallback
val <- Ptr (FunPtr C_VideoMetaMapFieldCallback)
-> IO (FunPtr C_VideoMetaMapFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (FunPtr C_VideoMetaMapFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
96) :: IO (FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback)
Maybe VideoMetaMapFieldCallback
result <- FunPtr C_VideoMetaMapFieldCallback
-> (FunPtr C_VideoMetaMapFieldCallback
-> IO VideoMetaMapFieldCallback)
-> IO (Maybe VideoMetaMapFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_VideoMetaMapFieldCallback
val ((FunPtr C_VideoMetaMapFieldCallback
-> IO VideoMetaMapFieldCallback)
-> IO (Maybe VideoMetaMapFieldCallback))
-> (FunPtr C_VideoMetaMapFieldCallback
-> IO VideoMetaMapFieldCallback)
-> IO (Maybe VideoMetaMapFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_VideoMetaMapFieldCallback
val' -> do
let val'' :: VideoMetaMapFieldCallback
val'' = FunPtr C_VideoMetaMapFieldCallback -> VideoMetaMapFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_VideoMetaMapFieldCallback
-> VideoMeta
-> Word32
-> MapInfo
-> Ptr ()
-> Int32
-> [MapFlags]
-> m Bool
GstVideo.Callbacks.dynamic_VideoMetaMapFieldCallback FunPtr C_VideoMetaMapFieldCallback
val'
VideoMetaMapFieldCallback -> IO VideoMetaMapFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return VideoMetaMapFieldCallback
val''
Maybe VideoMetaMapFieldCallback
-> IO (Maybe VideoMetaMapFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoMetaMapFieldCallback
result
setVideoMetaMap :: MonadIO m => VideoMeta -> FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback -> m ()
setVideoMetaMap :: forall (m :: * -> *).
MonadIO m =>
VideoMeta -> FunPtr C_VideoMetaMapFieldCallback -> m ()
setVideoMetaMap VideoMeta
s FunPtr C_VideoMetaMapFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Ptr (FunPtr C_VideoMetaMapFieldCallback)
-> FunPtr C_VideoMetaMapFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (FunPtr C_VideoMetaMapFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
96) (FunPtr C_VideoMetaMapFieldCallback
val :: FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback)
clearVideoMetaMap :: MonadIO m => VideoMeta -> m ()
clearVideoMetaMap :: forall (m :: * -> *). MonadIO m => VideoMeta -> m ()
clearVideoMetaMap VideoMeta
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Ptr (FunPtr C_VideoMetaMapFieldCallback)
-> FunPtr C_VideoMetaMapFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (FunPtr C_VideoMetaMapFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
96) (FunPtr C_VideoMetaMapFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback)
#if defined(ENABLE_OVERLOADING)
data VideoMetaMapFieldInfo
instance AttrInfo VideoMetaMapFieldInfo where
type AttrBaseTypeConstraint VideoMetaMapFieldInfo = (~) VideoMeta
type AttrAllowedOps VideoMetaMapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint VideoMetaMapFieldInfo = (~) (FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback)
type AttrTransferTypeConstraint VideoMetaMapFieldInfo = (~)GstVideo.Callbacks.VideoMetaMapFieldCallback
type AttrTransferType VideoMetaMapFieldInfo = (FunPtr GstVideo.Callbacks.C_VideoMetaMapFieldCallback)
type AttrGetType VideoMetaMapFieldInfo = Maybe GstVideo.Callbacks.VideoMetaMapFieldCallback
type AttrLabel VideoMetaMapFieldInfo = "map"
type AttrOrigin VideoMetaMapFieldInfo = VideoMeta
attrGet = getVideoMetaMap
attrSet = setVideoMetaMap
attrConstruct = undefined
attrClear = clearVideoMetaMap
attrTransfer _ v = do
GstVideo.Callbacks.mk_VideoMetaMapFieldCallback (GstVideo.Callbacks.wrap_VideoMetaMapFieldCallback Nothing v)
videoMeta_map :: AttrLabelProxy "map"
videoMeta_map = AttrLabelProxy
#endif
getVideoMetaUnmap :: MonadIO m => VideoMeta -> m (Maybe GstVideo.Callbacks.VideoMetaUnmapFieldCallback)
getVideoMetaUnmap :: forall (m :: * -> *).
MonadIO m =>
VideoMeta -> m (Maybe VideoMetaUnmapFieldCallback)
getVideoMetaUnmap VideoMeta
s = IO (Maybe VideoMetaUnmapFieldCallback)
-> m (Maybe VideoMetaUnmapFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VideoMetaUnmapFieldCallback)
-> m (Maybe VideoMetaUnmapFieldCallback))
-> IO (Maybe VideoMetaUnmapFieldCallback)
-> m (Maybe VideoMetaUnmapFieldCallback)
forall a b. (a -> b) -> a -> b
$ VideoMeta
-> (Ptr VideoMeta -> IO (Maybe VideoMetaUnmapFieldCallback))
-> IO (Maybe VideoMetaUnmapFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO (Maybe VideoMetaUnmapFieldCallback))
-> IO (Maybe VideoMetaUnmapFieldCallback))
-> (Ptr VideoMeta -> IO (Maybe VideoMetaUnmapFieldCallback))
-> IO (Maybe VideoMetaUnmapFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
FunPtr C_VideoMetaUnmapFieldCallback
val <- Ptr (FunPtr C_VideoMetaUnmapFieldCallback)
-> IO (FunPtr C_VideoMetaUnmapFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (FunPtr C_VideoMetaUnmapFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
104) :: IO (FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback)
Maybe VideoMetaUnmapFieldCallback
result <- FunPtr C_VideoMetaUnmapFieldCallback
-> (FunPtr C_VideoMetaUnmapFieldCallback
-> IO VideoMetaUnmapFieldCallback)
-> IO (Maybe VideoMetaUnmapFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_VideoMetaUnmapFieldCallback
val ((FunPtr C_VideoMetaUnmapFieldCallback
-> IO VideoMetaUnmapFieldCallback)
-> IO (Maybe VideoMetaUnmapFieldCallback))
-> (FunPtr C_VideoMetaUnmapFieldCallback
-> IO VideoMetaUnmapFieldCallback)
-> IO (Maybe VideoMetaUnmapFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_VideoMetaUnmapFieldCallback
val' -> do
let val'' :: VideoMetaUnmapFieldCallback
val'' = FunPtr C_VideoMetaUnmapFieldCallback -> VideoMetaUnmapFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_VideoMetaUnmapFieldCallback
-> VideoMeta -> Word32 -> MapInfo -> m Bool
GstVideo.Callbacks.dynamic_VideoMetaUnmapFieldCallback FunPtr C_VideoMetaUnmapFieldCallback
val'
VideoMetaUnmapFieldCallback -> IO VideoMetaUnmapFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return VideoMetaUnmapFieldCallback
val''
Maybe VideoMetaUnmapFieldCallback
-> IO (Maybe VideoMetaUnmapFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoMetaUnmapFieldCallback
result
setVideoMetaUnmap :: MonadIO m => VideoMeta -> FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback -> m ()
setVideoMetaUnmap :: forall (m :: * -> *).
MonadIO m =>
VideoMeta -> FunPtr C_VideoMetaUnmapFieldCallback -> m ()
setVideoMetaUnmap VideoMeta
s FunPtr C_VideoMetaUnmapFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Ptr (FunPtr C_VideoMetaUnmapFieldCallback)
-> FunPtr C_VideoMetaUnmapFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (FunPtr C_VideoMetaUnmapFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
104) (FunPtr C_VideoMetaUnmapFieldCallback
val :: FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback)
clearVideoMetaUnmap :: MonadIO m => VideoMeta -> m ()
clearVideoMetaUnmap :: forall (m :: * -> *). MonadIO m => VideoMeta -> m ()
clearVideoMetaUnmap VideoMeta
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ VideoMeta -> (Ptr VideoMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO ()) -> IO ())
-> (Ptr VideoMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
Ptr (FunPtr C_VideoMetaUnmapFieldCallback)
-> FunPtr C_VideoMetaUnmapFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr (FunPtr C_VideoMetaUnmapFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
104) (FunPtr C_VideoMetaUnmapFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback)
#if defined(ENABLE_OVERLOADING)
data VideoMetaUnmapFieldInfo
instance AttrInfo VideoMetaUnmapFieldInfo where
type AttrBaseTypeConstraint VideoMetaUnmapFieldInfo = (~) VideoMeta
type AttrAllowedOps VideoMetaUnmapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint VideoMetaUnmapFieldInfo = (~) (FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback)
type AttrTransferTypeConstraint VideoMetaUnmapFieldInfo = (~)GstVideo.Callbacks.VideoMetaUnmapFieldCallback
type AttrTransferType VideoMetaUnmapFieldInfo = (FunPtr GstVideo.Callbacks.C_VideoMetaUnmapFieldCallback)
type AttrGetType VideoMetaUnmapFieldInfo = Maybe GstVideo.Callbacks.VideoMetaUnmapFieldCallback
type AttrLabel VideoMetaUnmapFieldInfo = "unmap"
type AttrOrigin VideoMetaUnmapFieldInfo = VideoMeta
attrGet = getVideoMetaUnmap
attrSet = setVideoMetaUnmap
attrConstruct = undefined
attrClear = clearVideoMetaUnmap
attrTransfer _ v = do
GstVideo.Callbacks.mk_VideoMetaUnmapFieldCallback (GstVideo.Callbacks.wrap_VideoMetaUnmapFieldCallback Nothing v)
videoMeta_unmap :: AttrLabelProxy "unmap"
videoMeta_unmap = AttrLabelProxy
#endif
getVideoMetaAlignment :: MonadIO m => VideoMeta -> m GstVideo.VideoAlignment.VideoAlignment
getVideoMetaAlignment :: forall (m :: * -> *). MonadIO m => VideoMeta -> m VideoAlignment
getVideoMetaAlignment VideoMeta
s = IO VideoAlignment -> m VideoAlignment
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoAlignment -> m VideoAlignment)
-> IO VideoAlignment -> m VideoAlignment
forall a b. (a -> b) -> a -> b
$ VideoMeta
-> (Ptr VideoMeta -> IO VideoAlignment) -> IO VideoAlignment
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoMeta
s ((Ptr VideoMeta -> IO VideoAlignment) -> IO VideoAlignment)
-> (Ptr VideoMeta -> IO VideoAlignment) -> IO VideoAlignment
forall a b. (a -> b) -> a -> b
$ \Ptr VideoMeta
ptr -> do
let val :: Ptr VideoAlignment
val = Ptr VideoMeta
ptr Ptr VideoMeta -> Int -> Ptr VideoAlignment
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
112 :: (Ptr GstVideo.VideoAlignment.VideoAlignment)
VideoAlignment
val' <- ((ManagedPtr VideoAlignment -> VideoAlignment)
-> Ptr VideoAlignment -> IO VideoAlignment
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr VideoAlignment -> VideoAlignment
GstVideo.VideoAlignment.VideoAlignment) Ptr VideoAlignment
val
VideoAlignment -> IO VideoAlignment
forall (m :: * -> *) a. Monad m => a -> m a
return VideoAlignment
val'
#if defined(ENABLE_OVERLOADING)
data VideoMetaAlignmentFieldInfo
instance AttrInfo VideoMetaAlignmentFieldInfo where
type AttrBaseTypeConstraint VideoMetaAlignmentFieldInfo = (~) VideoMeta
type AttrAllowedOps VideoMetaAlignmentFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint VideoMetaAlignmentFieldInfo = (~) (Ptr GstVideo.VideoAlignment.VideoAlignment)
type AttrTransferTypeConstraint VideoMetaAlignmentFieldInfo = (~)(Ptr GstVideo.VideoAlignment.VideoAlignment)
type AttrTransferType VideoMetaAlignmentFieldInfo = (Ptr GstVideo.VideoAlignment.VideoAlignment)
type AttrGetType VideoMetaAlignmentFieldInfo = GstVideo.VideoAlignment.VideoAlignment
type AttrLabel VideoMetaAlignmentFieldInfo = "alignment"
type AttrOrigin VideoMetaAlignmentFieldInfo = VideoMeta
attrGet = getVideoMetaAlignment
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
videoMeta_alignment :: AttrLabelProxy "alignment"
videoMeta_alignment = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoMeta
type instance O.AttributeList VideoMeta = VideoMetaAttributeList
type VideoMetaAttributeList = ('[ '("meta", VideoMetaMetaFieldInfo), '("buffer", VideoMetaBufferFieldInfo), '("flags", VideoMetaFlagsFieldInfo), '("format", VideoMetaFormatFieldInfo), '("id", VideoMetaIdFieldInfo), '("width", VideoMetaWidthFieldInfo), '("height", VideoMetaHeightFieldInfo), '("nPlanes", VideoMetaNPlanesFieldInfo), '("map", VideoMetaMapFieldInfo), '("unmap", VideoMetaUnmapFieldInfo), '("alignment", VideoMetaAlignmentFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_video_meta_map" gst_video_meta_map ::
Ptr VideoMeta ->
Word32 ->
Ptr Gst.MapInfo.MapInfo ->
Ptr (Ptr ()) ->
Ptr Int32 ->
CUInt ->
IO CInt
videoMetaMap ::
(B.CallStack.HasCallStack, MonadIO m) =>
VideoMeta
-> Word32
-> Gst.MapInfo.MapInfo
-> [Gst.Flags.MapFlags]
-> m ((Bool, Ptr (), Int32))
videoMetaMap :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoMeta
-> Word32 -> MapInfo -> [MapFlags] -> m (Bool, Ptr (), Int32)
videoMetaMap VideoMeta
meta Word32
plane MapInfo
info [MapFlags]
flags = IO (Bool, Ptr (), Int32) -> m (Bool, Ptr (), Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Ptr (), Int32) -> m (Bool, Ptr (), Int32))
-> IO (Bool, Ptr (), Int32) -> m (Bool, Ptr (), Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr VideoMeta
meta' <- VideoMeta -> IO (Ptr VideoMeta)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoMeta
meta
Ptr MapInfo
info' <- MapInfo -> IO (Ptr MapInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MapInfo
info
Ptr (Ptr ())
data_ <- IO (Ptr (Ptr ()))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr ()))
Ptr Int32
stride <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
let flags' :: CUInt
flags' = [MapFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MapFlags]
flags
CInt
result <- Ptr VideoMeta
-> Word32
-> Ptr MapInfo
-> Ptr (Ptr ())
-> Ptr Int32
-> CUInt
-> IO CInt
gst_video_meta_map Ptr VideoMeta
meta' Word32
plane Ptr MapInfo
info' Ptr (Ptr ())
data_ Ptr Int32
stride CUInt
flags'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr ()
data_' <- Ptr (Ptr ()) -> IO (Ptr ())
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr ())
data_
Int32
stride' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
stride
VideoMeta -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoMeta
meta
MapInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MapInfo
info
Ptr (Ptr ()) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr ())
data_
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
stride
(Bool, Ptr (), Int32) -> IO (Bool, Ptr (), Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Ptr ()
data_', Int32
stride')
#if defined(ENABLE_OVERLOADING)
data VideoMetaMapMethodInfo
instance (signature ~ (Word32 -> Gst.MapInfo.MapInfo -> [Gst.Flags.MapFlags] -> m ((Bool, Ptr (), Int32))), MonadIO m) => O.OverloadedMethod VideoMetaMapMethodInfo VideoMeta signature where
overloadedMethod = videoMetaMap
instance O.OverloadedMethodInfo VideoMetaMapMethodInfo VideoMeta where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstVideo.Structs.VideoMeta.videoMetaMap",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.24/docs/GI-GstVideo-Structs-VideoMeta.html#v:videoMetaMap"
}
#endif
foreign import ccall "gst_video_meta_set_alignment" gst_video_meta_set_alignment ::
Ptr VideoMeta ->
Ptr GstVideo.VideoAlignment.VideoAlignment ->
IO CInt
videoMetaSetAlignment ::
(B.CallStack.HasCallStack, MonadIO m) =>
VideoMeta
-> GstVideo.VideoAlignment.VideoAlignment
-> m Bool
videoMetaSetAlignment :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoMeta -> VideoAlignment -> m Bool
videoMetaSetAlignment VideoMeta
meta VideoAlignment
alignment = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr VideoMeta
meta' <- VideoMeta -> IO (Ptr VideoMeta)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoMeta
meta
Ptr VideoAlignment
alignment' <- VideoAlignment -> IO (Ptr VideoAlignment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoAlignment
alignment
CInt
result <- Ptr VideoMeta -> Ptr VideoAlignment -> IO CInt
gst_video_meta_set_alignment Ptr VideoMeta
meta' Ptr VideoAlignment
alignment'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
VideoMeta -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoMeta
meta
VideoAlignment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoAlignment
alignment
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data VideoMetaSetAlignmentMethodInfo
instance (signature ~ (GstVideo.VideoAlignment.VideoAlignment -> m Bool), MonadIO m) => O.OverloadedMethod VideoMetaSetAlignmentMethodInfo VideoMeta signature where
overloadedMethod = videoMetaSetAlignment
instance O.OverloadedMethodInfo VideoMetaSetAlignmentMethodInfo VideoMeta where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstVideo.Structs.VideoMeta.videoMetaSetAlignment",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.24/docs/GI-GstVideo-Structs-VideoMeta.html#v:videoMetaSetAlignment"
}
#endif
foreign import ccall "gst_video_meta_unmap" gst_video_meta_unmap ::
Ptr VideoMeta ->
Word32 ->
Ptr Gst.MapInfo.MapInfo ->
IO CInt
videoMetaUnmap ::
(B.CallStack.HasCallStack, MonadIO m) =>
VideoMeta
-> Word32
-> Gst.MapInfo.MapInfo
-> m Bool
videoMetaUnmap :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoMeta -> Word32 -> MapInfo -> m Bool
videoMetaUnmap VideoMeta
meta Word32
plane MapInfo
info = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr VideoMeta
meta' <- VideoMeta -> IO (Ptr VideoMeta)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoMeta
meta
Ptr MapInfo
info' <- MapInfo -> IO (Ptr MapInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MapInfo
info
CInt
result <- C_VideoMetaUnmapFieldCallback
gst_video_meta_unmap Ptr VideoMeta
meta' Word32
plane Ptr MapInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
VideoMeta -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoMeta
meta
MapInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MapInfo
info
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data VideoMetaUnmapMethodInfo
instance (signature ~ (Word32 -> Gst.MapInfo.MapInfo -> m Bool), MonadIO m) => O.OverloadedMethod VideoMetaUnmapMethodInfo VideoMeta signature where
overloadedMethod = videoMetaUnmap
instance O.OverloadedMethodInfo VideoMetaUnmapMethodInfo VideoMeta where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstVideo.Structs.VideoMeta.videoMetaUnmap",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.24/docs/GI-GstVideo-Structs-VideoMeta.html#v:videoMetaUnmap"
}
#endif
foreign import ccall "gst_video_meta_get_info" gst_video_meta_get_info ::
IO (Ptr Gst.MetaInfo.MetaInfo)
videoMetaGetInfo ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Gst.MetaInfo.MetaInfo
videoMetaGetInfo :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m MetaInfo
videoMetaGetInfo = IO MetaInfo -> m MetaInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MetaInfo -> m MetaInfo) -> IO MetaInfo -> m MetaInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr MetaInfo
result <- IO (Ptr MetaInfo)
gst_video_meta_get_info
Text -> Ptr MetaInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoMetaGetInfo" Ptr MetaInfo
result
MetaInfo
result' <- ((ManagedPtr MetaInfo -> MetaInfo) -> Ptr MetaInfo -> IO MetaInfo
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr MetaInfo -> MetaInfo
Gst.MetaInfo.MetaInfo) Ptr MetaInfo
result
MetaInfo -> IO MetaInfo
forall (m :: * -> *) a. Monad m => a -> m a
return MetaInfo
result'
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveVideoMetaMethod (t :: Symbol) (o :: *) :: * where
ResolveVideoMetaMethod "map" o = VideoMetaMapMethodInfo
ResolveVideoMetaMethod "unmap" o = VideoMetaUnmapMethodInfo
ResolveVideoMetaMethod "setAlignment" o = VideoMetaSetAlignmentMethodInfo
ResolveVideoMetaMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveVideoMetaMethod t VideoMeta, O.OverloadedMethod info VideoMeta p) => OL.IsLabel t (VideoMeta -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveVideoMetaMethod t VideoMeta, O.OverloadedMethod info VideoMeta p, R.HasField t VideoMeta p) => R.HasField t VideoMeta p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveVideoMetaMethod t VideoMeta, O.OverloadedMethodInfo info VideoMeta) => OL.IsLabel t (O.MethodProxy info VideoMeta) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif