{-# 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 ,
#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.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.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 {-# 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 (SP.ManagedPtr PadProbeInfo)
deriving (PadProbeInfo -> PadProbeInfo -> Bool
(PadProbeInfo -> PadProbeInfo -> Bool)
-> (PadProbeInfo -> PadProbeInfo -> Bool) -> Eq PadProbeInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PadProbeInfo -> PadProbeInfo -> Bool
== :: PadProbeInfo -> PadProbeInfo -> Bool
$c/= :: PadProbeInfo -> PadProbeInfo -> Bool
/= :: PadProbeInfo -> PadProbeInfo -> Bool
Eq)
instance SP.ManagedPtrNewtype PadProbeInfo where
toManagedPtr :: PadProbeInfo -> ManagedPtr PadProbeInfo
toManagedPtr (PadProbeInfo ManagedPtr PadProbeInfo
p) = ManagedPtr PadProbeInfo
p
instance BoxedPtr PadProbeInfo where
boxedPtrCopy :: PadProbeInfo -> IO PadProbeInfo
boxedPtrCopy = \PadProbeInfo
p -> PadProbeInfo
-> (Ptr PadProbeInfo -> IO PadProbeInfo) -> IO PadProbeInfo
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr PadProbeInfo
p (Int -> Ptr PadProbeInfo -> IO (Ptr PadProbeInfo)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
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, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr PadProbeInfo -> PadProbeInfo
PadProbeInfo)
boxedPtrFree :: PadProbeInfo -> IO ()
boxedPtrFree = \PadProbeInfo
x -> PadProbeInfo -> (Ptr PadProbeInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr PadProbeInfo
x Ptr PadProbeInfo -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr PadProbeInfo where
boxedPtrCalloc :: IO (Ptr PadProbeInfo)
boxedPtrCalloc = Int -> IO (Ptr PadProbeInfo)
forall a. Int -> IO (Ptr a)
callocBytes Int
40
newZeroPadProbeInfo :: MonadIO m => m PadProbeInfo
newZeroPadProbeInfo :: forall (m :: * -> *). MonadIO m => m PadProbeInfo
newZeroPadProbeInfo = IO PadProbeInfo -> m PadProbeInfo
forall a. IO a -> m a
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. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr PadProbeInfo)
-> (Ptr PadProbeInfo -> IO PadProbeInfo) -> IO PadProbeInfo
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr PadProbeInfo -> PadProbeInfo)
-> Ptr PadProbeInfo -> IO PadProbeInfo
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr PadProbeInfo -> PadProbeInfo
PadProbeInfo
instance tag ~ 'AttrSet => Constructible PadProbeInfo tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr PadProbeInfo -> PadProbeInfo)
-> [AttrOp PadProbeInfo tag] -> m PadProbeInfo
new ManagedPtr PadProbeInfo -> PadProbeInfo
_ [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 a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return PadProbeInfo
o
getPadProbeInfoType :: MonadIO m => PadProbeInfo -> m [Gst.Flags.PadProbeType]
getPadProbeInfoType :: forall (m :: * -> *). MonadIO m => PadProbeInfo -> m [PadProbeType]
getPadProbeInfoType PadProbeInfo
s = IO [PadProbeType] -> m [PadProbeType]
forall a. IO a -> m a
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 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` Int
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [PadProbeType]
val'
setPadProbeInfoType :: MonadIO m => PadProbeInfo -> [Gst.Flags.PadProbeType] -> m ()
setPadProbeInfoType :: forall (m :: * -> *).
MonadIO m =>
PadProbeInfo -> [PadProbeType] -> m ()
setPadProbeInfoType PadProbeInfo
s [PadProbeType]
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
$ 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 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` Int
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.PadProbeInfo.type"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-PadProbeInfo.html#g:attr:type"
})
padProbeInfo_type :: AttrLabelProxy "type"
padProbeInfo_type = AttrLabelProxy
#endif
getPadProbeInfoId :: MonadIO m => PadProbeInfo -> m CULong
getPadProbeInfoId :: forall (m :: * -> *). MonadIO m => PadProbeInfo -> m CULong
getPadProbeInfoId PadProbeInfo
s = IO CULong -> m CULong
forall a. IO a -> m a
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 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` Int
8) :: IO CULong
CULong -> IO CULong
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CULong
val
setPadProbeInfoId :: MonadIO m => PadProbeInfo -> CULong -> m ()
setPadProbeInfoId :: forall (m :: * -> *). MonadIO m => PadProbeInfo -> CULong -> m ()
setPadProbeInfoId PadProbeInfo
s CULong
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
$ 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 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` Int
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.PadProbeInfo.id"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-PadProbeInfo.html#g:attr:id"
})
padProbeInfo_id :: AttrLabelProxy "id"
padProbeInfo_id = AttrLabelProxy
#endif
getPadProbeInfoData :: MonadIO m => PadProbeInfo -> m (Ptr ())
getPadProbeInfoData :: forall (m :: * -> *). MonadIO m => PadProbeInfo -> m (Ptr ())
getPadProbeInfoData PadProbeInfo
s = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
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 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` Int
16) :: IO (Ptr ())
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
val
setPadProbeInfoData :: MonadIO m => PadProbeInfo -> Ptr () -> m ()
setPadProbeInfoData :: forall (m :: * -> *). MonadIO m => PadProbeInfo -> Ptr () -> m ()
setPadProbeInfoData PadProbeInfo
s Ptr ()
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
$ 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 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` Int
16) (Ptr ()
val :: Ptr ())
clearPadProbeInfoData :: MonadIO m => PadProbeInfo -> m ()
clearPadProbeInfoData :: forall (m :: * -> *). MonadIO m => PadProbeInfo -> m ()
clearPadProbeInfoData PadProbeInfo
s = 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
$ 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 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` Int
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.PadProbeInfo.data"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-PadProbeInfo.html#g:attr:data"
})
padProbeInfo_data :: AttrLabelProxy "data"
padProbeInfo_data = AttrLabelProxy
#endif
getPadProbeInfoOffset :: MonadIO m => PadProbeInfo -> m Word64
getPadProbeInfoOffset :: forall (m :: * -> *). MonadIO m => PadProbeInfo -> m Word64
getPadProbeInfoOffset PadProbeInfo
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
$ 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 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` Int
24) :: IO Word64
Word64 -> IO Word64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
val
setPadProbeInfoOffset :: MonadIO m => PadProbeInfo -> Word64 -> m ()
setPadProbeInfoOffset :: forall (m :: * -> *). MonadIO m => PadProbeInfo -> Word64 -> m ()
setPadProbeInfoOffset PadProbeInfo
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
$ 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 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` Int
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.PadProbeInfo.offset"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-PadProbeInfo.html#g:attr:offset"
})
padProbeInfo_offset :: AttrLabelProxy "offset"
padProbeInfo_offset = AttrLabelProxy
#endif
getPadProbeInfoSize :: MonadIO m => PadProbeInfo -> m Word32
getPadProbeInfoSize :: forall (m :: * -> *). MonadIO m => PadProbeInfo -> m Word32
getPadProbeInfoSize PadProbeInfo
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
$ 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 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` Int
32) :: IO Word32
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setPadProbeInfoSize :: MonadIO m => PadProbeInfo -> Word32 -> m ()
setPadProbeInfoSize :: forall (m :: * -> *). MonadIO m => PadProbeInfo -> Word32 -> m ()
setPadProbeInfoSize PadProbeInfo
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
$ 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 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` Int
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.PadProbeInfo.size"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-PadProbeInfo.html#g:attr:size"
})
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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PadProbeInfo -> m (Maybe Buffer)
padProbeInfoGetBuffer PadProbeInfo
info = IO (Maybe Buffer) -> m (Maybe Buffer)
forall a. IO a -> m a
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
$ \Ptr Buffer
result' -> do
Buffer
result'' <- ((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
result'
Buffer -> IO Buffer
forall a. a -> IO a
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 a. a -> IO a
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.OverloadedMethod PadProbeInfoGetBufferMethodInfo PadProbeInfo signature where
overloadedMethod = padProbeInfoGetBuffer
instance O.OverloadedMethodInfo PadProbeInfoGetBufferMethodInfo PadProbeInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.PadProbeInfo.padProbeInfoGetBuffer",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-PadProbeInfo.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PadProbeInfo -> m (Maybe BufferList)
padProbeInfoGetBufferList PadProbeInfo
info = IO (Maybe BufferList) -> m (Maybe BufferList)
forall a. IO a -> m a
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
$ \Ptr BufferList
result' -> do
BufferList
result'' <- ((ManagedPtr BufferList -> BufferList)
-> Ptr BufferList -> IO BufferList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr BufferList -> BufferList
Gst.BufferList.BufferList) Ptr BufferList
result'
BufferList -> IO BufferList
forall a. a -> IO a
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 a. a -> IO a
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.OverloadedMethod PadProbeInfoGetBufferListMethodInfo PadProbeInfo signature where
overloadedMethod = padProbeInfoGetBufferList
instance O.OverloadedMethodInfo PadProbeInfoGetBufferListMethodInfo PadProbeInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.PadProbeInfo.padProbeInfoGetBufferList",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-PadProbeInfo.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PadProbeInfo -> m (Maybe Event)
padProbeInfoGetEvent PadProbeInfo
info = IO (Maybe Event) -> m (Maybe Event)
forall a. IO a -> m a
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
$ \Ptr Event
result' -> do
Event
result'' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Event -> Event
Gst.Event.Event) Ptr Event
result'
Event -> IO Event
forall a. a -> IO a
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 a. a -> IO a
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.OverloadedMethod PadProbeInfoGetEventMethodInfo PadProbeInfo signature where
overloadedMethod = padProbeInfoGetEvent
instance O.OverloadedMethodInfo PadProbeInfoGetEventMethodInfo PadProbeInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.PadProbeInfo.padProbeInfoGetEvent",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-PadProbeInfo.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PadProbeInfo -> m (Maybe Query)
padProbeInfoGetQuery PadProbeInfo
info = IO (Maybe Query) -> m (Maybe Query)
forall a. IO a -> m a
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
$ \Ptr Query
result' -> do
Query
result'' <- ((ManagedPtr Query -> Query) -> Ptr Query -> IO Query
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Query -> Query
Gst.Query.Query) Ptr Query
result'
Query -> IO Query
forall a. a -> IO a
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 a. a -> IO a
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.OverloadedMethod PadProbeInfoGetQueryMethodInfo PadProbeInfo signature where
overloadedMethod = padProbeInfoGetQuery
instance O.OverloadedMethodInfo PadProbeInfoGetQueryMethodInfo PadProbeInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Structs.PadProbeInfo.padProbeInfoGetQuery",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.26/docs/GI-Gst-Structs-PadProbeInfo.html#v: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.OverloadedMethod 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
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolvePadProbeInfoMethod t PadProbeInfo, O.OverloadedMethod info PadProbeInfo p, R.HasField t PadProbeInfo p) => R.HasField t PadProbeInfo p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolvePadProbeInfoMethod t PadProbeInfo, O.OverloadedMethodInfo info PadProbeInfo) => OL.IsLabel t (O.MethodProxy info PadProbeInfo) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif