module Sound.PortAudio.Base
(
abortStream_ffi,
closeStream_ffi,
getDefaultHostApi_ffi,
getDefaultInputDevice_ffi,
getDefaultOutputDevice_ffi,
getDeviceCount_ffi,
getDeviceInfo_ffi,
getHostApiCount_ffi,
getHostApiInfo_ffi,
getLastHostErrorInfo_ffi,
getSampleSize_ffi,
getStreamCpuLoad_ffi,
getStreamInfo_ffi,
getStreamReadAvailable_ffi,
getStreamTime_ffi,
getStreamWriteAvailable_ffi,
hostApiDeviceIndexToDeviceIndex_ffi,
hostApiTypeIdToHostApiIndex_ffi,
initialize_ffi,
isFormatSupported_ffi,
isStreamActive_ffi,
isStreamStopped_ffi,
openDefaultStream_ffi,
openStream_ffi,
paSleep_ffi,
readStream_ffi,
startStream_ffi,
stopStream_ffi,
terminate_ffi,
writeStream_ffi,
DeviceIndex,
HostApiIndex,
PaTime,
PaStream,
HostApiInfo(..),
SampleFormat(..),
StreamInfo(..),
StreamParameters(..),
DeviceInfo(..),
HostErrorInfo(..),
HostApiTypeId(..),
ErrorCode(..),
getErrorText,
getVersion,
getVersionText,
paNullPtr,
)
where
import C2HS
import Control.Monad.Error
import Sound.PortAudio.Helpers
paNullPtr = nullPtr
type PaError = Int
type DeviceIndex = Int
type HostApiIndex = Int
type PaTime = Double
type PaStreamBuffer = Ptr ()
data PaStream a = PaStream (IntPtr)
deriving (Show)
data HostApiInfo = HostApiInfo {
hostApiInfoStructVersion :: Int,
hostApiInfoApiType :: HostApiTypeId,
hostApiInfoName :: String,
hostApiInfoDeviceCount :: Int,
hostApiInfoDefaultInputDevice :: DeviceIndex,
hostApiInfoDefaultOutputDevice :: DeviceIndex
} deriving (Show)
data SampleFormat = PaFloat32
| PaInt32
| PaInt24
| PaInt16
| PaInt8
| PaUInt8
| PaCustomFormat
| PaNonInterleaved
deriving (Read,Show)
instance Enum SampleFormat where
fromEnum PaFloat32 = 0x00000001
fromEnum PaInt32 = 0x00000002
fromEnum PaInt24 = 0x00000004
fromEnum PaInt16 = 0x00000008
fromEnum PaInt8 = 0x00000010
fromEnum PaUInt8 = 0x00000020
fromEnum PaCustomFormat = 0x00010000
fromEnum PaNonInterleaved = 0x80000000
toEnum 0x00000001 = PaFloat32
toEnum 0x00000002 = PaInt32
toEnum 0x00000004 = PaInt24
toEnum 0x00000008 = PaInt16
toEnum 0x00000010 = PaInt8
toEnum 0x00000020 = PaUInt8
toEnum 0x00010000 = PaCustomFormat
toEnum 0x80000000 = PaNonInterleaved
toEnum unmatched = error ("SampleFormat.toEnum: Cannot match " ++ show unmatched)
data StreamInfo = StreamInfo {
streamInfoStructVersion :: Int,
streamInfoInputLatency :: PaTime,
streamInfoOutputLatency :: PaTime,
streamInfoSampleRate :: Double
}
deriving (Show)
data StreamParameters = StreamParameters {
streamParametersDevice :: DeviceIndex,
streamParametersChannelCount :: Int,
streamParametersSampleFormat :: SampleFormat,
streamParametersSuggestedLatency :: PaTime,
streamParametersHostApiSpecificStreamInfo :: Ptr ()
}
deriving (Show)
instance Storable StreamParameters where
sizeOf _ = 24
alignment _ = alignment (undefined :: CLong)
peek ptr = do
de <- liftM cIntConv $ (\ptr -> do {peekByteOff ptr 0 ::IO CInt}) ptr
cc <- liftM cIntConv $ (\ptr -> do {peekByteOff ptr 4 ::IO CInt}) ptr
sf <- liftM cToEnum $ (\ptr -> do {peekByteOff ptr 8 ::IO CULong}) ptr
sl <- liftM cFloatConv $ (\ptr -> do {peekByteOff ptr 12 ::IO CDouble}) ptr
ha <- (\ptr -> do {peekByteOff ptr 20 ::IO (Ptr ())}) ptr
return $ StreamParameters {
streamParametersDevice = de,
streamParametersChannelCount = cc,
streamParametersSampleFormat = sf,
streamParametersSuggestedLatency = sl,
streamParametersHostApiSpecificStreamInfo = ha
}
poke ptr (StreamParameters de cc sf sl ha) = do
(\ptr val -> do {pokeByteOff ptr 0 (val::CInt)}) ptr (cIntConv de)
(\ptr val -> do {pokeByteOff ptr 4 (val::CInt)}) ptr (cIntConv cc)
(\ptr val -> do {pokeByteOff ptr 8 (val::CULong)}) ptr (cFromEnum sf)
(\ptr val -> do {pokeByteOff ptr 12 (val::CDouble)}) ptr (cFloatConv sl)
(\ptr val -> do {pokeByteOff ptr 20 (val::(Ptr ()))}) ptr ha
data HostErrorInfo = HostErrorInfo {
hostErrorInfoHostApiType :: HostApiTypeId,
hostErrorInfoErrorCode :: Int,
hostErrorInfoErrorText :: String
}
deriving (Show)
data DeviceInfo = DeviceInfo {
deviceInfoStructVersion :: Int,
deviceInfoName :: String,
deviceInfoHostApi :: HostApiIndex,
deviceInfoMaxInputChannels :: Int,
deviceInfoMaxOutputChannels :: Int,
deviceInfoDefaultLowInputLatency :: PaTime,
deviceInfoDefaultLowOutputLatency :: PaTime,
deviceInfoDefaultHighInputLatency :: PaTime,
deviceInfoDefaultHighOutputLatency :: PaTime,
deviceInfoDefaultSampleRate :: Double
}
deriving (Show)
data HostApiTypeId = InDevelopment
| DirectSound
| MME
| ASIO
| SoundManager
| CoreAudio
| OSS
| ALSA
| AL
| BeOS
| WDMKS
| JACK
| WASAPI
| AudioScienceHPI
deriving (Show)
instance Enum HostApiTypeId where
fromEnum InDevelopment = 0
fromEnum DirectSound = 1
fromEnum MME = 2
fromEnum ASIO = 3
fromEnum SoundManager = 4
fromEnum CoreAudio = 5
fromEnum OSS = 7
fromEnum ALSA = 8
fromEnum AL = 9
fromEnum BeOS = 10
fromEnum WDMKS = 11
fromEnum JACK = 12
fromEnum WASAPI = 13
fromEnum AudioScienceHPI = 14
toEnum 0 = InDevelopment
toEnum 1 = DirectSound
toEnum 2 = MME
toEnum 3 = ASIO
toEnum 4 = SoundManager
toEnum 5 = CoreAudio
toEnum 7 = OSS
toEnum 8 = ALSA
toEnum 9 = AL
toEnum 10 = BeOS
toEnum 11 = WDMKS
toEnum 12 = JACK
toEnum 13 = WASAPI
toEnum 14 = AudioScienceHPI
toEnum unmatched = error ("HostApiTypeId.toEnum: Cannot match " ++ show unmatched)
data ErrorCode = NoError
| NotInitialized
| UnanticipatedHostError
| InvalidChannelCount
| InvalidSampleRate
| InvalidDevice
| InvalidFlag
| SampleFormatNotSupported
| BadIODeviceCombination
| InsufficientMemory
| BufferTooBig
| BufferTooSmall
| NullCallback
| BadStreamPtr
| TimedOut
| InternalError
| DeviceUnavailable
| IncompatibleHostApiSpecificStreamInfo
| StreamIsStopped
| StreamIsNotStopped
| InputOverflowed
| OutputUnderflowed
| HostApiNotFound
| InvalidHostApi
| CanNotReadFromACallbackStream
| CanNotWriteToACallbackStream
| CanNotReadFromAnOutputOnlyStream
| CanNotWriteToAnInputOnlyStream
| IncompatibleStreamHostApi
| BadBufferPtr
deriving (Show)
instance Enum ErrorCode where
fromEnum NoError = 0
fromEnum NotInitialized = (10000)
fromEnum UnanticipatedHostError = (9999)
fromEnum InvalidChannelCount = (9998)
fromEnum InvalidSampleRate = (9997)
fromEnum InvalidDevice = (9996)
fromEnum InvalidFlag = (9995)
fromEnum SampleFormatNotSupported = (9994)
fromEnum BadIODeviceCombination = (9993)
fromEnum InsufficientMemory = (9992)
fromEnum BufferTooBig = (9991)
fromEnum BufferTooSmall = (9990)
fromEnum NullCallback = (9989)
fromEnum BadStreamPtr = (9988)
fromEnum TimedOut = (9987)
fromEnum InternalError = (9986)
fromEnum DeviceUnavailable = (9985)
fromEnum IncompatibleHostApiSpecificStreamInfo = (9984)
fromEnum StreamIsStopped = (9983)
fromEnum StreamIsNotStopped = (9982)
fromEnum InputOverflowed = (9981)
fromEnum OutputUnderflowed = (9980)
fromEnum HostApiNotFound = (9979)
fromEnum InvalidHostApi = (9978)
fromEnum CanNotReadFromACallbackStream = (9977)
fromEnum CanNotWriteToACallbackStream = (9976)
fromEnum CanNotReadFromAnOutputOnlyStream = (9975)
fromEnum CanNotWriteToAnInputOnlyStream = (9974)
fromEnum IncompatibleStreamHostApi = (9973)
fromEnum BadBufferPtr = (9972)
toEnum 0 = NoError
toEnum (10000) = NotInitialized
toEnum (9999) = UnanticipatedHostError
toEnum (9998) = InvalidChannelCount
toEnum (9997) = InvalidSampleRate
toEnum (9996) = InvalidDevice
toEnum (9995) = InvalidFlag
toEnum (9994) = SampleFormatNotSupported
toEnum (9993) = BadIODeviceCombination
toEnum (9992) = InsufficientMemory
toEnum (9991) = BufferTooBig
toEnum (9990) = BufferTooSmall
toEnum (9989) = NullCallback
toEnum (9988) = BadStreamPtr
toEnum (9987) = TimedOut
toEnum (9986) = InternalError
toEnum (9985) = DeviceUnavailable
toEnum (9984) = IncompatibleHostApiSpecificStreamInfo
toEnum (9983) = StreamIsStopped
toEnum (9982) = StreamIsNotStopped
toEnum (9981) = InputOverflowed
toEnum (9980) = OutputUnderflowed
toEnum (9979) = HostApiNotFound
toEnum (9978) = InvalidHostApi
toEnum (9977) = CanNotReadFromACallbackStream
toEnum (9976) = CanNotWriteToACallbackStream
toEnum (9975) = CanNotReadFromAnOutputOnlyStream
toEnum (9974) = CanNotWriteToAnInputOnlyStream
toEnum (9973) = IncompatibleStreamHostApi
toEnum (9972) = BadBufferPtr
toEnum unmatched = error ("ErrorCode.toEnum: Cannot match " ++ show unmatched)
data StreamCallbackResult = Continue
| Complete
| Abort
instance Enum StreamCallbackResult where
fromEnum Continue = 0
fromEnum Complete = 1
fromEnum Abort = 2
toEnum 0 = Continue
toEnum 1 = Complete
toEnum 2 = Abort
toEnum unmatched = error ("StreamCallbackResult.toEnum: Cannot match " ++ show unmatched)
newtype HostApiInfoPtr = HostApiInfoPtr (Ptr (HostApiInfoPtr))
newtype StreamInfoPtr = StreamInfoPtr (Ptr (StreamInfoPtr))
type StreamParametersPtr = Ptr (StreamParameters)
nullStreamParameters = nullPtr :: StreamParametersPtr
newtype DeviceInfoPtr = DeviceInfoPtr (Ptr (DeviceInfoPtr))
newtype HostErrorInfoPtr = HostErrorInfoPtr (Ptr (HostErrorInfoPtr))
maybe_get_const_DeviceInfo p@(DeviceInfoPtr ptr) = do
r <- if (nullPtr == ptr)
then (return Nothing)
else do {m <- get_const_DeviceInfo p; return (Just m);}
return r
maybe_get_const_HostApiInfo p@(HostApiInfoPtr ptr) = do
r <- if (nullPtr == ptr)
then (return Nothing)
else do {m <- get_const_HostApiInfo p; return (Just m);}
return r
maybe_get_const_HostErrorInfo p@(HostErrorInfoPtr ptr) = do
r <- if (nullPtr == ptr)
then (return Nothing)
else do {m <- get_const_HostErrorInfo p; return (Just m);}
return r
maybe_get_const_StreamInfo p@(StreamInfoPtr ptr) = do
r <- if (nullPtr == ptr)
then (return Nothing)
else do {m <- get_const_StreamInfo p; return (Just m);}
return r
get_const_HostErrorInfo (HostErrorInfoPtr ptr) = do
ht <- liftM cToEnum $ (\ptr -> do {peekByteOff ptr 0 ::IO CInt}) ptr
ec <- liftM cIntConv $ (\ptr -> do {peekByteOff ptr 4 ::IO CLong}) ptr
et <- liftM peekCString $ (\ptr -> do {peekByteOff ptr 8 ::IO (Ptr CChar)}) ptr
et' <- et
return $ HostErrorInfo {
hostErrorInfoHostApiType = ht,
hostErrorInfoErrorCode = ec,
hostErrorInfoErrorText = et'
}
get_const_HostApiInfo (HostApiInfoPtr ptr) = do
vers <- liftM cIntConv $ (\ptr -> do {peekByteOff ptr 0 ::IO CInt}) ptr
apiType <- liftM cToEnum $ (\ptr -> do {peekByteOff ptr 4 :: IO CInt}) ptr
name' <- liftM peekCString $ (\ptr -> do {peekByteOff ptr 8 ::IO (Ptr CChar)}) ptr
deviceCount <- liftM cIntConv $ (\ptr -> do {peekByteOff ptr 12 ::IO CInt}) ptr
defaultInputDevice <- liftM cIntConv $ (\ptr -> do {peekByteOff ptr 16 ::IO CInt}) ptr
defaultOutputDevice <- liftM cIntConv $ (\ptr -> do {peekByteOff ptr 20 ::IO CInt}) ptr
name <- name'
return $ HostApiInfo {
hostApiInfoStructVersion = vers,
hostApiInfoApiType = apiType,
hostApiInfoName = name,
hostApiInfoDeviceCount = deviceCount,
hostApiInfoDefaultInputDevice = defaultInputDevice,
hostApiInfoDefaultOutputDevice = defaultOutputDevice
}
get_const_DeviceInfo (DeviceInfoPtr ptr) = do
sv <- liftM cToEnum $ (\ptr -> do {peekByteOff ptr 0 ::IO CInt}) ptr
nm <- liftM peekCString $ (\ptr -> do {peekByteOff ptr 4 ::IO (Ptr CChar)}) ptr
ha <- liftM cIntConv $ (\ptr -> do {peekByteOff ptr 8 ::IO CInt}) ptr
ic <- liftM cIntConv $ (\ptr -> do {peekByteOff ptr 12 ::IO CInt}) ptr
oc <- liftM cIntConv $ (\ptr -> do {peekByteOff ptr 16 ::IO CInt}) ptr
dli <- liftM cFloatConv $ (\ptr -> do {peekByteOff ptr 20 ::IO CDouble}) ptr
dlo <- liftM cFloatConv $ (\ptr -> do {peekByteOff ptr 28 ::IO CDouble}) ptr
dhi <- liftM cFloatConv $ (\ptr -> do {peekByteOff ptr 36 ::IO CDouble}) ptr
dho <- liftM cFloatConv $ (\ptr -> do {peekByteOff ptr 44 ::IO CDouble}) ptr
dsr <- liftM cFloatConv $ (\ptr -> do {peekByteOff ptr 52 ::IO CDouble}) ptr
nm' <- nm
return $ DeviceInfo {
deviceInfoStructVersion = sv,
deviceInfoName = nm',
deviceInfoHostApi = ha,
deviceInfoMaxInputChannels = ic,
deviceInfoMaxOutputChannels = oc,
deviceInfoDefaultLowInputLatency = dli,
deviceInfoDefaultLowOutputLatency = dlo,
deviceInfoDefaultHighInputLatency = dhi,
deviceInfoDefaultHighOutputLatency = dho,
deviceInfoDefaultSampleRate = dsr
}
get_const_StreamInfo (StreamInfoPtr ptr) = do
sv <- liftM cIntConv $ (\ptr -> do {peekByteOff ptr 0 ::IO CInt}) ptr
il <- liftM cFloatConv $ (\ptr -> do {peekByteOff ptr 4 ::IO CDouble}) ptr
ol <- liftM cFloatConv $ (\ptr -> do {peekByteOff ptr 12 ::IO CDouble}) ptr
sr <- liftM cFloatConv $ (\ptr -> do {peekByteOff ptr 20 ::IO CDouble}) ptr
return $ StreamInfo {
streamInfoStructVersion = sv,
streamInfoInputLatency = il,
streamInfoOutputLatency = ol,
streamInfoSampleRate = sr
}
withPA = maybeWith with
peekStream p = do
ip <- peek p
return $ PaStream $ ptrToIntPtr ip
unPaStream :: PaStream a -> Ptr ()
unPaStream (PaStream ptr) = intPtrToPtr ptr
getErrorText :: ErrorCode -> IO (String)
getErrorText a1 =
let {a1' = enumToC a1} in
getErrorText'_ a1' >>= \res ->
peekCString res >>= \res' ->
return (res')
getVersion :: Int
getVersion =
let {res = getVersion'_} in
let {res' = cIntConv res} in
(res')
getVersionText :: IO (String)
getVersionText =
getVersionText'_ >>= \res ->
peekCString res >>= \res' ->
return (res')
initialize_ffi :: IO (PaError)
initialize_ffi =
initialize_ffi'_ >>= \res ->
let {res' = cIntConv res} in
return (res')
terminate_ffi :: IO (PaError)
terminate_ffi =
terminate_ffi'_ >>= \res ->
let {res' = cIntConv res} in
return (res')
getHostApiCount_ffi :: IO (HostApiIndex)
getHostApiCount_ffi =
getHostApiCount_ffi'_ >>= \res ->
let {res' = cIntConv res} in
return (res')
getDefaultHostApi_ffi :: IO (HostApiIndex)
getDefaultHostApi_ffi =
getDefaultHostApi_ffi'_ >>= \res ->
let {res' = cIntConv res} in
return (res')
getHostApiInfo_ffi :: HostApiIndex -> IO (Maybe HostApiInfo)
getHostApiInfo_ffi a1 =
let {a1' = cIntConv a1} in
getHostApiInfo_ffi'_ a1' >>= \res ->
maybe_get_const_HostApiInfo res >>= \res' ->
return (res')
hostApiTypeIdToHostApiIndex_ffi :: HostApiTypeId -> IO (HostApiIndex)
hostApiTypeIdToHostApiIndex_ffi a1 =
let {a1' = enumToC a1} in
hostApiTypeIdToHostApiIndex_ffi'_ a1' >>= \res ->
let {res' = cIntConv res} in
return (res')
hostApiDeviceIndexToDeviceIndex_ffi :: HostApiIndex -> Int -> IO (DeviceIndex)
hostApiDeviceIndexToDeviceIndex_ffi a1 a2 =
let {a1' = cIntConv a1} in
let {a2' = cIntConv a2} in
hostApiDeviceIndexToDeviceIndex_ffi'_ a1' a2' >>= \res ->
let {res' = cIntConv res} in
return (res')
getLastHostErrorInfo_ffi :: IO (Maybe HostErrorInfo)
getLastHostErrorInfo_ffi =
getLastHostErrorInfo_ffi'_ >>= \res ->
maybe_get_const_HostErrorInfo res >>= \res' ->
return (res')
getDeviceCount_ffi :: IO (DeviceIndex)
getDeviceCount_ffi =
getDeviceCount_ffi'_ >>= \res ->
let {res' = cIntConv res} in
return (res')
getDefaultInputDevice_ffi :: IO (DeviceIndex)
getDefaultInputDevice_ffi =
getDefaultInputDevice_ffi'_ >>= \res ->
let {res' = cIntConv res} in
return (res')
getDefaultOutputDevice_ffi :: IO (DeviceIndex)
getDefaultOutputDevice_ffi =
getDefaultOutputDevice_ffi'_ >>= \res ->
let {res' = cIntConv res} in
return (res')
getDeviceInfo_ffi :: DeviceIndex -> IO (Maybe DeviceInfo)
getDeviceInfo_ffi a1 =
let {a1' = cIntConv a1} in
getDeviceInfo_ffi'_ a1' >>= \res ->
maybe_get_const_DeviceInfo res >>= \res' ->
return (res')
isFormatSupported_ffi :: Maybe StreamParameters -> Maybe StreamParameters -> Double -> IO (PaError)
isFormatSupported_ffi a1 a2 a3 =
withPA a1 $ \a1' ->
withPA a2 $ \a2' ->
let {a3' = cFloatConv a3} in
isFormatSupported_ffi'_ a1' a2' a3' >>= \res ->
let {res' = cToEnum res} in
return (res')
openStream_ffi :: Maybe StreamParameters -> Maybe StreamParameters -> Double -> Int -> Int -> Ptr () -> Ptr () -> IO (PaError, PaStream a)
openStream_ffi a2 a3 a4 a5 a6 a7 a8 =
alloca $ \a1' ->
withPA a2 $ \a2' ->
withPA a3 $ \a3' ->
let {a4' = cFloatConv a4} in
let {a5' = cIntConv a5} in
let {a6' = cIntConv a6} in
let {a7' = castPtrToFunPtr a7} in
let {a8' = id a8} in
openStream_ffi'_ a1' a2' a3' a4' a5' a6' a7' a8' >>= \res ->
peekStream a1'>>= \a1'' ->
let {res' = cToEnum res} in
return (res', a1'')
openDefaultStream_ffi :: Int -> Int -> SampleFormat -> Double -> Int -> Ptr () -> Ptr () -> IO (PaError, PaStream a)
openDefaultStream_ffi a2 a3 a4 a5 a6 a7 a8 =
alloca $ \a1' ->
let {a2' = cIntConv a2} in
let {a3' = cIntConv a3} in
let {a4' = enumToC a4} in
let {a5' = cFloatConv a5} in
let {a6' = cIntConv a6} in
let {a7' = castPtrToFunPtr a7} in
let {a8' = id a8} in
openDefaultStream_ffi'_ a1' a2' a3' a4' a5' a6' a7' a8' >>= \res ->
peekStream a1'>>= \a1'' ->
let {res' = cToEnum res} in
return (res', a1'')
closeStream_ffi :: PaStream a -> IO (PaError)
closeStream_ffi a1 =
let {a1' = unPaStream a1} in
closeStream_ffi'_ a1' >>= \res ->
let {res' = cToEnum res} in
return (res')
startStream_ffi :: PaStream a -> IO (PaError)
startStream_ffi a1 =
let {a1' = unPaStream a1} in
startStream_ffi'_ a1' >>= \res ->
let {res' = cToEnum res} in
return (res')
stopStream_ffi :: PaStream a -> IO (PaError)
stopStream_ffi a1 =
let {a1' = unPaStream a1} in
stopStream_ffi'_ a1' >>= \res ->
let {res' = cToEnum res} in
return (res')
abortStream_ffi :: PaStream a -> IO (PaError)
abortStream_ffi a1 =
let {a1' = unPaStream a1} in
abortStream_ffi'_ a1' >>= \res ->
let {res' = cToEnum res} in
return (res')
isStreamStopped_ffi :: PaStream a -> IO (PaError)
isStreamStopped_ffi a1 =
let {a1' = unPaStream a1} in
isStreamStopped_ffi'_ a1' >>= \res ->
let {res' = cToEnum res} in
return (res')
isStreamActive_ffi :: PaStream a -> IO (PaError)
isStreamActive_ffi a1 =
let {a1' = unPaStream a1} in
isStreamActive_ffi'_ a1' >>= \res ->
let {res' = cToEnum res} in
return (res')
getStreamInfo_ffi :: PaStream a -> IO (Maybe StreamInfo)
getStreamInfo_ffi a1 =
let {a1' = unPaStream a1} in
getStreamInfo_ffi'_ a1' >>= \res ->
maybe_get_const_StreamInfo res >>= \res' ->
return (res')
getStreamTime_ffi :: PaStream a -> IO (PaTime)
getStreamTime_ffi a1 =
let {a1' = unPaStream a1} in
getStreamTime_ffi'_ a1' >>= \res ->
let {res' = cFloatConv res} in
return (res')
getStreamCpuLoad_ffi :: PaStream a -> IO (Double)
getStreamCpuLoad_ffi a1 =
let {a1' = unPaStream a1} in
getStreamCpuLoad_ffi'_ a1' >>= \res ->
let {res' = cFloatConv res} in
return (res')
readStream_ffi :: PaStream a -> PaStreamBuffer -> Int -> IO (PaError)
readStream_ffi a1 a2 a3 =
let {a1' = unPaStream a1} in
let {a2' = id a2} in
let {a3' = cIntConv a3} in
readStream_ffi'_ a1' a2' a3' >>= \res ->
let {res' = cToEnum res} in
return (res')
writeStream_ffi :: PaStream a -> PaStreamBuffer -> Int -> IO (PaError)
writeStream_ffi a1 a2 a3 =
let {a1' = unPaStream a1} in
let {a2' = id a2} in
let {a3' = cIntConv a3} in
writeStream_ffi'_ a1' a2' a3' >>= \res ->
let {res' = cToEnum res} in
return (res')
getStreamReadAvailable_ffi :: PaStream a -> IO (Int)
getStreamReadAvailable_ffi a1 =
let {a1' = unPaStream a1} in
getStreamReadAvailable_ffi'_ a1' >>= \res ->
let {res' = cIntConv res} in
return (res')
getStreamWriteAvailable_ffi :: PaStream a -> IO (Int)
getStreamWriteAvailable_ffi a1 =
let {a1' = unPaStream a1} in
getStreamWriteAvailable_ffi'_ a1' >>= \res ->
let {res' = cIntConv res} in
return (res')
getSampleSize_ffi :: SampleFormat -> IO (Int)
getSampleSize_ffi a1 =
let {a1' = enumToC a1} in
getSampleSize_ffi'_ a1' >>= \res ->
let {res' = cIntConv res} in
return (res')
paSleep_ffi :: Int -> IO ()
paSleep_ffi a1 =
let {a1' = cIntConv a1} in
paSleep_ffi'_ a1' >>= \res ->
return ()
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetErrorText"
getErrorText'_ :: (CInt -> (IO (Ptr CChar)))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetVersion"
getVersion'_ :: CInt
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetVersionText"
getVersionText'_ :: (IO (Ptr CChar))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_Initialize"
initialize_ffi'_ :: (IO CInt)
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_Terminate"
terminate_ffi'_ :: (IO CInt)
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetHostApiCount"
getHostApiCount_ffi'_ :: (IO CInt)
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetDefaultHostApi"
getDefaultHostApi_ffi'_ :: (IO CInt)
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetHostApiInfo"
getHostApiInfo_ffi'_ :: (CInt -> (IO (HostApiInfoPtr)))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_HostApiTypeIdToHostApiIndex"
hostApiTypeIdToHostApiIndex_ffi'_ :: (CInt -> (IO CInt))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_HostApiDeviceIndexToDeviceIndex"
hostApiDeviceIndexToDeviceIndex_ffi'_ :: (CInt -> (CInt -> (IO CInt)))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetLastHostErrorInfo"
getLastHostErrorInfo_ffi'_ :: (IO (HostErrorInfoPtr))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetDeviceCount"
getDeviceCount_ffi'_ :: (IO CInt)
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetDefaultInputDevice"
getDefaultInputDevice_ffi'_ :: (IO CInt)
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetDefaultOutputDevice"
getDefaultOutputDevice_ffi'_ :: (IO CInt)
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetDeviceInfo"
getDeviceInfo_ffi'_ :: (CInt -> (IO (DeviceInfoPtr)))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_IsFormatSupported"
isFormatSupported_ffi'_ :: ((StreamParametersPtr) -> ((StreamParametersPtr) -> (CDouble -> (IO CInt))))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_OpenStream"
openStream_ffi'_ :: ((Ptr (Ptr ())) -> ((StreamParametersPtr) -> ((StreamParametersPtr) -> (CDouble -> (CULong -> (CULong -> ((FunPtr ((Ptr ()) -> ((Ptr ()) -> (CULong -> ((Ptr ()) -> (CULong -> ((Ptr ()) -> (IO CInt)))))))) -> ((Ptr ()) -> (IO CInt)))))))))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_OpenDefaultStream"
openDefaultStream_ffi'_ :: ((Ptr (Ptr ())) -> (CInt -> (CInt -> (CULong -> (CDouble -> (CULong -> ((FunPtr ((Ptr ()) -> ((Ptr ()) -> (CULong -> ((Ptr ()) -> (CULong -> ((Ptr ()) -> (IO CInt)))))))) -> ((Ptr ()) -> (IO CInt)))))))))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_CloseStream"
closeStream_ffi'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_StartStream"
startStream_ffi'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_StopStream"
stopStream_ffi'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_AbortStream"
abortStream_ffi'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_IsStreamStopped"
isStreamStopped_ffi'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_IsStreamActive"
isStreamActive_ffi'_ :: ((Ptr ()) -> (IO CInt))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetStreamInfo"
getStreamInfo_ffi'_ :: ((Ptr ()) -> (IO (StreamInfoPtr)))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetStreamTime"
getStreamTime_ffi'_ :: ((Ptr ()) -> (IO CDouble))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetStreamCpuLoad"
getStreamCpuLoad_ffi'_ :: ((Ptr ()) -> (IO CDouble))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_ReadStream"
readStream_ffi'_ :: ((Ptr ()) -> ((Ptr ()) -> (CULong -> (IO CInt))))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_WriteStream"
writeStream_ffi'_ :: ((Ptr ()) -> ((Ptr ()) -> (CULong -> (IO CInt))))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetStreamReadAvailable"
getStreamReadAvailable_ffi'_ :: ((Ptr ()) -> (IO CLong))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetStreamWriteAvailable"
getStreamWriteAvailable_ffi'_ :: ((Ptr ()) -> (IO CLong))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_GetSampleSize"
getSampleSize_ffi'_ :: (CULong -> (IO CInt))
foreign import ccall safe "Sound/PortAudio/Base.chs.h Pa_Sleep"
paSleep_ffi'_ :: (CLong -> (IO ()))