add plibsys

17 files changed, 1761 insertions, 0 deletions

diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/AsioDeviceAdapter.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/AsioDeviceAdapter.cxx
new file mode 100644
index 0000000..3efc100
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/AsioDeviceAdapter.cxx
@@ -0,0 +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;
+		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;
+		PaError err = PaAsio_GetOutputChannelName(device_->index(), channelIndex, &channelName);
+
+		if (err != paNoError)
+			throw PaException(err);
+
+		return channelName;
+	}
+}
+
+
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/BlockingStream.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/BlockingStream.cxx
new file mode 100644
index 0000000..b26b9e8
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/BlockingStream.cxx
@@ -0,0 +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
+
+
+
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/CFunCallbackStream.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/CFunCallbackStream.cxx
new file mode 100644
index 0000000..9cceda9
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/CFunCallbackStream.cxx
@@ -0,0 +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);
+		}
+	}
+}
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/CallbackInterface.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/CallbackInterface.cxx
new file mode 100644
index 0000000..0137261
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/CallbackInterface.cxx
@@ -0,0 +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
+
+
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/CallbackStream.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/CallbackStream.cxx
new file mode 100644
index 0000000..b6c8e1d
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/CallbackStream.cxx
@@ -0,0 +1,20 @@
+#include "portaudiocpp/CallbackStream.hxx"
+
+namespace portaudio
+{
+	CallbackStream::CallbackStream()
+	{
+	}
+
+	CallbackStream::~CallbackStream()
+	{
+	}
+
+	// -----------------------------------------------------------------------------------
+	
+	double CallbackStream::cpuLoad() const
+	{
+		return Pa_GetStreamCpuLoad(stream_);
+	}
+
+} // namespace portaudio
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/CppFunCallbackStream.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/CppFunCallbackStream.cxx
new file mode 100644
index 0000000..fe0b4ab
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/CppFunCallbackStream.cxx
@@ -0,0 +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);
+		}
+	}
+
+	// -----------------------------------------------------------------------------------
+}
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/Device.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/Device.cxx
new file mode 100644
index 0000000..7b21b03
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/Device.cxx
@@ -0,0 +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) const
+		{
+			return (index_ == rhs.index_);
+		}
+
+		bool Device::operator!=(const Device &rhs) const
+		{
+			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
+
+
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/DirectionSpecificStreamParameters.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/DirectionSpecificStreamParameters.cxx
new file mode 100644
index 0000000..68453d0
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/DirectionSpecificStreamParameters.cxx
@@ -0,0 +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
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/Exception.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/Exception.cxx
new file mode 100644
index 0000000..98945c8
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/Exception.cxx
@@ -0,0 +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
+
+
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/HostApi.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/HostApi.cxx
new file mode 100644
index 0000000..6a09670
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/HostApi.cxx
@@ -0,0 +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
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/InterfaceCallbackStream.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/InterfaceCallbackStream.cxx
new file mode 100644
index 0000000..5433fa3
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/InterfaceCallbackStream.cxx
@@ -0,0 +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);
+		}
+	}
+}
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/MemFunCallbackStream.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/MemFunCallbackStream.cxx
new file mode 100644
index 0000000..5141de2
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/MemFunCallbackStream.cxx
@@ -0,0 +1,4 @@
+#include "portaudiocpp/MemFunCallbackStream.hxx"
+
+// (... template class ...)
+
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/Stream.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/Stream.cxx
new file mode 100644
index 0000000..ba16e03
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/Stream.cxx
@@ -0,0 +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
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/StreamParameters.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/StreamParameters.cxx
new file mode 100644
index 0000000..5857710
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/StreamParameters.cxx
@@ -0,0 +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 retrieve 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
+
+
+
+
+
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/System.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/System.cxx
new file mode 100644
index 0000000..acb419d
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/System.cxx
@@ -0,0 +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
+
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/SystemDeviceIterator.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/SystemDeviceIterator.cxx
new file mode 100644
index 0000000..f94cf10
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/SystemDeviceIterator.cxx
@@ -0,0 +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) const
+	{
+		return (ptr_ == rhs.ptr_);
+	}
+
+	bool System::DeviceIterator::operator!=(const System::DeviceIterator &rhs) const
+	{
+		return !(*this == rhs);
+	}
+
+	// -----------------------------------------------------------------------------------
+} // namespace portaudio
+
+
diff --git a/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/SystemHostApiIterator.cxx b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/SystemHostApiIterator.cxx
new file mode 100644
index 0000000..03f2d6e
--- /dev/null
+++ b/3rdparty/portaudio/bindings/cpp/source/portaudiocpp/SystemHostApiIterator.cxx
@@ -0,0 +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) const
+	{
+		return (ptr_ == rhs.ptr_);
+	}
+
+	bool System::HostApiIterator::operator!=(const System::HostApiIterator &rhs) const
+	{
+		return !(*this == rhs);
+	}
+
+	// -----------------------------------------------------------------------------------
+} // namespace portaudio
+