{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Extra buffer metadata describing how much audio has to be clipped from
-- the start or end of a buffer. This is used for compressed formats, where
-- the first frame usually has some additional samples due to encoder and
-- decoder delays, and the last frame usually has some additional samples to
-- be able to fill the complete last frame.
-- 
-- This is used to ensure that decoded data in the end has the same amount of
-- samples, and multiply decoded streams can be gaplessly concatenated.
-- 
-- Note: If clipping of the start is done by adjusting the segment, this meta
-- has to be dropped from buffers as otherwise clipping could happen twice.
-- 
-- /Since: 1.8/

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

module GI.GstAudio.Structs.AudioClippingMeta
    ( 

-- * Exported types
    AudioClippingMeta(..)                   ,
    newZeroAudioClippingMeta                ,
    noAudioClippingMeta                     ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveAudioClippingMetaMethod          ,
#endif


-- ** getInfo #method:getInfo#

    audioClippingMetaGetInfo                ,




 -- * Properties
-- ** end #attr:end#
-- | Amount of  to clip from end of buffer

#if defined(ENABLE_OVERLOADING)
    audioClippingMeta_end                   ,
#endif
    getAudioClippingMetaEnd                 ,
    setAudioClippingMetaEnd                 ,


-- ** format #attr:format#
-- | GstFormat of /@start@/ and /@stop@/, GST_FORMAT_DEFAULT is samples

#if defined(ENABLE_OVERLOADING)
    audioClippingMeta_format                ,
#endif
    getAudioClippingMetaFormat              ,
    setAudioClippingMetaFormat              ,


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

#if defined(ENABLE_OVERLOADING)
    audioClippingMeta_meta                  ,
#endif
    getAudioClippingMetaMeta                ,


-- ** start #attr:start#
-- | Amount of audio to clip from start of buffer

#if defined(ENABLE_OVERLOADING)
    audioClippingMeta_start                 ,
#endif
    getAudioClippingMetaStart               ,
    setAudioClippingMetaStart               ,




    ) 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 qualified GI.Gst.Enums as Gst.Enums
import qualified GI.Gst.Structs.Meta as Gst.Meta
import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo

-- | Memory-managed wrapper type.
newtype AudioClippingMeta = AudioClippingMeta (ManagedPtr AudioClippingMeta)
    deriving (AudioClippingMeta -> AudioClippingMeta -> Bool
(AudioClippingMeta -> AudioClippingMeta -> Bool)
-> (AudioClippingMeta -> AudioClippingMeta -> Bool)
-> Eq AudioClippingMeta
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioClippingMeta -> AudioClippingMeta -> Bool
$c/= :: AudioClippingMeta -> AudioClippingMeta -> Bool
== :: AudioClippingMeta -> AudioClippingMeta -> Bool
$c== :: AudioClippingMeta -> AudioClippingMeta -> Bool
Eq)
instance WrappedPtr AudioClippingMeta where
    wrappedPtrCalloc :: IO (Ptr AudioClippingMeta)
wrappedPtrCalloc = Int -> IO (Ptr AudioClippingMeta)
forall a. Int -> IO (Ptr a)
callocBytes 40
    wrappedPtrCopy :: AudioClippingMeta -> IO AudioClippingMeta
wrappedPtrCopy = \p :: AudioClippingMeta
p -> AudioClippingMeta
-> (Ptr AudioClippingMeta -> IO AudioClippingMeta)
-> IO AudioClippingMeta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioClippingMeta
p (Int -> Ptr AudioClippingMeta -> IO (Ptr AudioClippingMeta)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 40 (Ptr AudioClippingMeta -> IO (Ptr AudioClippingMeta))
-> (Ptr AudioClippingMeta -> IO AudioClippingMeta)
-> Ptr AudioClippingMeta
-> IO AudioClippingMeta
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr AudioClippingMeta -> AudioClippingMeta)
-> Ptr AudioClippingMeta -> IO AudioClippingMeta
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr AudioClippingMeta -> AudioClippingMeta
AudioClippingMeta)
    wrappedPtrFree :: Maybe (GDestroyNotify AudioClippingMeta)
wrappedPtrFree = GDestroyNotify AudioClippingMeta
-> Maybe (GDestroyNotify AudioClippingMeta)
forall a. a -> Maybe a
Just GDestroyNotify AudioClippingMeta
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `AudioClippingMeta` struct initialized to zero.
newZeroAudioClippingMeta :: MonadIO m => m AudioClippingMeta
newZeroAudioClippingMeta :: m AudioClippingMeta
newZeroAudioClippingMeta = IO AudioClippingMeta -> m AudioClippingMeta
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AudioClippingMeta -> m AudioClippingMeta)
-> IO AudioClippingMeta -> m AudioClippingMeta
forall a b. (a -> b) -> a -> b
$ IO (Ptr AudioClippingMeta)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr AudioClippingMeta)
-> (Ptr AudioClippingMeta -> IO AudioClippingMeta)
-> IO AudioClippingMeta
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr AudioClippingMeta -> AudioClippingMeta)
-> Ptr AudioClippingMeta -> IO AudioClippingMeta
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr AudioClippingMeta -> AudioClippingMeta
AudioClippingMeta

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


-- | A convenience alias for `Nothing` :: `Maybe` `AudioClippingMeta`.
noAudioClippingMeta :: Maybe AudioClippingMeta
noAudioClippingMeta :: Maybe AudioClippingMeta
noAudioClippingMeta = Maybe AudioClippingMeta
forall a. Maybe a
Nothing

-- | Get the value of the “@meta@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' audioClippingMeta #meta
-- @
getAudioClippingMetaMeta :: MonadIO m => AudioClippingMeta -> m Gst.Meta.Meta
getAudioClippingMetaMeta :: AudioClippingMeta -> m Meta
getAudioClippingMetaMeta s :: AudioClippingMeta
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
$ AudioClippingMeta -> (Ptr AudioClippingMeta -> IO Meta) -> IO Meta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioClippingMeta
s ((Ptr AudioClippingMeta -> IO Meta) -> IO Meta)
-> (Ptr AudioClippingMeta -> IO Meta) -> IO Meta
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr AudioClippingMeta
ptr -> do
    let val :: Ptr Meta
val = Ptr AudioClippingMeta
ptr Ptr AudioClippingMeta -> Int -> Ptr Meta
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0 :: (Ptr Gst.Meta.Meta)
    Meta
val' <- ((ManagedPtr Meta -> Meta) -> Ptr Meta -> IO Meta
forall a.
(HasCallStack, WrappedPtr 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 AudioClippingMetaMetaFieldInfo
instance AttrInfo AudioClippingMetaMetaFieldInfo where
    type AttrBaseTypeConstraint AudioClippingMetaMetaFieldInfo = (~) AudioClippingMeta
    type AttrAllowedOps AudioClippingMetaMetaFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint AudioClippingMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta)
    type AttrTransferTypeConstraint AudioClippingMetaMetaFieldInfo = (~)(Ptr Gst.Meta.Meta)
    type AttrTransferType AudioClippingMetaMetaFieldInfo = (Ptr Gst.Meta.Meta)
    type AttrGetType AudioClippingMetaMetaFieldInfo = Gst.Meta.Meta
    type AttrLabel AudioClippingMetaMetaFieldInfo = "meta"
    type AttrOrigin AudioClippingMetaMetaFieldInfo = AudioClippingMeta
    attrGet = getAudioClippingMetaMeta
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

audioClippingMeta_meta :: AttrLabelProxy "meta"
audioClippingMeta_meta = AttrLabelProxy

#endif


-- | Get the value of the “@format@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' audioClippingMeta #format
-- @
getAudioClippingMetaFormat :: MonadIO m => AudioClippingMeta -> m Gst.Enums.Format
getAudioClippingMetaFormat :: AudioClippingMeta -> m Format
getAudioClippingMetaFormat s :: AudioClippingMeta
s = IO Format -> m Format
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Format -> m Format) -> IO Format -> m Format
forall a b. (a -> b) -> a -> b
$ AudioClippingMeta
-> (Ptr AudioClippingMeta -> IO Format) -> IO Format
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioClippingMeta
s ((Ptr AudioClippingMeta -> IO Format) -> IO Format)
-> (Ptr AudioClippingMeta -> IO Format) -> IO Format
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr AudioClippingMeta
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr AudioClippingMeta
ptr Ptr AudioClippingMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) :: IO CUInt
    let val' :: Format
val' = (Int -> Format
forall a. Enum a => Int -> a
toEnum (Int -> Format) -> (CUInt -> Int) -> CUInt -> Format
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    Format -> IO Format
forall (m :: * -> *) a. Monad m => a -> m a
return Format
val'

-- | Set the value of the “@format@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' audioClippingMeta [ #format 'Data.GI.Base.Attributes.:=' value ]
-- @
setAudioClippingMetaFormat :: MonadIO m => AudioClippingMeta -> Gst.Enums.Format -> m ()
setAudioClippingMetaFormat :: AudioClippingMeta -> Format -> m ()
setAudioClippingMetaFormat s :: AudioClippingMeta
s val :: Format
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ AudioClippingMeta -> (Ptr AudioClippingMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioClippingMeta
s ((Ptr AudioClippingMeta -> IO ()) -> IO ())
-> (Ptr AudioClippingMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr AudioClippingMeta
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AudioClippingMeta
ptr Ptr AudioClippingMeta -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data AudioClippingMetaFormatFieldInfo
instance AttrInfo AudioClippingMetaFormatFieldInfo where
    type AttrBaseTypeConstraint AudioClippingMetaFormatFieldInfo = (~) AudioClippingMeta
    type AttrAllowedOps AudioClippingMetaFormatFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AudioClippingMetaFormatFieldInfo = (~) Gst.Enums.Format
    type AttrTransferTypeConstraint AudioClippingMetaFormatFieldInfo = (~)Gst.Enums.Format
    type AttrTransferType AudioClippingMetaFormatFieldInfo = Gst.Enums.Format
    type AttrGetType AudioClippingMetaFormatFieldInfo = Gst.Enums.Format
    type AttrLabel AudioClippingMetaFormatFieldInfo = "format"
    type AttrOrigin AudioClippingMetaFormatFieldInfo = AudioClippingMeta
    attrGet = getAudioClippingMetaFormat
    attrSet = setAudioClippingMetaFormat
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

audioClippingMeta_format :: AttrLabelProxy "format"
audioClippingMeta_format = AttrLabelProxy

#endif


-- | Get the value of the “@start@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' audioClippingMeta #start
-- @
getAudioClippingMetaStart :: MonadIO m => AudioClippingMeta -> m Word64
getAudioClippingMetaStart :: AudioClippingMeta -> m Word64
getAudioClippingMetaStart s :: AudioClippingMeta
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
$ AudioClippingMeta
-> (Ptr AudioClippingMeta -> IO Word64) -> IO Word64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AudioClippingMeta
s ((Ptr AudioClippingMeta -> IO Word64) -> IO Word64)
-> (Ptr AudioClippingMeta -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr AudioClippingMeta
ptr -> do
    Word64
val <- Ptr Word64 -> IO Word64
forall a. Storable a => Ptr a -> IO a
peek (Ptr AudioClippingMeta
ptr Ptr AudioClippingMeta -> 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

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

#if defined(ENABLE_OVERLOADING)
data AudioClippingMetaStartFieldInfo
instance AttrInfo AudioClippingMetaStartFieldInfo where
    type AttrBaseTypeConstraint AudioClippingMetaStartFieldInfo = (~) AudioClippingMeta
    type AttrAllowedOps AudioClippingMetaStartFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AudioClippingMetaStartFieldInfo = (~) Word64
    type AttrTransferTypeConstraint AudioClippingMetaStartFieldInfo = (~)Word64
    type AttrTransferType AudioClippingMetaStartFieldInfo = Word64
    type AttrGetType AudioClippingMetaStartFieldInfo = Word64
    type AttrLabel AudioClippingMetaStartFieldInfo = "start"
    type AttrOrigin AudioClippingMetaStartFieldInfo = AudioClippingMeta
    attrGet = getAudioClippingMetaStart
    attrSet = setAudioClippingMetaStart
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

audioClippingMeta_start :: AttrLabelProxy "start"
audioClippingMeta_start = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data AudioClippingMetaEndFieldInfo
instance AttrInfo AudioClippingMetaEndFieldInfo where
    type AttrBaseTypeConstraint AudioClippingMetaEndFieldInfo = (~) AudioClippingMeta
    type AttrAllowedOps AudioClippingMetaEndFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AudioClippingMetaEndFieldInfo = (~) Word64
    type AttrTransferTypeConstraint AudioClippingMetaEndFieldInfo = (~)Word64
    type AttrTransferType AudioClippingMetaEndFieldInfo = Word64
    type AttrGetType AudioClippingMetaEndFieldInfo = Word64
    type AttrLabel AudioClippingMetaEndFieldInfo = "end"
    type AttrOrigin AudioClippingMetaEndFieldInfo = AudioClippingMeta
    attrGet = getAudioClippingMetaEnd
    attrSet = setAudioClippingMetaEnd
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

audioClippingMeta_end :: AttrLabelProxy "end"
audioClippingMeta_end = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList AudioClippingMeta
type instance O.AttributeList AudioClippingMeta = AudioClippingMetaAttributeList
type AudioClippingMetaAttributeList = ('[ '("meta", AudioClippingMetaMetaFieldInfo), '("format", AudioClippingMetaFormatFieldInfo), '("start", AudioClippingMetaStartFieldInfo), '("end", AudioClippingMetaEndFieldInfo)] :: [(Symbol, *)])
#endif

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

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

-- | /No description available in the introspection data./
audioClippingMetaGetInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Gst.MetaInfo.MetaInfo
audioClippingMetaGetInfo :: m MetaInfo
audioClippingMetaGetInfo  = 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_audio_clipping_meta_get_info
    Text -> Ptr MetaInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "audioClippingMetaGetInfo" Ptr MetaInfo
result
    MetaInfo
result' <- ((ManagedPtr MetaInfo -> MetaInfo) -> Ptr MetaInfo -> IO MetaInfo
forall a.
(HasCallStack, WrappedPtr 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 ResolveAudioClippingMetaMethod (t :: Symbol) (o :: *) :: * where
    ResolveAudioClippingMetaMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveAudioClippingMetaMethod t AudioClippingMeta, O.MethodInfo info AudioClippingMeta p) => OL.IsLabel t (AudioClippingMeta -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif