AudioClippingMeta.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

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/
-}

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

module GI.GstAudio.Structs.AudioClippingMeta
    ( 

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


 -- * Methods
-- ** getInfo #method:getInfo#

    audioClippingMetaGetInfo                ,




 -- * Properties
-- ** end #attr:end#
{- | Amount of  to clip from end of buffer
-}
#if ENABLE_OVERLOADING
    audioClippingMeta_end                   ,
#endif
    getAudioClippingMetaEnd                 ,
    setAudioClippingMetaEnd                 ,


-- ** format #attr:format#
{- | GstFormat of /@start@/ and /@stop@/, GST_FORMAT_DEFAULT is samples
-}
#if ENABLE_OVERLOADING
    audioClippingMeta_format                ,
#endif
    getAudioClippingMetaFormat              ,
    setAudioClippingMetaFormat              ,


-- ** meta #attr:meta#
{- | parent 'GI.Gst.Structs.Meta.Meta'
-}
#if ENABLE_OVERLOADING
    audioClippingMeta_meta                  ,
#endif
    getAudioClippingMetaMeta                ,


-- ** start #attr:start#
{- | Amount of audio to clip from start of buffer
-}
#if 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.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)
instance WrappedPtr AudioClippingMeta where
    wrappedPtrCalloc = callocBytes 40
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 40 >=> wrapPtr AudioClippingMeta)
    wrappedPtrFree = Just ptr_to_g_free

-- | Construct a `AudioClippingMeta` struct initialized to zero.
newZeroAudioClippingMeta :: MonadIO m => m AudioClippingMeta
newZeroAudioClippingMeta = liftIO $ wrappedPtrCalloc >>= wrapPtr AudioClippingMeta

instance tag ~ 'AttrSet => Constructible AudioClippingMeta tag where
    new _ attrs = do
        o <- newZeroAudioClippingMeta
        GI.Attributes.set o attrs
        return o


-- | A convenience alias for `Nothing` :: `Maybe` `AudioClippingMeta`.
noAudioClippingMeta :: Maybe AudioClippingMeta
noAudioClippingMeta = 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 s = liftIO $ withManagedPtr s $ \ptr -> do
    let val = ptr `plusPtr` 0 :: (Ptr Gst.Meta.Meta)
    val' <- (newPtr Gst.Meta.Meta) val
    return val'

#if ENABLE_OVERLOADING
data AudioClippingMetaMetaFieldInfo
instance AttrInfo AudioClippingMetaMetaFieldInfo where
    type AttrAllowedOps AudioClippingMetaMetaFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint AudioClippingMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta)
    type AttrBaseTypeConstraint AudioClippingMetaMetaFieldInfo = (~) AudioClippingMeta
    type AttrGetType AudioClippingMetaMetaFieldInfo = Gst.Meta.Meta
    type AttrLabel AudioClippingMetaMetaFieldInfo = "meta"
    type AttrOrigin AudioClippingMetaMetaFieldInfo = AudioClippingMeta
    attrGet _ = getAudioClippingMetaMeta
    attrSet _ = undefined
    attrConstruct = undefined
    attrClear _ = 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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO CUInt
    let val' = (toEnum . fromIntegral) val
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 16) (val' :: CUInt)

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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word64
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word64)

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

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 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Word64
    return 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 s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Word64)

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

audioClippingMeta_end :: AttrLabelProxy "end"
audioClippingMeta_end = AttrLabelProxy

#endif



#if 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  = liftIO $ do
    result <- gst_audio_clipping_meta_get_info
    checkUnexpectedReturnNULL "audioClippingMetaGetInfo" result
    result' <- (newPtr Gst.MetaInfo.MetaInfo) result
    return result'

#if ENABLE_OVERLOADING
#endif

#if 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 (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif