[DEV] start rework Lib

airtaudio/Api.cpp

@@ -34,15 +34,15 @@ airtaudio::Api::~Api(void) {
 	
 }
 
-void airtaudio::Api::openStream(airtaudio::StreamParameters *oParams,
+enum airtaudio::errorType airtaudio::Api::openStream(airtaudio::StreamParameters *oParams,
-                                airtaudio::StreamParameters *iParams,
+                                                     airtaudio::StreamParameters *iParams,
-                                airtaudio::format format,
+                                                     airtaudio::format format,
-                                uint32_t sampleRate,
+                                                     uint32_t sampleRate,
-                                uint32_t *bufferFrames,
+                                                     uint32_t *bufferFrames,
-                                airtaudio::AirTAudioCallback callback,
+                                                     airtaudio::AirTAudioCallback callback,
-                                void *userData,
+                                                     void *userData,
-                                airtaudio::StreamOptions *options,
+                                                     airtaudio::StreamOptions *options,
-                                airtaudio::AirTAudioErrorCallback errorCallback) {
+                                                     airtaudio::AirTAudioErrorCallback errorCallback) {
 	if (m_stream.state != airtaudio::api::STREAM_CLOSED) {
 		m_errorText = "airtaudio::Api::openStream: a stream is already open!";
 		error(airtaudio::errorInvalidUse);
@@ -113,7 +113,9 @@ void airtaudio::Api::openStream(airtaudio::StreamParameters *oParams,
 		                         bufferFrames,
 		                         options);
 		if (result == false) {
-			if (oChannels > 0) closeStream();
+			if (oChannels > 0) {
+				closeStream();
+			}
 			error(airtaudio::errorSystemError);
 			return;
 		}
@@ -137,9 +139,9 @@ uint32_t airtaudio::Api::getDefaultOutputDevice(void) {
 	return 0;
 }
 
-void airtaudio::Api::closeStream(void) {
+enum airtaudio::errorType airtaudio::Api::closeStream(void) {
 	// MUST be implemented in subclasses!
-	return;
+	return airtaudio::errorNone;
 }
 
 bool airtaudio::Api::probeDeviceOpen(uint32_t /*device*/,

airtaudio/Api.h

@@ -17,15 +17,20 @@ namespace airtaudio {
 		 * @brief Audio API specifier arguments.
 		 */
 		enum type {
-			UNSPECIFIED, /*!< Search for a working compiled API. */
+			UNSPECIFIED, //!< Search for a working compiled API.
-			LINUX_ALSA, /*!< The Advanced Linux Sound Architecture API. */
+			LINUX_ALSA, //!< The Advanced Linux Sound Architecture API.
-			LINUX_PULSE, /*!< The Linux PulseAudio API. */
+			LINUX_PULSE, //!< The Linux PulseAudio API.
-			LINUX_OSS, /*!< The Linux Open Sound System API. */
+			LINUX_OSS, //!< The Linux Open Sound System API.
-			UNIX_JACK, /*!< The Jack Low-Latency Audio Server API. */
+			UNIX_JACK, //!< The Jack Low-Latency Audio Server API.
-			MACOSX_CORE, /*!< Macintosh OS-X Core Audio API. */
+			MACOSX_CORE, //!< Macintosh OS-X Core Audio API.
-			WINDOWS_ASIO, /*!< The Steinberg Audio Stream I/O API. */
+			WINDOWS_ASIO, //!< The Steinberg Audio Stream I/O API.
-			WINDOWS_DS, /*!< The Microsoft Direct Sound API. */
+			WINDOWS_DS, //!< The Microsoft Direct Sound API.
-			RTAUDIO_DUMMY /*!< A compilable but non-functional API. */
+			RTAUDIO_DUMMY, //!< A compilable but non-functional API.
+			ANDROID_JAVA, //!< Android Interface.
+			USER_INTERFACE_1, //!< User interface 1.
+			USER_INTERFACE_2, //!< User interface 2.
+			USER_INTERFACE_3, //!< User interface 3.
+			USER_INTERFACE_4, //!< User interface 4.
 		};
 		
 		extern const uint32_t MAX_SAMPLE_RATES;
@@ -118,19 +123,19 @@ namespace airtaudio {
 			virtual airtaudio::DeviceInfo getDeviceInfo(uint32_t _device) = 0;
 			virtual uint32_t getDefaultInputDevice(void);
 			virtual uint32_t getDefaultOutputDevice(void);
-			void openStream(airtaudio::StreamParameters *_outputParameters,
+			enum airtaudio::errorType openStream(airtaudio::StreamParameters *_outputParameters,
-			                airtaudio::StreamParameters *_inputParameters,
+			                                     airtaudio::StreamParameters *_inputParameters,
-			                airtaudio::format _format,
+			                                     airtaudio::format _format,
-			                uint32_t _sampleRate,
+			                                     uint32_t _sampleRate,
-			                uint32_t *_bufferFrames,
+			                                     uint32_t *_bufferFrames,
-			                airtaudio::AirTAudioCallback _callback,
+			                                     airtaudio::AirTAudioCallback _callback,
-			                void *_userData,
+			                                     void *_userData,
-			                airtaudio::StreamOptions *_options,
+			                                     airtaudio::StreamOptions *_options,
-			                airtaudio::AirTAudioErrorCallback _errorCallback);
+			                                     airtaudio::AirTAudioErrorCallback _errorCallback);
-			virtual void closeStream(void);
+			virtual enum airtaudio::errorType closeStream(void);
-			virtual void startStream(void) = 0;
+			virtual enum airtaudio::errorType startStream(void) = 0;
-			virtual void stopStream(void) = 0;
+			virtual enum airtaudio::errorType stopStream(void) = 0;
-			virtual void abortStream(void) = 0;
+			virtual enum airtaudio::errorType abortStream(void) = 0;
 			long getStreamLatency(void);
 			uint32_t getStreamSampleRate(void);
 			virtual double getStreamTime(void);

airtaudio/Interface.cpp

@@ -13,110 +13,93 @@ std::vector<airtaudio::api::type> airtaudio::Interface::getCompiledApi(void) {
 	std::vector<airtaudio::api::type> apis;
 	// The order here will control the order of RtAudio's API search in
 	// the constructor.
-#if defined(__UNIX_JACK__)
+	for (auto &it : m_apiAvaillable) {
-	apis.push_back(airtaudio::api::UNIX_JACK);
+		apis.push_back(it.first);
-#endif
+	}
-#if defined(__LINUX_ALSA__)
-	apis.push_back(airtaudio::api::LINUX_ALSA);
-#endif
-#if defined(__LINUX_PULSE__)
-	apis.push_back(airtaudio::api::LINUX_PULSE);
-#endif
-#if defined(__LINUX_OSS__)
-	apis.push_back(airtaudio::api::LINUX_OSS);
-#endif
-#if defined(__WINDOWS_ASIO__)
-	apis.push_back(airtaudio::api::WINDOWS_ASIO);
-#endif
-#if defined(__WINDOWS_DS__)
-	apis.push_back(airtaudio::api::WINDOWS_DS);
-#endif
-#if defined(__MACOSX_CORE__)
-	apis.push_back(airtaudio::api::MACOSX_CORE);
-#endif
-#if defined(__AIRTAUDIO_DUMMY__)
-	apis.push_back(airtaudio::api::RTAUDIO_DUMMY);
-#endif
 	return apis;
 }
 
+
+
 void airtaudio::Interface::openRtApi(airtaudio::api::type _api) {
 	if (m_rtapi != NULL) {
 		delete m_rtapi;
 		m_rtapi = NULL;
 	}
-#if defined(__UNIX_JACK__)
+	for (auto &it :m_apiAvaillable) {
-	if (_api == airtaudio::api::UNIX_JACK) {
+		if (_api == it.first) {
-		m_rtapi = new airtaudio::api::Jack();
+			m_rtapi = it.second();
+			if (m_rtapi != NULL) {
+				return;
+			}
+		}
 	}
+	// TODO : An eror occured ...
+}
+
+
+airtaudio::Interface::Interface(void) :
+  m_rtapi(NULL) {
+#if defined(__UNIX_JACK__)
+	addInterface(airtaudio::api::UNIX_JACK, airtaudio::api::Jack::Create);
 #endif
 #if defined(__LINUX_ALSA__)
-	if (_api == airtaudio::api::LINUX_ALSA) {
+	addInterface(airtaudio::api::LINUX_ALSA, airtaudio::api::Alsa::Create);
-		m_rtapi = new airtaudio::api::Alsa();
-	}
 #endif
 #if defined(__LINUX_PULSE__)
-	if (_api == airtaudio::api::LINUX_PULSE) {
+	addInterface(airtaudio::api::LINUX_PULSE, airtaudio::api::Pulse::Create);
-		m_rtapi = new airtaudio::api::Pulse();
-	}
 #endif
 #if defined(__LINUX_OSS__)
-	if (_api == airtaudio::api::LINUX_OSS) {
+	addInterface(airtaudio::api::LINUX_OSS, airtaudio::api::Oss::Create);
-		m_rtapi = new airtaudio::api::Oss();
-	}
 #endif
 #if defined(__WINDOWS_ASIO__)
-	if (_api == airtaudio::api::WINDOWS_ASIO) {
+	addInterface(airtaudio::api::WINDOWS_ASIO, airtaudio::api::Asio::Create);
-		m_rtapi = new airtaudio::api::Asio();
-	}
 #endif
 #if defined(__WINDOWS_DS__)
-	if (_api == airtaudio::api::WINDOWS_DS) {
+	addInterface(airtaudio::api::WINDOWS_DS, airtaudio::api::Ds::Create);
-		m_rtapi = new airtaudio::api::Ds();
-	}
 #endif
 #if defined(__MACOSX_CORE__)
-	if (_api == airtaudio::api::MACOSX_CORE) {
+	addInterface(airtaudio::api::MACOSX_CORE, airtaudio::api::Core::Create);
-		m_rtapi = new airtaudio::api::Core();
-	}
 #endif
 #if defined(__AIRTAUDIO_DUMMY__)
-	if (_api == rtaudio::RTAUDIO_DUMMY) {
+	addInterface(airtaudio::api::RTAUDIO_DUMMY, airtaudio::api::Dummy::Create);
-		m_rtapi = new airtaudio::api::Dummy();
-	}
 #endif
 }
 
-airtaudio::Interface::Interface(airtaudio::api::type _api) :
+void airtaudio::Interface::addInterface(airtaudio::api::type _api, Api* (*_callbackCreate)(void)) {
-  m_rtapi(NULL) {
+	m_apiAvaillable.push_back(std::pair<airtaudio::api::type, Api* (*)(void)>(_api, _callbackCreate));
+}
+
+enum airtaudio::errorType airtaudio::Interface::instanciate(airtaudio::api::type _api) {
+	if (m_rtapi != NULL) {
+		std::cerr << "\nInterface already started ...!\n" << std::endl;
+		return airtaudio::errorNone;
+	}
 	if (_api != airtaudio::api::UNSPECIFIED) {
 		// Attempt to open the specified API.
 		openRtApi(_api);
 		if (m_rtapi != NULL) {
-			return;
+			return airtaudio::errorNone;
 		}
 		// No compiled support for specified API value.	Issue a debug
 		// warning and continue as if no API was specified.
 		std::cerr << "\nRtAudio: no compiled support for specified API argument!\n" << std::endl;
+		return airtaudio::errorFail;
 	}
 	// Iterate through the compiled APIs and return as soon as we find
 	// one with at least one device or we reach the end of the list.
 	std::vector<airtaudio::api::type> apis = getCompiledApi();
-	for (uint32_t iii=0; iii<apis.size(); ++iii) {
+	for (auto &it : apis) {
-		openRtApi(apis[iii]);
+		openRtApi(it);
 		if (m_rtapi->getDeviceCount() != 0) {
 			break;
 		}
 	}
 	if (m_rtapi != NULL) {
-		return;
+		return airtaudio::errorNone;
 	}
-	// It should not be possible to get here because the preprocessor
-	// definition __AIRTAUDIO_DUMMY__ is automatically defined if no
-	// API-specific definitions are passed to the compiler. But just in
-	// case something weird happens, we'll print out an error message.
-	// TODO : Set it in error ...
 	std::cout << "\nRtAudio: no compiled API support found ... critical error!!\n\n";
+	return airtaudio::errorFail;
 }
 
 airtaudio::Interface::~Interface(void) {
@@ -126,16 +109,16 @@ airtaudio::Interface::~Interface(void) {
 	}
 }
 
-void airtaudio::Interface::openStream(airtaudio::StreamParameters* _outputParameters,
+enum airtaudio::errorType airtaudio::Interface::openStream(
-                                      airtaudio::StreamParameters* _inputParameters,
+                airtaudio::StreamParameters* _outputParameters,
-                                      airtaudio::format _format,
+                airtaudio::StreamParameters* _inputParameters,
-                                      uint32_t _sampleRate,
+                airtaudio::format _format,
-                                      uint32_t* _bufferFrames,
+                uint32_t _sampleRate,
-                                      airtaudio::AirTAudioCallback _callback,
+                uint32_t* _bufferFrames,
-                                      void* _userData,
+                airtaudio::AirTAudioCallback _callback,
-                                      airtaudio::StreamOptions* _options,
+                void* _userData,
-                                      airtaudio::AirTAudioErrorCallback _errorCallback)
+                airtaudio::StreamOptions* _options,
-{
+                airtaudio::AirTAudioErrorCallback _errorCallback) {
 	if (m_rtapi == NULL) {
 		return;
 	}

airtaudio/Interface.h

@@ -35,6 +35,8 @@ namespace airtaudio {
 	 * attempts to make a "logical" API selection.
 	 */
 	class Interface {
+		protected:
+			std::vector<std::pair<airtaudio::api::type, Api* (*)(void)>> m_apiAvaillable;
 		protected:
 			airtaudio::Api *m_rtapi;
 		public:
@@ -51,18 +53,12 @@ namespace airtaudio {
 			 * the enumerated list values. Note that there can be more than one
 			 * API compiled for certain operating systems.
 			 */
-			static std::vector<airtaudio::api::type> getCompiledApi(void);
+			std::vector<airtaudio::api::type> getCompiledApi(void);
 			/**
 			 * @brief The class constructor.
-			 * 
+			 * @note the creating of the basic instance is done by Instanciate
-			 * The constructor performs minor initialization tasks.	No exceptions
-			 * can be thrown.
-			 * 
-			 * If no API argument is specified and multiple API support has been
-			 * compiled, the default order of use is JACK, ALSA, OSS (Linux
-			 * systems) and ASIO, DS (Windows systems).
 			 */
-			Interface(airtaudio::api::type _api = airtaudio::api::UNSPECIFIED);
+			Interface(void);
 			/**
 			 * @brief The destructor.
 			 * 
@@ -70,6 +66,16 @@ namespace airtaudio {
 			 * automatically.
 			 */
 			~Interface(void);
+			/**
+			 * @brief Add an interface of the Possible List.
+			 * @param[in] _api Type of the interface.
+			 * @param[in] _callbackCreate API creation callback.
+			 */
+			void addInterface(airtaudio::api::type _api, Api* (*_callbackCreate)(void));
+			/**
+			 * @brief Create an interface instance
+			 */
+			enum airtaudio::errorType instanciate(airtaudio::api::type _api = airtaudio::api::UNSPECIFIED);
 			/**
 			 * @return the audio API specifier for the current instance of airtaudio.
 			 */
@@ -179,15 +185,15 @@ namespace airtaudio {
 			 * @param  _errorCallback A client-defined function that will be invoked
 			 *           when an error has occured.
 			 */
-			void openStream(airtaudio::StreamParameters *_outputParameters,
+			enum airtaudio::errorType openStream(airtaudio::StreamParameters *_outputParameters,
-			                airtaudio::StreamParameters *_inputParameters,
+			                                     airtaudio::StreamParameters *_inputParameters,
-			                airtaudio::format _format,
+			                                     airtaudio::format _format,
-			                uint32_t _sampleRate,
+			                                     uint32_t _sampleRate,
-			                uint32_t *_bufferFrames,
+			                                     uint32_t *_bufferFrames,
-			                airtaudio::AirTAudioCallback _callback,
+			                                     airtaudio::AirTAudioCallback _callback,
-			                void *_userData = NULL,
+			                                     void *_userData = NULL,
-			                airtaudio::StreamOptions *_options = NULL,
+			                                     airtaudio::StreamOptions *_options = NULL,
-			                airtaudio::AirTAudioErrorCallback _errorCallback = NULL);
+			                                     airtaudio::AirTAudioErrorCallback _errorCallback = NULL);
 			
 			/**
 			 * @brief A function that closes a stream and frees any associated stream memory.
@@ -195,7 +201,7 @@ namespace airtaudio {
 			 * If a stream is not open, this function issues a warning and
 			 * returns (no exception is thrown).
 			 */
-			void closeStream(void) {
+			enum airtaudio::errorType closeStream(void) {
 				if (m_rtapi == NULL) {
 					return;
 				}
@@ -209,7 +215,7 @@ namespace airtaudio {
 			 * stream is not open.	A warning is issued if the stream is already
 			 * running.
 			 */
-			void startStream(void) {
+			enum airtaudio::errorType startStream(void) {
 				if (m_rtapi == NULL) {
 					return;
 				}
@@ -223,7 +229,7 @@ namespace airtaudio {
 			 * stream is not open.	A warning is issued if the stream is already
 			 * stopped.
 			*/
-			void stopStream(void) {
+			enum airtaudio::errorType stopStream(void) {
 				if (m_rtapi == NULL) {
 					return;
 				}
@@ -236,7 +242,7 @@ namespace airtaudio {
 			 * stream is not open.	A warning is issued if the stream is already
 			 * stopped.
 			 */
-			void abortStream(void) {
+			enum airtaudio::errorType abortStream(void) {
 				if (m_rtapi == NULL) {
 					return;
 				}
@@ -301,6 +307,9 @@ namespace airtaudio {
 			 * @brief Specify whether warning messages should be printed to stderr.
 			 */
 			void showWarnings(bool _value = true) {
+				if (m_rtapi == NULL) {
+					return;
+				}
 				m_rtapi->showWarnings(_value);
 			}
 		protected:

airtaudio/api/Alsa.cpp

@@ -14,6 +14,11 @@
 #include <airtaudio/Interface.h>
 #include <limits.h>
 
+airtaudio::Api* airtaudio::api::Alsa::Create(void) {
+	return new airtaudio::api::Alsa();
+}
+
+
 // A structure to hold various information related to the ALSA API
 // implementation.
 struct AlsaHandle {
@@ -370,13 +375,13 @@ void airtaudio::api::Alsa::saveDeviceInfo(void) {
 }
 
 bool airtaudio::api::Alsa::probeDeviceOpen(uint32_t _device,
-                                airtaudio::api::StreamMode _mode,
+                                           airtaudio::api::StreamMode _mode,
-                                uint32_t _channels,
+                                           uint32_t _channels,
-                                uint32_t _firstChannel,
+                                           uint32_t _firstChannel,
-                                uint32_t _sampleRate,
+                                           uint32_t _sampleRate,
-                                airtaudio::format _format,
+                                           airtaudio::format _format,
-                                uint32_t *_bufferSize,
+                                           uint32_t *_bufferSize,
-                                airtaudio::StreamOptions *_options) {
+                                           airtaudio::StreamOptions *_options) {
 #if defined(__RTAUDIO_DEBUG__)
 	snd_output_t *out;
 	snd_output_stdio_attach(&out, stderr, 0);
@@ -818,7 +823,7 @@ error:
 	return FAILURE;
 }
 
-void airtaudio::api::Alsa::closeStream(void) {
+enum airtaudio::errorType airtaudio::api::Alsa::closeStream(void) {
 	if (m_stream.state == STREAM_CLOSED) {
 		m_errorText = "airtaudio::api::Alsa::closeStream(): no open stream to close!";
 		error(airtaudio::errorWarning);
@@ -871,7 +876,7 @@ void airtaudio::api::Alsa::closeStream(void) {
 	m_stream.state = STREAM_CLOSED;
 }
 
-void airtaudio::api::Alsa::startStream(void) {
+enum airtaudio::errorType airtaudio::api::Alsa::startStream(void) {
 	// This method calls snd_pcm_prepare if the device isn't already in that state.
 	verifyStream();
 	if (m_stream.state == STREAM_RUNNING) {
@@ -918,7 +923,7 @@ unlock:
 	error(airtaudio::errorSystemError);
 }
 
-void airtaudio::api::Alsa::stopStream(void) {
+enum airtaudio::errorType airtaudio::api::Alsa::stopStream(void) {
 	verifyStream();
 	if (m_stream.state == STREAM_STOPPED) {
 		m_errorText = "airtaudio::api::Alsa::stopStream(): the stream is already stopped!";
@@ -960,7 +965,7 @@ unlock:
 	error(airtaudio::errorSystemError);
 }
 
-void airtaudio::api::Alsa::abortStream(void) {
+enum airtaudio::errorType airtaudio::api::Alsa::abortStream(void) {
 	verifyStream();
 	if (m_stream.state == STREAM_STOPPED) {
 		m_errorText = "airtaudio::api::Alsa::abortStream(): the stream is already stopped!";

airtaudio/api/Alsa.h

@@ -12,6 +12,8 @@
 namespace airtaudio {
 	namespace api {
 		class Alsa: public airtaudio::Api {
+			public:
+				static airtaudio::Api* Create(void);
 			public:
 				Alsa();
 				~Alsa();
@@ -20,10 +22,10 @@ namespace airtaudio {
 				}
 				uint32_t getDeviceCount(void);
 				airtaudio::DeviceInfo getDeviceInfo(uint32_t _device);
-				void closeStream(void);
+				enum airtaudio::errorType closeStream(void);
-				void startStream(void);
+				enum airtaudio::errorType startStream(void);
-				void stopStream(void);
+				enum airtaudio::errorType stopStream(void);
-				void abortStream(void);
+				enum airtaudio::errorType abortStream(void);
 				// This function is intended for internal use only.	It must be
 				// public because it is called by the internal callback handler,
 				// which is not a member of RtAudio.	External use of this function

airtaudio/api/Asio.cpp

@@ -11,6 +11,11 @@
 
 #include <airtaudio/Interface.h>
 
+airtaudio::Api* airtaudio::api::Asio::Create(void) {
+	return new airtaudio::api::Asio();
+}
+
+
 // The ASIO API is designed around a callback scheme, so this
 // implementation is similar to that used for OS-X CoreAudio and Linux
 // Jack.	The primary constraint with ASIO is that it only allows

airtaudio/api/Asio.h

@@ -12,6 +12,8 @@
 namespace airtaudio {
 	namespace api {
 		class Asio: public airtaudio::Api {
+			public:
+				static airtaudio::Api* Create(void);
 			public:
 				Asio();
 				~Asio();

airtaudio/api/Core.cpp

@@ -17,6 +17,11 @@
 
 #include <airtaudio/Interface.h>
 
+airtaudio::Api* airtaudio::api::Core::Create(void) {
+	return new airtaudio::api::Core();
+}
+
+
 // The OS X CoreAudio API is designed to use a separate callback
 // procedure for each of its audio devices.	A single RtAudio duplex
 // stream using two different devices is supported here, though it

airtaudio/api/Core.h

@@ -14,6 +14,8 @@
 namespace airtaudio {
 	namespace api {
 		class Core: public airtaudio::Api {
+			public:
+				static airtaudio::Api* Create(void);
 			public:
 				Core();
 				~Core();

airtaudio/api/Ds.cpp

@@ -10,6 +10,11 @@
 #if defined(__WINDOWS_DS__)
 #include <airtaudio/Interface.h>
 
+airtaudio::Api* airtaudio::api::Ds::Create(void) {
+	return new airtaudio::api::Ds();
+}
+
+
 // Modified by Robin Davies, October 2005
 // - Improvements to DirectX pointer chasing. 
 // - Bug fix for non-power-of-two Asio granularity used by Edirol PCR-A30.

airtaudio/api/Ds.h

@@ -12,6 +12,8 @@
 namespace airtaudio {
 	namespace api {
 		class Ds: public airtaudio::Api {
+			public:
+				static airtaudio::Api* Create(void);
 			public:
 				Ds(void);
 				~Ds(void);

airtaudio/api/Dummy.cpp

@@ -8,6 +8,11 @@
 
 #if defined(__AIRTAUDIO_DUMMY__)
 
+airtaudio::Api* airtaudio::api::Dummy::Create(void) {
+	return new airtaudio::api::Dummy();
+}
+
+
 airtaudio::api::Dummy::Dummy(void) {
 	m_errorText = "airtaudio::api::Dummy: This class provides no functionality.";
 	error(airtaudio::errorWarning);

airtaudio/api/Dummy.h

@@ -14,6 +14,8 @@
 namespace airtaudio {
 	namespace api {
 		class Dummy: public airtaudio::Api {
+			public:
+				static airtaudio::Api* Create(void);
 			public:
 				Dummy(void);
 				airtaudio::api::type getCurrentApi(void) {

airtaudio/api/Jack.cpp

@@ -14,6 +14,11 @@
 #include <airtaudio/Interface.h>
 #include <string.h>
 
+airtaudio::Api* airtaudio::api::Jack::Create(void) {
+	return new airtaudio::api::Jack();
+}
+
+
 // JACK is a low-latency audio server, originally written for the
 // GNU/Linux operating system and now also ported to OS-X. It can
 // connect a number of different applications to an audio device, as

airtaudio/api/Jack.h

@@ -12,6 +12,8 @@
 namespace airtaudio {
 	namespace api {
 		class Jack: public airtaudio::Api {
+			public:
+				static airtaudio::Api* Create(void);
 			public:
 				Jack(void);
 				~Jack(void);

airtaudio/api/Oss.cpp

@@ -18,6 +18,10 @@
 #include <errno.h>
 #include <math.h>
 
+airtaudio::Api* airtaudio::api::Oss::Create(void) {
+	return new airtaudio::api::Oss();
+}
+
 static void *ossCallbackHandler(void * ptr);
 
 // A structure to hold various information related to the OSS API
@@ -28,8 +32,13 @@ struct OssHandle {
 	bool triggered;
 	pthread_cond_t runnable;
 
-	OssHandle()
+	OssHandle(void):
-		:triggered(false) { id[0] = 0; id[1] = 0; xrun[0] = false; xrun[1] = false; }
+	  triggered(false) {
+		id[0] = 0;
+		id[1] = 0;
+		xrun[0] = false;
+		xrun[1] = false;
+	}
 };
 
 airtaudio::api::Oss::Oss(void) {

airtaudio/api/Oss.h

@@ -12,6 +12,8 @@
 namespace airtaudio {
 	namespace api {
 		class Oss: public airtaudio::Api {
+			public:
+				static airtaudio::Api* Create(void);
 			public:
 				Oss(void);
 				~Oss(void);

airtaudio/api/Pulse.cpp

@@ -19,6 +19,11 @@
 #include <pulse/simple.h>
 #include <cstdio>
 
+airtaudio::Api* airtaudio::api::Pulse::Create(void) {
+	return new airtaudio::api::Pulse();
+}
+
+
 static const uint32_t SUPPORTED_SAMPLERATES[] = {
 	8000,
 	16000,
@@ -47,7 +52,12 @@ struct PulseAudioHandle {
 	std::thread* thread;
 	std::condition_variable runnable_cv;
 	bool runnable;
-	PulseAudioHandle() : s_play(0), s_rec(0), runnable(false) { }
+	PulseAudioHandle(void) :
+	  s_play(0),
+	  s_rec(0),
+	  runnable(false) {
+		
+	}
 };
 
 airtaudio::api::Pulse::~Pulse()

airtaudio/api/Pulse.h

@@ -12,6 +12,8 @@
 namespace airtaudio {
 	namespace api {
 		class Pulse: public airtaudio::Api {
+			public:
+				static airtaudio::Api* Create(void);
 			public:
 				~Pulse(void);
 				airtaudio::api::type getCurrentApi(void) {

airtaudio/base.h

@@ -25,6 +25,8 @@
 namespace airtaudio {
 	//! Defined RtError types.
 	enum errorType {
+		errorNone, //!< No error
+		errorFail, //!< An error occure in the operation
 		errorWarning, //!< A non-critical error.
 		errorInvalidUse, //!< The function was called incorrectly.
 		errorSystemError //!< A system error occured.