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

Information for an audio format.
-}

module GI.GstAudio.Structs.AudioFormatInfo
    ( 

-- * Exported types
    AudioFormatInfo(..)                     ,
    newZeroAudioFormatInfo                  ,
    noAudioFormatInfo                       ,


 -- * Properties
-- ** depth #attr:depth#
    audioFormatInfo_depth                   ,
    getAudioFormatInfoDepth                 ,
    setAudioFormatInfoDepth                 ,


-- ** description #attr:description#
    audioFormatInfo_description             ,
    clearAudioFormatInfoDescription         ,
    getAudioFormatInfoDescription           ,
    setAudioFormatInfoDescription           ,


-- ** endianness #attr:endianness#
    audioFormatInfo_endianness              ,
    getAudioFormatInfoEndianness            ,
    setAudioFormatInfoEndianness            ,


-- ** flags #attr:flags#
    audioFormatInfo_flags                   ,
    getAudioFormatInfoFlags                 ,
    setAudioFormatInfoFlags                 ,


-- ** format #attr:format#
    audioFormatInfo_format                  ,
    getAudioFormatInfoFormat                ,
    setAudioFormatInfoFormat                ,


-- ** name #attr:name#
    audioFormatInfo_name                    ,
    clearAudioFormatInfoName                ,
    getAudioFormatInfoName                  ,
    setAudioFormatInfoName                  ,


-- ** packFunc #attr:packFunc#
    audioFormatInfo_packFunc                ,
    clearAudioFormatInfoPackFunc            ,
    getAudioFormatInfoPackFunc              ,
    setAudioFormatInfoPackFunc              ,


-- ** unpackFormat #attr:unpackFormat#
    audioFormatInfo_unpackFormat            ,
    getAudioFormatInfoUnpackFormat          ,
    setAudioFormatInfoUnpackFormat          ,


-- ** unpackFunc #attr:unpackFunc#
    audioFormatInfo_unpackFunc              ,
    clearAudioFormatInfoUnpackFunc          ,
    getAudioFormatInfoUnpackFunc            ,
    setAudioFormatInfoUnpackFunc            ,


-- ** width #attr:width#
    audioFormatInfo_width                   ,
    getAudioFormatInfoWidth                 ,
    setAudioFormatInfoWidth                 ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GstAudio.Callbacks as GstAudio.Callbacks
import {-# SOURCE #-} qualified GI.GstAudio.Enums as GstAudio.Enums
import {-# SOURCE #-} qualified GI.GstAudio.Flags as GstAudio.Flags

newtype AudioFormatInfo = AudioFormatInfo (ManagedPtr AudioFormatInfo)
instance WrappedPtr AudioFormatInfo where
    wrappedPtrCalloc = callocBytes 104
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 104 >=> wrapPtr AudioFormatInfo)
    wrappedPtrFree = Just ptr_to_g_free

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

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


noAudioFormatInfo :: Maybe AudioFormatInfo
noAudioFormatInfo = Nothing

getAudioFormatInfoFormat :: MonadIO m => AudioFormatInfo -> m GstAudio.Enums.AudioFormat
getAudioFormatInfoFormat s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CUInt
    let val' = (toEnum . fromIntegral) val
    return val'

setAudioFormatInfoFormat :: MonadIO m => AudioFormatInfo -> GstAudio.Enums.AudioFormat -> m ()
setAudioFormatInfoFormat s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 0) (val' :: CUInt)

data AudioFormatInfoFormatFieldInfo
instance AttrInfo AudioFormatInfoFormatFieldInfo where
    type AttrAllowedOps AudioFormatInfoFormatFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AudioFormatInfoFormatFieldInfo = (~) GstAudio.Enums.AudioFormat
    type AttrBaseTypeConstraint AudioFormatInfoFormatFieldInfo = (~) AudioFormatInfo
    type AttrGetType AudioFormatInfoFormatFieldInfo = GstAudio.Enums.AudioFormat
    type AttrLabel AudioFormatInfoFormatFieldInfo = "format"
    type AttrOrigin AudioFormatInfoFormatFieldInfo = AudioFormatInfo
    attrGet _ = getAudioFormatInfoFormat
    attrSet _ = setAudioFormatInfoFormat
    attrConstruct = undefined
    attrClear _ = undefined

audioFormatInfo_format :: AttrLabelProxy "format"
audioFormatInfo_format = AttrLabelProxy


getAudioFormatInfoName :: MonadIO m => AudioFormatInfo -> m (Maybe T.Text)
getAudioFormatInfoName s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setAudioFormatInfoName :: MonadIO m => AudioFormatInfo -> CString -> m ()
setAudioFormatInfoName s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: CString)

clearAudioFormatInfoName :: MonadIO m => AudioFormatInfo -> m ()
clearAudioFormatInfoName s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: CString)

data AudioFormatInfoNameFieldInfo
instance AttrInfo AudioFormatInfoNameFieldInfo where
    type AttrAllowedOps AudioFormatInfoNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint AudioFormatInfoNameFieldInfo = (~) CString
    type AttrBaseTypeConstraint AudioFormatInfoNameFieldInfo = (~) AudioFormatInfo
    type AttrGetType AudioFormatInfoNameFieldInfo = Maybe T.Text
    type AttrLabel AudioFormatInfoNameFieldInfo = "name"
    type AttrOrigin AudioFormatInfoNameFieldInfo = AudioFormatInfo
    attrGet _ = getAudioFormatInfoName
    attrSet _ = setAudioFormatInfoName
    attrConstruct = undefined
    attrClear _ = clearAudioFormatInfoName

audioFormatInfo_name :: AttrLabelProxy "name"
audioFormatInfo_name = AttrLabelProxy


getAudioFormatInfoDescription :: MonadIO m => AudioFormatInfo -> m (Maybe T.Text)
getAudioFormatInfoDescription s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setAudioFormatInfoDescription :: MonadIO m => AudioFormatInfo -> CString -> m ()
setAudioFormatInfoDescription s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: CString)

clearAudioFormatInfoDescription :: MonadIO m => AudioFormatInfo -> m ()
clearAudioFormatInfoDescription s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (FP.nullPtr :: CString)

data AudioFormatInfoDescriptionFieldInfo
instance AttrInfo AudioFormatInfoDescriptionFieldInfo where
    type AttrAllowedOps AudioFormatInfoDescriptionFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint AudioFormatInfoDescriptionFieldInfo = (~) CString
    type AttrBaseTypeConstraint AudioFormatInfoDescriptionFieldInfo = (~) AudioFormatInfo
    type AttrGetType AudioFormatInfoDescriptionFieldInfo = Maybe T.Text
    type AttrLabel AudioFormatInfoDescriptionFieldInfo = "description"
    type AttrOrigin AudioFormatInfoDescriptionFieldInfo = AudioFormatInfo
    attrGet _ = getAudioFormatInfoDescription
    attrSet _ = setAudioFormatInfoDescription
    attrConstruct = undefined
    attrClear _ = clearAudioFormatInfoDescription

audioFormatInfo_description :: AttrLabelProxy "description"
audioFormatInfo_description = AttrLabelProxy


getAudioFormatInfoFlags :: MonadIO m => AudioFormatInfo -> m [GstAudio.Flags.AudioFormatFlags]
getAudioFormatInfoFlags s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO CUInt
    let val' = wordToGFlags val
    return val'

setAudioFormatInfoFlags :: MonadIO m => AudioFormatInfo -> [GstAudio.Flags.AudioFormatFlags] -> m ()
setAudioFormatInfoFlags s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = gflagsToWord val
    poke (ptr `plusPtr` 24) (val' :: CUInt)

data AudioFormatInfoFlagsFieldInfo
instance AttrInfo AudioFormatInfoFlagsFieldInfo where
    type AttrAllowedOps AudioFormatInfoFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AudioFormatInfoFlagsFieldInfo = (~) [GstAudio.Flags.AudioFormatFlags]
    type AttrBaseTypeConstraint AudioFormatInfoFlagsFieldInfo = (~) AudioFormatInfo
    type AttrGetType AudioFormatInfoFlagsFieldInfo = [GstAudio.Flags.AudioFormatFlags]
    type AttrLabel AudioFormatInfoFlagsFieldInfo = "flags"
    type AttrOrigin AudioFormatInfoFlagsFieldInfo = AudioFormatInfo
    attrGet _ = getAudioFormatInfoFlags
    attrSet _ = setAudioFormatInfoFlags
    attrConstruct = undefined
    attrClear _ = undefined

audioFormatInfo_flags :: AttrLabelProxy "flags"
audioFormatInfo_flags = AttrLabelProxy


getAudioFormatInfoEndianness :: MonadIO m => AudioFormatInfo -> m Int32
getAudioFormatInfoEndianness s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 28) :: IO Int32
    return val

setAudioFormatInfoEndianness :: MonadIO m => AudioFormatInfo -> Int32 -> m ()
setAudioFormatInfoEndianness s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 28) (val :: Int32)

data AudioFormatInfoEndiannessFieldInfo
instance AttrInfo AudioFormatInfoEndiannessFieldInfo where
    type AttrAllowedOps AudioFormatInfoEndiannessFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AudioFormatInfoEndiannessFieldInfo = (~) Int32
    type AttrBaseTypeConstraint AudioFormatInfoEndiannessFieldInfo = (~) AudioFormatInfo
    type AttrGetType AudioFormatInfoEndiannessFieldInfo = Int32
    type AttrLabel AudioFormatInfoEndiannessFieldInfo = "endianness"
    type AttrOrigin AudioFormatInfoEndiannessFieldInfo = AudioFormatInfo
    attrGet _ = getAudioFormatInfoEndianness
    attrSet _ = setAudioFormatInfoEndianness
    attrConstruct = undefined
    attrClear _ = undefined

audioFormatInfo_endianness :: AttrLabelProxy "endianness"
audioFormatInfo_endianness = AttrLabelProxy


getAudioFormatInfoWidth :: MonadIO m => AudioFormatInfo -> m Int32
getAudioFormatInfoWidth s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Int32
    return val

setAudioFormatInfoWidth :: MonadIO m => AudioFormatInfo -> Int32 -> m ()
setAudioFormatInfoWidth s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Int32)

data AudioFormatInfoWidthFieldInfo
instance AttrInfo AudioFormatInfoWidthFieldInfo where
    type AttrAllowedOps AudioFormatInfoWidthFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AudioFormatInfoWidthFieldInfo = (~) Int32
    type AttrBaseTypeConstraint AudioFormatInfoWidthFieldInfo = (~) AudioFormatInfo
    type AttrGetType AudioFormatInfoWidthFieldInfo = Int32
    type AttrLabel AudioFormatInfoWidthFieldInfo = "width"
    type AttrOrigin AudioFormatInfoWidthFieldInfo = AudioFormatInfo
    attrGet _ = getAudioFormatInfoWidth
    attrSet _ = setAudioFormatInfoWidth
    attrConstruct = undefined
    attrClear _ = undefined

audioFormatInfo_width :: AttrLabelProxy "width"
audioFormatInfo_width = AttrLabelProxy


getAudioFormatInfoDepth :: MonadIO m => AudioFormatInfo -> m Int32
getAudioFormatInfoDepth s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 36) :: IO Int32
    return val

setAudioFormatInfoDepth :: MonadIO m => AudioFormatInfo -> Int32 -> m ()
setAudioFormatInfoDepth s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 36) (val :: Int32)

data AudioFormatInfoDepthFieldInfo
instance AttrInfo AudioFormatInfoDepthFieldInfo where
    type AttrAllowedOps AudioFormatInfoDepthFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AudioFormatInfoDepthFieldInfo = (~) Int32
    type AttrBaseTypeConstraint AudioFormatInfoDepthFieldInfo = (~) AudioFormatInfo
    type AttrGetType AudioFormatInfoDepthFieldInfo = Int32
    type AttrLabel AudioFormatInfoDepthFieldInfo = "depth"
    type AttrOrigin AudioFormatInfoDepthFieldInfo = AudioFormatInfo
    attrGet _ = getAudioFormatInfoDepth
    attrSet _ = setAudioFormatInfoDepth
    attrConstruct = undefined
    attrClear _ = undefined

audioFormatInfo_depth :: AttrLabelProxy "depth"
audioFormatInfo_depth = AttrLabelProxy


-- XXX Skipped attribute for "AudioFormatInfo:silence" :: Not implemented: "Don't know how to unpack C array of type TCArray False 8 (-1) (TBasicType TUInt8)"
getAudioFormatInfoUnpackFormat :: MonadIO m => AudioFormatInfo -> m GstAudio.Enums.AudioFormat
getAudioFormatInfoUnpackFormat s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 48) :: IO CUInt
    let val' = (toEnum . fromIntegral) val
    return val'

setAudioFormatInfoUnpackFormat :: MonadIO m => AudioFormatInfo -> GstAudio.Enums.AudioFormat -> m ()
setAudioFormatInfoUnpackFormat s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 48) (val' :: CUInt)

data AudioFormatInfoUnpackFormatFieldInfo
instance AttrInfo AudioFormatInfoUnpackFormatFieldInfo where
    type AttrAllowedOps AudioFormatInfoUnpackFormatFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AudioFormatInfoUnpackFormatFieldInfo = (~) GstAudio.Enums.AudioFormat
    type AttrBaseTypeConstraint AudioFormatInfoUnpackFormatFieldInfo = (~) AudioFormatInfo
    type AttrGetType AudioFormatInfoUnpackFormatFieldInfo = GstAudio.Enums.AudioFormat
    type AttrLabel AudioFormatInfoUnpackFormatFieldInfo = "unpack_format"
    type AttrOrigin AudioFormatInfoUnpackFormatFieldInfo = AudioFormatInfo
    attrGet _ = getAudioFormatInfoUnpackFormat
    attrSet _ = setAudioFormatInfoUnpackFormat
    attrConstruct = undefined
    attrClear _ = undefined

audioFormatInfo_unpackFormat :: AttrLabelProxy "unpackFormat"
audioFormatInfo_unpackFormat = AttrLabelProxy


getAudioFormatInfoUnpackFunc :: MonadIO m => AudioFormatInfo -> m (Maybe GstAudio.Callbacks.AudioFormatUnpack)
getAudioFormatInfoUnpackFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 56) :: IO (FunPtr GstAudio.Callbacks.C_AudioFormatUnpack)
    result <- SP.convertFunPtrIfNonNull val $ \val' -> do
        let val'' = GstAudio.Callbacks.dynamic_AudioFormatUnpack val'
        return val''
    return result

setAudioFormatInfoUnpackFunc :: MonadIO m => AudioFormatInfo -> FunPtr GstAudio.Callbacks.C_AudioFormatUnpack -> m ()
setAudioFormatInfoUnpackFunc s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 56) (val :: FunPtr GstAudio.Callbacks.C_AudioFormatUnpack)

clearAudioFormatInfoUnpackFunc :: MonadIO m => AudioFormatInfo -> m ()
clearAudioFormatInfoUnpackFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 56) (FP.nullFunPtr :: FunPtr GstAudio.Callbacks.C_AudioFormatUnpack)

data AudioFormatInfoUnpackFuncFieldInfo
instance AttrInfo AudioFormatInfoUnpackFuncFieldInfo where
    type AttrAllowedOps AudioFormatInfoUnpackFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint AudioFormatInfoUnpackFuncFieldInfo = (~) (FunPtr GstAudio.Callbacks.C_AudioFormatUnpack)
    type AttrBaseTypeConstraint AudioFormatInfoUnpackFuncFieldInfo = (~) AudioFormatInfo
    type AttrGetType AudioFormatInfoUnpackFuncFieldInfo = Maybe GstAudio.Callbacks.AudioFormatUnpack
    type AttrLabel AudioFormatInfoUnpackFuncFieldInfo = "unpack_func"
    type AttrOrigin AudioFormatInfoUnpackFuncFieldInfo = AudioFormatInfo
    attrGet _ = getAudioFormatInfoUnpackFunc
    attrSet _ = setAudioFormatInfoUnpackFunc
    attrConstruct = undefined
    attrClear _ = clearAudioFormatInfoUnpackFunc

audioFormatInfo_unpackFunc :: AttrLabelProxy "unpackFunc"
audioFormatInfo_unpackFunc = AttrLabelProxy


getAudioFormatInfoPackFunc :: MonadIO m => AudioFormatInfo -> m (Maybe GstAudio.Callbacks.AudioFormatPack)
getAudioFormatInfoPackFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 64) :: IO (FunPtr GstAudio.Callbacks.C_AudioFormatPack)
    result <- SP.convertFunPtrIfNonNull val $ \val' -> do
        let val'' = GstAudio.Callbacks.dynamic_AudioFormatPack val'
        return val''
    return result

setAudioFormatInfoPackFunc :: MonadIO m => AudioFormatInfo -> FunPtr GstAudio.Callbacks.C_AudioFormatPack -> m ()
setAudioFormatInfoPackFunc s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 64) (val :: FunPtr GstAudio.Callbacks.C_AudioFormatPack)

clearAudioFormatInfoPackFunc :: MonadIO m => AudioFormatInfo -> m ()
clearAudioFormatInfoPackFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 64) (FP.nullFunPtr :: FunPtr GstAudio.Callbacks.C_AudioFormatPack)

data AudioFormatInfoPackFuncFieldInfo
instance AttrInfo AudioFormatInfoPackFuncFieldInfo where
    type AttrAllowedOps AudioFormatInfoPackFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint AudioFormatInfoPackFuncFieldInfo = (~) (FunPtr GstAudio.Callbacks.C_AudioFormatPack)
    type AttrBaseTypeConstraint AudioFormatInfoPackFuncFieldInfo = (~) AudioFormatInfo
    type AttrGetType AudioFormatInfoPackFuncFieldInfo = Maybe GstAudio.Callbacks.AudioFormatPack
    type AttrLabel AudioFormatInfoPackFuncFieldInfo = "pack_func"
    type AttrOrigin AudioFormatInfoPackFuncFieldInfo = AudioFormatInfo
    attrGet _ = getAudioFormatInfoPackFunc
    attrSet _ = setAudioFormatInfoPackFunc
    attrConstruct = undefined
    attrClear _ = clearAudioFormatInfoPackFunc

audioFormatInfo_packFunc :: AttrLabelProxy "packFunc"
audioFormatInfo_packFunc = AttrLabelProxy



instance O.HasAttributeList AudioFormatInfo
type instance O.AttributeList AudioFormatInfo = AudioFormatInfoAttributeList
type AudioFormatInfoAttributeList = ('[ '("format", AudioFormatInfoFormatFieldInfo), '("name", AudioFormatInfoNameFieldInfo), '("description", AudioFormatInfoDescriptionFieldInfo), '("flags", AudioFormatInfoFlagsFieldInfo), '("endianness", AudioFormatInfoEndiannessFieldInfo), '("width", AudioFormatInfoWidthFieldInfo), '("depth", AudioFormatInfoDepthFieldInfo), '("unpackFormat", AudioFormatInfoUnpackFormatFieldInfo), '("unpackFunc", AudioFormatInfoUnpackFuncFieldInfo), '("packFunc", AudioFormatInfoPackFuncFieldInfo)] :: [(Symbol, *)])

type family ResolveAudioFormatInfoMethod (t :: Symbol) (o :: *) :: * where
    ResolveAudioFormatInfoMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveAudioFormatInfoMethod t AudioFormatInfo, O.MethodInfo info AudioFormatInfo p) => O.IsLabelProxy t (AudioFormatInfo -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveAudioFormatInfoMethod t AudioFormatInfo, O.MethodInfo info AudioFormatInfo p) => O.IsLabel t (AudioFormatInfo -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif