{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.PadProbeInfo
(
PadProbeInfo(..) ,
newZeroPadProbeInfo ,
noPadProbeInfo ,
#if defined(ENABLE_OVERLOADING)
ResolvePadProbeInfoMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
PadProbeInfoGetBufferMethodInfo ,
#endif
padProbeInfoGetBuffer ,
#if defined(ENABLE_OVERLOADING)
PadProbeInfoGetBufferListMethodInfo ,
#endif
padProbeInfoGetBufferList ,
#if defined(ENABLE_OVERLOADING)
PadProbeInfoGetEventMethodInfo ,
#endif
padProbeInfoGetEvent ,
#if defined(ENABLE_OVERLOADING)
PadProbeInfoGetQueryMethodInfo ,
#endif
padProbeInfoGetQuery ,
clearPadProbeInfoData ,
getPadProbeInfoData ,
#if defined(ENABLE_OVERLOADING)
padProbeInfo_data ,
#endif
setPadProbeInfoData ,
getPadProbeInfoId ,
#if defined(ENABLE_OVERLOADING)
padProbeInfo_id ,
#endif
setPadProbeInfoId ,
getPadProbeInfoOffset ,
#if defined(ENABLE_OVERLOADING)
padProbeInfo_offset ,
#endif
setPadProbeInfoOffset ,
getPadProbeInfoSize ,
#if defined(ENABLE_OVERLOADING)
padProbeInfo_size ,
#endif
setPadProbeInfoSize ,
getPadProbeInfoType ,
#if defined(ENABLE_OVERLOADING)
padProbeInfo_type ,
#endif
setPadProbeInfoType ,
) 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.ManagedPtr as B.ManagedPtr
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 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 {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
import {-# SOURCE #-} qualified GI.Gst.Structs.Buffer as Gst.Buffer
import {-# SOURCE #-} qualified GI.Gst.Structs.BufferList as Gst.BufferList
import {-# SOURCE #-} qualified GI.Gst.Structs.Event as Gst.Event
import {-# SOURCE #-} qualified GI.Gst.Structs.Query as Gst.Query
newtype PadProbeInfo = PadProbeInfo (ManagedPtr PadProbeInfo)
deriving (PadProbeInfo -> PadProbeInfo -> Bool
(PadProbeInfo -> PadProbeInfo -> Bool)
-> (PadProbeInfo -> PadProbeInfo -> Bool) -> Eq PadProbeInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PadProbeInfo -> PadProbeInfo -> Bool
$c/= :: PadProbeInfo -> PadProbeInfo -> Bool
== :: PadProbeInfo -> PadProbeInfo -> Bool
$c== :: PadProbeInfo -> PadProbeInfo -> Bool
Eq)
instance WrappedPtr PadProbeInfo where
wrappedPtrCalloc :: IO (Ptr PadProbeInfo)
wrappedPtrCalloc = Int -> IO (Ptr PadProbeInfo)
forall a. Int -> IO (Ptr a)
callocBytes 40
wrappedPtrCopy :: PadProbeInfo -> IO PadProbeInfo
wrappedPtrCopy = \p :: PadProbeInfo
p -> PadProbeInfo
-> (Ptr PadProbeInfo -> IO PadProbeInfo) -> IO PadProbeInfo
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
p (Int -> Ptr PadProbeInfo -> IO (Ptr PadProbeInfo)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 40 (Ptr PadProbeInfo -> IO (Ptr PadProbeInfo))
-> (Ptr PadProbeInfo -> IO PadProbeInfo)
-> Ptr PadProbeInfo
-> IO PadProbeInfo
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr PadProbeInfo -> PadProbeInfo)
-> Ptr PadProbeInfo -> IO PadProbeInfo
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr PadProbeInfo -> PadProbeInfo
PadProbeInfo)
wrappedPtrFree :: Maybe (GDestroyNotify PadProbeInfo)
wrappedPtrFree = GDestroyNotify PadProbeInfo -> Maybe (GDestroyNotify PadProbeInfo)
forall a. a -> Maybe a
Just GDestroyNotify PadProbeInfo
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free
newZeroPadProbeInfo :: MonadIO m => m PadProbeInfo
newZeroPadProbeInfo :: m PadProbeInfo
newZeroPadProbeInfo = IO PadProbeInfo -> m PadProbeInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadProbeInfo -> m PadProbeInfo)
-> IO PadProbeInfo -> m PadProbeInfo
forall a b. (a -> b) -> a -> b
$ IO (Ptr PadProbeInfo)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr PadProbeInfo)
-> (Ptr PadProbeInfo -> IO PadProbeInfo) -> IO PadProbeInfo
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr PadProbeInfo -> PadProbeInfo)
-> Ptr PadProbeInfo -> IO PadProbeInfo
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr PadProbeInfo -> PadProbeInfo
PadProbeInfo
instance tag ~ 'AttrSet => Constructible PadProbeInfo tag where
new :: (ManagedPtr PadProbeInfo -> PadProbeInfo)
-> [AttrOp PadProbeInfo tag] -> m PadProbeInfo
new _ attrs :: [AttrOp PadProbeInfo tag]
attrs = do
PadProbeInfo
o <- m PadProbeInfo
forall (m :: * -> *). MonadIO m => m PadProbeInfo
newZeroPadProbeInfo
PadProbeInfo -> [AttrOp PadProbeInfo 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set PadProbeInfo
o [AttrOp PadProbeInfo tag]
[AttrOp PadProbeInfo 'AttrSet]
attrs
PadProbeInfo -> m PadProbeInfo
forall (m :: * -> *) a. Monad m => a -> m a
return PadProbeInfo
o
noPadProbeInfo :: Maybe PadProbeInfo
noPadProbeInfo :: Maybe PadProbeInfo
noPadProbeInfo = Maybe PadProbeInfo
forall a. Maybe a
Nothing
getPadProbeInfoType :: MonadIO m => PadProbeInfo -> m [Gst.Flags.PadProbeType]
getPadProbeInfoType :: PadProbeInfo -> m [PadProbeType]
getPadProbeInfoType s :: PadProbeInfo
s = IO [PadProbeType] -> m [PadProbeType]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [PadProbeType] -> m [PadProbeType])
-> IO [PadProbeType] -> m [PadProbeType]
forall a b. (a -> b) -> a -> b
$ PadProbeInfo
-> (Ptr PadProbeInfo -> IO [PadProbeType]) -> IO [PadProbeType]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO [PadProbeType]) -> IO [PadProbeType])
-> (Ptr PadProbeInfo -> IO [PadProbeType]) -> IO [PadProbeType]
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO CUInt
let val' :: [PadProbeType]
val' = CUInt -> [PadProbeType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
[PadProbeType] -> IO [PadProbeType]
forall (m :: * -> *) a. Monad m => a -> m a
return [PadProbeType]
val'
setPadProbeInfoType :: MonadIO m => PadProbeInfo -> [Gst.Flags.PadProbeType] -> m ()
setPadProbeInfoType :: PadProbeInfo -> [PadProbeType] -> m ()
setPadProbeInfoType s :: PadProbeInfo
s val :: [PadProbeType]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PadProbeInfo -> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO ()) -> IO ())
-> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
let val' :: CUInt
val' = [PadProbeType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PadProbeType]
val
Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data PadProbeInfoTypeFieldInfo
instance AttrInfo PadProbeInfoTypeFieldInfo where
type AttrBaseTypeConstraint PadProbeInfoTypeFieldInfo = (~) PadProbeInfo
type AttrAllowedOps PadProbeInfoTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint PadProbeInfoTypeFieldInfo = (~) [Gst.Flags.PadProbeType]
type AttrTransferTypeConstraint PadProbeInfoTypeFieldInfo = (~)[Gst.Flags.PadProbeType]
type AttrTransferType PadProbeInfoTypeFieldInfo = [Gst.Flags.PadProbeType]
type AttrGetType PadProbeInfoTypeFieldInfo = [Gst.Flags.PadProbeType]
type AttrLabel PadProbeInfoTypeFieldInfo = "type"
type AttrOrigin PadProbeInfoTypeFieldInfo = PadProbeInfo
attrGet = getPadProbeInfoType
attrSet = setPadProbeInfoType
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
padProbeInfo_type :: AttrLabelProxy "type"
padProbeInfo_type = AttrLabelProxy
#endif
getPadProbeInfoId :: MonadIO m => PadProbeInfo -> m CULong
getPadProbeInfoId :: PadProbeInfo -> m CULong
getPadProbeInfoId s :: PadProbeInfo
s = IO CULong -> m CULong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ PadProbeInfo -> (Ptr PadProbeInfo -> IO CULong) -> IO CULong
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO CULong) -> IO CULong)
-> (Ptr PadProbeInfo -> IO CULong) -> IO CULong
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
CULong
val <- Ptr CULong -> IO CULong
forall a. Storable a => Ptr a -> IO a
peek (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) :: IO CULong
CULong -> IO CULong
forall (m :: * -> *) a. Monad m => a -> m a
return CULong
val
setPadProbeInfoId :: MonadIO m => PadProbeInfo -> CULong -> m ()
setPadProbeInfoId :: PadProbeInfo -> CULong -> m ()
setPadProbeInfoId s :: PadProbeInfo
s val :: CULong
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PadProbeInfo -> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO ()) -> IO ())
-> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
Ptr CULong -> CULong -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (CULong
val :: CULong)
#if defined(ENABLE_OVERLOADING)
data PadProbeInfoIdFieldInfo
instance AttrInfo PadProbeInfoIdFieldInfo where
type AttrBaseTypeConstraint PadProbeInfoIdFieldInfo = (~) PadProbeInfo
type AttrAllowedOps PadProbeInfoIdFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint PadProbeInfoIdFieldInfo = (~) CULong
type AttrTransferTypeConstraint PadProbeInfoIdFieldInfo = (~)CULong
type AttrTransferType PadProbeInfoIdFieldInfo = CULong
type AttrGetType PadProbeInfoIdFieldInfo = CULong
type AttrLabel PadProbeInfoIdFieldInfo = "id"
type AttrOrigin PadProbeInfoIdFieldInfo = PadProbeInfo
attrGet = getPadProbeInfoId
attrSet = setPadProbeInfoId
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
padProbeInfo_id :: AttrLabelProxy "id"
padProbeInfo_id = AttrLabelProxy
#endif
getPadProbeInfoData :: MonadIO m => PadProbeInfo -> m (Ptr ())
getPadProbeInfoData :: PadProbeInfo -> m (Ptr ())
getPadProbeInfoData s :: PadProbeInfo
s = IO (Ptr ()) -> m (Ptr ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ PadProbeInfo -> (Ptr PadProbeInfo -> IO (Ptr ())) -> IO (Ptr ())
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO (Ptr ())) -> IO (Ptr ()))
-> (Ptr PadProbeInfo -> IO (Ptr ())) -> IO (Ptr ())
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
Ptr ()
val <- Ptr (Ptr ()) -> IO (Ptr ())
forall a. Storable a => Ptr a -> IO a
peek (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) :: IO (Ptr ())
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
val
setPadProbeInfoData :: MonadIO m => PadProbeInfo -> Ptr () -> m ()
setPadProbeInfoData :: PadProbeInfo -> Ptr () -> m ()
setPadProbeInfoData s :: PadProbeInfo
s val :: Ptr ()
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PadProbeInfo -> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO ()) -> IO ())
-> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (Ptr ()
val :: Ptr ())
clearPadProbeInfoData :: MonadIO m => PadProbeInfo -> m ()
clearPadProbeInfoData :: PadProbeInfo -> m ()
clearPadProbeInfoData s :: PadProbeInfo
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PadProbeInfo -> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO ()) -> IO ())
-> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
Ptr (Ptr ()) -> Ptr () -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr (Ptr ())
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (Ptr ()
forall a. Ptr a
FP.nullPtr :: Ptr ())
#if defined(ENABLE_OVERLOADING)
data PadProbeInfoDataFieldInfo
instance AttrInfo PadProbeInfoDataFieldInfo where
type AttrBaseTypeConstraint PadProbeInfoDataFieldInfo = (~) PadProbeInfo
type AttrAllowedOps PadProbeInfoDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint PadProbeInfoDataFieldInfo = (~) (Ptr ())
type AttrTransferTypeConstraint PadProbeInfoDataFieldInfo = (~)(Ptr ())
type AttrTransferType PadProbeInfoDataFieldInfo = (Ptr ())
type AttrGetType PadProbeInfoDataFieldInfo = Ptr ()
type AttrLabel PadProbeInfoDataFieldInfo = "data"
type AttrOrigin PadProbeInfoDataFieldInfo = PadProbeInfo
attrGet = getPadProbeInfoData
attrSet = setPadProbeInfoData
attrConstruct = undefined
attrClear = clearPadProbeInfoData
attrTransfer _ v = do
return v
padProbeInfo_data :: AttrLabelProxy "data"
padProbeInfo_data = AttrLabelProxy
#endif
getPadProbeInfoOffset :: MonadIO m => PadProbeInfo -> m Word64
getPadProbeInfoOffset :: PadProbeInfo -> m Word64
getPadProbeInfoOffset s :: PadProbeInfo
s = IO Word64 -> m Word64
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
$ PadProbeInfo -> (Ptr PadProbeInfo -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO Word64) -> IO Word64)
-> (Ptr PadProbeInfo -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) :: IO Word64
Word64 -> IO Word64
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setPadProbeInfoOffset :: MonadIO m => PadProbeInfo -> Word64 -> m ()
setPadProbeInfoOffset :: PadProbeInfo -> Word64 -> m ()
setPadProbeInfoOffset s :: PadProbeInfo
s val :: Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PadProbeInfo -> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO ()) -> IO ())
-> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
Ptr Word64 -> Word64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr Word64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (Word64
val :: Word64)
#if defined(ENABLE_OVERLOADING)
data PadProbeInfoOffsetFieldInfo
instance AttrInfo PadProbeInfoOffsetFieldInfo where
type AttrBaseTypeConstraint PadProbeInfoOffsetFieldInfo = (~) PadProbeInfo
type AttrAllowedOps PadProbeInfoOffsetFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint PadProbeInfoOffsetFieldInfo = (~) Word64
type AttrTransferTypeConstraint PadProbeInfoOffsetFieldInfo = (~)Word64
type AttrTransferType PadProbeInfoOffsetFieldInfo = Word64
type AttrGetType PadProbeInfoOffsetFieldInfo = Word64
type AttrLabel PadProbeInfoOffsetFieldInfo = "offset"
type AttrOrigin PadProbeInfoOffsetFieldInfo = PadProbeInfo
attrGet = getPadProbeInfoOffset
attrSet = setPadProbeInfoOffset
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
padProbeInfo_offset :: AttrLabelProxy "offset"
padProbeInfo_offset = AttrLabelProxy
#endif
getPadProbeInfoSize :: MonadIO m => PadProbeInfo -> m Word32
getPadProbeInfoSize :: PadProbeInfo -> m Word32
getPadProbeInfoSize s :: PadProbeInfo
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
$ PadProbeInfo -> (Ptr PadProbeInfo -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO Word32) -> IO Word32)
-> (Ptr PadProbeInfo -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) :: IO Word32
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setPadProbeInfoSize :: MonadIO m => PadProbeInfo -> Word32 -> m ()
setPadProbeInfoSize :: PadProbeInfo -> Word32 -> m ()
setPadProbeInfoSize s :: PadProbeInfo
s val :: 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
$ PadProbeInfo -> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadProbeInfo
s ((Ptr PadProbeInfo -> IO ()) -> IO ())
-> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadProbeInfo
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PadProbeInfo
ptr Ptr PadProbeInfo -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data PadProbeInfoSizeFieldInfo
instance AttrInfo PadProbeInfoSizeFieldInfo where
type AttrBaseTypeConstraint PadProbeInfoSizeFieldInfo = (~) PadProbeInfo
type AttrAllowedOps PadProbeInfoSizeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint PadProbeInfoSizeFieldInfo = (~) Word32
type AttrTransferTypeConstraint PadProbeInfoSizeFieldInfo = (~)Word32
type AttrTransferType PadProbeInfoSizeFieldInfo = Word32
type AttrGetType PadProbeInfoSizeFieldInfo = Word32
type AttrLabel PadProbeInfoSizeFieldInfo = "size"
type AttrOrigin PadProbeInfoSizeFieldInfo = PadProbeInfo
attrGet = getPadProbeInfoSize
attrSet = setPadProbeInfoSize
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
padProbeInfo_size :: AttrLabelProxy "size"
padProbeInfo_size = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PadProbeInfo
type instance O.AttributeList PadProbeInfo = PadProbeInfoAttributeList
type PadProbeInfoAttributeList = ('[ '("type", PadProbeInfoTypeFieldInfo), '("id", PadProbeInfoIdFieldInfo), '("data", PadProbeInfoDataFieldInfo), '("offset", PadProbeInfoOffsetFieldInfo), '("size", PadProbeInfoSizeFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_pad_probe_info_get_buffer" gst_pad_probe_info_get_buffer ::
Ptr PadProbeInfo ->
IO (Ptr Gst.Buffer.Buffer)
padProbeInfoGetBuffer ::
(B.CallStack.HasCallStack, MonadIO m) =>
PadProbeInfo
-> m (Maybe Gst.Buffer.Buffer)
padProbeInfoGetBuffer :: PadProbeInfo -> m (Maybe Buffer)
padProbeInfoGetBuffer info :: PadProbeInfo
info = 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
$ do
Ptr PadProbeInfo
info' <- PadProbeInfo -> IO (Ptr PadProbeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PadProbeInfo
info
Ptr Buffer
result <- Ptr PadProbeInfo -> IO (Ptr Buffer)
gst_pad_probe_info_get_buffer Ptr PadProbeInfo
info'
Maybe Buffer
maybeResult <- Ptr Buffer -> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Buffer
result ((Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer))
-> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Buffer
result' -> do
Buffer
result'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
result'
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result''
PadProbeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr PadProbeInfo
info
Maybe Buffer -> IO (Maybe Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadProbeInfoGetBufferMethodInfo
instance (signature ~ (m (Maybe Gst.Buffer.Buffer)), MonadIO m) => O.MethodInfo PadProbeInfoGetBufferMethodInfo PadProbeInfo signature where
overloadedMethod = padProbeInfoGetBuffer
#endif
foreign import ccall "gst_pad_probe_info_get_buffer_list" gst_pad_probe_info_get_buffer_list ::
Ptr PadProbeInfo ->
IO (Ptr Gst.BufferList.BufferList)
padProbeInfoGetBufferList ::
(B.CallStack.HasCallStack, MonadIO m) =>
PadProbeInfo
-> m (Maybe Gst.BufferList.BufferList)
padProbeInfoGetBufferList :: PadProbeInfo -> m (Maybe BufferList)
padProbeInfoGetBufferList info :: PadProbeInfo
info = IO (Maybe BufferList) -> m (Maybe BufferList)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BufferList) -> m (Maybe BufferList))
-> IO (Maybe BufferList) -> m (Maybe BufferList)
forall a b. (a -> b) -> a -> b
$ do
Ptr PadProbeInfo
info' <- PadProbeInfo -> IO (Ptr PadProbeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PadProbeInfo
info
Ptr BufferList
result <- Ptr PadProbeInfo -> IO (Ptr BufferList)
gst_pad_probe_info_get_buffer_list Ptr PadProbeInfo
info'
Maybe BufferList
maybeResult <- Ptr BufferList
-> (Ptr BufferList -> IO BufferList) -> IO (Maybe BufferList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BufferList
result ((Ptr BufferList -> IO BufferList) -> IO (Maybe BufferList))
-> (Ptr BufferList -> IO BufferList) -> IO (Maybe BufferList)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr BufferList
result' -> do
BufferList
result'' <- ((ManagedPtr BufferList -> BufferList)
-> Ptr BufferList -> IO BufferList
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr BufferList -> BufferList
Gst.BufferList.BufferList) Ptr BufferList
result'
BufferList -> IO BufferList
forall (m :: * -> *) a. Monad m => a -> m a
return BufferList
result''
PadProbeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr PadProbeInfo
info
Maybe BufferList -> IO (Maybe BufferList)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BufferList
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadProbeInfoGetBufferListMethodInfo
instance (signature ~ (m (Maybe Gst.BufferList.BufferList)), MonadIO m) => O.MethodInfo PadProbeInfoGetBufferListMethodInfo PadProbeInfo signature where
overloadedMethod = padProbeInfoGetBufferList
#endif
foreign import ccall "gst_pad_probe_info_get_event" gst_pad_probe_info_get_event ::
Ptr PadProbeInfo ->
IO (Ptr Gst.Event.Event)
padProbeInfoGetEvent ::
(B.CallStack.HasCallStack, MonadIO m) =>
PadProbeInfo
-> m (Maybe Gst.Event.Event)
padProbeInfoGetEvent :: PadProbeInfo -> m (Maybe Event)
padProbeInfoGetEvent info :: PadProbeInfo
info = IO (Maybe Event) -> m (Maybe Event)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Event) -> m (Maybe Event))
-> IO (Maybe Event) -> m (Maybe Event)
forall a b. (a -> b) -> a -> b
$ do
Ptr PadProbeInfo
info' <- PadProbeInfo -> IO (Ptr PadProbeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PadProbeInfo
info
Ptr Event
result <- Ptr PadProbeInfo -> IO (Ptr Event)
gst_pad_probe_info_get_event Ptr PadProbeInfo
info'
Maybe Event
maybeResult <- Ptr Event -> (Ptr Event -> IO Event) -> IO (Maybe Event)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Event
result ((Ptr Event -> IO Event) -> IO (Maybe Event))
-> (Ptr Event -> IO Event) -> IO (Maybe Event)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Event
result' -> do
Event
result'' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Event -> Event
Gst.Event.Event) Ptr Event
result'
Event -> IO Event
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result''
PadProbeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr PadProbeInfo
info
Maybe Event -> IO (Maybe Event)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Event
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadProbeInfoGetEventMethodInfo
instance (signature ~ (m (Maybe Gst.Event.Event)), MonadIO m) => O.MethodInfo PadProbeInfoGetEventMethodInfo PadProbeInfo signature where
overloadedMethod = padProbeInfoGetEvent
#endif
foreign import ccall "gst_pad_probe_info_get_query" gst_pad_probe_info_get_query ::
Ptr PadProbeInfo ->
IO (Ptr Gst.Query.Query)
padProbeInfoGetQuery ::
(B.CallStack.HasCallStack, MonadIO m) =>
PadProbeInfo
-> m (Maybe Gst.Query.Query)
padProbeInfoGetQuery :: PadProbeInfo -> m (Maybe Query)
padProbeInfoGetQuery info :: PadProbeInfo
info = IO (Maybe Query) -> m (Maybe Query)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Query) -> m (Maybe Query))
-> IO (Maybe Query) -> m (Maybe Query)
forall a b. (a -> b) -> a -> b
$ do
Ptr PadProbeInfo
info' <- PadProbeInfo -> IO (Ptr PadProbeInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr PadProbeInfo
info
Ptr Query
result <- Ptr PadProbeInfo -> IO (Ptr Query)
gst_pad_probe_info_get_query Ptr PadProbeInfo
info'
Maybe Query
maybeResult <- Ptr Query -> (Ptr Query -> IO Query) -> IO (Maybe Query)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Query
result ((Ptr Query -> IO Query) -> IO (Maybe Query))
-> (Ptr Query -> IO Query) -> IO (Maybe Query)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Query
result' -> do
Query
result'' <- ((ManagedPtr Query -> Query) -> Ptr Query -> IO Query
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Query -> Query
Gst.Query.Query) Ptr Query
result'
Query -> IO Query
forall (m :: * -> *) a. Monad m => a -> m a
return Query
result''
PadProbeInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr PadProbeInfo
info
Maybe Query -> IO (Maybe Query)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Query
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadProbeInfoGetQueryMethodInfo
instance (signature ~ (m (Maybe Gst.Query.Query)), MonadIO m) => O.MethodInfo PadProbeInfoGetQueryMethodInfo PadProbeInfo signature where
overloadedMethod = padProbeInfoGetQuery
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolvePadProbeInfoMethod (t :: Symbol) (o :: *) :: * where
ResolvePadProbeInfoMethod "getBuffer" o = PadProbeInfoGetBufferMethodInfo
ResolvePadProbeInfoMethod "getBufferList" o = PadProbeInfoGetBufferListMethodInfo
ResolvePadProbeInfoMethod "getEvent" o = PadProbeInfoGetEventMethodInfo
ResolvePadProbeInfoMethod "getQuery" o = PadProbeInfoGetQueryMethodInfo
ResolvePadProbeInfoMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolvePadProbeInfoMethod t PadProbeInfo, O.MethodInfo info PadProbeInfo p) => OL.IsLabel t (PadProbeInfo -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif