Autres/audacity
1
0
Fork 0
mirror of https://github.com/cookiengineer/audacity synced 2025-10-21 14:02:57 +02:00
Code Issues Releases Wiki Activity

Reverting r12850...hopefully

Browse Source 
Never removed one before, but I'm pretty sure it is correct.
This commit is contained in:
lllucius
2013-11-03 01:54:50 +00:00
parent a68955a0dd
commit b4ba110811
360 changed files with 62988 additions and 62988 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/AsioDeviceAdapter.cxx
View File

@@ -1,83 +1,83 @@
#include "portaudiocpp/AsioDeviceAdapter.hxx"
#include "portaudio.h"
#include "pa_asio.h"
#include "portaudiocpp/Device.hxx"
#include "portaudiocpp/HostApi.hxx"
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
AsioDeviceAdapter::AsioDeviceAdapter(Device &device)
{
if (device.hostApi().typeId() != paASIO)
throw PaCppException(PaCppException::UNABLE_TO_ADAPT_DEVICE);
device_ = &device;
PaError err = PaAsio_GetAvailableLatencyValues(device_->index(), &minBufferSize_, &maxBufferSize_,
&preferredBufferSize_, &granularity_);
if (err != paNoError)
throw PaException(err);
}
Device &AsioDeviceAdapter::device()
{
return *device_;
}
long AsioDeviceAdapter::minBufferSize() const
{
return minBufferSize_;
}
long AsioDeviceAdapter::maxBufferSize() const
{
return maxBufferSize_;
}
long AsioDeviceAdapter::preferredBufferSize() const
{
return preferredBufferSize_;
}
long AsioDeviceAdapter::granularity() const
{
return granularity_;
}
void AsioDeviceAdapter::showControlPanel(void *systemSpecific)
{
PaError err = PaAsio_ShowControlPanel(device_->index(), systemSpecific);
if (err != paNoError)
throw PaException(err);
}
const char *AsioDeviceAdapter::inputChannelName(int channelIndex) const
{
const char *channelName;
#include "portaudiocpp/AsioDeviceAdapter.hxx"
#include "portaudio.h"
#include "pa_asio.h"
#include "portaudiocpp/Device.hxx"
#include "portaudiocpp/HostApi.hxx"
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
AsioDeviceAdapter::AsioDeviceAdapter(Device &device)
{
if (device.hostApi().typeId() != paASIO)
throw PaCppException(PaCppException::UNABLE_TO_ADAPT_DEVICE);
device_ = &device;
PaError err = PaAsio_GetAvailableLatencyValues(device_->index(), &minBufferSize_, &maxBufferSize_,
&preferredBufferSize_, &granularity_);
if (err != paNoError)
throw PaException(err);
}
Device &AsioDeviceAdapter::device()
{
return *device_;
}
long AsioDeviceAdapter::minBufferSize() const
{
return minBufferSize_;
}
long AsioDeviceAdapter::maxBufferSize() const
{
return maxBufferSize_;
}
long AsioDeviceAdapter::preferredBufferSize() const
{
return preferredBufferSize_;
}
long AsioDeviceAdapter::granularity() const
{
return granularity_;
}
void AsioDeviceAdapter::showControlPanel(void *systemSpecific)
{
PaError err = PaAsio_ShowControlPanel(device_->index(), systemSpecific);
if (err != paNoError)
throw PaException(err);
}
const char *AsioDeviceAdapter::inputChannelName(int channelIndex) const
{
const char *channelName;
PaError err = PaAsio_GetInputChannelName(device_->index(), channelIndex, &channelName);
if (err != paNoError)
throw PaException(err);
return channelName;
}
const char *AsioDeviceAdapter::outputChannelName(int channelIndex) const
{
const char *channelName;
}
const char *AsioDeviceAdapter::outputChannelName(int channelIndex) const
{
const char *channelName;
PaError err = PaAsio_GetOutputChannelName(device_->index(), channelIndex, &channelName);
if (err != paNoError)
throw PaException(err);
return channelName;
}
}
}
}

200
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/BlockingStream.cxx
View File

@@ -1,100 +1,100 @@
#include "portaudiocpp/BlockingStream.hxx"
#include "portaudio.h"
#include "portaudiocpp/StreamParameters.hxx"
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
// --------------------------------------------------------------------------------------
BlockingStream::BlockingStream()
{
}
BlockingStream::BlockingStream(const StreamParameters &parameters)
{
open(parameters);
}
BlockingStream::~BlockingStream()
{
try
{
close();
}
catch (...)
{
// ignore all errors
}
}
// --------------------------------------------------------------------------------------
void BlockingStream::open(const StreamParameters &parameters)
{
PaError err = Pa_OpenStream(&stream_, parameters.inputParameters().paStreamParameters(), parameters.outputParameters().paStreamParameters(),
parameters.sampleRate(), parameters.framesPerBuffer(), parameters.flags(), NULL, NULL);
if (err != paNoError)
{
throw PaException(err);
}
}
// --------------------------------------------------------------------------------------
void BlockingStream::read(void *buffer, unsigned long numFrames)
{
PaError err = Pa_ReadStream(stream_, buffer, numFrames);
if (err != paNoError)
{
throw PaException(err);
}
}
void BlockingStream::write(const void *buffer, unsigned long numFrames)
{
PaError err = Pa_WriteStream(stream_, buffer, numFrames);
if (err != paNoError)
{
throw PaException(err);
}
}
// --------------------------------------------------------------------------------------
signed long BlockingStream::availableReadSize() const
{
signed long avail = Pa_GetStreamReadAvailable(stream_);
if (avail < 0)
{
throw PaException(avail);
}
return avail;
}
signed long BlockingStream::availableWriteSize() const
{
signed long avail = Pa_GetStreamWriteAvailable(stream_);
if (avail < 0)
{
throw PaException(avail);
}
return avail;
}
// --------------------------------------------------------------------------------------
} // portaudio
#include "portaudiocpp/BlockingStream.hxx"
#include "portaudio.h"
#include "portaudiocpp/StreamParameters.hxx"
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
// --------------------------------------------------------------------------------------
BlockingStream::BlockingStream()
{
}
BlockingStream::BlockingStream(const StreamParameters &parameters)
{
open(parameters);
}
BlockingStream::~BlockingStream()
{
try
{
close();
}
catch (...)
{
// ignore all errors
}
}
// --------------------------------------------------------------------------------------
void BlockingStream::open(const StreamParameters &parameters)
{
PaError err = Pa_OpenStream(&stream_, parameters.inputParameters().paStreamParameters(), parameters.outputParameters().paStreamParameters(),
parameters.sampleRate(), parameters.framesPerBuffer(), parameters.flags(), NULL, NULL);
if (err != paNoError)
{
throw PaException(err);
}
}
// --------------------------------------------------------------------------------------
void BlockingStream::read(void *buffer, unsigned long numFrames)
{
PaError err = Pa_ReadStream(stream_, buffer, numFrames);
if (err != paNoError)
{
throw PaException(err);
}
}
void BlockingStream::write(const void *buffer, unsigned long numFrames)
{
PaError err = Pa_WriteStream(stream_, buffer, numFrames);
if (err != paNoError)
{
throw PaException(err);
}
}
// --------------------------------------------------------------------------------------
signed long BlockingStream::availableReadSize() const
{
signed long avail = Pa_GetStreamReadAvailable(stream_);
if (avail < 0)
{
throw PaException(avail);
}
return avail;
}
signed long BlockingStream::availableWriteSize() const
{
signed long avail = Pa_GetStreamWriteAvailable(stream_);
if (avail < 0)
{
throw PaException(avail);
}
return avail;
}
// --------------------------------------------------------------------------------------
} // portaudio

82
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/CFunCallbackStream.cxx
View File

@@ -1,41 +1,41 @@
#include "portaudiocpp/CFunCallbackStream.hxx"
#include "portaudiocpp/StreamParameters.hxx"
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
CFunCallbackStream::CFunCallbackStream()
{
}
CFunCallbackStream::CFunCallbackStream(const StreamParameters &parameters, PaStreamCallback *funPtr, void *userData)
{
open(parameters, funPtr, userData);
}
CFunCallbackStream::~CFunCallbackStream()
{
try
{
close();
}
catch (...)
{
// ignore all errors
}
}
// ---------------------------------------------------------------------------------==
void CFunCallbackStream::open(const StreamParameters &parameters, PaStreamCallback *funPtr, void *userData)
{
PaError err = Pa_OpenStream(&stream_, parameters.inputParameters().paStreamParameters(), parameters.outputParameters().paStreamParameters(),
parameters.sampleRate(), parameters.framesPerBuffer(), parameters.flags(), funPtr, userData);
if (err != paNoError)
{
throw PaException(err);
}
}
}
#include "portaudiocpp/CFunCallbackStream.hxx"
#include "portaudiocpp/StreamParameters.hxx"
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
CFunCallbackStream::CFunCallbackStream()
{
}
CFunCallbackStream::CFunCallbackStream(const StreamParameters &parameters, PaStreamCallback *funPtr, void *userData)
{
open(parameters, funPtr, userData);
}
CFunCallbackStream::~CFunCallbackStream()
{
try
{
close();
}
catch (...)
{
// ignore all errors
}
}
// ---------------------------------------------------------------------------------==
void CFunCallbackStream::open(const StreamParameters &parameters, PaStreamCallback *funPtr, void *userData)
{
PaError err = Pa_OpenStream(&stream_, parameters.inputParameters().paStreamParameters(), parameters.outputParameters().paStreamParameters(),
parameters.sampleRate(), parameters.framesPerBuffer(), parameters.flags(), funPtr, userData);
if (err != paNoError)
{
throw PaException(err);
}
}
}

50
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/CallbackInterface.cxx
View File

@@ -1,25 +1,25 @@
#include "portaudiocpp/CallbackInterface.hxx"
namespace portaudio
{
namespace impl
{
//////
/// Adapts any CallbackInterface object to a C-callable function (ie this function). A
/// pointer to the object should be passed as ``userData'' when setting up the callback.
//////
int callbackInterfaceToPaCallbackAdapter(const void *inputBuffer, void *outputBuffer, unsigned long numFrames,
const PaStreamCallbackTimeInfo *timeInfo, PaStreamCallbackFlags statusFlags, void *userData)
{
CallbackInterface *cb = static_cast<CallbackInterface *>(userData);
return cb->paCallbackFun(inputBuffer, outputBuffer, numFrames, timeInfo, statusFlags);
}
} // namespace impl
} // namespace portaudio
#include "portaudiocpp/CallbackInterface.hxx"
namespace portaudio
{
namespace impl
{
//////
/// Adapts any CallbackInterface object to a C-callable function (ie this function). A
/// pointer to the object should be passed as ``userData'' when setting up the callback.
//////
int callbackInterfaceToPaCallbackAdapter(const void *inputBuffer, void *outputBuffer, unsigned long numFrames,
const PaStreamCallbackTimeInfo *timeInfo, PaStreamCallbackFlags statusFlags, void *userData)
{
CallbackInterface *cb = static_cast<CallbackInterface *>(userData);
return cb->paCallbackFun(inputBuffer, outputBuffer, numFrames, timeInfo, statusFlags);
}
} // namespace impl
} // namespace portaudio

40
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/CallbackStream.cxx
View File

@@ -1,20 +1,20 @@
#include "portaudiocpp/CallbackStream.hxx"
namespace portaudio
{
CallbackStream::CallbackStream()
{
}
CallbackStream::~CallbackStream()
{
}
// -----------------------------------------------------------------------------------
double CallbackStream::cpuLoad() const
{
return Pa_GetStreamCpuLoad(stream_);
}
} // namespace portaudio
#include "portaudiocpp/CallbackStream.hxx"
namespace portaudio
{
CallbackStream::CallbackStream()
{
}
CallbackStream::~CallbackStream()
{
}
// -----------------------------------------------------------------------------------
double CallbackStream::cpuLoad() const
{
return Pa_GetStreamCpuLoad(stream_);
}
} // namespace portaudio

162
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/CppFunCallbackStream.cxx
View File

@@ -1,81 +1,81 @@
#include "portaudiocpp/CppFunCallbackStream.hxx"
#include "portaudiocpp/StreamParameters.hxx"
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
namespace impl
{
//////
/// Adapts any a C++ callback to a C-callable function (ie this function). A
/// pointer to a struct with the C++ function pointer and the actual user data should be
/// passed as the ``userData'' parameter when setting up the callback.
//////
int cppCallbackToPaCallbackAdapter(const void *inputBuffer, void *outputBuffer, unsigned long numFrames,
const PaStreamCallbackTimeInfo *timeInfo, PaStreamCallbackFlags statusFlags, void *userData)
{
FunCallbackStream::CppToCCallbackData *data = static_cast<FunCallbackStream::CppToCCallbackData *>(userData);
return data->funPtr(inputBuffer, outputBuffer, numFrames, timeInfo, statusFlags, data->userData);
}
}
// -----------------------------------------------------------------------------------
FunCallbackStream::CppToCCallbackData::CppToCCallbackData()
{
}
FunCallbackStream::CppToCCallbackData::CppToCCallbackData(CallbackFunPtr funPtr, void *userData) : funPtr(funPtr), userData(userData)
{
}
void FunCallbackStream::CppToCCallbackData::init(CallbackFunPtr funPtr, void *userData)
{
this->funPtr = funPtr;
this->userData = userData;
}
// -----------------------------------------------------------------------------------
FunCallbackStream::FunCallbackStream()
{
}
FunCallbackStream::FunCallbackStream(const StreamParameters &parameters, CallbackFunPtr funPtr, void *userData) : adapterData_(funPtr, userData)
{
open(parameters);
}
FunCallbackStream::~FunCallbackStream()
{
try
{
close();
}
catch (...)
{
// ignore all errors
}
}
void FunCallbackStream::open(const StreamParameters &parameters, CallbackFunPtr funPtr, void *userData)
{
adapterData_.init(funPtr, userData);
open(parameters);
}
void FunCallbackStream::open(const StreamParameters &parameters)
{
PaError err = Pa_OpenStream(&stream_, parameters.inputParameters().paStreamParameters(), parameters.outputParameters().paStreamParameters(),
parameters.sampleRate(), parameters.framesPerBuffer(), parameters.flags(), &impl::cppCallbackToPaCallbackAdapter,
static_cast<void *>(&adapterData_));
if (err != paNoError)
{
throw PaException(err);
}
}
// -----------------------------------------------------------------------------------
}
#include "portaudiocpp/CppFunCallbackStream.hxx"
#include "portaudiocpp/StreamParameters.hxx"
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
namespace impl
{
//////
/// Adapts any a C++ callback to a C-callable function (ie this function). A
/// pointer to a struct with the C++ function pointer and the actual user data should be
/// passed as the ``userData'' parameter when setting up the callback.
//////
int cppCallbackToPaCallbackAdapter(const void *inputBuffer, void *outputBuffer, unsigned long numFrames,
const PaStreamCallbackTimeInfo *timeInfo, PaStreamCallbackFlags statusFlags, void *userData)
{
FunCallbackStream::CppToCCallbackData *data = static_cast<FunCallbackStream::CppToCCallbackData *>(userData);
return data->funPtr(inputBuffer, outputBuffer, numFrames, timeInfo, statusFlags, data->userData);
}
}
// -----------------------------------------------------------------------------------
FunCallbackStream::CppToCCallbackData::CppToCCallbackData()
{
}
FunCallbackStream::CppToCCallbackData::CppToCCallbackData(CallbackFunPtr funPtr, void *userData) : funPtr(funPtr), userData(userData)
{
}
void FunCallbackStream::CppToCCallbackData::init(CallbackFunPtr funPtr, void *userData)
{
this->funPtr = funPtr;
this->userData = userData;
}
// -----------------------------------------------------------------------------------
FunCallbackStream::FunCallbackStream()
{
}
FunCallbackStream::FunCallbackStream(const StreamParameters &parameters, CallbackFunPtr funPtr, void *userData) : adapterData_(funPtr, userData)
{
open(parameters);
}
FunCallbackStream::~FunCallbackStream()
{
try
{
close();
}
catch (...)
{
// ignore all errors
}
}
void FunCallbackStream::open(const StreamParameters &parameters, CallbackFunPtr funPtr, void *userData)
{
adapterData_.init(funPtr, userData);
open(parameters);
}
void FunCallbackStream::open(const StreamParameters &parameters)
{
PaError err = Pa_OpenStream(&stream_, parameters.inputParameters().paStreamParameters(), parameters.outputParameters().paStreamParameters(),
parameters.sampleRate(), parameters.framesPerBuffer(), parameters.flags(), &impl::cppCallbackToPaCallbackAdapter,
static_cast<void *>(&adapterData_));
if (err != paNoError)
{
throw PaException(err);
}
}
// -----------------------------------------------------------------------------------
}

336
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/Device.cxx
View File

@@ -1,168 +1,168 @@
#include "portaudiocpp/Device.hxx"
#include <cstddef>
#include "portaudiocpp/HostApi.hxx"
#include "portaudiocpp/System.hxx"
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
// -------------------------------------------------------------------------------
Device::Device(PaDeviceIndex index) : index_(index)
{
if (index == paNoDevice)
info_ = NULL;
else
info_ = Pa_GetDeviceInfo(index);
}
Device::~Device()
{
}
PaDeviceIndex Device::index() const
{
return index_;
}
const char *Device::name() const
{
if (info_ == NULL)
return "";
return info_->name;
}
int Device::maxInputChannels() const
{
if (info_ == NULL)
return 0;
return info_->maxInputChannels;
}
int Device::maxOutputChannels() const
{
if (info_ == NULL)
return 0;
return info_->maxOutputChannels;
}
PaTime Device::defaultLowInputLatency() const
{
if (info_ == NULL)
return static_cast<PaTime>(0.0);
return info_->defaultLowInputLatency;
}
PaTime Device::defaultHighInputLatency() const
{
if (info_ == NULL)
return static_cast<PaTime>(0.0);
return info_->defaultHighInputLatency;
}
PaTime Device::defaultLowOutputLatency() const
{
if (info_ == NULL)
return static_cast<PaTime>(0.0);
return info_->defaultLowOutputLatency;
}
PaTime Device::defaultHighOutputLatency() const
{
if (info_ == NULL)
return static_cast<PaTime>(0.0);
return info_->defaultHighOutputLatency;
}
double Device::defaultSampleRate() const
{
if (info_ == NULL)
return 0.0;
return info_->defaultSampleRate;
}
// -------------------------------------------------------------------------------
bool Device::isInputOnlyDevice() const
{
return (maxOutputChannels() == 0);
}
bool Device::isOutputOnlyDevice() const
{
return (maxInputChannels() == 0);
}
bool Device::isFullDuplexDevice() const
{
return (maxInputChannels() > 0 && maxOutputChannels() > 0);
}
bool Device::isSystemDefaultInputDevice() const
{
return (System::instance().defaultInputDevice() == *this);
}
bool Device::isSystemDefaultOutputDevice() const
{
return (System::instance().defaultOutputDevice() == *this);
}
bool Device::isHostApiDefaultInputDevice() const
{
return (hostApi().defaultInputDevice() == *this);
}
bool Device::isHostApiDefaultOutputDevice() const
{
return (hostApi().defaultOutputDevice() == *this);
}
// -------------------------------------------------------------------------------
bool Device::operator==(const Device &rhs)
{
return (index_ == rhs.index_);
}
bool Device::operator!=(const Device &rhs)
{
return !(*this == rhs);
}
// -------------------------------------------------------------------------------
HostApi &Device::hostApi()
{
// NOTE: will cause an exception when called for the null device
if (info_ == NULL)
throw PaException(paInternalError);
return System::instance().hostApiByIndex(info_->hostApi);
}
const HostApi &Device::hostApi() const
{
// NOTE; will cause an exception when called for the null device
if (info_ == NULL)
throw PaException(paInternalError);
return System::instance().hostApiByIndex(info_->hostApi);
}
// -------------------------------------------------------------------------------
} // namespace portaudio
#include "portaudiocpp/Device.hxx"
#include <cstddef>
#include "portaudiocpp/HostApi.hxx"
#include "portaudiocpp/System.hxx"
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
// -------------------------------------------------------------------------------
Device::Device(PaDeviceIndex index) : index_(index)
{
if (index == paNoDevice)
info_ = NULL;
else
info_ = Pa_GetDeviceInfo(index);
}
Device::~Device()
{
}
PaDeviceIndex Device::index() const
{
return index_;
}
const char *Device::name() const
{
if (info_ == NULL)
return "";
return info_->name;
}
int Device::maxInputChannels() const
{
if (info_ == NULL)
return 0;
return info_->maxInputChannels;
}
int Device::maxOutputChannels() const
{
if (info_ == NULL)
return 0;
return info_->maxOutputChannels;
}
PaTime Device::defaultLowInputLatency() const
{
if (info_ == NULL)
return static_cast<PaTime>(0.0);
return info_->defaultLowInputLatency;
}
PaTime Device::defaultHighInputLatency() const
{
if (info_ == NULL)
return static_cast<PaTime>(0.0);
return info_->defaultHighInputLatency;
}
PaTime Device::defaultLowOutputLatency() const
{
if (info_ == NULL)
return static_cast<PaTime>(0.0);
return info_->defaultLowOutputLatency;
}
PaTime Device::defaultHighOutputLatency() const
{
if (info_ == NULL)
return static_cast<PaTime>(0.0);
return info_->defaultHighOutputLatency;
}
double Device::defaultSampleRate() const
{
if (info_ == NULL)
return 0.0;
return info_->defaultSampleRate;
}
// -------------------------------------------------------------------------------
bool Device::isInputOnlyDevice() const
{
return (maxOutputChannels() == 0);
}
bool Device::isOutputOnlyDevice() const
{
return (maxInputChannels() == 0);
}
bool Device::isFullDuplexDevice() const
{
return (maxInputChannels() > 0 && maxOutputChannels() > 0);
}
bool Device::isSystemDefaultInputDevice() const
{
return (System::instance().defaultInputDevice() == *this);
}
bool Device::isSystemDefaultOutputDevice() const
{
return (System::instance().defaultOutputDevice() == *this);
}
bool Device::isHostApiDefaultInputDevice() const
{
return (hostApi().defaultInputDevice() == *this);
}
bool Device::isHostApiDefaultOutputDevice() const
{
return (hostApi().defaultOutputDevice() == *this);
}
// -------------------------------------------------------------------------------
bool Device::operator==(const Device &rhs)
{
return (index_ == rhs.index_);
}
bool Device::operator!=(const Device &rhs)
{
return !(*this == rhs);
}
// -------------------------------------------------------------------------------
HostApi &Device::hostApi()
{
// NOTE: will cause an exception when called for the null device
if (info_ == NULL)
throw PaException(paInternalError);
return System::instance().hostApiByIndex(info_->hostApi);
}
const HostApi &Device::hostApi() const
{
// NOTE; will cause an exception when called for the null device
if (info_ == NULL)
throw PaException(paInternalError);
return System::instance().hostApiByIndex(info_->hostApi);
}
// -------------------------------------------------------------------------------
} // namespace portaudio

326
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/DirectionSpecificStreamParameters.cxx
View File

@@ -1,163 +1,163 @@
#include "portaudiocpp/DirectionSpecificStreamParameters.hxx"
#include "portaudiocpp/Device.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
//////
/// Returns a `nil' DirectionSpecificStreamParameters object. This can be used to
/// specify that one direction of a Stream is not required (i.e. when creating
/// a half-duplex Stream). All fields of the null DirectionSpecificStreamParameters
/// object are invalid except for the device and the number of channel, which are set
/// to paNoDevice and 0 respectively.
//////
DirectionSpecificStreamParameters DirectionSpecificStreamParameters::null()
{
DirectionSpecificStreamParameters tmp;
tmp.paStreamParameters_.device = paNoDevice;
tmp.paStreamParameters_.channelCount = 0;
return tmp;
}
// -----------------------------------------------------------------------------------
//////
/// Default constructor -- all parameters will be uninitialized.
//////
DirectionSpecificStreamParameters::DirectionSpecificStreamParameters()
{
}
//////
/// Constructor which sets all required fields.
//////
DirectionSpecificStreamParameters::DirectionSpecificStreamParameters(const Device &device, int numChannels,
SampleDataFormat format, bool interleaved, PaTime suggestedLatency, void *hostApiSpecificStreamInfo)
{
setDevice(device);
setNumChannels(numChannels);
setSampleFormat(format, interleaved);
setSuggestedLatency(suggestedLatency);
setHostApiSpecificStreamInfo(hostApiSpecificStreamInfo);
}
// -----------------------------------------------------------------------------------
void DirectionSpecificStreamParameters::setDevice(const Device &device)
{
paStreamParameters_.device = device.index();
}
void DirectionSpecificStreamParameters::setNumChannels(int numChannels)
{
paStreamParameters_.channelCount = numChannels;
}
void DirectionSpecificStreamParameters::setSampleFormat(SampleDataFormat format, bool interleaved)
{
paStreamParameters_.sampleFormat = static_cast<PaSampleFormat>(format);
if (!interleaved)
paStreamParameters_.sampleFormat |= paNonInterleaved;
}
void DirectionSpecificStreamParameters::setHostApiSpecificSampleFormat(PaSampleFormat format, bool interleaved)
{
paStreamParameters_.sampleFormat = format;
paStreamParameters_.sampleFormat |= paCustomFormat;
if (!interleaved)
paStreamParameters_.sampleFormat |= paNonInterleaved;
}
void DirectionSpecificStreamParameters::setSuggestedLatency(PaTime latency)
{
paStreamParameters_.suggestedLatency = latency;
}
void DirectionSpecificStreamParameters::setHostApiSpecificStreamInfo(void *streamInfo)
{
paStreamParameters_.hostApiSpecificStreamInfo = streamInfo;
}
// -----------------------------------------------------------------------------------
PaStreamParameters *DirectionSpecificStreamParameters::paStreamParameters()
{
if (paStreamParameters_.channelCount > 0 && paStreamParameters_.device != paNoDevice)
return &paStreamParameters_;
else
return NULL;
}
const PaStreamParameters *DirectionSpecificStreamParameters::paStreamParameters() const
{
if (paStreamParameters_.channelCount > 0 && paStreamParameters_.device != paNoDevice)
return &paStreamParameters_;
else
return NULL;
}
Device &DirectionSpecificStreamParameters::device() const
{
return System::instance().deviceByIndex(paStreamParameters_.device);
}
int DirectionSpecificStreamParameters::numChannels() const
{
return paStreamParameters_.channelCount;
}
//////
/// Returns the (non host api-specific) sample format, without including
/// the paNonInterleaved flag. If the sample format is host api-spefific,
/// INVALID_FORMAT (0) will be returned.
//////
SampleDataFormat DirectionSpecificStreamParameters::sampleFormat() const
{
if (isSampleFormatHostApiSpecific())
return INVALID_FORMAT;
else
return static_cast<SampleDataFormat>(paStreamParameters_.sampleFormat & ~paNonInterleaved);
}
bool DirectionSpecificStreamParameters::isSampleFormatInterleaved() const
{
return ((paStreamParameters_.sampleFormat & paNonInterleaved) == 0);
}
bool DirectionSpecificStreamParameters::isSampleFormatHostApiSpecific() const
{
return ((paStreamParameters_.sampleFormat & paCustomFormat) == 0);
}
//////
/// Returns the host api-specific sample format, without including any
/// paCustomFormat or paNonInterleaved flags. Will return 0 if the sample format is
/// not host api-specific.
//////
PaSampleFormat DirectionSpecificStreamParameters::hostApiSpecificSampleFormat() const
{
if (isSampleFormatHostApiSpecific())
return paStreamParameters_.sampleFormat & ~paCustomFormat & ~paNonInterleaved;
else
return 0;
}
PaTime DirectionSpecificStreamParameters::suggestedLatency() const
{
return paStreamParameters_.suggestedLatency;
}
void *DirectionSpecificStreamParameters::hostApiSpecificStreamInfo() const
{
return paStreamParameters_.hostApiSpecificStreamInfo;
}
// -----------------------------------------------------------------------------------
} // namespace portaudio
#include "portaudiocpp/DirectionSpecificStreamParameters.hxx"
#include "portaudiocpp/Device.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
//////
/// Returns a `nil' DirectionSpecificStreamParameters object. This can be used to
/// specify that one direction of a Stream is not required (i.e. when creating
/// a half-duplex Stream). All fields of the null DirectionSpecificStreamParameters
/// object are invalid except for the device and the number of channel, which are set
/// to paNoDevice and 0 respectively.
//////
DirectionSpecificStreamParameters DirectionSpecificStreamParameters::null()
{
DirectionSpecificStreamParameters tmp;
tmp.paStreamParameters_.device = paNoDevice;
tmp.paStreamParameters_.channelCount = 0;
return tmp;
}
// -----------------------------------------------------------------------------------
//////
/// Default constructor -- all parameters will be uninitialized.
//////
DirectionSpecificStreamParameters::DirectionSpecificStreamParameters()
{
}
//////
/// Constructor which sets all required fields.
//////
DirectionSpecificStreamParameters::DirectionSpecificStreamParameters(const Device &device, int numChannels,
SampleDataFormat format, bool interleaved, PaTime suggestedLatency, void *hostApiSpecificStreamInfo)
{
setDevice(device);
setNumChannels(numChannels);
setSampleFormat(format, interleaved);
setSuggestedLatency(suggestedLatency);
setHostApiSpecificStreamInfo(hostApiSpecificStreamInfo);
}
// -----------------------------------------------------------------------------------
void DirectionSpecificStreamParameters::setDevice(const Device &device)
{
paStreamParameters_.device = device.index();
}
void DirectionSpecificStreamParameters::setNumChannels(int numChannels)
{
paStreamParameters_.channelCount = numChannels;
}
void DirectionSpecificStreamParameters::setSampleFormat(SampleDataFormat format, bool interleaved)
{
paStreamParameters_.sampleFormat = static_cast<PaSampleFormat>(format);
if (!interleaved)
paStreamParameters_.sampleFormat |= paNonInterleaved;
}
void DirectionSpecificStreamParameters::setHostApiSpecificSampleFormat(PaSampleFormat format, bool interleaved)
{
paStreamParameters_.sampleFormat = format;
paStreamParameters_.sampleFormat |= paCustomFormat;
if (!interleaved)
paStreamParameters_.sampleFormat |= paNonInterleaved;
}
void DirectionSpecificStreamParameters::setSuggestedLatency(PaTime latency)
{
paStreamParameters_.suggestedLatency = latency;
}
void DirectionSpecificStreamParameters::setHostApiSpecificStreamInfo(void *streamInfo)
{
paStreamParameters_.hostApiSpecificStreamInfo = streamInfo;
}
// -----------------------------------------------------------------------------------
PaStreamParameters *DirectionSpecificStreamParameters::paStreamParameters()
{
if (paStreamParameters_.channelCount > 0 && paStreamParameters_.device != paNoDevice)
return &paStreamParameters_;
else
return NULL;
}
const PaStreamParameters *DirectionSpecificStreamParameters::paStreamParameters() const
{
if (paStreamParameters_.channelCount > 0 && paStreamParameters_.device != paNoDevice)
return &paStreamParameters_;
else
return NULL;
}
Device &DirectionSpecificStreamParameters::device() const
{
return System::instance().deviceByIndex(paStreamParameters_.device);
}
int DirectionSpecificStreamParameters::numChannels() const
{
return paStreamParameters_.channelCount;
}
//////
/// Returns the (non host api-specific) sample format, without including
/// the paNonInterleaved flag. If the sample format is host api-spefific,
/// INVALID_FORMAT (0) will be returned.
//////
SampleDataFormat DirectionSpecificStreamParameters::sampleFormat() const
{
if (isSampleFormatHostApiSpecific())
return INVALID_FORMAT;
else
return static_cast<SampleDataFormat>(paStreamParameters_.sampleFormat & ~paNonInterleaved);
}
bool DirectionSpecificStreamParameters::isSampleFormatInterleaved() const
{
return ((paStreamParameters_.sampleFormat & paNonInterleaved) == 0);
}
bool DirectionSpecificStreamParameters::isSampleFormatHostApiSpecific() const
{
return ((paStreamParameters_.sampleFormat & paCustomFormat) == 0);
}
//////
/// Returns the host api-specific sample format, without including any
/// paCustomFormat or paNonInterleaved flags. Will return 0 if the sample format is
/// not host api-specific.
//////
PaSampleFormat DirectionSpecificStreamParameters::hostApiSpecificSampleFormat() const
{
if (isSampleFormatHostApiSpecific())
return paStreamParameters_.sampleFormat & ~paCustomFormat & ~paNonInterleaved;
else
return 0;
}
PaTime DirectionSpecificStreamParameters::suggestedLatency() const
{
return paStreamParameters_.suggestedLatency;
}
void *DirectionSpecificStreamParameters::hostApiSpecificStreamInfo() const
{
return paStreamParameters_.hostApiSpecificStreamInfo;
}
// -----------------------------------------------------------------------------------
} // namespace portaudio

246
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/Exception.cxx
View File

@@ -1,123 +1,123 @@
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
// PaException:
// -----------------------------------------------------------------------------------
//////
/// Wraps a PortAudio error into a PortAudioCpp PaException.
//////
PaException::PaException(PaError error) : error_(error)
{
}
// -----------------------------------------------------------------------------------
//////
/// Alias for paErrorText(), to have std::exception compliance.
//////
const char *PaException::what() const throw()
{
return paErrorText();
}
// -----------------------------------------------------------------------------------
//////
/// Returns the PortAudio error code (PaError).
//////
PaError PaException::paError() const
{
return error_;
}
//////
/// Returns the error as a (zero-terminated) text string.
//////
const char *PaException::paErrorText() const
{
return Pa_GetErrorText(error_);
}
//////
/// Returns true is the error is a HostApi error.
//////
bool PaException::isHostApiError() const
{
return (error_ == paUnanticipatedHostError);
}
//////
/// Returns the last HostApi error (which is the current one if
/// isHostApiError() returns true) as an error code.
//////
long PaException::lastHostApiError() const
{
return Pa_GetLastHostErrorInfo()->errorCode;
}
//////
/// Returns the last HostApi error (which is the current one if
/// isHostApiError() returns true) as a (zero-terminated) text
/// string, if it's available.
//////
const char *PaException::lastHostApiErrorText() const
{
return Pa_GetLastHostErrorInfo()->errorText;
}
// -----------------------------------------------------------------------------------
bool PaException::operator==(const PaException &rhs) const
{
return (error_ == rhs.error_);
}
bool PaException::operator!=(const PaException &rhs) const
{
return !(*this == rhs);
}
// -----------------------------------------------------------------------------------
// PaCppException:
// -----------------------------------------------------------------------------------
PaCppException::PaCppException(ExceptionSpecifier specifier) : specifier_(specifier)
{
}
const char *PaCppException::what() const throw()
{
switch (specifier_)
{
case UNABLE_TO_ADAPT_DEVICE:
{
return "Unable to adapt the given device to the specified host api specific device extension";
}
}
return "Unknown exception";
}
PaCppException::ExceptionSpecifier PaCppException::specifier() const
{
return specifier_;
}
bool PaCppException::operator==(const PaCppException &rhs) const
{
return (specifier_ == rhs.specifier_);
}
bool PaCppException::operator!=(const PaCppException &rhs) const
{
return !(*this == rhs);
}
// -----------------------------------------------------------------------------------
} // namespace portaudio
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
// PaException:
// -----------------------------------------------------------------------------------
//////
/// Wraps a PortAudio error into a PortAudioCpp PaException.
//////
PaException::PaException(PaError error) : error_(error)
{
}
// -----------------------------------------------------------------------------------
//////
/// Alias for paErrorText(), to have std::exception compliance.
//////
const char *PaException::what() const throw()
{
return paErrorText();
}
// -----------------------------------------------------------------------------------
//////
/// Returns the PortAudio error code (PaError).
//////
PaError PaException::paError() const
{
return error_;
}
//////
/// Returns the error as a (zero-terminated) text string.
//////
const char *PaException::paErrorText() const
{
return Pa_GetErrorText(error_);
}
//////
/// Returns true is the error is a HostApi error.
//////
bool PaException::isHostApiError() const
{
return (error_ == paUnanticipatedHostError);
}
//////
/// Returns the last HostApi error (which is the current one if
/// isHostApiError() returns true) as an error code.
//////
long PaException::lastHostApiError() const
{
return Pa_GetLastHostErrorInfo()->errorCode;
}
//////
/// Returns the last HostApi error (which is the current one if
/// isHostApiError() returns true) as a (zero-terminated) text
/// string, if it's available.
//////
const char *PaException::lastHostApiErrorText() const
{
return Pa_GetLastHostErrorInfo()->errorText;
}
// -----------------------------------------------------------------------------------
bool PaException::operator==(const PaException &rhs) const
{
return (error_ == rhs.error_);
}
bool PaException::operator!=(const PaException &rhs) const
{
return !(*this == rhs);
}
// -----------------------------------------------------------------------------------
// PaCppException:
// -----------------------------------------------------------------------------------
PaCppException::PaCppException(ExceptionSpecifier specifier) : specifier_(specifier)
{
}
const char *PaCppException::what() const throw()
{
switch (specifier_)
{
case UNABLE_TO_ADAPT_DEVICE:
{
return "Unable to adapt the given device to the specified host api specific device extension";
}
}
return "Unknown exception";
}
PaCppException::ExceptionSpecifier PaCppException::specifier() const
{
return specifier_;
}
bool PaCppException::operator==(const PaCppException &rhs) const
{
return (specifier_ == rhs.specifier_);
}
bool PaCppException::operator!=(const PaCppException &rhs) const
{
return !(*this == rhs);
}
// -----------------------------------------------------------------------------------
} // namespace portaudio

242
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/HostApi.cxx
View File

@@ -1,121 +1,121 @@
#include "portaudiocpp/HostApi.hxx"
#include "portaudiocpp/System.hxx"
#include "portaudiocpp/Device.hxx"
#include "portaudiocpp/SystemDeviceIterator.hxx"
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
HostApi::HostApi(PaHostApiIndex index) : devices_(NULL)
{
try
{
info_ = Pa_GetHostApiInfo(index);
// Create and populate devices array:
int numDevices = deviceCount();
devices_ = new Device*[numDevices];
for (int i = 0; i < numDevices; ++i)
{
PaDeviceIndex deviceIndex = Pa_HostApiDeviceIndexToDeviceIndex(index, i);
if (deviceIndex < 0)
{
throw PaException(deviceIndex);
}
devices_[i] = &System::instance().deviceByIndex(deviceIndex);
}
}
catch (const std::exception &e)
{
// Delete any (partially) constructed objects (deconstructor isn't called):
delete[] devices_; // devices_ is either NULL or valid
// Re-throw exception:
throw e;
}
}
HostApi::~HostApi()
{
// Destroy devices array:
delete[] devices_;
}
// -----------------------------------------------------------------------------------
PaHostApiTypeId HostApi::typeId() const
{
return info_->type;
}
PaHostApiIndex HostApi::index() const
{
PaHostApiIndex index = Pa_HostApiTypeIdToHostApiIndex(typeId());
if (index < 0)
throw PaException(index);
return index;
}
const char *HostApi::name() const
{
return info_->name;
}
int HostApi::deviceCount() const
{
return info_->deviceCount;
}
// -----------------------------------------------------------------------------------
HostApi::DeviceIterator HostApi::devicesBegin()
{
DeviceIterator tmp;
tmp.ptr_ = &devices_[0]; // begin (first element)
return tmp;
}
HostApi::DeviceIterator HostApi::devicesEnd()
{
DeviceIterator tmp;
tmp.ptr_ = &devices_[deviceCount()]; // end (one past last element)
return tmp;
}
// -----------------------------------------------------------------------------------
Device &HostApi::defaultInputDevice() const
{
return System::instance().deviceByIndex(info_->defaultInputDevice);
}
Device &HostApi::defaultOutputDevice() const
{
return System::instance().deviceByIndex(info_->defaultOutputDevice);
}
// -----------------------------------------------------------------------------------
bool HostApi::operator==(const HostApi &rhs) const
{
return (typeId() == rhs.typeId());
}
bool HostApi::operator!=(const HostApi &rhs) const
{
return !(*this == rhs);
}
// -----------------------------------------------------------------------------------
} // namespace portaudio
#include "portaudiocpp/HostApi.hxx"
#include "portaudiocpp/System.hxx"
#include "portaudiocpp/Device.hxx"
#include "portaudiocpp/SystemDeviceIterator.hxx"
#include "portaudiocpp/Exception.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
HostApi::HostApi(PaHostApiIndex index) : devices_(NULL)
{
try
{
info_ = Pa_GetHostApiInfo(index);
// Create and populate devices array:
int numDevices = deviceCount();
devices_ = new Device*[numDevices];
for (int i = 0; i < numDevices; ++i)
{
PaDeviceIndex deviceIndex = Pa_HostApiDeviceIndexToDeviceIndex(index, i);
if (deviceIndex < 0)
{
throw PaException(deviceIndex);
}
devices_[i] = &System::instance().deviceByIndex(deviceIndex);
}
}
catch (const std::exception &e)
{
// Delete any (partially) constructed objects (deconstructor isn't called):
delete[] devices_; // devices_ is either NULL or valid
// Re-throw exception:
throw e;
}
}
HostApi::~HostApi()
{
// Destroy devices array:
delete[] devices_;
}
// -----------------------------------------------------------------------------------
PaHostApiTypeId HostApi::typeId() const
{
return info_->type;
}
PaHostApiIndex HostApi::index() const
{
PaHostApiIndex index = Pa_HostApiTypeIdToHostApiIndex(typeId());
if (index < 0)
throw PaException(index);
return index;
}
const char *HostApi::name() const
{
return info_->name;
}
int HostApi::deviceCount() const
{
return info_->deviceCount;
}
// -----------------------------------------------------------------------------------
HostApi::DeviceIterator HostApi::devicesBegin()
{
DeviceIterator tmp;
tmp.ptr_ = &devices_[0]; // begin (first element)
return tmp;
}
HostApi::DeviceIterator HostApi::devicesEnd()
{
DeviceIterator tmp;
tmp.ptr_ = &devices_[deviceCount()]; // end (one past last element)
return tmp;
}
// -----------------------------------------------------------------------------------
Device &HostApi::defaultInputDevice() const
{
return System::instance().deviceByIndex(info_->defaultInputDevice);
}
Device &HostApi::defaultOutputDevice() const
{
return System::instance().deviceByIndex(info_->defaultOutputDevice);
}
// -----------------------------------------------------------------------------------
bool HostApi::operator==(const HostApi &rhs) const
{
return (typeId() == rhs.typeId());
}
bool HostApi::operator!=(const HostApi &rhs) const
{
return !(*this == rhs);
}
// -----------------------------------------------------------------------------------
} // namespace portaudio

90
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/InterfaceCallbackStream.cxx
View File

@@ -1,45 +1,45 @@
#include "portaudiocpp/InterfaceCallbackStream.hxx"
#include "portaudiocpp/StreamParameters.hxx"
#include "portaudiocpp/Exception.hxx"
#include "portaudiocpp/CallbackInterface.hxx"
namespace portaudio
{
// ---------------------------------------------------------------------------------==
InterfaceCallbackStream::InterfaceCallbackStream()
{
}
InterfaceCallbackStream::InterfaceCallbackStream(const StreamParameters &parameters, CallbackInterface &instance)
{
open(parameters, instance);
}
InterfaceCallbackStream::~InterfaceCallbackStream()
{
try
{
close();
}
catch (...)
{
// ignore all errors
}
}
// ---------------------------------------------------------------------------------==
void InterfaceCallbackStream::open(const StreamParameters &parameters, CallbackInterface &instance)
{
PaError err = Pa_OpenStream(&stream_, parameters.inputParameters().paStreamParameters(), parameters.outputParameters().paStreamParameters(),
parameters.sampleRate(), parameters.framesPerBuffer(), parameters.flags(), &impl::callbackInterfaceToPaCallbackAdapter, static_cast<void *>(&instance));
if (err != paNoError)
{
throw PaException(err);
}
}
}
#include "portaudiocpp/InterfaceCallbackStream.hxx"
#include "portaudiocpp/StreamParameters.hxx"
#include "portaudiocpp/Exception.hxx"
#include "portaudiocpp/CallbackInterface.hxx"
namespace portaudio
{
// ---------------------------------------------------------------------------------==
InterfaceCallbackStream::InterfaceCallbackStream()
{
}
InterfaceCallbackStream::InterfaceCallbackStream(const StreamParameters &parameters, CallbackInterface &instance)
{
open(parameters, instance);
}
InterfaceCallbackStream::~InterfaceCallbackStream()
{
try
{
close();
}
catch (...)
{
// ignore all errors
}
}
// ---------------------------------------------------------------------------------==
void InterfaceCallbackStream::open(const StreamParameters &parameters, CallbackInterface &instance)
{
PaError err = Pa_OpenStream(&stream_, parameters.inputParameters().paStreamParameters(), parameters.outputParameters().paStreamParameters(),
parameters.sampleRate(), parameters.framesPerBuffer(), parameters.flags(), &impl::callbackInterfaceToPaCallbackAdapter, static_cast<void *>(&instance));
if (err != paNoError)
{
throw PaException(err);
}
}
}

8
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/MemFunCallbackStream.cxx
View File

@@ -1,4 +1,4 @@
#include "portaudiocpp/MemFunCallbackStream.hxx"
// (... template class ...)
#include "portaudiocpp/MemFunCallbackStream.hxx"
// (... template class ...)

390
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/Stream.cxx
View File

@@ -1,195 +1,195 @@
#include "portaudiocpp/Stream.hxx"
#include <cstddef>
#include "portaudiocpp/Exception.hxx"
#include "portaudiocpp/System.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
Stream::Stream() : stream_(NULL)
{
}
Stream::~Stream()
{
// (can't call close here,
// the derived class should atleast call
// close() in it's deconstructor)
}
// -----------------------------------------------------------------------------------
//////
/// Closes the Stream if it's open, else does nothing.
//////
void Stream::close()
{
if (isOpen() && System::exists())
{
PaError err = Pa_CloseStream(stream_);
stream_ = NULL;
if (err != paNoError)
throw PaException(err);
}
}
//////
/// Returns true if the Stream is open.
//////
bool Stream::isOpen() const
{
return (stream_ != NULL);
}
// -----------------------------------------------------------------------------------
void Stream::setStreamFinishedCallback(PaStreamFinishedCallback *callback)
{
PaError err = Pa_SetStreamFinishedCallback(stream_, callback);
if (err != paNoError)
throw PaException(err);
}
// -----------------------------------------------------------------------------------
void Stream::start()
{
PaError err = Pa_StartStream(stream_);
if (err != paNoError)
throw PaException(err);
}
void Stream::stop()
{
PaError err = Pa_StopStream(stream_);
if (err != paNoError)
throw PaException(err);
}
void Stream::abort()
{
PaError err = Pa_AbortStream(stream_);
if (err != paNoError)
throw PaException(err);
}
bool Stream::isStopped() const
{
PaError ret = Pa_IsStreamStopped(stream_);
if (ret < 0)
throw PaException(ret);
return (ret == 1);
}
bool Stream::isActive() const
{
PaError ret = Pa_IsStreamActive(stream_);
if (ret < 0)
throw PaException(ret);
return (ret == 1);
}
// -----------------------------------------------------------------------------------
//////
/// Returns the best known input latency for the Stream. This value may differ from the
/// suggested input latency set in the StreamParameters. Includes all sources of
/// latency known to PortAudio such as internal buffering, and Host API reported latency.
/// Doesn't include any estimates of unknown latency.
//////
PaTime Stream::inputLatency() const
{
const PaStreamInfo *info = Pa_GetStreamInfo(stream_);
if (info == NULL)
{
throw PaException(paInternalError);
return PaTime(0.0);
}
return info->inputLatency;
}
//////
/// Returns the best known output latency for the Stream. This value may differ from the
/// suggested output latency set in the StreamParameters. Includes all sources of
/// latency known to PortAudio such as internal buffering, and Host API reported latency.
/// Doesn't include any estimates of unknown latency.
//////
PaTime Stream::outputLatency() const
{
const PaStreamInfo *info = Pa_GetStreamInfo(stream_);
if (info == NULL)
{
throw PaException(paInternalError);
return PaTime(0.0);
}
return info->outputLatency;
}
//////
/// Returns the sample rate of the Stream. Usually this will be the
/// best known estimate of the used sample rate. For instance when opening a
/// Stream setting 44100.0 Hz in the StreamParameters, the actual sample
/// rate might be something like 44103.2 Hz (due to imperfections in the
/// sound card hardware).
//////
double Stream::sampleRate() const
{
const PaStreamInfo *info = Pa_GetStreamInfo(stream_);
if (info == NULL)
{
throw PaException(paInternalError);
return 0.0;
}
return info->sampleRate;
}
// -----------------------------------------------------------------------------------
PaTime Stream::time() const
{
return Pa_GetStreamTime(stream_);
}
// -----------------------------------------------------------------------------------
//////
/// Accessor (const) for PortAudio PaStream pointer, useful for interfacing with
/// PortAudio add-ons such as PortMixer for instance. Normally accessing this
/// pointer should not be needed as PortAudioCpp aims to provide all of PortAudio's
/// functionality.
//////
const PaStream *Stream::paStream() const
{
return stream_;
}
//////
/// Accessor (non-const) for PortAudio PaStream pointer, useful for interfacing with
/// PortAudio add-ons such as PortMixer for instance. Normally accessing this
/// pointer should not be needed as PortAudioCpp aims to provide all of PortAudio's
/// functionality.
//////
PaStream *Stream::paStream()
{
return stream_;
}
// -----------------------------------------------------------------------------------
} // namespace portaudio
#include "portaudiocpp/Stream.hxx"
#include <cstddef>
#include "portaudiocpp/Exception.hxx"
#include "portaudiocpp/System.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
Stream::Stream() : stream_(NULL)
{
}
Stream::~Stream()
{
// (can't call close here,
// the derived class should atleast call
// close() in it's deconstructor)
}
// -----------------------------------------------------------------------------------
//////
/// Closes the Stream if it's open, else does nothing.
//////
void Stream::close()
{
if (isOpen() && System::exists())
{
PaError err = Pa_CloseStream(stream_);
stream_ = NULL;
if (err != paNoError)
throw PaException(err);
}
}
//////
/// Returns true if the Stream is open.
//////
bool Stream::isOpen() const
{
return (stream_ != NULL);
}
// -----------------------------------------------------------------------------------
void Stream::setStreamFinishedCallback(PaStreamFinishedCallback *callback)
{
PaError err = Pa_SetStreamFinishedCallback(stream_, callback);
if (err != paNoError)
throw PaException(err);
}
// -----------------------------------------------------------------------------------
void Stream::start()
{
PaError err = Pa_StartStream(stream_);
if (err != paNoError)
throw PaException(err);
}
void Stream::stop()
{
PaError err = Pa_StopStream(stream_);
if (err != paNoError)
throw PaException(err);
}
void Stream::abort()
{
PaError err = Pa_AbortStream(stream_);
if (err != paNoError)
throw PaException(err);
}
bool Stream::isStopped() const
{
PaError ret = Pa_IsStreamStopped(stream_);
if (ret < 0)
throw PaException(ret);
return (ret == 1);
}
bool Stream::isActive() const
{
PaError ret = Pa_IsStreamActive(stream_);
if (ret < 0)
throw PaException(ret);
return (ret == 1);
}
// -----------------------------------------------------------------------------------
//////
/// Returns the best known input latency for the Stream. This value may differ from the
/// suggested input latency set in the StreamParameters. Includes all sources of
/// latency known to PortAudio such as internal buffering, and Host API reported latency.
/// Doesn't include any estimates of unknown latency.
//////
PaTime Stream::inputLatency() const
{
const PaStreamInfo *info = Pa_GetStreamInfo(stream_);
if (info == NULL)
{
throw PaException(paInternalError);
return PaTime(0.0);
}
return info->inputLatency;
}
//////
/// Returns the best known output latency for the Stream. This value may differ from the
/// suggested output latency set in the StreamParameters. Includes all sources of
/// latency known to PortAudio such as internal buffering, and Host API reported latency.
/// Doesn't include any estimates of unknown latency.
//////
PaTime Stream::outputLatency() const
{
const PaStreamInfo *info = Pa_GetStreamInfo(stream_);
if (info == NULL)
{
throw PaException(paInternalError);
return PaTime(0.0);
}
return info->outputLatency;
}
//////
/// Returns the sample rate of the Stream. Usually this will be the
/// best known estimate of the used sample rate. For instance when opening a
/// Stream setting 44100.0 Hz in the StreamParameters, the actual sample
/// rate might be something like 44103.2 Hz (due to imperfections in the
/// sound card hardware).
//////
double Stream::sampleRate() const
{
const PaStreamInfo *info = Pa_GetStreamInfo(stream_);
if (info == NULL)
{
throw PaException(paInternalError);
return 0.0;
}
return info->sampleRate;
}
// -----------------------------------------------------------------------------------
PaTime Stream::time() const
{
return Pa_GetStreamTime(stream_);
}
// -----------------------------------------------------------------------------------
//////
/// Accessor (const) for PortAudio PaStream pointer, useful for interfacing with
/// PortAudio add-ons such as PortMixer for instance. Normally accessing this
/// pointer should not be needed as PortAudioCpp aims to provide all of PortAudio's
/// functionality.
//////
const PaStream *Stream::paStream() const
{
return stream_;
}
//////
/// Accessor (non-const) for PortAudio PaStream pointer, useful for interfacing with
/// PortAudio add-ons such as PortMixer for instance. Normally accessing this
/// pointer should not be needed as PortAudioCpp aims to provide all of PortAudio's
/// functionality.
//////
PaStream *Stream::paStream()
{
return stream_;
}
// -----------------------------------------------------------------------------------
} // namespace portaudio

330
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/StreamParameters.cxx
View File

@@ -1,165 +1,165 @@
#include "portaudiocpp/StreamParameters.hxx"
#include <cstddef>
#include "portaudiocpp/Device.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
//////
/// Default constructor; does nothing.
//////
StreamParameters::StreamParameters()
{
}
//////
/// Sets up the all parameters needed to open either a half-duplex or full-duplex Stream.
///
/// @param inputParameters The parameters for the input direction of the to-be opened
/// Stream or DirectionSpecificStreamParameters::null() for an output-only Stream.
/// @param outputParameters The parameters for the output direction of the to-be opened
/// Stream or DirectionSpecificStreamParameters::null() for an input-only Stream.
/// @param sampleRate The to-be opened Stream's sample rate in Hz.
/// @param framesPerBuffer The number of frames per buffer for a CallbackStream, or
/// the preferred buffer granularity for a BlockingStream.
/// @param flags The flags for the to-be opened Stream; default paNoFlag.
//////
StreamParameters::StreamParameters(const DirectionSpecificStreamParameters &inputParameters,
const DirectionSpecificStreamParameters &outputParameters, double sampleRate, unsigned long framesPerBuffer,
PaStreamFlags flags) : inputParameters_(inputParameters), outputParameters_(outputParameters),
sampleRate_(sampleRate), framesPerBuffer_(framesPerBuffer), flags_(flags)
{
}
// -----------------------------------------------------------------------------------
//////
/// Sets the requested sample rate. If this sample rate isn't supported by the hardware, the
/// Stream will fail to open. The real-life sample rate used might differ slightly due to
/// imperfections in the sound card hardware; use Stream::sampleRate() to retreive the
/// best known estimate for this value.
//////
void StreamParameters::setSampleRate(double sampleRate)
{
sampleRate_ = sampleRate;
}
//////
/// Either the number of frames per buffer for a CallbackStream, or
/// the preferred buffer granularity for a BlockingStream. See PortAudio
/// documentation.
//////
void StreamParameters::setFramesPerBuffer(unsigned long framesPerBuffer)
{
framesPerBuffer_ = framesPerBuffer;
}
//////
/// Sets the specified flag or does nothing when the flag is already set. Doesn't
/// `unset' any previously existing flags (use clearFlags() for that).
//////
void StreamParameters::setFlag(PaStreamFlags flag)
{
flags_ |= flag;
}
//////
/// Unsets the specified flag or does nothing if the flag isn't set. Doesn't affect
/// any other flags.
//////
void StreamParameters::unsetFlag(PaStreamFlags flag)
{
flags_ &= ~flag;
}
//////
/// Clears or `unsets' all set flags.
//////
void StreamParameters::clearFlags()
{
flags_ = paNoFlag;
}
// -----------------------------------------------------------------------------------
void StreamParameters::setInputParameters(const DirectionSpecificStreamParameters &parameters)
{
inputParameters_ = parameters;
}
void StreamParameters::setOutputParameters(const DirectionSpecificStreamParameters &parameters)
{
outputParameters_ = parameters;
}
// -----------------------------------------------------------------------------------
bool StreamParameters::isSupported() const
{
return (Pa_IsFormatSupported(inputParameters_.paStreamParameters(),
outputParameters_.paStreamParameters(), sampleRate_) == paFormatIsSupported);
}
// -----------------------------------------------------------------------------------
double StreamParameters::sampleRate() const
{
return sampleRate_;
}
unsigned long StreamParameters::framesPerBuffer() const
{
return framesPerBuffer_;
}
//////
/// Returns all currently set flags as a binary combined
/// integer value (PaStreamFlags). Use isFlagSet() to
/// avoid dealing with the bitmasks.
//////
PaStreamFlags StreamParameters::flags() const
{
return flags_;
}
//////
/// Returns true if the specified flag is currently set
/// or false if it isn't.
//////
bool StreamParameters::isFlagSet(PaStreamFlags flag) const
{
return ((flags_ & flag) != 0);
}
// -----------------------------------------------------------------------------------
DirectionSpecificStreamParameters &StreamParameters::inputParameters()
{
return inputParameters_;
}
const DirectionSpecificStreamParameters &StreamParameters::inputParameters() const
{
return inputParameters_;
}
DirectionSpecificStreamParameters &StreamParameters::outputParameters()
{
return outputParameters_;
}
const DirectionSpecificStreamParameters &StreamParameters::outputParameters() const
{
return outputParameters_;
}
// -----------------------------------------------------------------------------------
} // namespace portaudio
#include "portaudiocpp/StreamParameters.hxx"
#include <cstddef>
#include "portaudiocpp/Device.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
//////
/// Default constructor; does nothing.
//////
StreamParameters::StreamParameters()
{
}
//////
/// Sets up the all parameters needed to open either a half-duplex or full-duplex Stream.
///
/// @param inputParameters The parameters for the input direction of the to-be opened
/// Stream or DirectionSpecificStreamParameters::null() for an output-only Stream.
/// @param outputParameters The parameters for the output direction of the to-be opened
/// Stream or DirectionSpecificStreamParameters::null() for an input-only Stream.
/// @param sampleRate The to-be opened Stream's sample rate in Hz.
/// @param framesPerBuffer The number of frames per buffer for a CallbackStream, or
/// the preferred buffer granularity for a BlockingStream.
/// @param flags The flags for the to-be opened Stream; default paNoFlag.
//////
StreamParameters::StreamParameters(const DirectionSpecificStreamParameters &inputParameters,
const DirectionSpecificStreamParameters &outputParameters, double sampleRate, unsigned long framesPerBuffer,
PaStreamFlags flags) : inputParameters_(inputParameters), outputParameters_(outputParameters),
sampleRate_(sampleRate), framesPerBuffer_(framesPerBuffer), flags_(flags)
{
}
// -----------------------------------------------------------------------------------
//////
/// Sets the requested sample rate. If this sample rate isn't supported by the hardware, the
/// Stream will fail to open. The real-life sample rate used might differ slightly due to
/// imperfections in the sound card hardware; use Stream::sampleRate() to retreive the
/// best known estimate for this value.
//////
void StreamParameters::setSampleRate(double sampleRate)
{
sampleRate_ = sampleRate;
}
//////
/// Either the number of frames per buffer for a CallbackStream, or
/// the preferred buffer granularity for a BlockingStream. See PortAudio
/// documentation.
//////
void StreamParameters::setFramesPerBuffer(unsigned long framesPerBuffer)
{
framesPerBuffer_ = framesPerBuffer;
}
//////
/// Sets the specified flag or does nothing when the flag is already set. Doesn't
/// `unset' any previously existing flags (use clearFlags() for that).
//////
void StreamParameters::setFlag(PaStreamFlags flag)
{
flags_ |= flag;
}
//////
/// Unsets the specified flag or does nothing if the flag isn't set. Doesn't affect
/// any other flags.
//////
void StreamParameters::unsetFlag(PaStreamFlags flag)
{
flags_ &= ~flag;
}
//////
/// Clears or `unsets' all set flags.
//////
void StreamParameters::clearFlags()
{
flags_ = paNoFlag;
}
// -----------------------------------------------------------------------------------
void StreamParameters::setInputParameters(const DirectionSpecificStreamParameters &parameters)
{
inputParameters_ = parameters;
}
void StreamParameters::setOutputParameters(const DirectionSpecificStreamParameters &parameters)
{
outputParameters_ = parameters;
}
// -----------------------------------------------------------------------------------
bool StreamParameters::isSupported() const
{
return (Pa_IsFormatSupported(inputParameters_.paStreamParameters(),
outputParameters_.paStreamParameters(), sampleRate_) == paFormatIsSupported);
}
// -----------------------------------------------------------------------------------
double StreamParameters::sampleRate() const
{
return sampleRate_;
}
unsigned long StreamParameters::framesPerBuffer() const
{
return framesPerBuffer_;
}
//////
/// Returns all currently set flags as a binary combined
/// integer value (PaStreamFlags). Use isFlagSet() to
/// avoid dealing with the bitmasks.
//////
PaStreamFlags StreamParameters::flags() const
{
return flags_;
}
//////
/// Returns true if the specified flag is currently set
/// or false if it isn't.
//////
bool StreamParameters::isFlagSet(PaStreamFlags flag) const
{
return ((flags_ & flag) != 0);
}
// -----------------------------------------------------------------------------------
DirectionSpecificStreamParameters &StreamParameters::inputParameters()
{
return inputParameters_;
}
const DirectionSpecificStreamParameters &StreamParameters::inputParameters() const
{
return inputParameters_;
}
DirectionSpecificStreamParameters &StreamParameters::outputParameters()
{
return outputParameters_;
}
const DirectionSpecificStreamParameters &StreamParameters::outputParameters() const
{
return outputParameters_;
}
// -----------------------------------------------------------------------------------
} // namespace portaudio

616
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/System.cxx
View File

@@ -1,308 +1,308 @@
#include "portaudiocpp/System.hxx"
#include <cstddef>
#include <cassert>
#include "portaudiocpp/HostApi.hxx"
#include "portaudiocpp/Device.hxx"
#include "portaudiocpp/Stream.hxx"
#include "portaudiocpp/Exception.hxx"
#include "portaudiocpp/SystemHostApiIterator.hxx"
#include "portaudiocpp/SystemDeviceIterator.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
// Static members:
System *System::instance_ = NULL;
int System::initCount_ = 0;
HostApi **System::hostApis_ = NULL;
Device **System::devices_ = NULL;
Device *System::nullDevice_ = NULL;
// -----------------------------------------------------------------------------------
int System::version()
{
return Pa_GetVersion();
}
const char *System::versionText()
{
return Pa_GetVersionText();
}
void System::initialize()
{
++initCount_;
if (initCount_ == 1)
{
// Create singleton:
assert(instance_ == NULL);
instance_ = new System();
// Initialize the PortAudio system:
{
PaError err = Pa_Initialize();
if (err != paNoError)
throw PaException(err);
}
// Create and populate device array:
{
int numDevices = instance().deviceCount();
devices_ = new Device*[numDevices];
for (int i = 0; i < numDevices; ++i)
devices_[i] = new Device(i);
}
// Create and populate host api array:
{
int numHostApis = instance().hostApiCount();
hostApis_ = new HostApi*[numHostApis];
for (int i = 0; i < numHostApis; ++i)
hostApis_[i] = new HostApi(i);
}
// Create null device:
nullDevice_ = new Device(paNoDevice);
}
}
void System::terminate()
{
PaError err = paNoError;
if (initCount_ == 1)
{
// Destroy null device:
delete nullDevice_;
// Destroy host api array:
{
if (hostApis_ != NULL)
{
int numHostApis = instance().hostApiCount();
for (int i = 0; i < numHostApis; ++i)
delete hostApis_[i];
delete[] hostApis_;
hostApis_ = NULL;
}
}
// Destroy device array:
{
if (devices_ != NULL)
{
int numDevices = instance().deviceCount();
for (int i = 0; i < numDevices; ++i)
delete devices_[i];
delete[] devices_;
devices_ = NULL;
}
}
// Terminate the PortAudio system:
assert(instance_ != NULL);
err = Pa_Terminate();
// Destroy singleton:
delete instance_;
instance_ = NULL;
}
if (initCount_ > 0)
--initCount_;
if (err != paNoError)
throw PaException(err);
}
System &System::instance()
{
assert(exists());
return *instance_;
}
bool System::exists()
{
return (instance_ != NULL);
}
// -----------------------------------------------------------------------------------
System::HostApiIterator System::hostApisBegin()
{
System::HostApiIterator tmp;
tmp.ptr_ = &hostApis_[0]; // begin (first element)
return tmp;
}
System::HostApiIterator System::hostApisEnd()
{
int count = hostApiCount();
System::HostApiIterator tmp;
tmp.ptr_ = &hostApis_[count]; // end (one past last element)
return tmp;
}
HostApi &System::defaultHostApi()
{
PaHostApiIndex defaultHostApi = Pa_GetDefaultHostApi();
if (defaultHostApi < 0)
throw PaException(defaultHostApi);
return *hostApis_[defaultHostApi];
}
HostApi &System::hostApiByTypeId(PaHostApiTypeId type)
{
PaHostApiIndex index = Pa_HostApiTypeIdToHostApiIndex(type);
if (index < 0)
throw PaException(index);
return *hostApis_[index];
}
HostApi &System::hostApiByIndex(PaHostApiIndex index)
{
if (index < 0 || index >= hostApiCount())
throw PaException(paInternalError);
return *hostApis_[index];
}
int System::hostApiCount()
{
PaHostApiIndex count = Pa_GetHostApiCount();
if (count < 0)
throw PaException(count);
return count;
}
// -----------------------------------------------------------------------------------
System::DeviceIterator System::devicesBegin()
{
DeviceIterator tmp;
tmp.ptr_ = &devices_[0];
return tmp;
}
System::DeviceIterator System::devicesEnd()
{
int count = deviceCount();
DeviceIterator tmp;
tmp.ptr_ = &devices_[count];
return tmp;
}
//////
/// Returns the System's default input Device, or the null Device if none
/// was available.
//////
Device &System::defaultInputDevice()
{
PaDeviceIndex index = Pa_GetDefaultInputDevice();
return deviceByIndex(index);
}
//////
/// Returns the System's default output Device, or the null Device if none
/// was available.
//////
Device &System::defaultOutputDevice()
{
PaDeviceIndex index = Pa_GetDefaultOutputDevice();
return deviceByIndex(index);
}
//////
/// Returns the Device for the given index.
/// Will throw a paInternalError equivalent PaException if the given index
/// is out of range.
//////
Device &System::deviceByIndex(PaDeviceIndex index)
{
if (index < -1 || index >= deviceCount())
{
throw PaException(paInternalError);
}
if (index == -1)
return System::instance().nullDevice();
return *devices_[index];
}
int System::deviceCount()
{
PaDeviceIndex count = Pa_GetDeviceCount();
if (count < 0)
throw PaException(count);
return count;
}
Device &System::nullDevice()
{
return *nullDevice_;
}
// -----------------------------------------------------------------------------------
void System::sleep(long msec)
{
Pa_Sleep(msec);
}
int System::sizeOfSample(PaSampleFormat format)
{
PaError err = Pa_GetSampleSize(format);
if (err < 0)
{
throw PaException(err);
return 0;
}
return err;
}
// -----------------------------------------------------------------------------------
System::System()
{
// (left blank intentionally)
}
System::~System()
{
// (left blank intentionally)
}
// -----------------------------------------------------------------------------------
} // namespace portaudio
#include "portaudiocpp/System.hxx"
#include <cstddef>
#include <cassert>
#include "portaudiocpp/HostApi.hxx"
#include "portaudiocpp/Device.hxx"
#include "portaudiocpp/Stream.hxx"
#include "portaudiocpp/Exception.hxx"
#include "portaudiocpp/SystemHostApiIterator.hxx"
#include "portaudiocpp/SystemDeviceIterator.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
// Static members:
System *System::instance_ = NULL;
int System::initCount_ = 0;
HostApi **System::hostApis_ = NULL;
Device **System::devices_ = NULL;
Device *System::nullDevice_ = NULL;
// -----------------------------------------------------------------------------------
int System::version()
{
return Pa_GetVersion();
}
const char *System::versionText()
{
return Pa_GetVersionText();
}
void System::initialize()
{
++initCount_;
if (initCount_ == 1)
{
// Create singleton:
assert(instance_ == NULL);
instance_ = new System();
// Initialize the PortAudio system:
{
PaError err = Pa_Initialize();
if (err != paNoError)
throw PaException(err);
}
// Create and populate device array:
{
int numDevices = instance().deviceCount();
devices_ = new Device*[numDevices];
for (int i = 0; i < numDevices; ++i)
devices_[i] = new Device(i);
}
// Create and populate host api array:
{
int numHostApis = instance().hostApiCount();
hostApis_ = new HostApi*[numHostApis];
for (int i = 0; i < numHostApis; ++i)
hostApis_[i] = new HostApi(i);
}
// Create null device:
nullDevice_ = new Device(paNoDevice);
}
}
void System::terminate()
{
PaError err = paNoError;
if (initCount_ == 1)
{
// Destroy null device:
delete nullDevice_;
// Destroy host api array:
{
if (hostApis_ != NULL)
{
int numHostApis = instance().hostApiCount();
for (int i = 0; i < numHostApis; ++i)
delete hostApis_[i];
delete[] hostApis_;
hostApis_ = NULL;
}
}
// Destroy device array:
{
if (devices_ != NULL)
{
int numDevices = instance().deviceCount();
for (int i = 0; i < numDevices; ++i)
delete devices_[i];
delete[] devices_;
devices_ = NULL;
}
}
// Terminate the PortAudio system:
assert(instance_ != NULL);
err = Pa_Terminate();
// Destroy singleton:
delete instance_;
instance_ = NULL;
}
if (initCount_ > 0)
--initCount_;
if (err != paNoError)
throw PaException(err);
}
System &System::instance()
{
assert(exists());
return *instance_;
}
bool System::exists()
{
return (instance_ != NULL);
}
// -----------------------------------------------------------------------------------
System::HostApiIterator System::hostApisBegin()
{
System::HostApiIterator tmp;
tmp.ptr_ = &hostApis_[0]; // begin (first element)
return tmp;
}
System::HostApiIterator System::hostApisEnd()
{
int count = hostApiCount();
System::HostApiIterator tmp;
tmp.ptr_ = &hostApis_[count]; // end (one past last element)
return tmp;
}
HostApi &System::defaultHostApi()
{
PaHostApiIndex defaultHostApi = Pa_GetDefaultHostApi();
if (defaultHostApi < 0)
throw PaException(defaultHostApi);
return *hostApis_[defaultHostApi];
}
HostApi &System::hostApiByTypeId(PaHostApiTypeId type)
{
PaHostApiIndex index = Pa_HostApiTypeIdToHostApiIndex(type);
if (index < 0)
throw PaException(index);
return *hostApis_[index];
}
HostApi &System::hostApiByIndex(PaHostApiIndex index)
{
if (index < 0 || index >= hostApiCount())
throw PaException(paInternalError);
return *hostApis_[index];
}
int System::hostApiCount()
{
PaHostApiIndex count = Pa_GetHostApiCount();
if (count < 0)
throw PaException(count);
return count;
}
// -----------------------------------------------------------------------------------
System::DeviceIterator System::devicesBegin()
{
DeviceIterator tmp;
tmp.ptr_ = &devices_[0];
return tmp;
}
System::DeviceIterator System::devicesEnd()
{
int count = deviceCount();
DeviceIterator tmp;
tmp.ptr_ = &devices_[count];
return tmp;
}
//////
/// Returns the System's default input Device, or the null Device if none
/// was available.
//////
Device &System::defaultInputDevice()
{
PaDeviceIndex index = Pa_GetDefaultInputDevice();
return deviceByIndex(index);
}
//////
/// Returns the System's default output Device, or the null Device if none
/// was available.
//////
Device &System::defaultOutputDevice()
{
PaDeviceIndex index = Pa_GetDefaultOutputDevice();
return deviceByIndex(index);
}
//////
/// Returns the Device for the given index.
/// Will throw a paInternalError equivalent PaException if the given index
/// is out of range.
//////
Device &System::deviceByIndex(PaDeviceIndex index)
{
if (index < -1 || index >= deviceCount())
{
throw PaException(paInternalError);
}
if (index == -1)
return System::instance().nullDevice();
return *devices_[index];
}
int System::deviceCount()
{
PaDeviceIndex count = Pa_GetDeviceCount();
if (count < 0)
throw PaException(count);
return count;
}
Device &System::nullDevice()
{
return *nullDevice_;
}
// -----------------------------------------------------------------------------------
void System::sleep(long msec)
{
Pa_Sleep(msec);
}
int System::sizeOfSample(PaSampleFormat format)
{
PaError err = Pa_GetSampleSize(format);
if (err < 0)
{
throw PaException(err);
return 0;
}
return err;
}
// -----------------------------------------------------------------------------------
System::System()
{
// (left blank intentionally)
}
System::~System()
{
// (left blank intentionally)
}
// -----------------------------------------------------------------------------------
} // namespace portaudio

120
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/SystemDeviceIterator.cxx
View File

@@ -1,60 +1,60 @@
#include "portaudiocpp/SystemDeviceIterator.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
Device &System::DeviceIterator::operator*() const
{
return **ptr_;
}
Device *System::DeviceIterator::operator->() const
{
return &**this;
}
// -----------------------------------------------------------------------------------
System::DeviceIterator &System::DeviceIterator::operator++()
{
++ptr_;
return *this;
}
System::DeviceIterator System::DeviceIterator::operator++(int)
{
System::DeviceIterator prev = *this;
++*this;
return prev;
}
System::DeviceIterator &System::DeviceIterator::operator--()
{
--ptr_;
return *this;
}
System::DeviceIterator System::DeviceIterator::operator--(int)
{
System::DeviceIterator prev = *this;
--*this;
return prev;
}
// -----------------------------------------------------------------------------------
bool System::DeviceIterator::operator==(const System::DeviceIterator &rhs)
{
return (ptr_ == rhs.ptr_);
}
bool System::DeviceIterator::operator!=(const System::DeviceIterator &rhs)
{
return !(*this == rhs);
}
// -----------------------------------------------------------------------------------
} // namespace portaudio
#include "portaudiocpp/SystemDeviceIterator.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
Device &System::DeviceIterator::operator*() const
{
return **ptr_;
}
Device *System::DeviceIterator::operator->() const
{
return &**this;
}
// -----------------------------------------------------------------------------------
System::DeviceIterator &System::DeviceIterator::operator++()
{
++ptr_;
return *this;
}
System::DeviceIterator System::DeviceIterator::operator++(int)
{
System::DeviceIterator prev = *this;
++*this;
return prev;
}
System::DeviceIterator &System::DeviceIterator::operator--()
{
--ptr_;
return *this;
}
System::DeviceIterator System::DeviceIterator::operator--(int)
{
System::DeviceIterator prev = *this;
--*this;
return prev;
}
// -----------------------------------------------------------------------------------
bool System::DeviceIterator::operator==(const System::DeviceIterator &rhs)
{
return (ptr_ == rhs.ptr_);
}
bool System::DeviceIterator::operator!=(const System::DeviceIterator &rhs)
{
return !(*this == rhs);
}
// -----------------------------------------------------------------------------------
} // namespace portaudio

118
lib-src/portaudio-v19/bindings/cpp/source/portaudiocpp/SystemHostApiIterator.cxx
View File

@@ -1,59 +1,59 @@
#include "portaudiocpp/SystemHostApiIterator.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
HostApi &System::HostApiIterator::operator*() const
{
return **ptr_;
}
HostApi *System::HostApiIterator::operator->() const
{
return &**this;
}
// -----------------------------------------------------------------------------------
System::HostApiIterator &System::HostApiIterator::operator++()
{
++ptr_;
return *this;
}
System::HostApiIterator System::HostApiIterator::operator++(int)
{
System::HostApiIterator prev = *this;
++*this;
return prev;
}
System::HostApiIterator &System::HostApiIterator::operator--()
{
--ptr_;
return *this;
}
System::HostApiIterator System::HostApiIterator::operator--(int)
{
System::HostApiIterator prev = *this;
--*this;
return prev;
}
// -----------------------------------------------------------------------------------
bool System::HostApiIterator::operator==(const System::HostApiIterator &rhs)
{
return (ptr_ == rhs.ptr_);
}
bool System::HostApiIterator::operator!=(const System::HostApiIterator &rhs)
{
return !(*this == rhs);
}
// -----------------------------------------------------------------------------------
} // namespace portaudio
#include "portaudiocpp/SystemHostApiIterator.hxx"
namespace portaudio
{
// -----------------------------------------------------------------------------------
HostApi &System::HostApiIterator::operator*() const
{
return **ptr_;
}
HostApi *System::HostApiIterator::operator->() const
{
return &**this;
}
// -----------------------------------------------------------------------------------
System::HostApiIterator &System::HostApiIterator::operator++()
{
++ptr_;
return *this;
}
System::HostApiIterator System::HostApiIterator::operator++(int)
{
System::HostApiIterator prev = *this;
++*this;
return prev;
}
System::HostApiIterator &System::HostApiIterator::operator--()
{
--ptr_;
return *this;
}
System::HostApiIterator System::HostApiIterator::operator--(int)
{
System::HostApiIterator prev = *this;
--*this;
return prev;
}
// -----------------------------------------------------------------------------------
bool System::HostApiIterator::operator==(const System::HostApiIterator &rhs)
{
return (ptr_ == rhs.ptr_);
}
bool System::HostApiIterator::operator!=(const System::HostApiIterator &rhs)
{
return !(*this == rhs);
}
// -----------------------------------------------------------------------------------
} // namespace portaudio