[RELEASE] create release 0.3.0

audio/orchestra/Api.cpp

@@ -13,9 +13,6 @@
 #include <cstring>
 #include <climits>
 
-#undef __class__
-#define __class__ "api"
-
 // Static variable definitions.
 const std::vector<uint32_t>& audio::orchestra::genericSampleRate() {
 	static std::vector<uint32_t> list;
@@ -47,7 +44,7 @@ audio::orchestra::Api::Api() :
   m_deviceBuffer(nullptr) {
 	m_device[0] = 11111;
 	m_device[1] = 11111;
-	m_state = audio::orchestra::state_closed;
+	m_state = audio::orchestra::state::closed;
 	m_mode = audio::orchestra::mode_unknow;
 }
 
@@ -69,7 +66,7 @@ enum audio::orchestra::error audio::orchestra::Api::openStream(audio::orchestra:
                                                  uint32_t* _bufferFrames,
                                                  audio::orchestra::AirTAudioCallback _callback,
                                                  const audio::orchestra::StreamOptions& _options) {
-	if (m_state != audio::orchestra::state_closed) {
+	if (m_state != audio::orchestra::state::closed) {
 		ATA_ERROR("a stream is already open!");
 		return audio::orchestra::error_invalidUse;
 	}
@@ -168,7 +165,7 @@ enum audio::orchestra::error audio::orchestra::Api::openStream(audio::orchestra:
 	}
 	m_callback = _callback;
 	//_options.numberOfBuffers = m_nBuffers;
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	return audio::orchestra::error_none;
 }
 
@@ -237,7 +234,7 @@ uint32_t audio::orchestra::Api::getStreamSampleRate() {
 }
 
 enum audio::orchestra::error audio::orchestra::Api::verifyStream() {
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("a stream is not open!");
 		return audio::orchestra::error_invalidUse;
 	}
@@ -246,7 +243,7 @@ enum audio::orchestra::error audio::orchestra::Api::verifyStream() {
 
 void audio::orchestra::Api::clearStreamInfo() {
 	m_mode = audio::orchestra::mode_unknow;
-	m_state = audio::orchestra::state_closed;
+	m_state = audio::orchestra::state::closed;
 	m_sampleRate = 0;
 	m_bufferSize = 0;
 	m_nBuffers = 0;

audio/orchestra/Api.h

@@ -13,7 +13,7 @@
 #include <audio/orchestra/mode.h>
 #include <audio/Time.h>
 #include <audio/Duration.h>
-#include <memory>
+#include <ememory/memory.h>
 
 namespace audio {
 	namespace orchestra {
@@ -45,7 +45,7 @@ namespace audio {
 				std::vector<int> outOffset;
 		};
 	
-		class Api : public std::enable_shared_from_this<Api>{
+		class Api : public ememory::EnableSharedFromThis<Api>{
 			protected:
 				std::string m_name;
 			public:
@@ -78,10 +78,10 @@ namespace audio {
 				uint32_t getStreamSampleRate();
 				virtual audio::Time getStreamTime();
 				bool isStreamOpen() const {
-					return m_state != audio::orchestra::state_closed;
+					return m_state != audio::orchestra::state::closed;
 				}
 				bool isStreamRunning() const {
-					return m_state == audio::orchestra::state_running;
+					return m_state == audio::orchestra::state::running;
 				}
 				
 			protected:
@@ -166,7 +166,7 @@ namespace audio {
 				                    uint32_t _firstChannel);
 				
 			public:
-				virtual bool isMasterOf(std::shared_ptr<audio::orchestra::Api> _api) {
+				virtual bool isMasterOf(ememory::SharedPtr<audio::orchestra::Api> _api) {
 					return false;
 				};
 		};

audio/orchestra/DeviceInfo.cpp

@@ -11,9 +11,6 @@
 #include <etk/stdTools.h>
 #include <iostream>
 
-#undef __class__
-#define __class__ "DeviceInfo"
-
 void audio::orchestra::DeviceInfo::display(int32_t _tabNumber) const {
 	std::string space;
 	for (int32_t iii=0; iii<_tabNumber; ++iii) {

audio/orchestra/Interface.cpp

@@ -19,9 +19,6 @@
 #include <audio/orchestra/api/Jack.h>
 #include <audio/orchestra/api/Pulse.h>
 
-#undef __class__
-#define __class__ "Interface"
-
 std::vector<std::string> audio::orchestra::Interface::getListApi() {
 	std::vector<std::string> apis;
 	// The order here will control the order of RtAudio's API search in
@@ -55,36 +52,36 @@ audio::orchestra::Interface::Interface() :
   m_api(nullptr) {
 	ATA_DEBUG("Add interface:");
 #if defined(ORCHESTRA_BUILD_JACK)
-	addInterface(audio::orchestra::type_jack, audio::orchestra::api::Jack::create);
+	addInterface(audio::orchestra::typeJack, audio::orchestra::api::Jack::create);
 #endif
 #if defined(ORCHESTRA_BUILD_ALSA)
-	addInterface(audio::orchestra::type_alsa, audio::orchestra::api::Alsa::create);
+	addInterface(audio::orchestra::typeAlsa, audio::orchestra::api::Alsa::create);
 #endif
 #if defined(ORCHESTRA_BUILD_PULSE)
-	addInterface(audio::orchestra::type_pulse, audio::orchestra::api::Pulse::create);
+	addInterface(audio::orchestra::typePulse, audio::orchestra::api::Pulse::create);
 #endif
 #if defined(ORCHESTRA_BUILD_ASIO)
-	addInterface(audio::orchestra::type_asio, audio::orchestra::api::Asio::create);
+	addInterface(audio::orchestra::typeAsio, audio::orchestra::api::Asio::create);
 #endif
 #if defined(ORCHESTRA_BUILD_DS)
-	addInterface(audio::orchestra::type_ds, audio::orchestra::api::Ds::create);
+	addInterface(audio::orchestra::typeDs, audio::orchestra::api::Ds::create);
 #endif
 #if defined(ORCHESTRA_BUILD_MACOSX_CORE)
-	addInterface(audio::orchestra::type_coreOSX, audio::orchestra::api::Core::create);
+	addInterface(audio::orchestra::typeCoreOSX, audio::orchestra::api::Core::create);
 #endif
 #if defined(ORCHESTRA_BUILD_IOS_CORE)
-	addInterface(audio::orchestra::type_coreIOS, audio::orchestra::api::CoreIos::create);
+	addInterface(audio::orchestra::typeCoreIOS, audio::orchestra::api::CoreIos::create);
 #endif
 #if defined(ORCHESTRA_BUILD_JAVA)
-	addInterface(audio::orchestra::type_java, audio::orchestra::api::Android::create);
+	addInterface(audio::orchestra::typeJava, audio::orchestra::api::Android::create);
 #endif
 #if defined(ORCHESTRA_BUILD_DUMMY)
-	addInterface(audio::orchestra::type_dummy, audio::orchestra::api::Dummy::create);
+	addInterface(audio::orchestra::typeDummy, audio::orchestra::api::Dummy::create);
 #endif
 }
 
-void audio::orchestra::Interface::addInterface(const std::string& _api, std::shared_ptr<Api> (*_callbackCreate)()) {
+void audio::orchestra::Interface::addInterface(const std::string& _api, ememory::SharedPtr<Api> (*_callbackCreate)()) {
-	m_apiAvaillable.push_back(std::pair<std::string, std::shared_ptr<Api> (*)()>(_api, _callbackCreate));
+	m_apiAvaillable.push_back(std::pair<std::string, ememory::SharedPtr<Api> (*)()>(_api, _callbackCreate));
 }
 
 enum audio::orchestra::error audio::orchestra::Interface::clear() {
@@ -103,7 +100,7 @@ enum audio::orchestra::error audio::orchestra::Interface::instanciate(const std:
 		ATA_WARNING("Interface already started!");
 		return audio::orchestra::error_none;
 	}
-	if (_api != audio::orchestra::type_undefined) {
+	if (_api != audio::orchestra::typeUndefined) {
 		ATA_INFO("API specified : " << _api);
 		// Attempt to open the specified API.
 		openApi(_api);
@@ -181,8 +178,8 @@ bool audio::orchestra::Interface::isMasterOf(audio::orchestra::Interface& _inter
 		ATA_ERROR("Can not link 2 Interface with not the same Low level type (?)");//" << _interface.m_adac->getCurrentApi() << " != " << m_adac->getCurrentApi() << ")");
 		return false;
 	}
-	if (m_api->getCurrentApi() != audio::orchestra::type_alsa) {
+	if (m_api->getCurrentApi() != audio::orchestra::typeAlsa) {
-		ATA_ERROR("Link 2 device together work only if the interafec is ?");// << audio::orchestra::type_alsa << " not for " << m_api->getCurrentApi());
+		ATA_ERROR("Link 2 device together work only if the interafec is ?");// << audio::orchestra::type::alsa << " not for " << m_api->getCurrentApi());
 		return false;
 	}
 	return m_api->isMasterOf(_interface.m_api);

audio/orchestra/Interface.h

@@ -26,9 +26,9 @@ namespace audio {
 		 */
 		class Interface {
 			protected:
-				std::vector<std::pair<std::string, std::shared_ptr<Api> (*)()> > m_apiAvaillable;
+				std::vector<std::pair<std::string, ememory::SharedPtr<Api> (*)()> > m_apiAvaillable;
 			protected:
-				std::shared_ptr<audio::orchestra::Api> m_api;
+				ememory::SharedPtr<audio::orchestra::Api> m_api;
 			public:
 				void setName(const std::string& _name) {
 					if (m_api == nullptr) {
@@ -46,7 +46,7 @@ namespace audio {
 				 * @param[in] _api Type of the interface.
 				 * @param[in] _callbackCreate API creation callback.
 				 */
-				void addInterface(const std::string& _api, std::shared_ptr<Api> (*_callbackCreate)());
+				void addInterface(const std::string& _api, ememory::SharedPtr<Api> (*_callbackCreate)());
 				/**
 				 * @brief The class constructor.
 				 * @note the creating of the basic instance is done by Instanciate
@@ -66,13 +66,13 @@ namespace audio {
 				/**
 				 * @brief Create an interface instance
 				 */
-				enum audio::orchestra::error instanciate(const std::string& _api = audio::orchestra::type_undefined);
+				enum audio::orchestra::error instanciate(const std::string& _api = audio::orchestra::typeUndefined);
 				/**
 				 * @return the audio API specifier for the current instance of airtaudio.
 				 */
 				const std::string& getCurrentApi() {
 					if (m_api == nullptr) {
-						return audio::orchestra::type_undefined;
+						return audio::orchestra::typeUndefined;
 					}
 					return m_api->getCurrentApi();
 				}

audio/orchestra/StreamOptions.h

@@ -12,7 +12,7 @@ namespace audio {
 	namespace orchestra {
 		enum timestampMode {
 			timestampMode_Hardware, //!< enable harware timestamp
-			timestampMode_trigered, //!< get harware triger time stamp and ingrement with duration
+			timestampMode_trigered, //!< get harware triger time stamp and increment with duration
 			timestampMode_soft, //!< Simulate all timestamp.
 		};
 		std::ostream& operator <<(std::ostream& _os, enum audio::orchestra::timestampMode _obj);

audio/orchestra/api/Alsa.cpp

@@ -27,11 +27,9 @@ extern "C" {
 #include <math.h>
 #include <poll.h>
 }
-#undef __class__
-#define __class__ "api::Alsa"
 
-std::shared_ptr<audio::orchestra::Api> audio::orchestra::api::Alsa::create() {
+ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Alsa::create() {
-	return std::shared_ptr<audio::orchestra::Api>(new audio::orchestra::api::Alsa());
+	return ememory::SharedPtr<audio::orchestra::api::Alsa>(new audio::orchestra::api::Alsa());
 }
 
 namespace audio {
@@ -65,12 +63,12 @@ namespace audio {
 }
 
 audio::orchestra::api::Alsa::Alsa() :
-  m_private(std::make_shared<audio::orchestra::api::AlsaPrivate>()) {
+  m_private(ememory::makeShared<audio::orchestra::api::AlsaPrivate>()) {
 	// Nothing to do here.
 }
 
 audio::orchestra::api::Alsa::~Alsa() {
-	if (m_state != audio::orchestra::state_closed) {
+	if (m_state != audio::orchestra::state::closed) {
 		closeStream();
 	}
 }
@@ -284,6 +282,7 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Alsa::getDeviceInfo(uint32_t
 				ATA_WARNING("control next device, card = " << card << ", " << snd_strerror(result) << ".");
 				break;
 			}
+			ATA_WARNING("    ==> nbSubdevice = " << subdevice);
 			if (subdevice < 0) {
 				break;
 			}
@@ -322,7 +321,7 @@ foundDevice:
 	snd_ctl_close(chandle);
 	// If a stream is already open, we cannot probe the stream devices.
 	// Thus, use the saved results.
-	if (    m_state != audio::orchestra::state_closed
+	if (    m_state != audio::orchestra::state::closed
 	     && (    m_device[0] == _device
 	          || m_device[1] == _device)) {
 		if (_device >= m_devices.size()) {
@@ -795,7 +794,7 @@ bool audio::orchestra::api::Alsa::openName(const std::string& _deviceName,
 	m_nBuffers = periods;
 	ATA_INFO("ALSA NB buffer = " << m_nBuffers);
 	// TODO : m_device[modeToIdTable(_mode)] = _device;
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	// Setup the buffer conversion information structure.
 	if (m_doConvertBuffer[modeToIdTable(_mode)]) {
 		setConvertInfo(_mode, _firstChannel);
@@ -824,18 +823,18 @@ error:
 		free(m_deviceBuffer);
 		m_deviceBuffer = 0;
 	}
-	m_state = audio::orchestra::state_closed;
+	m_state = audio::orchestra::state::closed;
 	return false;
 }
 
 enum audio::orchestra::error audio::orchestra::api::Alsa::closeStream() {
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("no open stream to close!");
 		return audio::orchestra::error_warning;
 	}
 	m_private->threadRunning = false;
 	m_mutex.lock();
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		m_private->runnable = true;
 		m_private->runnable_cv.notify_one();
 	}
@@ -844,8 +843,8 @@ enum audio::orchestra::error audio::orchestra::api::Alsa::closeStream() {
 		m_private->thread->join();
 		m_private->thread = nullptr;
 	}
-	if (m_state == audio::orchestra::state_running) {
+	if (m_state == audio::orchestra::state::running) {
-		m_state = audio::orchestra::state_stopped;
+		m_state = audio::orchestra::state::stopped;
 		snd_pcm_drop(m_private->handle);
 	}
 	// close all stream :
@@ -861,7 +860,7 @@ enum audio::orchestra::error audio::orchestra::api::Alsa::closeStream() {
 		m_deviceBuffer = 0;
 	}
 	m_mode = audio::orchestra::mode_unknow;
-	m_state = audio::orchestra::state_closed;
+	m_state = audio::orchestra::state::closed;
 	return audio::orchestra::error_none;
 }
 
@@ -872,7 +871,7 @@ enum audio::orchestra::error audio::orchestra::api::Alsa::startStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_running) {
+	if (m_state == audio::orchestra::state::running) {
 		ATA_ERROR("the stream is already running!");
 		return audio::orchestra::error_warning;
 	}
@@ -891,7 +890,7 @@ enum audio::orchestra::error audio::orchestra::api::Alsa::startStream() {
 			goto unlock;
 		}
 	}
-	m_state = audio::orchestra::state_running;
+	m_state = audio::orchestra::state::running;
 unlock:
 	m_private->runnable = true;
 	m_private->runnable_cv.notify_one();
@@ -905,11 +904,11 @@ enum audio::orchestra::error audio::orchestra::api::Alsa::stopStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		ATA_ERROR("the stream is already stopped!");
 		return audio::orchestra::error_warning;
 	}
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	std::unique_lock<std::mutex> lck(m_mutex);
 	int32_t result = 0;
 	if (m_mode == audio::orchestra::mode_output) {
@@ -932,11 +931,11 @@ enum audio::orchestra::error audio::orchestra::api::Alsa::abortStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		ATA_ERROR("the stream is already stopped!");
 		return audio::orchestra::error_warning;
 	}
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	std::unique_lock<std::mutex> lck(m_mutex);
 	int32_t result = 0;
 	result = snd_pcm_drop(m_private->handle);
@@ -979,12 +978,12 @@ static int32_t wait_for_poll(snd_pcm_t* _handle, struct pollfd* _ufds, unsigned
 
 void audio::orchestra::api::Alsa::callbackEvent() {
 	// Lock while the system is not started ...
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		std::unique_lock<std::mutex> lck(m_mutex);
 		while (!m_private->runnable) {
 			m_private->runnable_cv.wait(lck);
 		}
-		if (m_state != audio::orchestra::state_running) {
+		if (m_state != audio::orchestra::state::running) {
 			return;
 		}
 	}
@@ -1100,7 +1099,8 @@ audio::Time audio::orchestra::api::Alsa::getStreamTime() {
 }
 
 void audio::orchestra::api::Alsa::callbackEventOneCycleRead() {
-	if (m_state == audio::orchestra::state_closed) {
+	ATA_VERBOSE("One cycle read ...");
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_CRITICAL("the stream is closed ... this shouldn't happen!");
 		return; // TODO : notify appl: audio::orchestra::error_warning;
 	}
@@ -1108,7 +1108,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleRead() {
 	audio::Time streamTime;
 	std::vector<enum audio::orchestra::status> status;
 	if (m_private->xrun[0] == true) {
-		status.push_back(audio::orchestra::status_underflow);
+		status.push_back(audio::orchestra::status::underflow);
 		m_private->xrun[0] = false;
 	}
 	int32_t result;
@@ -1117,7 +1117,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleRead() {
 	snd_pcm_sframes_t frames;
 	audio::format format;
 	
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		// !!! goto unlock;
 	}
 	
@@ -1151,7 +1151,8 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleRead() {
 	}
 	// get timestamp : (to init here ...
 	streamTime = getStreamTime();
-	if (result < (int) m_bufferSize) {
+	ATA_VERBOSE("get data :" << result << " request:" << int32_t(m_bufferSize));
+	if (result < int32_t(m_bufferSize)) {
 		// Either an error or overrun occured.
 		if (result == -EPIPE) {
 			snd_pcm_state_t state = snd_pcm_state(m_private->handle);
@@ -1216,7 +1217,7 @@ unlock:
 }
 
 void audio::orchestra::api::Alsa::callbackEventOneCycleWrite() {
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_CRITICAL("the stream is closed ... this shouldn't happen!");
 		return; // TODO : notify appl: audio::orchestra::error_warning;
 	}
@@ -1224,7 +1225,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleWrite() {
 	audio::Time streamTime;
 	std::vector<enum audio::orchestra::status> status;
 	if (m_private->xrun[1] == true) {
-		status.push_back(audio::orchestra::status_overflow);
+		status.push_back(audio::orchestra::status::overflow);
 		m_private->xrun[1] = false;
 	}
 	int32_t result;
@@ -1233,7 +1234,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleWrite() {
 	snd_pcm_sframes_t frames;
 	audio::format format;
 	
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		// !!! goto unlock;
 	}
 	
@@ -1318,7 +1319,7 @@ unlock:
 }
 
 void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPWrite() {
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_CRITICAL("the stream is closed ... this shouldn't happen!");
 		return; // TODO : notify appl: audio::orchestra::error_warning;
 	}
@@ -1326,7 +1327,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPWrite() {
 	audio::Time streamTime;
 	std::vector<enum audio::orchestra::status> status;
 	if (m_private->xrun[1] == true) {
-		status.push_back(audio::orchestra::status_overflow);
+		status.push_back(audio::orchestra::status::overflow);
 		m_private->xrun[1] = false;
 	}
 	int32_t result;
@@ -1335,7 +1336,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPWrite() {
 	snd_pcm_sframes_t frames;
 	audio::format format;
 	
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		// !!! goto unlock;
 	}
 	int32_t avail = snd_pcm_avail_update(m_private->handle);
@@ -1451,7 +1452,8 @@ unlock:
 	}
 }
 void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPRead() {
-	if (m_state == audio::orchestra::state_closed) {
+	ATA_VERBOSE("One cycle read ...");
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_CRITICAL("the stream is closed ... this shouldn't happen!");
 		return; // TODO : notify appl: audio::orchestra::error_warning;
 	}
@@ -1459,7 +1461,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPRead() {
 	audio::Time streamTime;
 	std::vector<enum audio::orchestra::status> status;
 	if (m_private->xrun[0] == true) {
-		status.push_back(audio::orchestra::status_underflow);
+		status.push_back(audio::orchestra::status::underflow);
 		m_private->xrun[0] = false;
 	}
 	int32_t result;
@@ -1468,7 +1470,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPRead() {
 	snd_pcm_sframes_t frames;
 	audio::format format;
 	
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		goto unlock;
 	}
 	{
@@ -1500,9 +1502,11 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPRead() {
 				ATA_ERROR("Xrun...");
 			}
 		}
-		// get timestamp : (to init here ...
+		ATA_VERBOSE("get data :" << result << " request:" << int32_t(m_bufferSize));
-		streamTime = getStreamTime();
 		if (result < (int) m_bufferSize) {
+			if (result<0) {
+				ATA_PRINT("HAVE AN ERROR " << strerror(-result));
+			}
 			// Either an error or overrun occured.
 			if (result == -EPIPE) {
 				snd_pcm_state_t state = snd_pcm_state(m_private->handle);
@@ -1522,6 +1526,8 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPRead() {
 			// TODO : Notify application ... audio::orchestra::error_warning;
 			goto noInput;
 		}
+		// get timestamp : (to init here ...
+		streamTime = getStreamTime();
 		// Do byte swapping if necessary.
 		if (m_doByteSwap[1]) {
 			byteSwapBuffer(buffer, m_bufferSize * channels, format);
@@ -1566,17 +1572,17 @@ unlock:
 }
 
 
-bool audio::orchestra::api::Alsa::isMasterOf(std::shared_ptr<audio::orchestra::Api> _api) {
+bool audio::orchestra::api::Alsa::isMasterOf(ememory::SharedPtr<audio::orchestra::Api> _api) {
-	std::shared_ptr<audio::orchestra::api::Alsa> slave = std::dynamic_pointer_cast<audio::orchestra::api::Alsa>(_api);
+	ememory::SharedPtr<audio::orchestra::api::Alsa> slave = ememory::dynamicPointerCast<audio::orchestra::api::Alsa>(_api);
 	if (slave == nullptr) {
 		ATA_ERROR("NULL ptr API (not ALSA ...)");
 		return false;
 	}
-	if (m_state == audio::orchestra::state_running) {
+	if (m_state == audio::orchestra::state::running) {
 		ATA_ERROR("The MASTER stream is already running! ==> can not synchronize ...");
 		return false;
 	}
-	if (slave->m_state == audio::orchestra::state_running) {
+	if (slave->m_state == audio::orchestra::state::running) {
 		ATA_ERROR("The SLAVE stream is already running! ==> can not synchronize ...");
 		return false;
 	}

audio/orchestra/api/Alsa.h

@@ -14,12 +14,12 @@ namespace audio {
 			class AlsaPrivate;
 			class Alsa: public audio::orchestra::Api {
 				public:
-					static std::shared_ptr<audio::orchestra::Api> create();
+					static ememory::SharedPtr<audio::orchestra::Api> create();
 				public:
 					Alsa();
 					virtual ~Alsa();
 					const std::string& getCurrentApi() {
-						return audio::orchestra::type_alsa;
+						return audio::orchestra::typeAlsa;
 					}
 					uint32_t getDeviceCount();
 				private:
@@ -50,7 +50,7 @@ namespace audio {
 				private:
 					static void alsaCallbackEvent(void* _userData);
 				private:
-					std::shared_ptr<AlsaPrivate> m_private;
+					ememory::SharedPtr<AlsaPrivate> m_private;
 					std::vector<audio::orchestra::DeviceInfo> m_devices;
 					void saveDeviceInfo();
 					bool open(uint32_t _device,
@@ -72,7 +72,7 @@ namespace audio {
 					              const audio::orchestra::StreamOptions& _options);
 					virtual audio::Time getStreamTime();
 				public:
-					bool isMasterOf(std::shared_ptr<audio::orchestra::Api> _api);
+					bool isMasterOf(ememory::SharedPtr<audio::orchestra::Api> _api);
 			};
 		}
 	}

audio/orchestra/api/Android.cpp

@@ -15,12 +15,9 @@
 #include <audio/orchestra/api/Android.h>
 #include <limits.h>
 
-#undef __class__
+ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Android::create() {
-#define __class__ "api::Android"
-
-std::shared_ptr<audio::orchestra::Api> audio::orchestra::api::Android::create() {
 	ATA_INFO("Create Android device ... ");
-	return std::shared_ptr<audio::orchestra::Api>(new audio::orchestra::api::Android());
+	return ememory::SharedPtr<audio::orchestra::api::Android>(new audio::orchestra::api::Android());
 }
 
 
@@ -148,7 +145,7 @@ bool audio::orchestra::api::Android::open(uint32_t _device,
 	m_userFormat = _format;
 	m_nUserChannels[modeToIdTable(m_mode)] = _channels;
 	
-	m_uid = audio::orchestra::api::android::open(_device, m_mode, _channels, _firstChannel, _sampleRate, _format, _bufferSize, _options, std::static_pointer_cast<audio::orchestra::api::Android>(shared_from_this()));
+	m_uid = audio::orchestra::api::android::open(_device, m_mode, _channels, _firstChannel, _sampleRate, _format, _bufferSize, _options, ememory::staticPointerCast<audio::orchestra::api::Android>(sharedFromThis()));
 	if (m_uid < 0) {
 		ret = false;
 	} else {

audio/orchestra/api/Android.h

@@ -14,12 +14,12 @@ namespace audio {
 		namespace api {
 			class Android: public audio::orchestra::Api {
 				public:
-					static std::shared_ptr<audio::orchestra::Api> create();
+					static ememory::SharedPtr<audio::orchestra::Api> create();
 				public:
 					Android();
 					virtual ~Android();
 					const std::string& getCurrentApi() {
-						return audio::orchestra::type_java;
+						return audio::orchestra::typeJava;
 					}
 					uint32_t getDeviceCount();
 					audio::orchestra::DeviceInfo getDeviceInfo(uint32_t _device);

audio/orchestra/api/AndroidNativeInterface.cpp

@@ -14,7 +14,7 @@
 /* include auto generated file */
 #include <org_musicdsp_orchestra_OrchestraConstants.h>
 #include <jvm-basics/jvm-basics.h>
-#include <memory>
+#include <ememory/memory.h>
 #include <ejson/ejson.h>
 
 class AndroidOrchestraContext {
@@ -253,7 +253,7 @@ class AndroidOrchestraContext {
 			} else {
 				info.input = true;
 			}
-			std::shared_ptr<const ejson::Array> list = doc.getArray("sample-rate");
+			ememory::SharedPtr<const ejson::Array> list = doc.getArray("sample-rate");
 			if (list != nullptr) {
 				for (size_t iii=0; iii<list->size(); ++iii) {
 					info.sampleRates.push_back(int32_t(list->getNumberValue(iii, 48000)));
@@ -276,7 +276,7 @@ class AndroidOrchestraContext {
 			return info;
 		}
 	private:
-		std::vector<std::weak_ptr<audio::orchestra::api::Android> > m_instanceList; // list of connected handle ...
+		std::vector<ememory::WeakPtr<audio::orchestra::api::Android> > m_instanceList; // list of connected handle ...
 		//AndroidAudioCallback m_audioCallBack;
 		//void* m_audioCallBackUserData;
 	public:
@@ -288,7 +288,7 @@ class AndroidOrchestraContext {
 		             audio::format _format,
 		             uint32_t *_bufferSize,
 		             const audio::orchestra::StreamOptions& _options,
-		             std::shared_ptr<audio::orchestra::api::Android> _instance) {
+		             ememory::SharedPtr<audio::orchestra::api::Android> _instance) {
 			ATA_DEBUG("C->java : audio open device");
 			int status;
 			if(!java_attach_current_thread(&status)) {
@@ -395,7 +395,7 @@ class AndroidOrchestraContext {
 		}
 };
 
-static std::shared_ptr<AndroidOrchestraContext> s_localContext;
+static ememory::SharedPtr<AndroidOrchestraContext> s_localContext;
 static int32_t s_nbContextRequested(0);
 
 
@@ -422,7 +422,7 @@ int32_t audio::orchestra::api::android::open(uint32_t _device,
                                              audio::format _format,
                                              uint32_t *_bufferSize,
                                              const audio::orchestra::StreamOptions& _options,
-                                             std::shared_ptr<audio::orchestra::api::Android> _instance) {
+                                             ememory::SharedPtr<audio::orchestra::api::Android> _instance) {
 	if (s_localContext == nullptr) {
 		return -1;
 	}
@@ -468,7 +468,7 @@ extern "C" {
 		if (s_localContext != nullptr) {
 			s_nbContextRequested++;
 		}
-		s_localContext = std::make_shared<AndroidOrchestraContext>(_env, _classBase, _objCallback);
+		s_localContext = ememory::makeShared<AndroidOrchestraContext>(_env, _classBase, _objCallback);
 		if (s_localContext == nullptr) {
 			ATA_ERROR("Can not allocate the orchestra main context instance");
 			return;

audio/orchestra/api/AndroidNativeInterface.h

@@ -12,7 +12,7 @@
 #include <audio/orchestra/error.h>
 #include <audio/orchestra/StreamOptions.h>
 #include <audio/format.h>
-#include <memory>
+#include <ememory/memory.h>
 
 namespace audio {
 	namespace orchestra {
@@ -29,7 +29,7 @@ namespace audio {
 				             audio::format _format,
 				             uint32_t *_bufferSize,
 				             const audio::orchestra::StreamOptions& _options,
-				             std::shared_ptr<audio::orchestra::api::Android> _instance);
+				             ememory::SharedPtr<audio::orchestra::api::Android> _instance);
 				enum audio::orchestra::error closeStream(int32_t _id);
 				enum audio::orchestra::error startStream(int32_t _id);
 				enum audio::orchestra::error stopStream(int32_t _id);

audio/orchestra/api/Asio.cpp

@@ -11,8 +11,8 @@
 #include <audio/orchestra/Interface.h>
 #include <audio/orchestra/debug.h>
 
-std::shared_ptr<audio::orchestra::Api> audio::orchestra::api::Asio::create() {
+ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Asio::create() {
-	return std::shared_ptr<audio::orchestra::Api>(new audio::orchestra::api::Asio());
+	return ememory::SharedPtr<audio::orchestra::api::Asio>(new audio::orchestra::api::Asio());
 }
 
 
@@ -38,9 +38,6 @@ std::shared_ptr<audio::orchestra::Api> audio::orchestra::api::Asio::create() {
 #include "asiodrivers.h"
 #include <cmath>
 
-#undef __class__
-#define __class__ "api::Asio"
-
 static AsioDrivers drivers;
 static ASIOCallbacks asioCallbacks;
 static ASIODriverInfo driverInfo;
@@ -90,7 +87,7 @@ audio::orchestra::api::Asio::Asio() :
 }
 
 audio::orchestra::api::Asio::~Asio() {
-	if (m_state != audio::orchestra::state_closed) {
+	if (m_state != audio::orchestra::state::closed) {
 		closeStream();
 	}
 	if (m_coInitialized) {
@@ -116,7 +113,7 @@ rtaudio::DeviceInfo audio::orchestra::api::Asio::getDeviceInfo(uint32_t _device)
 		return info;
 	}
 	// If a stream is already open, we cannot probe other devices.	Thus, use the saved results.
-	if (m_state != audio::orchestra::state_closed) {
+	if (m_state != audio::orchestra::state::closed) {
 		if (_device >= m_devices.size()) {
 			ATA_ERROR("device ID was not present before stream was opened.");
 			return info;
@@ -503,7 +500,7 @@ bool audio::orchestra::api::Asio::open(uint32_t _device,
 	}
 	m_sampleRate = _sampleRate;
 	m_device[modeToIdTable(_mode)] = _device;
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	if (    _mode == audio::orchestra::mode_output
 	     && _mode == audio::orchestra::mode_input) {
 		// We had already set up an output stream.
@@ -550,12 +547,12 @@ error:
 }
 
 enum audio::orchestra::error audio::orchestra::api::Asio::closeStream() {
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("no open stream to close!");
 		return audio::orchestra::error_warning;
 	}
-	if (m_state == audio::orchestra::state_running) {
+	if (m_state == audio::orchestra::state::running) {
-		m_state = audio::orchestra::state_stopped;
+		m_state = audio::orchestra::state::stopped;
 		ASIOStop();
 	}
 	ASIODisposeBuffers();
@@ -575,7 +572,7 @@ enum audio::orchestra::error audio::orchestra::api::Asio::closeStream() {
 		m_deviceBuffer = 0;
 	}
 	m_mode = audio::orchestra::mode_unknow;
-	m_state = audio::orchestra::state_closed;
+	m_state = audio::orchestra::state::closed;
 	return audio::orchestra::error_none;
 }
 
@@ -587,7 +584,7 @@ enum audio::orchestra::error audio::orchestra::api::Asio::startStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_running) {
+	if (m_state == audio::orchestra::state::running) {
 		ATA_ERROR("the stream is already running!");
 		return audio::orchestra::error_warning;
 	}
@@ -599,7 +596,7 @@ enum audio::orchestra::error audio::orchestra::api::Asio::startStream() {
 	m_private->drainCounter = 0;
 	m_private->internalDrain = false;
 	ResetEvent(m_private->condition);
-	m_state = audio::orchestra::state_running;
+	m_state = audio::orchestra::state::running;
 	asioXRun = false;
 unlock:
 	stopThreadCalled = false;
@@ -613,7 +610,7 @@ enum audio::orchestra::error audio::orchestra::api::Asio::stopStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		ATA_ERROR("the stream is already stopped!");
 		return audio::orchestra::error_warning;
 	}
@@ -623,7 +620,7 @@ enum audio::orchestra::error audio::orchestra::api::Asio::stopStream() {
 			WaitForSingleObject(m_private->condition, INFINITE);	// block until signaled
 		}
 	}
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	ASIOError result = ASIOStop();
 	if (result != ASE_OK) {
 		ATA_ERROR("error (" << getAsioErrorString(result) << ") stopping device.");
@@ -638,7 +635,7 @@ enum audio::orchestra::error audio::orchestra::api::Asio::abortStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		ATA_ERROR("the stream is already stopped!");
 		error(audio::orchestra::error_warning);
 		return;
@@ -666,18 +663,18 @@ static unsigned __stdcall asioStopStream(void *_ptr) {
 }
 
 bool audio::orchestra::api::Asio::callbackEvent(long bufferIndex) {
-	if (    m_state == audio::orchestra::state_stopped
+	if (    m_state == audio::orchestra::state::stopped
-	     || m_state == audio::orchestra::state_stopping) {
+	     || m_state == audio::orchestra::state::stopping) {
 		return true;
 	}
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("the stream is closed ... this shouldn't happen!");
 		return false;
 	}
 	CallbackInfo *info = (CallbackInfo *) &m_callbackInfo;
 	// Check if we were draining the stream and signal if finished.
 	if (m_private->drainCounter > 3) {
-		m_state = audio::orchestra::state_stopping;
+		m_state = audio::orchestra::state::stopping;
 		if (m_private->internalDrain == false) {
 			SetEvent(m_private->condition);
 		} else { // spawn a thread to stop the stream
@@ -697,11 +694,11 @@ bool audio::orchestra::api::Asio::callbackEvent(long bufferIndex) {
 		audio::Time streamTime = getStreamTime();
 		std::vector<enum audio::orchestra::status status;
 		if (m_mode != audio::orchestra::mode_input && asioXRun == true) {
-			status.push_back(audio::orchestra::status_underflow);
+			status.push_back(audio::orchestra::status::underflow);
 			asioXRun = false;
 		}
 		if (m_mode != audio::orchestra::mode_output && asioXRun == true) {
-			status.push_back(audio::orchestra::status_underflow;
+			status.push_back(audio::orchestra::status::underflow;
 			asioXRun = false;
 		}
 		int32_t cbReturnValue = info->callback(m_userBuffer[1],
@@ -711,7 +708,7 @@ bool audio::orchestra::api::Asio::callbackEvent(long bufferIndex) {
 		                                       m_bufferSize,
 		                                       status);
 		if (cbReturnValue == 2) {
-			m_state = audio::orchestra::state_stopping;
+			m_state = audio::orchestra::state::stopping;
 			m_private->drainCounter = 2;
 			unsigned threadId;
 			m_callbackInfo.thread = _beginthreadex(nullptr,

audio/orchestra/api/Asio.h

@@ -13,12 +13,12 @@ namespace audio {
 			class AsioPrivate:
 			class Asio: public audio::orchestra::Api {
 				public:
-					static std::shared_ptr<audio::orchestra::Api> create();
+					static ememory::SharedPtr<audio::orchestra::Api> create();
 				public:
 					Asio();
 					virtual ~Asio();
 					const std::string& getCurrentApi() {
-						return audio::orchestra::WINDOWS_ASIO;
+						return audio::orchestra::typeAsio;
 					}
 					uint32_t getDeviceCount();
 					audio::orchestra::DeviceInfo getDeviceInfo(uint32_t _device);
@@ -33,7 +33,7 @@ namespace audio {
 					// will most likely produce highly undesireable results!
 					bool callbackEvent(long _bufferIndex);
 				private:
-					std::shared_ptr<AsioPrivate> m_private;
+					ememory::SharedPtr<AsioPrivate> m_private;
 					std::vector<audio::orchestra::DeviceInfo> m_devices;
 					void saveDeviceInfo();
 					bool m_coInitialized;

audio/orchestra/api/Core.cpp

@@ -20,13 +20,10 @@
 #include <ethread/tools.h>
 #include <audio/orchestra/api/Core.h>
 
-std::shared_ptr<audio::orchestra::Api> audio::orchestra::api::Core::create() {
+ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Core::create() {
-	return std::shared_ptr<audio::orchestra::Api>(new audio::orchestra::api::Core());
+	return ememory::SharedPtr<audio::orchestra::api::Core>(new audio::orchestra::api::Core());
 }
 
-#undef __class__
-#define __class__ "api::Core"
-
 namespace audio {
 	namespace orchestra {
 		namespace api {
@@ -88,7 +85,7 @@ audio::orchestra::api::Core::~Core() {
 	// The subclass destructor gets called before the base class
 	// destructor, so close an existing stream before deallocating
 	// apiDeviceId memory.
-	if (m_state != audio::orchestra::state_closed) {
+	if (m_state != audio::orchestra::state::closed) {
 		closeStream();
 	}
 }
@@ -828,7 +825,7 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
 	}
 	m_sampleRate = _sampleRate;
 	m_device[modeToIdTable(_mode)] = _device;
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	ATA_VERBOSE("Set state as stopped");
 	// Setup the buffer conversion information structure.
 	if (m_doConvertBuffer[modeToIdTable(_mode)]) {
@@ -872,19 +869,19 @@ error:
 		free(m_deviceBuffer);
 		m_deviceBuffer = 0;
 	}
-	m_state = audio::orchestra::state_closed;
+	m_state = audio::orchestra::state::closed;
 	ATA_VERBOSE("Set state as closed");
 	return false;
 }
 
 enum audio::orchestra::error audio::orchestra::api::Core::closeStream() {
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("no open stream to close!");
 		return audio::orchestra::error_warning;
 	}
 	if (    m_mode == audio::orchestra::mode_output
 	     || m_mode == audio::orchestra::mode_duplex) {
-		if (m_state == audio::orchestra::state_running) {
+		if (m_state == audio::orchestra::state::running) {
 			AudioDeviceStop(m_private->id[0], &audio::orchestra::api::Core::callbackEvent);
 		}
 #if defined(MAC_OS_X_VERSION_10_5) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5)
@@ -897,7 +894,7 @@ enum audio::orchestra::error audio::orchestra::api::Core::closeStream() {
 	if (    m_mode == audio::orchestra::mode_input
 	     || (    m_mode == audio::orchestra::mode_duplex
 	          && m_device[0] != m_device[1])) {
-		if (m_state == audio::orchestra::state_running) {
+		if (m_state == audio::orchestra::state::running) {
 			AudioDeviceStop(m_private->id[1], &audio::orchestra::api::Core::callbackEvent);
 		}
 #if defined(MAC_OS_X_VERSION_10_5) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5)
@@ -914,7 +911,7 @@ enum audio::orchestra::error audio::orchestra::api::Core::closeStream() {
 		m_deviceBuffer = nullptr;
 	}
 	m_mode = audio::orchestra::mode_unknow;
-	m_state = audio::orchestra::state_closed;
+	m_state = audio::orchestra::state::closed;
 	ATA_VERBOSE("Set state as closed");
 	return audio::orchestra::error_none;
 }
@@ -925,7 +922,7 @@ enum audio::orchestra::error audio::orchestra::api::Core::startStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_running) {
+	if (m_state == audio::orchestra::state::running) {
 		ATA_ERROR("the stream is already running!");
 		return audio::orchestra::error_warning;
 	}
@@ -949,7 +946,7 @@ enum audio::orchestra::error audio::orchestra::api::Core::startStream() {
 	}
 	m_private->drainCounter = 0;
 	m_private->internalDrain = false;
-	m_state = audio::orchestra::state_running;
+	m_state = audio::orchestra::state::running;
 	ATA_VERBOSE("Set state as running");
 unlock:
 	if (result == noErr) {
@@ -962,7 +959,7 @@ enum audio::orchestra::error audio::orchestra::api::Core::stopStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		ATA_ERROR("the stream is already stopped!");
 		return audio::orchestra::error_warning;
 	}
@@ -989,7 +986,7 @@ enum audio::orchestra::error audio::orchestra::api::Core::stopStream() {
 			goto unlock;
 		}
 	}
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	ATA_VERBOSE("Set state as stopped");
 unlock:
 	if (result == noErr) {
@@ -1002,7 +999,7 @@ enum audio::orchestra::error audio::orchestra::api::Core::abortStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		ATA_ERROR("the stream is already stopped!");
 		return audio::orchestra::error_warning;
 	}
@@ -1026,17 +1023,17 @@ bool audio::orchestra::api::Core::callbackEvent(AudioDeviceID _deviceId,
                                          const audio::Time& _inTime,
                                          const AudioBufferList *_outBufferList,
                                          const audio::Time& _outTime) {
-	if (    m_state == audio::orchestra::state_stopped
+	if (    m_state == audio::orchestra::state::stopped
-	     || m_state == audio::orchestra::state_stopping) {
+	     || m_state == audio::orchestra::state::stopping) {
 		return true;
 	}
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("the stream is closed ... this shouldn't happen!");
 		return false;
 	}
 	// Check if we were draining the stream and signal is finished.
 	if (m_private->drainCounter > 3) {
-		m_state = audio::orchestra::state_stopping;
+		m_state = audio::orchestra::state::stopping;
 		ATA_VERBOSE("Set state as stopping");
 		if (m_private->internalDrain == true) {
 			new std::thread(&audio::orchestra::api::Core::coreStopStream, this);
@@ -1054,12 +1051,12 @@ bool audio::orchestra::api::Core::callbackEvent(AudioDeviceID _deviceId,
 		std::vector<enum audio::orchestra::status> status;
 		if (    m_mode != audio::orchestra::mode_input
 		     && m_private->xrun[0] == true) {
-			status.push_back(audio::orchestra::status_underflow);
+			status.push_back(audio::orchestra::status::underflow);
 			m_private->xrun[0] = false;
 		}
 		if (    m_mode != audio::orchestra::mode_output
 		     && m_private->xrun[1] == true) {
-			status.push_back(audio::orchestra::status_overflow);
+			status.push_back(audio::orchestra::status::overflow);
 			m_private->xrun[1] = false;
 		}
 		int32_t cbReturnValue = m_callback(&m_userBuffer[1][0],
@@ -1069,7 +1066,7 @@ bool audio::orchestra::api::Core::callbackEvent(AudioDeviceID _deviceId,
 		                                   m_bufferSize,
 		                                   status);
 		if (cbReturnValue == 2) {
-			m_state = audio::orchestra::state_stopping;
+			m_state = audio::orchestra::state::stopping;
 			ATA_VERBOSE("Set state as stopping");
 			m_private->drainCounter = 2;
 			abortStream();

audio/orchestra/api/Core.h

@@ -16,12 +16,12 @@ namespace audio {
 			class CorePrivate;
 			class Core: public audio::orchestra::Api {
 				public:
-					static std::shared_ptr<audio::orchestra::Api> create();
+					static ememory::SharedPtr<audio::orchestra::Api> create();
 				public:
 					Core();
 					virtual ~Core();
 					const std::string& getCurrentApi() {
-						return audio::orchestra::type_coreOSX;
+						return audio::orchestra::typeCoreOSX;
 					}
 					uint32_t getDeviceCount();
 					audio::orchestra::DeviceInfo getDeviceInfo(uint32_t _device);
@@ -46,7 +46,7 @@ namespace audio {
 					                              void* _infoPointer);
 					static void coreStopStream(void *_userData);
 				private:
-					std::shared_ptr<CorePrivate> m_private;
+					ememory::SharedPtr<CorePrivate> m_private;
 					bool open(uint32_t _device,
 					          audio::orchestra::mode _mode,
 					          uint32_t _channels,

audio/orchestra/api/CoreIos.h

@@ -13,12 +13,12 @@ namespace audio {
 			class CoreIosPrivate;
 			class CoreIos: public audio::orchestra::Api {
 				public:
-					static std::shared_ptr<audio::orchestra::Api> create();
+					static ememory::SharedPtr<audio::orchestra::Api> create();
 				public:
 					CoreIos();
 					virtual ~CoreIos();
 					const std::string& getCurrentApi() {
-						return audio::orchestra::type_coreIOS;
+						return audio::orchestra::typeCoreIOS;
 					}
 					uint32_t getDeviceCount();
 					audio::orchestra::DeviceInfo getDeviceInfo(uint32_t _device);
@@ -47,7 +47,7 @@ namespace audio {
 					                   int32_t _nbChunk,
 					                   const audio::Time& _time);
 				public:
-					std::shared_ptr<CoreIosPrivate> m_private;
+					ememory::SharedPtr<CoreIosPrivate> m_private;
 			};
 		}
 	}

audio/orchestra/api/CoreIos.mm

@@ -16,12 +16,9 @@
 #include <limits.h>
 #include <audio/orchestra/api/CoreIos.h>
 
-#undef __class__
+ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::CoreIos::create() {
-#define __class__ "api::CoreIos"
-
-std::shared_ptr<audio::orchestra::Api> audio::orchestra::api::CoreIos::create() {
 	ATA_INFO("Create CoreIos device ... ");
-	return std::shared_ptr<audio::orchestra::Api>(new audio::orchestra::api::CoreIos());
+	return ememory::SharedPtr<audio::orchestra::api::CoreIos>(new audio::orchestra::api::CoreIos());
 }
 
 #define kOutputBus 0

audio/orchestra/api/Ds.cpp

@@ -12,11 +12,8 @@
 #include <ethread/tools.h>
 #include <audio/orchestra/api/Ds.h>
 
-#undef __class__
+ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Ds::create() {
-#define __class__ "api::Ds"
+	return ememory::SharedPtr<audio::orchestra::api::Ds>(new audio::orchestra::api::Ds());
-
-std::shared_ptr<audio::orchestra::Api> audio::orchestra::api::Ds::create() {
-	return std::shared_ptr<audio::orchestra::Api>(new audio::orchestra::api::Ds());
 }
 
 
@@ -75,7 +72,7 @@ namespace audio {
 		namespace api {
 			class DsPrivate {
 				public:
-					std::shared_ptr<std::thread> thread;
+					ememory::SharedPtr<std::thread> thread;
 					bool threadRunning;
 					uint32_t drainCounter; // Tracks callback counts when draining
 					bool internalDrain; // Indicates if stop is initiated from callback or not.
@@ -128,7 +125,7 @@ audio::orchestra::api::Ds::~Ds() {
 	if (m_coInitialized) {
 		CoUninitialize(); // balanced call.
 	}
-	if (m_state != audio::orchestra::state_closed) {
+	if (m_state != audio::orchestra::state::closed) {
 		closeStream();
 	}
 }
@@ -748,7 +745,7 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
 	m_private->dsBufferSize[modeToIdTable(_mode)] = dsBufferSize;
 	m_private->dsPointerLeadTime[modeToIdTable(_mode)] = dsPointerLeadTime;
 	m_device[modeToIdTable(_mode)] = _device;
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	if (    m_mode == audio::orchestra::mode_output
 	     && _mode == audio::orchestra::mode_input) {
 		// We had already set up an output stream.
@@ -765,14 +762,14 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
 	// Setup the callback thread.
 	if (m_private->threadRunning == false) {
 		m_private->threadRunning = true;
-		std::shared_ptr<std::thread> tmpThread(new std::thread(&audio::orchestra::api::Ds::dsCallbackEvent, this));
+		ememory::SharedPtr<std::thread> tmpThread(new std::thread(&audio::orchestra::api::Ds::dsCallbackEvent, this));
 		m_private->thread =	std::move(tmpThread);
 		if (m_private->thread == nullptr) {
 			ATA_ERROR("error creating callback thread!");
 			goto error;
 		}
 		// Boost DS thread priority
-		etk::thread::setPriority(*m_private->thread, -6);
+		ethread::setPriority(*m_private->thread, -6);
 	}
 	return true;
 error:
@@ -800,12 +797,12 @@ error:
 		free(m_deviceBuffer);
 		m_deviceBuffer = 0;
 	}
-	m_state = audio::orchestra::state_closed;
+	m_state = audio::orchestra::state::closed;
 	return false;
 }
 
 enum audio::orchestra::error audio::orchestra::api::Ds::closeStream() {
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("no open stream to close!");
 		return audio::orchestra::error_warning;
 	}
@@ -842,7 +839,7 @@ enum audio::orchestra::error audio::orchestra::api::Ds::closeStream() {
 		m_deviceBuffer = 0;
 	}
 	m_mode = audio::orchestra::mode_unknow;
-	m_state = audio::orchestra::state_closed;
+	m_state = audio::orchestra::state::closed;
 }
 
 enum audio::orchestra::error audio::orchestra::api::Ds::startStream() {
@@ -851,7 +848,7 @@ enum audio::orchestra::error audio::orchestra::api::Ds::startStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_running) {
+	if (m_state == audio::orchestra::state::running) {
 		ATA_ERROR("the stream is already running!");
 		return audio::orchestra::error_warning;
 	}
@@ -887,7 +884,7 @@ enum audio::orchestra::error audio::orchestra::api::Ds::startStream() {
 	m_private->drainCounter = 0;
 	m_private->internalDrain = false;
 	ResetEvent(m_private->condition);
-	m_state = audio::orchestra::state_running;
+	m_state = audio::orchestra::state::running;
 unlock:
 	if (FAILED(result)) {
 		return audio::orchestra::error_systemError;
@@ -899,7 +896,7 @@ enum audio::orchestra::error audio::orchestra::api::Ds::stopStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		ATA_ERROR("the stream is already stopped!");
 		return audio::orchestra::error_warning;
 	}
@@ -912,7 +909,7 @@ enum audio::orchestra::error audio::orchestra::api::Ds::stopStream() {
 			m_private->drainCounter = 2;
 			WaitForSingleObject(m_private->condition, INFINITE);	// block until signaled
 		}
-		m_state = audio::orchestra::state_stopped;
+		m_state = audio::orchestra::state::stopped;
 		// Stop the buffer and clear memory
 		LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) m_private->buffer[0];
 		result = buffer->Stop();
@@ -943,7 +940,7 @@ enum audio::orchestra::error audio::orchestra::api::Ds::stopStream() {
 		LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) m_private->buffer[1];
 		audioPtr = nullptr;
 		dataLen = 0;
-		m_state = audio::orchestra::state_stopped;
+		m_state = audio::orchestra::state::stopped;
 		result = buffer->Stop();
 		if (FAILED(result)) {
 			ATA_ERROR(getErrorString(result) << ": stopping input buffer!");
@@ -979,7 +976,7 @@ enum audio::orchestra::error audio::orchestra::api::Ds::abortStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		ATA_ERROR("the stream is already stopped!");
 		return audio::orchestra::error_warning;
 	}
@@ -989,17 +986,17 @@ enum audio::orchestra::error audio::orchestra::api::Ds::abortStream() {
 
 void audio::orchestra::api::Ds::callbackEvent() {
 	ethread::setName("DS IO-" + m_name);
-	if (m_state == audio::orchestra::state_stopped || m_state == audio::orchestra::state_stopping) {
+	if (m_state == audio::orchestra::state::stopped || m_state == audio::orchestra::state_stopping) {
 		Sleep(50); // sleep 50 milliseconds
 		return;
 	}
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("the stream is closed ... this shouldn't happen!");
 		return;
 	}
 	// Check if we were draining the stream and signal is finished.
 	if (m_private->drainCounter > m_nBuffers + 2) {
-		m_state = audio::orchestra::state_stopping;
+		m_state = audio::orchestra::state::stopping;
 		if (m_private->internalDrain == false) {
 			SetEvent(m_private->condition);
 		} else {
@@ -1014,12 +1011,12 @@ void audio::orchestra::api::Ds::callbackEvent() {
 		std::vector<audio::orchestra::status> status;
 		if (    m_mode != audio::orchestra::mode_input
 		     && m_private->xrun[0] == true) {
-			status.push_back(audio::orchestra::status_underflow);
+			status.push_back(audio::orchestra::status::underflow);
 			m_private->xrun[0] = false;
 		}
 		if (    m_mode != audio::orchestra::mode_output
 		     && m_private->xrun[1] == true) {
-			status.push_back(audio::orchestra::status_overflow);
+			status.push_back(audio::orchestra::status::overflow);
 			m_private->xrun[1] = false;
 		}
 		int32_t cbReturnValue = m_callback(&m_userBuffer[1][0],
@@ -1029,7 +1026,7 @@ void audio::orchestra::api::Ds::callbackEvent() {
 		                                   m_bufferSize,
 		                                   status);
 		if (cbReturnValue == 2) {
-			m_state = audio::orchestra::state_stopping;
+			m_state = audio::orchestra::state::stopping;
 			m_private->drainCounter = 2;
 			abortStream();
 			return;

audio/orchestra/api/Ds.h

@@ -13,12 +13,12 @@ namespace audio {
 			class DsPrivate;
 			class Ds: public audio::orchestra::Api {
 				public:
-					static std::shared_ptr<audio::orchestra::Api> create();
+					static ememory::SharedPtr<audio::orchestra::Api> create();
 				public:
 					Ds();
 					virtual ~Ds();
 					const std::string& getCurrentApi() {
-						return audio::orchestra::type_ds;
+						return audio::orchestra::typeDs;
 					}
 					uint32_t getDeviceCount();
 					audio::orchestra::DeviceInfo getDeviceInfo(uint32_t _device);
@@ -34,7 +34,7 @@ namespace audio {
 					void callbackEvent();
 				private:
 					static void dsCallbackEvent(void *_userData);
-					std::shared_ptr<DsPrivate> m_private;
+					ememory::SharedPtr<DsPrivate> m_private;
 					bool m_coInitialized;
 					bool m_buffersRolling;
 					long m_duplexPrerollBytes;

audio/orchestra/api/Dummy.cpp

@@ -9,11 +9,8 @@
 #include <audio/orchestra/api/Dummy.h>
 #include <audio/orchestra/debug.h>
 
-#undef __class__
+ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Dummy::create() {
-#define __class__ "api::Dummy"
+	return ememory::SharedPtr<audio::orchestra::api::Dummy>(new audio::orchestra::api::Dummy());
-
-std::shared_ptr<audio::orchestra::Api> audio::orchestra::api::Dummy::create() {
-	return std::shared_ptr<audio::orchestra::Api>(new audio::orchestra::api::Dummy());
 }
 
 

audio/orchestra/api/Dummy.h

@@ -15,11 +15,11 @@ namespace audio {
 		namespace api {
 			class Dummy: public audio::orchestra::Api {
 				public:
-					static std::shared_ptr<audio::orchestra::Api> create();
+					static ememory::SharedPtr<audio::orchestra::Api> create();
 				public:
 					Dummy();
 					const std::string& getCurrentApi() {
-						return audio::orchestra::type_dummy;
+						return audio::orchestra::typeDummy;
 					}
 					uint32_t getDeviceCount();
 					audio::orchestra::DeviceInfo getDeviceInfo(uint32_t _device);

audio/orchestra/api/Jack.cpp

@@ -16,11 +16,8 @@
 #include <ethread/tools.h>
 #include <audio/orchestra/api/Jack.h>
 
-#undef __class__
+ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Jack::create() {
-#define __class__ "api::Jack"
+	return ememory::SharedPtr<audio::orchestra::api::Jack>(new audio::orchestra::api::Jack());
-
-std::shared_ptr<audio::orchestra::Api> audio::orchestra::api::Jack::create() {
-	return std::shared_ptr<audio::orchestra::Api>(new audio::orchestra::api::Jack());
 }
 
 
@@ -92,7 +89,7 @@ audio::orchestra::api::Jack::Jack() :
 }
 
 audio::orchestra::api::Jack::~Jack() {
-	if (m_state != audio::orchestra::state_closed) {
+	if (m_state != audio::orchestra::state::closed) {
 		closeStream();
 	}
 }
@@ -426,7 +423,7 @@ bool audio::orchestra::api::Jack::open(uint32_t _device,
 	}
 	m_device[modeToIdTable(_mode)] = _device;
 	m_channelOffset[modeToIdTable(_mode)] = _firstChannel;
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	if (    m_mode == audio::orchestra::mode_output
 	     && _mode == audio::orchestra::mode_input) {
 		// We had already set up the stream for output.
@@ -486,12 +483,12 @@ error:
 }
 
 enum audio::orchestra::error audio::orchestra::api::Jack::closeStream() {
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("no open stream to close!");
 		return audio::orchestra::error_warning;
 	}
 	if (m_private != nullptr) {
-		if (m_state == audio::orchestra::state_running) {
+		if (m_state == audio::orchestra::state::running) {
 			jack_deactivate(m_private->client);
 		}
 		jack_client_close(m_private->client);
@@ -512,7 +509,7 @@ enum audio::orchestra::error audio::orchestra::api::Jack::closeStream() {
 		m_deviceBuffer = nullptr;
 	}
 	m_mode = audio::orchestra::mode_unknow;
-	m_state = audio::orchestra::state_closed;
+	m_state = audio::orchestra::state::closed;
 	return audio::orchestra::error_none;
 }
 
@@ -522,7 +519,7 @@ enum audio::orchestra::error audio::orchestra::api::Jack::startStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_running) {
+	if (m_state == audio::orchestra::state::running) {
 		ATA_ERROR("the stream is already running!");
 		return audio::orchestra::error_warning;
 	}
@@ -580,7 +577,7 @@ enum audio::orchestra::error audio::orchestra::api::Jack::startStream() {
 	}
 	m_private->drainCounter = 0;
 	m_private->internalDrain = false;
-	m_state = audio::orchestra::state_running;
+	m_state = audio::orchestra::state::running;
 unlock:
 	if (result == 0) {
 		return audio::orchestra::error_none;
@@ -592,7 +589,7 @@ enum audio::orchestra::error audio::orchestra::api::Jack::stopStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		ATA_ERROR("the stream is already stopped!");
 		return audio::orchestra::error_warning;
 	}
@@ -605,7 +602,7 @@ enum audio::orchestra::error audio::orchestra::api::Jack::stopStream() {
 		}
 	}
 	jack_deactivate(m_private->client);
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	return audio::orchestra::error_none;
 }
 
@@ -613,7 +610,7 @@ enum audio::orchestra::error audio::orchestra::api::Jack::abortStream() {
 	if (verifyStream() != audio::orchestra::error_none) {
 		return audio::orchestra::error_fail;
 	}
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		ATA_ERROR("the stream is already stopped!");
 		return audio::orchestra::error_warning;
 	}
@@ -633,11 +630,11 @@ static void jackStopStream(void* _userData) {
 }
 
 bool audio::orchestra::api::Jack::callbackEvent(uint64_t _nframes) {
-	if (    m_state == audio::orchestra::state_stopped
+	if (    m_state == audio::orchestra::state::stopped
-	     || m_state == audio::orchestra::state_stopping) {
+	     || m_state == audio::orchestra::state::stopping) {
 		return true;
 	}
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("the stream is closed ... this shouldn't happen!");
 		return false;
 	}
@@ -647,7 +644,7 @@ bool audio::orchestra::api::Jack::callbackEvent(uint64_t _nframes) {
 	}
 	// Check if we were draining the stream and signal is finished.
 	if (m_private->drainCounter > 3) {
-		m_state = audio::orchestra::state_stopping;
+		m_state = audio::orchestra::state::stopping;
 		if (m_private->internalDrain == true) {
 			new std::thread(jackStopStream, this);
 		} else {
@@ -660,11 +657,11 @@ bool audio::orchestra::api::Jack::callbackEvent(uint64_t _nframes) {
 		audio::Time streamTime = getStreamTime();
 		std::vector<enum audio::orchestra::status> status;
 		if (m_mode != audio::orchestra::mode_input && m_private->xrun[0] == true) {
-			status.push_back(audio::orchestra::status_underflow);
+			status.push_back(audio::orchestra::status::underflow);
 			m_private->xrun[0] = false;
 		}
 		if (m_mode != audio::orchestra::mode_output && m_private->xrun[1] == true) {
-			status.push_back(audio::orchestra::status_overflow);
+			status.push_back(audio::orchestra::status::overflow);
 			m_private->xrun[1] = false;
 		}
 		int32_t cbReturnValue = m_callback(&m_userBuffer[1][0],
@@ -674,7 +671,7 @@ bool audio::orchestra::api::Jack::callbackEvent(uint64_t _nframes) {
 		                                   m_bufferSize,
 		                                   status);
 		if (cbReturnValue == 2) {
-			m_state = audio::orchestra::state_stopping;
+			m_state = audio::orchestra::state::stopping;
 			m_private->drainCounter = 2;
 			new std::thread(jackStopStream, this);
 			return true;

audio/orchestra/api/Jack.h

@@ -15,12 +15,12 @@ namespace audio {
 			class JackPrivate;
 			class Jack: public audio::orchestra::Api {
 				public:
-					static std::shared_ptr<audio::orchestra::Api> create();
+					static ememory::SharedPtr<audio::orchestra::Api> create();
 				public:
 					Jack();
 					virtual ~Jack();
 					const std::string& getCurrentApi() {
-						return audio::orchestra::type_jack;
+						return audio::orchestra::typeJack;
 					}
 					uint32_t getDeviceCount();
 					audio::orchestra::DeviceInfo getDeviceInfo(uint32_t _device);
@@ -40,7 +40,7 @@ namespace audio {
 					static void jackShutdown(void* _userData);
 					static int32_t jackCallbackHandler(jack_nframes_t _nframes, void* _userData);
 				private:
-					std::shared_ptr<JackPrivate> m_private;
+					ememory::SharedPtr<JackPrivate> m_private;
 					bool open(uint32_t _device,
 					          audio::orchestra::mode _mode,
 					          uint32_t _channels,

audio/orchestra/api/Pulse.cpp

@@ -19,11 +19,8 @@
 #include <audio/orchestra/api/PulseDeviceList.h>
 #include <audio/orchestra/api/Pulse.h>
 
-#undef __class__
+ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Pulse::create() {
-#define __class__ "api::Pulse"
+	return ememory::SharedPtr<audio::orchestra::api::Pulse>(new audio::orchestra::api::Pulse());
-
-std::shared_ptr<audio::orchestra::Api> audio::orchestra::api::Pulse::create() {
-	return std::shared_ptr<audio::orchestra::Api>(new audio::orchestra::api::Pulse());
 }
 
 
@@ -56,7 +53,7 @@ namespace audio {
 			class PulsePrivate {
 				public:
 					pa_simple* handle;
-					std::shared_ptr<std::thread> thread;
+					ememory::SharedPtr<std::thread> thread;
 					bool threadRunning;
 					std::condition_variable runnable_cv;
 					bool runnable;
@@ -76,7 +73,7 @@ audio::orchestra::api::Pulse::Pulse() :
 }
 
 audio::orchestra::api::Pulse::~Pulse() {
-	if (m_state != audio::orchestra::state_closed) {
+	if (m_state != audio::orchestra::state::closed) {
 		closeStream();
 	}
 }
@@ -114,7 +111,7 @@ void audio::orchestra::api::Pulse::callbackEvent() {
 enum audio::orchestra::error audio::orchestra::api::Pulse::closeStream() {
 	m_private->threadRunning = false;
 	m_mutex.lock();
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		m_private->runnable = true;
 		m_private->runnable_cv.notify_one();;
 	}
@@ -127,23 +124,23 @@ enum audio::orchestra::error audio::orchestra::api::Pulse::closeStream() {
 	m_private->handle = nullptr;
 	m_userBuffer[0].clear();
 	m_userBuffer[1].clear();
-	m_state = audio::orchestra::state_closed;
+	m_state = audio::orchestra::state::closed;
 	m_mode = audio::orchestra::mode_unknow;
 	return audio::orchestra::error_none;
 }
 
 void audio::orchestra::api::Pulse::callbackEventOneCycle() {
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		std::unique_lock<std::mutex> lck(m_mutex);
 		while (!m_private->runnable) {
 			m_private->runnable_cv.wait(lck);
 		}
-		if (m_state != audio::orchestra::state_running) {
+		if (m_state != audio::orchestra::state::running) {
 			m_mutex.unlock();
 			return;
 		}
 	}
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("the stream is closed ... this shouldn't happen!");
 		return;
 	}
@@ -162,7 +159,7 @@ void audio::orchestra::api::Pulse::callbackEventOneCycle() {
 	m_mutex.lock();
 	void *pulse_in = m_doConvertBuffer[audio::orchestra::modeToIdTable(audio::orchestra::mode_input)] ? m_deviceBuffer : &m_userBuffer[audio::orchestra::modeToIdTable(audio::orchestra::mode_input)][0];
 	void *pulse_out = m_doConvertBuffer[audio::orchestra::modeToIdTable(audio::orchestra::mode_output)] ? m_deviceBuffer : &m_userBuffer[audio::orchestra::modeToIdTable(audio::orchestra::mode_output)][0];
-	if (m_state != audio::orchestra::state_running) {
+	if (m_state != audio::orchestra::state::running) {
 		goto unlock;
 	}
 	int32_t pa_error;
@@ -210,16 +207,16 @@ unlock:
 enum audio::orchestra::error audio::orchestra::api::Pulse::startStream() {
 	// TODO : Check return ...
 	audio::orchestra::Api::startStream();
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("the stream is not open!");
 		return audio::orchestra::error_invalidUse;
 	}
-	if (m_state == audio::orchestra::state_running) {
+	if (m_state == audio::orchestra::state::running) {
 		ATA_ERROR("the stream is already running!");
 		return audio::orchestra::error_warning;
 	}
 	m_mutex.lock();
-	m_state = audio::orchestra::state_running;
+	m_state = audio::orchestra::state::running;
 	m_private->runnable = true;
 	m_private->runnable_cv.notify_one();
 	m_mutex.unlock();
@@ -227,15 +224,15 @@ enum audio::orchestra::error audio::orchestra::api::Pulse::startStream() {
 }
 
 enum audio::orchestra::error audio::orchestra::api::Pulse::stopStream() {
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("the stream is not open!");
 		return audio::orchestra::error_invalidUse;
 	}
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		ATA_ERROR("the stream is already stopped!");
 		return audio::orchestra::error_warning;
 	}
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	m_mutex.lock();
 	if (    m_private != nullptr
 	     && m_private->handle != nullptr
@@ -247,21 +244,21 @@ enum audio::orchestra::error audio::orchestra::api::Pulse::stopStream() {
 			return audio::orchestra::error_systemError;
 		}
 	}
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	m_mutex.unlock();
 	return audio::orchestra::error_none;
 }
 
 enum audio::orchestra::error audio::orchestra::api::Pulse::abortStream() {
-	if (m_state == audio::orchestra::state_closed) {
+	if (m_state == audio::orchestra::state::closed) {
 		ATA_ERROR("the stream is not open!");
 		return audio::orchestra::error_invalidUse;
 	}
-	if (m_state == audio::orchestra::state_stopped) {
+	if (m_state == audio::orchestra::state::stopped) {
 		ATA_ERROR("the stream is already stopped!");
 		return audio::orchestra::error_warning;
 	}
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	m_mutex.lock();
 	if (    m_private != nullptr
 	     && m_private->handle != nullptr
@@ -273,7 +270,7 @@ enum audio::orchestra::error audio::orchestra::api::Pulse::abortStream() {
 			return audio::orchestra::error_systemError;
 		}
 	}
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	m_mutex.unlock();
 	return audio::orchestra::error_none;
 }
@@ -396,13 +393,13 @@ bool audio::orchestra::api::Pulse::open(uint32_t _device,
 	}
 	if (m_private->threadRunning == false) {
 		m_private->threadRunning = true;
-		m_private->thread = std::make_shared<std::thread>(&pulseaudio_callback, this);
+		m_private->thread = ememory::makeShared<std::thread>(&pulseaudio_callback, this);
 		if (m_private->thread == nullptr) {
 			ATA_ERROR("error creating thread.");
 			goto error;
 		}
 	}
-	m_state = audio::orchestra::state_stopped;
+	m_state = audio::orchestra::state::stopped;
 	return true;
 error:
 	for (int32_t iii=0; iii<2; ++iii) {

audio/orchestra/api/Pulse.h

@@ -13,12 +13,12 @@ namespace audio {
 			class PulsePrivate;
 			class Pulse: public audio::orchestra::Api {
 				public:
-					static std::shared_ptr<audio::orchestra::Api> create();
+					static ememory::SharedPtr<audio::orchestra::Api> create();
 				public:
 					Pulse();
 					virtual ~Pulse();
 					const std::string& getCurrentApi() {
-						return audio::orchestra::type_pulse;
+						return audio::orchestra::typePulse;
 					}
 					uint32_t getDeviceCount();
 					audio::orchestra::DeviceInfo getDeviceInfo(uint32_t _device);
@@ -33,7 +33,7 @@ namespace audio {
 					void callbackEventOneCycle();
 					void callbackEvent();
 				private:
-					std::shared_ptr<PulsePrivate> m_private;
+					ememory::SharedPtr<PulsePrivate> m_private;
 					std::vector<audio::orchestra::DeviceInfo> m_devices;
 					void saveDeviceInfo();
 					bool open(uint32_t _device,

audio/orchestra/base.h

@@ -11,7 +11,7 @@
 #include <mutex>
 #include <chrono>
 #include <functional>
-#include <memory>
+#include <ememory/memory.h>
 #include <audio/channel.h>
 #include <audio/format.h>
 #include <audio/orchestra/error.h>

audio/orchestra/state.h

@@ -10,11 +10,11 @@
 
 namespace audio {
 	namespace orchestra {
-		enum state {
+		enum class state {
-			state_closed,
+			closed,
-			state_stopped,
+			stopped,
-			state_stopping,
+			stopping,
-			state_running
+			running
 		};
 	}
 }

audio/orchestra/status.cpp

@@ -14,7 +14,7 @@ static const char* listValue[] = {
 };
 
 std::ostream& audio::orchestra::operator <<(std::ostream& _os, enum audio::orchestra::status _obj) {
-	_os << listValue[_obj];
+	_os << listValue[int32_t(_obj)];
 	return _os;
 }
 

audio/orchestra/status.h

@@ -10,10 +10,10 @@
 
 namespace audio {
 	namespace orchestra {
-		enum status {
+		enum class status {
-			status_ok, //!< nothing...
+			ok, //!< nothing...
-			status_overflow, //!< Internal buffer has more data than they can accept
+			overflow, //!< Internal buffer has more data than they can accept
-			status_underflow //!< The internal buffer is empty
+			underflow //!< The internal buffer is empty
 		};
 		std::ostream& operator <<(std::ostream& _os, enum audio::orchestra::status _obj);
 		std::ostream& operator <<(std::ostream& _os, const std::vector<enum audio::orchestra::status>& _obj);

audio/orchestra/type.cpp

@@ -12,17 +12,14 @@
 #include <cstring>
 #include <climits>
 
-#undef __class__
+const std::string audio::orchestra::typeUndefined = "undefined";
-#define __class__ "type"
+const std::string audio::orchestra::typeAlsa = "alsa";
-
+const std::string audio::orchestra::typePulse = "pulse";
-const std::string audio::orchestra::type_undefined = "undefined";
+const std::string audio::orchestra::typeOss = "oss";
-const std::string audio::orchestra::type_alsa = "alsa";
+const std::string audio::orchestra::typeJack = "jack";
-const std::string audio::orchestra::type_pulse = "pulse";
+const std::string audio::orchestra::typeCoreOSX = "coreOSX";
-const std::string audio::orchestra::type_oss = "oss";
+const std::string audio::orchestra::typeCoreIOS = "coreIOS";
-const std::string audio::orchestra::type_jack = "jack";
+const std::string audio::orchestra::typeAsio = "asio";
-const std::string audio::orchestra::type_coreOSX = "coreOSX";
+const std::string audio::orchestra::typeDs = "ds";
-const std::string audio::orchestra::type_coreIOS = "coreIOS";
+const std::string audio::orchestra::typeJava = "java";
-const std::string audio::orchestra::type_asio = "asio";
+const std::string audio::orchestra::typeDummy = "dummy";
-const std::string audio::orchestra::type_ds = "ds";
-const std::string audio::orchestra::type_java = "java";
-const std::string audio::orchestra::type_dummy = "dummy";

audio/orchestra/type.h

@@ -14,17 +14,17 @@ namespace audio {
 		/**
 		 * @brief Audio API specifier arguments.
 		 */
-		extern const std::string type_undefined; //!< Error API.
+		extern const std::string typeUndefined; //!< Error API.
-		extern const std::string type_alsa; //!< LINUX The Advanced Linux Sound Architecture.
+		extern const std::string typeAlsa; //!< LINUX The Advanced Linux Sound Architecture.
-		extern const std::string type_pulse; //!< LINUX The Linux PulseAudio.
+		extern const std::string typePulse; //!< LINUX The Linux PulseAudio.
-		extern const std::string type_oss; //!< LINUX The Linux Open Sound System.
+		extern const std::string typeOss; //!< LINUX The Linux Open Sound System.
-		extern const std::string type_jack; //!< UNIX The Jack Low-Latency Audio Server.
+		extern const std::string typeJack; //!< UNIX The Jack Low-Latency Audio Server.
-		extern const std::string type_coreOSX; //!< Macintosh OSX Core Audio.
+		extern const std::string typeCoreOSX; //!< Macintosh OSX Core Audio.
-		extern const std::string type_coreIOS; //!< Macintosh iOS Core Audio.
+		extern const std::string typeCoreIOS; //!< Macintosh iOS Core Audio.
-		extern const std::string type_asio; //!< WINDOWS The Steinberg Audio Stream I/O.
+		extern const std::string typeAsio; //!< WINDOWS The Steinberg Audio Stream I/O.
-		extern const std::string type_ds; //!< WINDOWS The Microsoft Direct Sound.
+		extern const std::string typeDs; //!< WINDOWS The Microsoft Direct Sound.
-		extern const std::string type_java; //!< ANDROID Interface.
+		extern const std::string typeJava; //!< ANDROID Interface.
-		extern const std::string type_dummy; //!< Empty wrapper (non-functional).
+		extern const std::string typeDummy; //!< Empty wrapper (non-functional).
 	}
 }
 

lutin_audio-orchestra.py

@@ -23,7 +23,7 @@ def get_maintainer():
 	return ["Mr DUPIN Edouard <yui.heero@gmail.com>"]
 
 def get_version():
-	return [0,0,0]
+	return [0,3,0]
 
 def create(target, module_name):
 	my_module = module.Module(__file__, module_name, get_type())
@@ -63,7 +63,7 @@ def create(target, module_name):
 	my_module.add_export_flag('c++', ['-DORCHESTRA_BUILD_DUMMY'])
 	# TODO : Add a FILE interface:
 	
-	if target.name=="Windows":
+	if target.config_based_on=="Windows":
 		my_module.add_src_file([
 			'audio/orchestra/api/Asio.cpp',
 			'audio/orchestra/api/Ds.cpp',
@@ -72,7 +72,7 @@ def create(target, module_name):
 		my_module.add_optionnal_module_depend('asio', ["c++", "-DORCHESTRA_BUILD_ASIO"])
 		my_module.add_optionnal_module_depend('ds', ["c++", "-DORCHESTRA_BUILD_DS"])
 		my_module.add_optionnal_module_depend('wasapi', ["c++", "-DORCHESTRA_BUILD_WASAPI"])
-	elif target.name=="Linux":
+	elif target.config_based_on=="Linux":
 		my_module.add_src_file([
 			'audio/orchestra/api/Alsa.cpp',
 			'audio/orchestra/api/Jack.cpp',
@@ -82,17 +82,17 @@ def create(target, module_name):
 		my_module.add_optionnal_module_depend('alsa', ["c++", "-DORCHESTRA_BUILD_ALSA"])
 		my_module.add_optionnal_module_depend('jack', ["c++", "-DORCHESTRA_BUILD_JACK"])
 		my_module.add_optionnal_module_depend('pulse', ["c++", "-DORCHESTRA_BUILD_PULSE"])
-	elif target.name=="MacOs":
+	elif target.config_based_on=="MacOs":
 		my_module.add_src_file([
 							   'audio/orchestra/api/Core.cpp'
 							   ])
 		# MacOsX core
 		my_module.add_optionnal_module_depend('CoreAudio', ["c++", "-DORCHESTRA_BUILD_MACOSX_CORE"])
-	elif target.name=="IOs":
+	elif target.config_based_on=="IOs":
 		my_module.add_src_file('audio/orchestra/api/CoreIos.mm')
 		# IOsX core
 		my_module.add_optionnal_module_depend('CoreAudio', ["c++", "-DORCHESTRA_BUILD_IOS_CORE"])
-	elif target.name=="Android":
+	elif target.config_based_on=="Android":
 		my_module.add_src_file('android/org/musicdsp/orchestra/OrchestraConstants.java')
 		my_module.add_src_file('android/org/musicdsp/orchestra/OrchestraManagerCallback.java')
 		my_module.add_src_file('android/org/musicdsp/orchestra/OrchestraNative.java')