diff --git a/airtio/Interface.cpp b/airtio/Interface.cpp
index ef73368..a59ce65 100644
--- a/airtio/Interface.cpp
+++ b/airtio/Interface.cpp
@@ -4,7 +4,9 @@
  * @license APACHE v2.0 (see license file)
  */
 
+#include "debug.h"
 #include "Interface.h"
+#include "io/Node.h"
 #include <airtalgo/ChannelReorder.h>
 #include <airtalgo/FormatUpdate.h>
 #include <airtalgo/Resampler.h>
@@ -14,11 +16,11 @@
 
 
 airtio::Interface::Interface(void) :
-  m_name(""),
   m_node(nullptr),
   m_freq(8000),
   m_map(),
   m_format(airtalgo::format_int16),
+  m_name(""),
   m_volume(0.0f) {
 	
 }
@@ -33,7 +35,72 @@ bool airtio::Interface::init(const std::string& _name,
 	m_freq = _freq;
 	m_map = _map;
 	m_format = _format;
+	m_process = std::make_shared<airtalgo::Process>();
 	m_volume = 0.0f;
+	
+	// Create convertion interface
+	if (m_node->isInput() == true) {
+		if (m_map != m_node->getMap()) {
+			std::shared_ptr<airtalgo::ChannelReorder> algo = std::make_shared<airtalgo::ChannelReorder>();
+			algo->setInputFormat(airtalgo::IOFormatInterface(m_node->getMap(), m_node->getFormat(), m_node->getFrequency()));
+			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_node->getFrequency()));
+			m_process->pushBack(algo);
+			AIRTIO_INFO("convert " << m_node->getMap() << " -> " << m_map);
+		}
+		if (m_freq != m_node->getFrequency()) {
+			std::shared_ptr<airtalgo::Resampler> algo = std::make_shared<airtalgo::Resampler>();
+			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_node->getFrequency()));
+			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_freq));
+			m_process->pushBack(algo);
+			AIRTIO_INFO("convert " << m_node->getFrequency() << " -> " << m_freq);
+		}
+		if (m_format != m_node->getFormat()) {
+			std::shared_ptr<airtalgo::FormatUpdate> algo = std::make_shared<airtalgo::FormatUpdate>();
+			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_freq));
+			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
+			m_process->pushBack(algo);
+			AIRTIO_INFO("convert " << m_node->getFormat() << " -> " << m_format);
+		}
+		// by default we add a read node
+		if (true) {
+			std::shared_ptr<airtalgo::EndPointRead> algo = std::make_shared<airtalgo::EndPointRead>();
+			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
+			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
+			m_process->pushBack(algo);
+			AIRTIO_INFO("add default read node ...");
+		}
+	} else {
+		// by default we add a write node:
+		if (true) {
+			std::shared_ptr<airtalgo::EndPointWrite> algo = std::make_shared<airtalgo::EndPointWrite>();
+			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
+			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
+			m_process->pushBack(algo);
+			AIRTIO_INFO("add default write node ...");
+		}
+		if (m_format != m_node->getFormat()) {
+			std::shared_ptr<airtalgo::FormatUpdate> algo = std::make_shared<airtalgo::FormatUpdate>();
+			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
+			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_freq));
+			m_process->pushBack(algo);
+			AIRTIO_INFO("convert " << m_format << " -> " << m_node->getFormat());
+		}
+		if (m_freq != m_node->getFrequency()) {
+			std::shared_ptr<airtalgo::Resampler> algo = std::make_shared<airtalgo::Resampler>();
+			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_freq));
+			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_node->getFrequency()));
+			m_process->pushBack(algo);
+			AIRTIO_INFO("convert " << m_freq << " -> " << m_node->getFrequency());
+		}
+		if (m_map != m_node->getMap()) {
+			std::shared_ptr<airtalgo::ChannelReorder> algo = std::make_shared<airtalgo::ChannelReorder>();
+			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_node->getFrequency()));
+			algo->setOutputFormat(airtalgo::IOFormatInterface(m_node->getMap(), m_node->getFormat(), m_node->getFrequency()));
+			m_process->pushBack(algo);
+			AIRTIO_INFO("convert " << m_map << " -> " << m_node->getMap());
+		}
+	}
+	//m_node->interfaceAdd(shared_from_this());
 	return true;
 }
 
@@ -42,149 +109,70 @@ std::shared_ptr<airtio::Interface> airtio::Interface::create(const std::string&
                                                              const std::vector<airtalgo::channel>& _map,
                                                              airtalgo::format _format,
                                                              const std::shared_ptr<airtio::io::Node>& _node) {
-	std::shared_ptr<airtio::Interface> out = std::make_shared<airtio::Interface>(new airtio::Interface());
+	std::shared_ptr<airtio::Interface> out = std::shared_ptr<airtio::Interface>(new airtio::Interface());
 	out->init(_name, _freq, _map, _format, _node);
 	return out;
 }
 
-void airtio::Interface::init() {
-	
-	// Create convertion interface
-	if (m_node->isInput() == true) {
-		if (m_map != m_node->getMap()) {
-			std::shared_ptr<airtalgo::ChannelReorder> algo = boost::make_shared<airtalgo::ChannelReorder>();
-			algo->setInputFormat(airtalgo::IOFormatInterface(m_node->getMap(), m_node->getFormat(), m_node->getFrequency()));
-			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_node->getFrequency()));
-			m_listAlgo.push_back(algo);
-			std::cout << "[INFO] convert " << m_node->getMap() << " -> " << m_map << std::endl;
-		}
-		if (m_freq != m_node->getFrequency()) {
-			std::shared_ptr<airtalgo::Resampler> algo = boost::make_shared<airtalgo::Resampler>();
-			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_node->getFrequency()));
-			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_freq));
-			m_listAlgo.push_back(algo);
-			std::cout << "[INFO] convert " << m_node->getFrequency() << " -> " << m_freq << std::endl;
-		}
-		if (m_format != m_node->getFormat()) {
-			std::shared_ptr<airtalgo::FormatUpdate> algo = boost::make_shared<airtalgo::FormatUpdate>();
-			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_freq));
-			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
-			m_listAlgo.push_back(algo);
-			std::cout << "[INFO] convert " << m_node->getFormat() << " -> " << m_format << std::endl;
-		}
-		// by default we add a read node
-		if (true) {
-			std::shared_ptr<airtalgo::EndPointRead> algo = boost::make_shared<airtalgo::EndPointRead>();
-			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
-			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
-			m_listAlgo.push_back(algo);
-			std::cout << "[INFO] add default read node ..." << std::endl;
-		}
-	} else {
-		// by default we add a write node:
-		if (true) {
-			std::shared_ptr<airtalgo::EndPointWrite> algo = boost::make_shared<airtalgo::EndPointWrite>();
-			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
-			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
-			m_listAlgo.push_back(algo);
-			std::cout << "[INFO] add default write node ..." << std::endl;
-		}
-		if (m_format != m_node->getFormat()) {
-			std::shared_ptr<airtalgo::FormatUpdate> algo = boost::make_shared<airtalgo::FormatUpdate>();
-			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
-			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_freq));
-			m_listAlgo.push_back(algo);
-			std::cout << "[INFO] convert " << m_format << " -> " << m_node->getFormat() << std::endl;
-		}
-		if (m_freq != m_node->getFrequency()) {
-			std::shared_ptr<airtalgo::Resampler> algo = boost::make_shared<airtalgo::Resampler>();
-			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_freq));
-			algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_node->getFrequency()));
-			m_listAlgo.push_back(algo);
-			std::cout << "[INFO] convert " << m_freq << " -> " << m_node->getFrequency() << std::endl;
-		}
-		if (m_map != m_node->getMap()) {
-			std::shared_ptr<airtalgo::ChannelReorder> algo = boost::make_shared<airtalgo::ChannelReorder>();
-			algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_node->getFormat(), m_node->getFrequency()));
-			algo->setOutputFormat(airtalgo::IOFormatInterface(m_node->getMap(), m_node->getFormat(), m_node->getFrequency()));
-			m_listAlgo.push_back(algo);
-			std::cout << "[INFO] convert " << m_map << " -> " << m_node->getMap() << std::endl;
-		}
-	}
-	//m_node->interfaceAdd(shared_from_this());
-}
-
 airtio::Interface::~Interface() {
 	std::unique_lock<std::mutex> lock(m_mutex);
 	//m_node->interfaceRemove(shared_from_this());
 }
 
 
-void airtio::Interface::setWriteCallbackInt16(size_t _chunkSize, writeNeedDataFunction_int16_t _function) {
-	std::unique_lock<std::mutex> lock(m_mutex);
-	if (m_listAlgo.size() <= 0) {
-		return;
-	}
-	std::shared_ptr<airtalgo::EndPointWrite> algo = boost::dynamic_pointer_cast<airtalgo::EndPointWrite>(m_listAlgo[0]);
-	if (algo == nullptr) {
-		return;
-	}
-	algo->setCallback(_function);
-}
-
 void airtio::Interface::setOutputCallback(size_t _chunkSize, airtalgo::needDataFunction _function, enum airtalgo::formatDataType _dataType) {
 	std::unique_lock<std::mutex> lock(m_mutex);
-	if (m_listAlgo.size() > 0) {
-		std::shared_ptr<airtalgo::EndPoint> algoEP = boost::dynamic_pointer_cast<airtalgo::EndPoint>(m_listAlgo[0]);
-		if (algoEP != nullptr) {
-			m_listAlgo.erase(m_listAlgo.begin());
-		}
-	}
-	std::shared_ptr<airtalgo::Algo> algo = boost::make_shared<airtalgo::EndPointCallback16>(_function, _dataType);
-	std::cout << "[INFO] set property: " << m_map << " " << m_format << " " << m_freq <<std::endl;
+	m_process->removeIfFirst<airtalgo::EndPoint>();
+	std::shared_ptr<airtalgo::Algo> algo = std::make_shared<airtalgo::EndPointCallback>(_function, _dataType);
+	AIRTIO_INFO("set property: " << m_map << " " << m_format << " " << m_freq);
 	algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
 	algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
-	m_listAlgo.insert(m_listAlgo.begin(), algo);
+	m_process->pushFront(algo);
 }
 
 void airtio::Interface::setInputCallback(size_t _chunkSize, airtalgo::haveNewDataFunction _function, enum airtalgo::formatDataType _dataType) {
 	std::unique_lock<std::mutex> lock(m_mutex);
-	if (m_listAlgo.size() > 0) {
-		std::shared_ptr<airtalgo::EndPoint> algoEP = boost::dynamic_pointer_cast<airtalgo::EndPoint>(m_listAlgo[m_listAlgo.size()-1]);
-		if (algoEP != nullptr) {
-			m_listAlgo.erase(m_listAlgo.begin()+m_listAlgo.size()-1);
-		}
-	}
-	std::shared_ptr<airtalgo::Algo> algo = boost::make_shared<airtalgo::EndPointCallback16>(_function, _dataType);
+	m_process->removeIfLast<airtalgo::EndPoint>();
+	std::shared_ptr<airtalgo::Algo> algo = std::make_shared<airtalgo::EndPointCallback>(_function, _dataType);
 	algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
 	algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
-	m_listAlgo.push_back(algo);
+	m_process->pushBack(algo);
 }
 
 
 void airtio::Interface::start(const std::chrono::system_clock::time_point& _time) {
 	std::unique_lock<std::mutex> lock(m_mutex);
+	AIRTIO_DEBUG("start [BEGIN]");
 	m_node->interfaceAdd(shared_from_this());
+	AIRTIO_DEBUG("start [ END ]");
 }
 
 void airtio::Interface::stop(bool _fast, bool _abort) {
 	std::unique_lock<std::mutex> lock(m_mutex);
+	AIRTIO_DEBUG("stop [BEGIN]");
 	m_node->interfaceRemove(shared_from_this());
+	AIRTIO_DEBUG("stop [ END]");
 }
 
 void airtio::Interface::abort() {
 	std::unique_lock<std::mutex> lock(m_mutex);
+	AIRTIO_DEBUG("abort [BEGIN]");
 	// TODO :...
+	AIRTIO_DEBUG("abort [ END ]");
 }
 
 void airtio::Interface::setVolume(float _gainDB) {
 	std::unique_lock<std::mutex> lock(m_mutex);
+	AIRTIO_DEBUG("setVolume [BEGIN]");
 	// TODO :...
+	AIRTIO_DEBUG("setVolume [ END ]");
 }
 
 float airtio::Interface::getVolume() const {
 	std::unique_lock<std::mutex> lock(m_mutex);
+	AIRTIO_DEBUG("getVolume [BEGIN]");
 	// TODO :...
+	AIRTIO_DEBUG("getVolume [ END ]");
 	return 0;
 }
 
@@ -199,7 +187,7 @@ void airtio::Interface::write(const std::vector<int16_t>& _value) {
 
 void airtio::Interface::write(const int16_t* _value, size_t _nbChunk) {
 	std::unique_lock<std::mutex> lock(m_mutex);
-	std::shared_ptr<airtalgo::EndPointWrite> algo = boost::dynamic_pointer_cast<airtalgo::EndPointWrite>(m_listAlgo[0]);
+	std::shared_ptr<airtalgo::EndPointWrite> algo = m_process->get<airtalgo::EndPointWrite>(0);
 	if (algo == nullptr) {
 		return;
 	}
@@ -247,7 +235,7 @@ void airtio::Interface::setBufferSize(size_t _nbChunk) {
 	
 }
 
-void airtio::Interface::setBufferSize(const std::chrono::duration<int64_t, boost::micro>& _time) {
+void airtio::Interface::setBufferSize(const std::chrono::duration<int64_t, std::micro>& _time) {
 	std::unique_lock<std::mutex> lock(m_mutex);
 	// TODO :...
 	
@@ -266,45 +254,19 @@ std::chrono::system_clock::time_point airtio::Interface::getCurrentTime() const
 	return std::chrono::system_clock::now();
 }
 
-void airtio::Interface::setMasterVolume(float _gainDB) {
-	std::unique_lock<std::mutex> lock(m_mutex);
-	//m_volumeMaster = _gainDB;
-	// TODO :...
-}
-
-bool airtio::Interface::process(std::chrono::system_clock::time_point& _time,
-                                               void* _input,
-                                               size_t _inputNbChunk,
-                                               void*& _output,
-                                               size_t& _outputNbChunk) {
-	if (m_listAlgo.size() == 0) {
-		_output = _input;
-		_outputNbChunk = _inputNbChunk;
-		return true;
-	}
-	for (size_t iii=0; iii<m_listAlgo.size(); ++iii) {
-		//std::cout << "            Algo " << iii+1 << "/" << m_listAlgo.size() << std::endl;
-		if (m_listAlgo[iii] != nullptr) {
-			m_listAlgo[iii]->process(_time, _input, _inputNbChunk, _output, _outputNbChunk);
-			_input = _output;
-			_inputNbChunk = _outputNbChunk;
-		}
-	}
-	return true;
-}
 
 
 void airtio::Interface::systemNewInputData(std::chrono::system_clock::time_point _time, void* _data, int32_t _nbChunk) {
-	void* out = nullptr;
-	size_t nbChunkOut;
-	//std::cout << "        Interface DIRECT " << std::endl;
-	process(_time, _data, _nbChunk, out, nbChunkOut);
+	m_process->push(_time, _data, _nbChunk);
 }
 
 void airtio::Interface::systemNeedOutputData(std::chrono::system_clock::time_point _time, void* _data, int32_t _nbChunk, size_t _chunkSize) {
+	size_t nbChunk2 = _nbChunk;
+	m_process->pull(_time, _data, nbChunk2);//, _chunkSize);
+#if 0
 	// TODO : while enought data or fhush data:
 	memset(_data, 0, _nbChunk*_chunkSize);
-	//std::cout << "        Interface DIRECT " << std::endl;
+	AIRTIO_VERBOSE("        Interface DIRECT ");
 	while(m_data.size()<_nbChunk*_chunkSize) {
 		void* in = nullptr;
 		size_t nbChunkIn = _nbChunk - m_data.size()/_chunkSize;
@@ -324,9 +286,9 @@ void airtio::Interface::systemNeedOutputData(std::chrono::system_clock::time_poi
 		}
 		//nbChunkIn *= 4;
 		// get data from the upstream
-		//std::cout << "         * request " << nbChunkIn << " chunk" << std::endl;
-		process(_time, in, nbChunkIn, out, nbChunkOut);
-		//std::cout << "         * get " << nbChunkOut << " chunk" << std::endl;
+		AIRTIO_VERBOSE("         * request " << nbChunkIn << " chunk");
+		m_process->process(_time, in, nbChunkIn, out, nbChunkOut);
+		AIRTIO_VERBOSE("         * get " << nbChunkOut << " chunk");
 		if (nbChunkOut > 0) {
 			size_t position = m_data.size();
 			m_data.resize(m_data.size() + nbChunkOut*_chunkSize);
@@ -337,20 +299,21 @@ void airtio::Interface::systemNeedOutputData(std::chrono::system_clock::time_poi
 		}
 	}
 	if (m_data.size()>=_nbChunk*_chunkSize) {
-		//std::cout << "         * copy needed data" << std::endl;
+		AIRTIO_VERBOSE("         * copy needed data");
 		memcpy(_data, &m_data[0], _nbChunk*_chunkSize);
 		m_data.erase(m_data.begin(), m_data.begin()+_nbChunk*_chunkSize);
 	} else {
-		//std::cout << "         * soft underflow" << std::endl;
+		AIRTIO_VERBOSE("         * soft underflow");
 		// ERROR
 		m_data.clear();
 	}
 	/*
 	process(_time, in, nbChunkIn, out, nbChunkOut);
 	if (nbChunkIn!=nbChunkOut) {
-		std::cout << " wrong size : request=" << _nbChunk << " get=" << nbChunkOut << std::endl;
+		AIRTIO_ERROR(" wrong size : request=" << _nbChunk << " get=" << nbChunkOut);
 		return;
 	}
 	memcpy(_data, out, _nbChunk*_chunkSize);
 	*/
+#endif
 }
diff --git a/airtio/Interface.h b/airtio/Interface.h
index a2c159c..c2e2b58 100644
--- a/airtio/Interface.h
+++ b/airtio/Interface.h
@@ -54,7 +54,7 @@ namespace airtio {
 			/**
 			 * @brief Destructor
 			 */
-			virtual ~Interface() {};
+			virtual ~Interface();
 			static std::shared_ptr<Interface> create(const std::string& _name,
 			                                         float _freq,
 			                                         const std::vector<airtalgo::channel>& _map,
@@ -156,11 +156,6 @@ namespace airtio {
 			
 			std::vector<int8_t> m_data;
 			float m_volume; //!< Local channel Volume
-			bool process(std::chrono::system_clock::time_point& _time,
-			             void* _input,
-			             size_t _inputNbChunk,
-			             void*& _output,
-			             size_t& _outputNbChunk);
 	};
 };
 
diff --git a/airtio/Manager.cpp b/airtio/Manager.cpp
index 36ef84c..804bc65 100644
--- a/airtio/Manager.cpp
+++ b/airtio/Manager.cpp
@@ -5,7 +5,7 @@
  */
 
 #include "Manager.h"
-#include "InterfaceDirect.h"
+#include "Interface.h"
 #include <memory>
 #include <stdexcept>
 
@@ -13,7 +13,7 @@
 #include "io/Node.h"
 
 std::shared_ptr<airtio::Manager> airtio::Manager::create(const std::string& _applicationUniqueId) {
-	return std::make_shared<airtio::Manager>(_applicationUniqueId);
+	return std::shared_ptr<airtio::Manager>(new airtio::Manager(_applicationUniqueId));
 }
 
 airtio::Manager::Manager(const std::string& _applicationUniqueId) :
@@ -41,6 +41,7 @@ std::vector<std::pair<std::string,std::string> > airtio::Manager::getListStreamO
 	return output;
 }
 
+// TODO : Deprecated ...
 void airtio::Manager::setMasterOutputVolume(float _gainDB) {
 	if (_gainDB < m_masterVolumeRange.first) {
 		//throw std::range_error(std::string(_gainDB) + " is out of bonds : [" + m_masterVolumeRange.first + ".." + m_masterVolumeRange.second + "]");
@@ -51,15 +52,13 @@ void airtio::Manager::setMasterOutputVolume(float _gainDB) {
 		return;
 	}
 	m_masterVolume = _gainDB;
-	for (std::list<std::weak_ptr<airtio::InterfaceDirect> >::iterator it(m_listOpenInterface.begin());
-	     it != m_listOpenInterface.end();
-	     ++it) {
-		std::shared_ptr<airtio::InterfaceDirect> tmpElem = it->lock();
+	for (auto &it : m_listOpenInterface) {
+		std::shared_ptr<airtio::Interface> tmpElem = it.lock();
 		if (tmpElem == nullptr) {
 			continue;
 		}
 		// TODO : Deprecated ...
-		tmpElem->setMasterVolume(m_masterVolume);
+		//tmpElem->setMasterVolume(m_masterVolume);
 	}
 }
 
@@ -94,13 +93,12 @@ airtio::Manager::createOutput(float _freq,
 	// get the output or input channel :
 	std::shared_ptr<airtio::io::Node> node = manager->getNode(_streamName, false);
 	// create user iterface:
-	std::shared_ptr<airtio::InterfaceDirect> interface;
-	interface = std::make_shared<airtio::InterfaceDirect>(_name, _freq, _map, _format, node);
-	interface->init();
+	std::shared_ptr<airtio::Interface> interface;
+	interface = airtio::Interface::create(_name, _freq, _map, _format, node);
 	// store it in a list (needed to apply some parameters).
 	m_listOpenInterface.push_back(interface);
 	// TODO : DEPRECATED ...
-	interface->setMasterVolume(m_masterVolume);
+	//interface->setMasterVolume(m_masterVolume);
 	return interface;
 }
 
@@ -115,12 +113,11 @@ airtio::Manager::createInput(float _freq,
 	// get the output or input channel :
 	std::shared_ptr<airtio::io::Node> node = manager->getNode(_streamName, true);
 	// create user iterface:
-	std::shared_ptr<airtio::InterfaceDirect> interface;
-	interface = std::make_shared<airtio::InterfaceDirect>(_name, _freq, _map, _format, node);
-	interface->init();
+	std::shared_ptr<airtio::Interface> interface;
+	interface = airtio::Interface::create(_name, _freq, _map, _format, node);
 	// store it in a list (needed to apply some parameters).
 	m_listOpenInterface.push_back(interface);
 	// TODO : DEPRECATED ...
-	interface->setMasterVolume(m_masterVolume);
+	//interface->setMasterVolume(m_masterVolume);
 	return interface;
 }
diff --git a/airtio/Manager.h b/airtio/Manager.h
index 6ecac95..4fa0cda 100644
--- a/airtio/Manager.h
+++ b/airtio/Manager.h
@@ -21,29 +21,29 @@ namespace airtio {
 	class Manager {
 		private:
 			const std::string& m_applicationUniqueId; //!< name of the application that open the Audio Interface.
-			std::list<std::weak_ptr<airtio::InterfaceDirect> > m_listOpenInterface; //!< List of all open Stream.
+			std::vector<std::weak_ptr<airtio::Interface> > m_listOpenInterface; //!< List of all open Stream.
 		protected:
 			/**
 			 * @brief Constructor
 			 */
-			Manager() {};
+			Manager(const std::string& _applicationUniqueId);
 		public:
 			static std::shared_ptr<airtio::Manager> create(const std::string& _applicationUniqueId);
 			/**
 			 * @brief Destructor
 			 */
-			virtual ~Manager() {};
+			virtual ~Manager();
 		public:
 			/**
 			 * @brief Get all input audio stream description.
 			 * @return a list of all availlables input stream (name + description)
 			 */
-			virtual std::vector<std::pair<std::string,std::string> > getListStreamInput() = 0;
+			virtual std::vector<std::pair<std::string,std::string> > getListStreamInput();
 			/**
 			 * @brief Get all output audio stream description.
 			 * @return a list of all availlables output stream (name + description)
 			 */
-			virtual std::vector<std::pair<std::string,std::string> > getListStreamOutput() = 0;
+			virtual std::vector<std::pair<std::string,std::string> > getListStreamOutput();
 		protected:
 			float m_masterVolume;
 			std::pair<float,float> m_masterVolumeRange;
diff --git a/airtio/io/Manager.h b/airtio/io/Manager.h
index f1c1384..5f9cee0 100644
--- a/airtio/io/Manager.h
+++ b/airtio/io/Manager.h
@@ -11,12 +11,11 @@
 #include <vector>
 #include <list>
 #include <stdint.h>
-#include <std/chrono.hpp>
-#include <std/function.hpp>
-#include <audio_algo_core/format.hpp>
-#include <audio_algo_core/channel.hpp>
-#include <std/shared_ptr.hpp>
-#include <std/weak_ptr.hpp>
+#include <chrono>
+#include <functional>
+#include <airtalgo/format.h>
+#include <airtalgo/channel.h>
+#include <memory>
 
 namespace airtio {
 	namespace io {
diff --git a/airtio/io/Node.cpp b/airtio/io/Node.cpp
index 8d526a8..6bde9c9 100644
--- a/airtio/io/Node.cpp
+++ b/airtio/io/Node.cpp
@@ -4,7 +4,8 @@
  * @license APACHE v2.0 (see license file)
  */
 
-#include "Node.hpp"
+#include "Node.h"
+#include <airtio/debug.h>
 
 #include <memory>
 
@@ -26,7 +27,7 @@ static int rtAudioCallbackStatic(void* _outputBuffer,
                                  void* _inputBuffer,
                                  unsigned int _nBufferFrames,
                                  double _streamTime,
-                                 RtAudioStreamStatus _status,
+                                 airtaudio::streamStatus _status,
                                  void* _data) {
 	airtio::io::Node* interface = static_cast<airtio::io::Node*>(_data);
 	return interface->rtAudioCallback(static_cast<int16_t*>(_outputBuffer),
@@ -37,23 +38,22 @@ static int rtAudioCallbackStatic(void* _outputBuffer,
 }
 
 int airtio::io::Node::rtAudioCallback(int16_t* _outputBuffer,
-                                               int16_t* _inputBuffer,
-                                               unsigned int _nBufferFrames,
-                                               double _streamTime,
-                                               RtAudioStreamStatus _status) {
-	std::mutex::scoped_lock lock(m_mutex);
-	
-	std::chrono::system_clock::time_point ttime = boost::chrono::system_clock::time_point();//boost::chrono::system_clock::now();
+                                      int16_t* _inputBuffer,
+                                      unsigned int _nBufferFrames,
+                                      double _streamTime,
+                                      airtaudio::streamStatus _status) {
+	std::unique_lock<std::mutex> lock(m_mutex);
+	std::chrono::system_clock::time_point ttime = std::chrono::system_clock::time_point();//std::chrono::system_clock::now();
 	
 	if (_outputBuffer != nullptr) {
-		//std::cout << "data Output" << std::endl;
+		AIRTIO_VERBOSE("data Output");
 		std::vector<int32_t> output;
 		output.resize(_nBufferFrames*m_map.size(), 0);
 		std::vector<int16_t> outputTmp;
 		outputTmp.resize(_nBufferFrames*m_map.size());
 		for (size_t iii=0; iii< m_list.size(); ++iii) {
 			if (m_list[iii] != nullptr) {
-				//std::cout << "    IO : " << iii+1 << "/" << m_list.size() << " name="<< m_list[iii]->getName() << std::endl;
+				AIRTIO_VERBOSE("    IO : " << iii+1 << "/" << m_list.size() << " name="<< m_list[iii]->getName());
 				m_list[iii]->systemNeedOutputData(ttime, &outputTmp[0], _nBufferFrames, sizeof(int16_t)*m_map.size());
 				//m_list[iii]->systemNeedOutputData(ttime, _outputBuffer, _nBufferFrames, sizeof(int16_t)*m_map.size());
 				// Add data to the output tmp buffer :
@@ -70,10 +70,10 @@ int airtio::io::Node::rtAudioCallback(int16_t* _outputBuffer,
 		}
 	}
 	if (_inputBuffer != nullptr) {
-		std::cout << "data Input" << std::endl;
+		AIRTIO_INFO("data Input");
 		for (size_t iii=0; iii< m_list.size(); ++iii) {
 			if (m_list[iii] != nullptr) {
-				std::cout << "    IO : " << iii+1 << "/" << m_list.size() << " name="<< m_list[iii]->getName() << std::endl;
+				AIRTIO_INFO("    IO : " << iii+1 << "/" << m_list.size() << " name="<< m_list[iii]->getName());
 				m_list[iii]->systemNewInputData(ttime, _inputBuffer, _nBufferFrames);
 			}
 		}
@@ -91,10 +91,11 @@ airtio::io::Node::Node(const std::string& _streamName, bool _isInput) :
   m_frequency(48000),
   m_format(airtalgo::format_int16),
   m_isInput(_isInput) {
-	std::cout << "-----------------------------------------------------------------" << std::endl;
-	std::cout << "--                       CREATE NODE                           --" << std::endl;
-	std::cout << "-----------------------------------------------------------------" << std::endl;
-	
+	AIRTIO_INFO("-----------------------------------------------------------------");
+	AIRTIO_INFO("--                       CREATE NODE                           --");
+	AIRTIO_INFO("-----------------------------------------------------------------");
+	// intanciate specific API ...
+	m_adac.instanciate();
 	
 	if (m_streamName == "") {
 		m_streamName = "default";
@@ -104,19 +105,19 @@ airtio::io::Node::Node(const std::string& _streamName, bool _isInput) :
 	m_map.push_back(airtalgo::channel_frontRight);
 	
 	// search device ID :
-	std::cout << "Open :" << std::endl;
-	std::cout << "    m_streamName=" << m_streamName << std::endl;
-	std::cout << "    m_freq=" << m_frequency << std::endl;
-	std::cout << "    m_map=" << m_map << std::endl;
-	std::cout << "    m_format=" << m_format << std::endl;
-	std::cout << "    m_isInput=" << m_isInput << std::endl;
+	AIRTIO_INFO("Open :");
+	AIRTIO_INFO("    m_streamName=" << m_streamName);
+	AIRTIO_INFO("    m_freq=" << m_frequency);
+	AIRTIO_INFO("    m_map=" << m_map);
+	AIRTIO_INFO("    m_format=" << m_format);
+	AIRTIO_INFO("    m_isInput=" << m_isInput);
 	int32_t deviceId = 0;
-	std::cout << "Device list:" << std::endl;
+	AIRTIO_INFO("Device list:");
 	for (int32_t iii=0; iii<m_adac.getDeviceCount(); ++iii) {
 		m_info = m_adac.getDeviceInfo(iii);
-		std::cout << "    " << iii << " name :" << m_info.name << std::endl;
+		AIRTIO_INFO("    " << iii << " name :" << m_info.name);
 		if (m_info.name == m_streamName) {
-			std::cout << "        Select ..." << std::endl;
+			AIRTIO_INFO("        Select ...");
 			deviceId = iii;
 		}
 	}
@@ -124,48 +125,48 @@ airtio::io::Node::Node(const std::string& _streamName, bool _isInput) :
 	m_info = m_adac.getDeviceInfo(deviceId);
 	// display property :
 	{
-		std::cout << "Device " << deviceId << " property :" << std::endl;
-		std::cout << "    probe=" << (m_info.probed==true?"true":"false") << std::endl;
-		std::cout << "    name=" << m_info.name << std::endl;
-		std::cout << "    outputChannels=" << m_info.outputChannels << std::endl;
-		std::cout << "    inputChannels=" << m_info.inputChannels << std::endl;
-		std::cout << "    duplexChannels=" << m_info.duplexChannels << std::endl;
-		std::cout << "    isDefaultOutput=" << (m_info.isDefaultOutput==true?"true":"false") << std::endl;
-		std::cout << "    isDefaultInput=" << (m_info.isDefaultInput==true?"true":"false") << std::endl;
+		AIRTIO_INFO("Device " << deviceId << " property :");
+		AIRTIO_INFO("    probe=" << (m_info.probed==true?"true":"false"));
+		AIRTIO_INFO("    name=" << m_info.name);
+		AIRTIO_INFO("    outputChannels=" << m_info.outputChannels);
+		AIRTIO_INFO("    inputChannels=" << m_info.inputChannels);
+		AIRTIO_INFO("    duplexChannels=" << m_info.duplexChannels);
+		AIRTIO_INFO("    isDefaultOutput=" << (m_info.isDefaultOutput==true?"true":"false"));
+		AIRTIO_INFO("    isDefaultInput=" << (m_info.isDefaultInput==true?"true":"false"));
 		//std::string rrate;
 		std::stringstream rrate;
 		for (int32_t jjj=0; jjj<m_info.sampleRates.size(); ++jjj) {
 			rrate << m_info.sampleRates[jjj] << ";";
 		}
-		std::cout << "    rates=" << rrate.str() << std::endl;
+		AIRTIO_INFO("    rates=" << rrate.str());
 		switch(m_info.nativeFormats) {
-			case RTAUDIO_SINT8:
-				std::cout << "    native Format: 8-bit signed integer" << std::endl;
+			case airtaudio::SINT8:
+				AIRTIO_INFO("    native Format: 8-bit signed integer");
 				break;
-			case RTAUDIO_SINT16:
-				std::cout << "    native Format: 16-bit signed integer" << std::endl;
+			case airtaudio::SINT16:
+				AIRTIO_INFO("    native Format: 16-bit signed integer");
 				break;
-			case RTAUDIO_SINT24:
-				std::cout << "    native Format: 24-bit signed integer" << std::endl;
+			case airtaudio::SINT24:
+				AIRTIO_INFO("    native Format: 24-bit signed integer");
 				break;
-			case RTAUDIO_SINT32:
-				std::cout << "    native Format: 32-bit signed integer" << std::endl;
+			case airtaudio::SINT32:
+				AIRTIO_INFO("    native Format: 32-bit signed integer");
 				break;
-			case RTAUDIO_FLOAT32:
-				std::cout << "    native Format: Normalized between plus/minus 1.0" << std::endl;
+			case airtaudio::FLOAT32:
+				AIRTIO_INFO("    native Format: Normalized between plus/minus 1.0");
 				break;
-			case RTAUDIO_FLOAT64:
-				std::cout << "    native Format: Normalized between plus/minus 1.0" << std::endl;
+			case airtaudio::FLOAT64:
+				AIRTIO_INFO("    native Format: Normalized between plus/minus 1.0");
 				break;
 			default:
-				std::cout << "    native Format: Unknow" << std::endl;
+				AIRTIO_INFO("    native Format: Unknow");
 				break;
 		}
 	}
 	
 	// open Audio device:
 	unsigned int nbChunk= 1024;
-	RtAudio::StreamParameters params;
+	airtaudio::StreamParameters params;
 	params.deviceId = deviceId;
 	if (m_isInput == true) {
 		m_info.inputChannels = 2;
@@ -176,78 +177,65 @@ airtio::io::Node::Node(const std::string& _streamName, bool _isInput) :
 	}
 	
 	m_rtaudioFrameSize = nbChunk;
-	std::cout << "Open output stream nbChannels=" << params.nChannels << std::endl;
-	try {
-		if (m_isInput == true) {
-			m_adac.openStream( nullptr, &params, RTAUDIO_SINT16, m_frequency, &m_rtaudioFrameSize, &rtAudioCallbackStatic, (void *)this );
-		} else {
-			m_adac.openStream( &params, nullptr, RTAUDIO_SINT16, m_frequency, &m_rtaudioFrameSize, &rtAudioCallbackStatic, (void *)this );
-		}
-	} catch ( RtAudioError& e ) {
-		e.printMessage();
-		std::cout << "[ERROR]Can not open device Output" << std::endl;
-		return;
+	AIRTIO_INFO("Open output stream nbChannels=" << params.nChannels);
+	enum airtaudio::errorType err = airtaudio::errorNone;
+	if (m_isInput == true) {
+		err = m_adac.openStream( nullptr, &params, airtaudio::SINT16, m_frequency, &m_rtaudioFrameSize, &rtAudioCallbackStatic, (void *)this );
+	} else {
+		err = m_adac.openStream( &params, nullptr, airtaudio::SINT16, m_frequency, &m_rtaudioFrameSize, &rtAudioCallbackStatic, (void *)this );
+	}
+	if (err != airtaudio::errorNone) {
+		AIRTIO_ERROR("Create stream : '" << m_streamName << "' mode=" << (m_isInput?"input":"output") << " can not create strem " << err);
 	}
 }
 
 airtio::io::Node::~Node() {
-	std::mutex::scoped_lock lock(m_mutex);
-	std::cout << "-----------------------------------------------------------------" << std::endl;
-	std::cout << "--                       DESTRO NODE                           --" << std::endl;
-	std::cout << "-----------------------------------------------------------------" << std::endl;
-	std::cout << "close input stream" << std::endl;
+	std::unique_lock<std::mutex> lock(m_mutex);
+	AIRTIO_INFO("-----------------------------------------------------------------");
+	AIRTIO_INFO("--                       DESTRO NODE                           --");
+	AIRTIO_INFO("-----------------------------------------------------------------");
+	AIRTIO_INFO("close input stream");
 	if (m_adac.isStreamOpen() ) {
 		m_adac.closeStream();
 	}
 };
 
 void airtio::io::Node::start() {
-	std::mutex::scoped_lock lock(m_mutex);
-	std::cout << "[INFO] Start stream : '" << m_streamName << "' mode=" << (m_isInput?"input":"output")<< std::endl;
-	try {
-		m_adac.startStream();
-	} catch (RtAudioError& e ) {
-		e.printMessage();
-		std::cout << "[ERROR] Can not start stream Input" << std::endl;
-		if (m_adac.isStreamOpen() ) {
-			m_adac.closeStream();
-		}
-		return;
+	std::unique_lock<std::mutex> lock(m_mutex);
+	AIRTIO_INFO("Start stream : '" << m_streamName << "' mode=" << (m_isInput?"input":"output") );
+	enum airtaudio::errorType err = m_adac.startStream();
+	if (err != airtaudio::errorNone) {
+		AIRTIO_ERROR("Start stream : '" << m_streamName << "' mode=" << (m_isInput?"input":"output") << " can not start stream ... " << err);
 	}
 }
 
 void airtio::io::Node::stop() {
-	std::mutex::scoped_lock lock(m_mutex);
-	std::cout << "[INFO] Stop stream : '" << m_streamName << "' mode=" << (m_isInput?"input":"output")<< std::endl;
-	try {
-		m_adac.stopStream();
-	} catch ( RtAudioError& e ) {
-		e.printMessage();
-		std::cout << "[ERROR] Can not stop stream" << std::endl;
-		if (m_adac.isStreamOpen() ) {
-			m_adac.closeStream();
-		}
-		return;
+	std::unique_lock<std::mutex> lock(m_mutex);
+	AIRTIO_INFO("Stop stream : '" << m_streamName << "' mode=" << (m_isInput?"input":"output") );
+	enum airtaudio::errorType err = m_adac.stopStream();
+	if (err != airtaudio::errorNone) {
+		AIRTIO_ERROR("Stop stream : '" << m_streamName << "' mode=" << (m_isInput?"input":"output") << " can not stop stream ... " << err);
 	}
 }
 
-
-
-
 void airtio::io::Node::interfaceAdd(const std::shared_ptr<airtio::Interface>& _interface) {
 	for (size_t iii=0; iii< m_list.size(); ++iii) {
 		if (_interface == m_list[iii]) {
 			return;
 		}
 	}
+	AIRTIO_INFO("ADD interface for stream : '" << m_streamName << "' mode=" << (m_isInput?"input":"output") );
 	m_list.push_back(_interface);
-	start();
+	if (m_list.size() == 1) {
+		start();
+	}
 }
 
 void airtio::io::Node::interfaceRemove(const std::shared_ptr<airtio::Interface>& _interface) {
 	for (size_t iii=0; iii< m_list.size(); ++iii) {
 		if (_interface == m_list[iii]) {
 			m_list.erase(m_list.begin()+iii);
+			AIRTIO_INFO("RM interface for stream : '" << m_streamName << "' mode=" << (m_isInput?"input":"output") );
 			break;
 		}
 	}
diff --git a/airtio/io/Node.h b/airtio/io/Node.h
index b1f0bbf..061475f 100644
--- a/airtio/io/Node.h
+++ b/airtio/io/Node.h
@@ -15,9 +15,10 @@
 #include <functional>
 #include <airtalgo/format.h>
 #include <airtalgo/channel.h>
-#include "io/Manager.h"
+#include "Manager.h"
 #include <memory>
 #include <airtio/Interface.h>
+#include <airtaudio/Interface.h>
 
 namespace airtio {
 	namespace io {
@@ -42,15 +43,15 @@ namespace airtio {
 				void interfaceAdd(const std::shared_ptr<airtio::Interface>& _interface);
 				void interfaceRemove(const std::shared_ptr<airtio::Interface>& _interface);
 			private:
-				RtAudio m_adac; //!< Real audio interface
-				RtAudio::DeviceInfo m_info;
+				airtaudio::Interface m_adac; //!< Real audio interface
+				airtaudio::DeviceInfo m_info;
 				unsigned int m_rtaudioFrameSize;
 			public:
 				int rtAudioCallback(int16_t* _outputBuffer,
 				                    int16_t* _inputBuffer,
 				                    unsigned int _nBufferFrames,
 				                    double _streamTime,
-				                    RtAudioStreamStatus _status);
+				                    airtaudio::streamStatus _status);
 			private:
 				std::string m_streamName;
 			public:
diff --git a/lutin_airtio_test.py b/lutin_airtio_test.py
new file mode 100644
index 0000000..dada5ab
--- /dev/null
+++ b/lutin_airtio_test.py
@@ -0,0 +1,30 @@
+#!/usr/bin/python
+import lutinModule as module
+import lutinTools as tools
+import lutinDebug as debug
+
+def get_desc():
+	return "airtio_test : Multi-nodal audio interface test"
+
+
+def create(target):
+	myModule = module.Module(__file__, 'airtio_test', 'BINARY')
+	
+	myModule.add_src_file([
+		'test/main.cpp',
+		'test/debug.cpp'
+		])
+	
+	myModule.add_module_depend(['airtio', 'gtest', 'etk'])
+	
+	# add the currrent module at the 
+	return myModule
+
+
+
+
+
+
+
+
+
diff --git a/test/debug.cpp b/test/debug.cpp
new file mode 100644
index 0000000..bc8cd03
--- /dev/null
+++ b/test/debug.cpp
@@ -0,0 +1,15 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2010, Edouard DUPIN, all right reserved
+ * 
+ * @license GPL v3 (see license file)
+ */
+
+#include "debug.h"
+
+int32_t appl::getLogId() {
+	static int32_t g_val = etk::log::registerInstance("test");
+	return g_val;
+}
+
diff --git a/test/debug.h b/test/debug.h
new file mode 100644
index 0000000..2b07d37
--- /dev/null
+++ b/test/debug.h
@@ -0,0 +1,51 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2010, Edouard DUPIN, all right reserved
+ * 
+ * @license GPL v3 (see license file)
+ */
+
+#ifndef __APPL_DEBUG_H__
+#define __APPL_DEBUG_H__
+
+#include <etk/log.h>
+
+namespace appl {
+	int32_t getLogId();
+};
+// TODO : Review this problem of multiple intanciation of "std::stringbuf sb"
+#define APPL_BASE(info,data) \
+	do { \
+		if (info <= etk::log::getLevel(appl::getLogId())) { \
+			std::stringbuf sb; \
+			std::ostream tmpStream(&sb); \
+			tmpStream << data; \
+			etk::log::logStream(appl::getLogId(), info, __LINE__, __class__, __func__, tmpStream); \
+		} \
+	} while(0)
+
+#define APPL_CRITICAL(data)      APPL_BASE(1, data)
+#define APPL_ERROR(data)         APPL_BASE(2, data)
+#define APPL_WARNING(data)       APPL_BASE(3, data)
+#ifdef DEBUG
+	#define APPL_INFO(data)          APPL_BASE(4, data)
+	#define APPL_DEBUG(data)         APPL_BASE(5, data)
+	#define APPL_VERBOSE(data)       APPL_BASE(6, data)
+	#define APPL_TODO(data)          APPL_BASE(4, "TODO : " << data)
+#else
+	#define APPL_INFO(data)          do { } while(false)
+	#define APPL_DEBUG(data)         do { } while(false)
+	#define APPL_VERBOSE(data)       do { } while(false)
+	#define APPL_TODO(data)          do { } while(false)
+#endif
+
+#define APPL_ASSERT(cond,data) \
+	do { \
+		if (!(cond)) { \
+			APPL_CRITICAL(data); \
+			assert(!#cond); \
+		} \
+	} while (0)
+
+#endif
diff --git a/test/main.cpp b/test/main.cpp
index 051ef7a..36b5fc3 100644
--- a/test/main.cpp
+++ b/test/main.cpp
@@ -1,24 +1,33 @@
-#include "ros/ros.h"
-#include <audio_base/Manager.hpp>
-#include <audio_base/Interface.hpp>
+/** @file
+ * @author Edouard DUPIN 
+ * @copyright 2015, Edouard DUPIN, all right reserved
+ * @license APACHE v2.0 (see license file)
+ */
+
+#include "debug.h"
+#include <airtio/Manager.h>
+#include <airtio/Interface.h>
+#include <gtest/gtest.h>
+#include <etk/os/FSNode.h>
 
 #include <sstream>
+#include <unistd.h>
 
-
+#if 0
 class testOutWrite {
 	private:
-		std::vector<audio_algo_core::channel> m_channelMap;
-		boost::shared_ptr<audio_base::Manager> m_manager;
-		boost::shared_ptr<audio_base::Interface> m_interface;
+		std::vector<airtalgo::channel> m_channelMap;
+		std::shared_ptr<airtio::Manager> m_manager;
+		std::shared_ptr<airtio::Interface> m_interface;
 	public:
-		testOutWrite(boost::shared_ptr<audio_base::Manager> _manager) :
+		testOutWrite(std::shared_ptr<airtio::Manager> _manager) :
 		  m_manager(_manager){
 			//Set stereo output:
-			m_channelMap.push_back(audio_algo_core::channel_frontLeft);
-			m_channelMap.push_back(audio_algo_core::channel_frontRight);
+			m_channelMap.push_back(airtalgo::channel_frontLeft);
+			m_channelMap.push_back(airtalgo::channel_frontRight);
 			m_interface = m_manager->createOutput(48000,
 			                                      m_channelMap,
-			                                      audio_algo_core::format_int16,
+			                                      airtalgo::format_int16,
 			                                      "default",
 			                                      "WriteMode");
 		}
@@ -42,47 +51,73 @@ class testOutWrite {
 						phase -= 2*M_PI;
 					}
 				}
-				ROS_INFO("send data");
+				APPL_INFO("send data");
 				m_interface->write(data);
 			}
 			m_interface->stop();
 		}
 };
-
+#endif
 
 class testOutCallback {
 	private:
-		boost::shared_ptr<audio_base::Manager> m_manager;
-		boost::shared_ptr<audio_base::Interface> m_interface;
+		std::shared_ptr<airtio::Manager> m_manager;
+		std::shared_ptr<airtio::Interface> m_interface;
 		double m_phase;
 	public:
-		testOutCallback(boost::shared_ptr<audio_base::Manager> _manager) :
+		testOutCallback(std::shared_ptr<airtio::Manager> _manager) :
 		  m_manager(_manager),
 		  m_phase(0) {
 			//Set stereo output:
-			std::vector<audio_algo_core::channel> channelMap;
-			channelMap.push_back(audio_algo_core::channel_frontLeft);
-			channelMap.push_back(audio_algo_core::channel_frontRight);
+			std::vector<airtalgo::channel> channelMap;
+			channelMap.push_back(airtalgo::channel_frontLeft);
+			channelMap.push_back(airtalgo::channel_frontRight);
 			m_interface = m_manager->createOutput(48000,
 			                                      channelMap,
-			                                      audio_algo_core::format_int16,
+			                                      airtalgo::format_int16,
 			                                      "default",
 			                                      "WriteModeCallback");
 			// set callback mode ...
-			m_interface->setOutputCallbackInt16(1024, boost::bind(&testOutCallback::onDataNeeded, this, _1, _2, _3));
+			m_interface->setOutputCallback(1024,
+			                               std::bind(&testOutCallback::onDataNeeded,
+			                                         this,
+			                                         std::placeholders::_1,
+			                                         std::placeholders::_2,
+			                                         std::placeholders::_3,
+			                                         std::placeholders::_4,
+			                                         std::placeholders::_5),
+			                               airtalgo::formatDataTypeInt16);
 		}
 		
 		~testOutCallback() {
 			
 		}
 		
-		std::vector<int16_t> onDataNeeded(const boost::chrono::system_clock::time_point& _playTime,
-		                                  const size_t& _nbChunk,
-		                                  const std::vector<audio_algo_core::channel>& _map) {
+		void onDataNeeded(const std::chrono::system_clock::time_point& _playTime,
+		                  const size_t& _nbChunk,
+		                  const std::vector<airtalgo::channel>& _map,
+		                  void* _data,
+		                  enum airtalgo::formatDataType& _type) {
+			if (_type != airtalgo::formatDataTypeInt16) {
+				APPL_ERROR("call wrong type ...");
+			}
+			int16_t* data = static_cast<int16_t*>(_data);
+			double baseCycle = 2.0*M_PI/(double)48000 * (double)550;
+			APPL_INFO("Get data ...");
+			for (int32_t iii=0; iii<_nbChunk; iii++) {
+				for (int32_t jjj=0; jjj<_map.size(); jjj++) {
+					data[_map.size()*iii+jjj] = cos(m_phase) * 30000;
+				}
+				m_phase += baseCycle;
+				if (m_phase >= 2*M_PI) {
+					m_phase -= 2*M_PI;
+				}
+			}
+			/*
 			std::vector<int16_t> data;
 			data.resize(_nbChunk*_map.size());
 			double baseCycle = 2.0*M_PI/(double)48000 * (double)550;
-			ROS_INFO("Get data ...");
+			APPL_INFO("Get data ...");
 			
 			for (int32_t iii=0; iii<data.size()/_map.size(); iii++) {
 				for (int32_t jjj=0; jjj<_map.size(); jjj++) {
@@ -94,6 +129,7 @@ class testOutCallback {
 				}
 			}
 			return data;
+			*/
 		}
 		
 		void run() {
@@ -104,21 +140,21 @@ class testOutCallback {
 		}
 };
 
-
+#if 0
 class testInRead {
 	private:
-		std::vector<audio_algo_core::channel> m_channelMap;
-		boost::shared_ptr<audio_base::Manager> m_manager;
-		boost::shared_ptr<audio_base::Interface> m_interface;
+		std::vector<airtalgo::channel> m_channelMap;
+		std::shared_ptr<airtio::Manager> m_manager;
+		std::shared_ptr<airtio::Interface> m_interface;
 	public:
-		testInRead(boost::shared_ptr<audio_base::Manager> _manager) :
+		testInRead(std::shared_ptr<airtio::Manager> _manager) :
 		  m_manager(_manager){
 			//Set stereo output:
-			m_channelMap.push_back(audio_algo_core::channel_frontLeft);
-			m_channelMap.push_back(audio_algo_core::channel_frontRight);
+			m_channelMap.push_back(airtalgo::channel_frontLeft);
+			m_channelMap.push_back(airtalgo::channel_frontRight);
 			m_interface = m_manager->createInput(48000,
 			                                     m_channelMap,
-			                                     audio_algo_core::format_int16,
+			                                     airtalgo::format_int16,
 			                                     "default",
 			                                     "WriteMode");
 		}
@@ -136,7 +172,7 @@ class testInRead {
 					value += std::abs(data[iii]);
 				}
 				value /= data.size();
-				ROS_INFO("Get data ... average = %d", static_cast<int32_t>(value));
+				APPL_INFO("Get data ... average=" << int32_t(value));
 			}
 			m_interface->stop();
 		}
@@ -145,40 +181,40 @@ class testInRead {
 
 class testInCallback {
 	private:
-		boost::shared_ptr<audio_base::Manager> m_manager;
-		boost::shared_ptr<audio_base::Interface> m_interface;
+		std::shared_ptr<airtio::Manager> m_manager;
+		std::shared_ptr<airtio::Interface> m_interface;
 		double m_phase;
 	public:
-		testInCallback(boost::shared_ptr<audio_base::Manager> _manager) :
+		testInCallback(std::shared_ptr<airtio::Manager> _manager) :
 		  m_manager(_manager),
 		  m_phase(0) {
 			//Set stereo output:
-			std::vector<audio_algo_core::channel> channelMap;
-			channelMap.push_back(audio_algo_core::channel_frontLeft);
-			channelMap.push_back(audio_algo_core::channel_frontRight);
+			std::vector<airtalgo::channel> channelMap;
+			channelMap.push_back(airtalgo::channel_frontLeft);
+			channelMap.push_back(airtalgo::channel_frontRight);
 			m_interface = m_manager->createInput(48000,
 			                                     channelMap,
-			                                     audio_algo_core::format_int16,
+			                                     airtalgo::format_int16,
 			                                     "default",
 			                                     "WriteModeCallback");
 			// set callback mode ...
-			m_interface->setInputCallbackInt16(1024, boost::bind(&testInCallback::onDataReceived, this, _1, _2, _3, _4));
+			m_interface->setInputCallbackInt16(1024, std::bind(&testInCallback::onDataReceived, this, _1, _2, _3, _4));
 		}
 		
 		~testInCallback() {
 			
 		}
 		
-		void onDataReceived(const boost::chrono::system_clock::time_point& _playTime,
+		void onDataReceived(const std::chrono::system_clock::time_point& _playTime,
 		                    const size_t& _nbChunk,
-		                    const std::vector<audio_algo_core::channel>& _map,
+		                    const std::vector<airtalgo::channel>& _map,
 		                    const std::vector<int16_t>& _data) {
 			int64_t value = 0;
 			for (size_t iii=0; iii<_data.size(); ++iii) {
 				value += std::abs(_data[iii]);
 			}
 			value /= _data.size();
-			ROS_INFO("Get data ... average = %d", static_cast<int32_t>(value));
+			APPL_INFO("Get data ... average=" << int32_t(value));
 		}
 		
 		void run() {
@@ -192,76 +228,76 @@ class testInCallback {
 
 class testOutCallbackFloat {
 	private:
-		boost::shared_ptr<audio_base::Manager> m_manager;
-		boost::shared_ptr<audio_base::Interface> m_interface;
+		std::shared_ptr<airtio::Manager> m_manager;
+		std::shared_ptr<airtio::Interface> m_interface;
 		double m_phase;
 		float m_freq;
 		int32_t m_nbChannels;
 		float m_generateFreq;
 		
 	public:
-		testOutCallbackFloat(boost::shared_ptr<audio_base::Manager> _manager,
+		testOutCallbackFloat(std::shared_ptr<airtio::Manager> _manager,
 		                     float _freq=48000.0f,
 		                     int32_t _nbChannels=2,
-		                     audio_algo_core::format _format=audio_algo_core::format_int16) :
+		                     airtalgo::format _format=airtalgo::format_int16) :
 		  m_manager(_manager),
 		  m_phase(0),
 		  m_freq(_freq),
 		  m_nbChannels(_nbChannels),
 		  m_generateFreq(550.0f) {
 			//Set stereo output:
-			std::vector<audio_algo_core::channel> channelMap;
+			std::vector<airtalgo::channel> channelMap;
 			if (m_nbChannels == 1) {
-				channelMap.push_back(audio_algo_core::channel_frontCenter);
+				channelMap.push_back(airtalgo::channel_frontCenter);
 			} else if (m_nbChannels == 2) {
-				channelMap.push_back(audio_algo_core::channel_frontLeft);
-				channelMap.push_back(audio_algo_core::channel_frontRight);
+				channelMap.push_back(airtalgo::channel_frontLeft);
+				channelMap.push_back(airtalgo::channel_frontRight);
 			} else if (m_nbChannels == 4) {
-				channelMap.push_back(audio_algo_core::channel_frontLeft);
-				channelMap.push_back(audio_algo_core::channel_frontRight);
-				channelMap.push_back(audio_algo_core::channel_rearLeft);
-				channelMap.push_back(audio_algo_core::channel_rearRight);
+				channelMap.push_back(airtalgo::channel_frontLeft);
+				channelMap.push_back(airtalgo::channel_frontRight);
+				channelMap.push_back(airtalgo::channel_rearLeft);
+				channelMap.push_back(airtalgo::channel_rearRight);
 			} else {
-				ROS_ERROR("Can not generate with channel != 1,2,4");
+				APPL_ERROR("Can not generate with channel != 1,2,4");
 				return;
 			}
 			switch (_format) {
-				case audio_algo_core::format_int16:
+				case airtalgo::format_int16:
 					m_interface = m_manager->createOutput(m_freq,
 					                                      channelMap,
 					                                      _format,
 					                                      "default",
 					                                      "WriteModeCallbackI16");
 					// set callback mode ...
-					ROS_ERROR("Set callback");
-					m_interface->setOutputCallbackInt16(1024, boost::bind(&testOutCallbackFloat::onDataNeededI16, this, _1, _2, _3));
+					APPL_ERROR("Set callback");
+					m_interface->setOutputCallbackInt16(1024, std::bind(&testOutCallbackFloat::onDataNeededI16, this, _1, _2, _3));
 					break;
-				case audio_algo_core::format_int16_on_int32:
+				case airtalgo::format_int16_on_int32:
 					m_interface = m_manager->createOutput(m_freq,
 					                                      channelMap,
 					                                      _format,
 					                                      "default",
 					                                      "WriteModeCallbackI16onI32");
 					// set callback mode ...
-					m_interface->setOutputCallbackInt32(1024, boost::bind(&testOutCallbackFloat::onDataNeededI16_I32, this, _1, _2, _3));
+					m_interface->setOutputCallbackInt32(1024, std::bind(&testOutCallbackFloat::onDataNeededI16_I32, this, _1, _2, _3));
 					break;
-				case audio_algo_core::format_int32:
+				case airtalgo::format_int32:
 					m_interface = m_manager->createOutput(m_freq,
 					                                      channelMap,
 					                                      _format,
 					                                      "default",
 					                                      "WriteModeCallbackI32");
 					// set callback mode ...
-					m_interface->setOutputCallbackInt32(1024, boost::bind(&testOutCallbackFloat::onDataNeededI32, this, _1, _2, _3));
+					m_interface->setOutputCallbackInt32(1024, std::bind(&testOutCallbackFloat::onDataNeededI32, this, _1, _2, _3));
 					break;
-				case audio_algo_core::format_float:
+				case airtalgo::format_float:
 					m_interface = m_manager->createOutput(m_freq,
 					                                      channelMap,
 					                                      _format,
 					                                      "default",
 					                                      "WriteModeCallbackFloat");
 					// set callback mode ...
-					m_interface->setOutputCallbackFloat(1024, boost::bind(&testOutCallbackFloat::onDataNeededFloat, this, _1, _2, _3));
+					m_interface->setOutputCallbackFloat(1024, std::bind(&testOutCallbackFloat::onDataNeededFloat, this, _1, _2, _3));
 					break;
 			}
 		}
@@ -270,13 +306,13 @@ class testOutCallbackFloat {
 			
 		}
 		
-		std::vector<int16_t> onDataNeededI16(const boost::chrono::system_clock::time_point& _playTime,
+		std::vector<int16_t> onDataNeededI16(const std::chrono::system_clock::time_point& _playTime,
 		                                     const size_t& _nbChunk,
-		                                     const std::vector<audio_algo_core::channel>& _map) {
+		                                     const std::vector<airtalgo::channel>& _map) {
 			std::vector<int16_t> data;
 			data.resize(_nbChunk*_map.size());
 			double baseCycle = 2.0*M_PI/(double)m_freq * (double)m_generateFreq;
-			ROS_INFO("Get data ... %ld", _map.size());
+			APPL_INFO("Get data ... " << _map.size());
 			
 			for (int32_t iii=0; iii<data.size()/_map.size(); iii++) {
 				for (int32_t jjj=0; jjj<_map.size(); jjj++) {
@@ -290,13 +326,13 @@ class testOutCallbackFloat {
 			return data;
 		}
 		
-		std::vector<int32_t> onDataNeededI16_I32(const boost::chrono::system_clock::time_point& _playTime,
+		std::vector<int32_t> onDataNeededI16_I32(const std::chrono::system_clock::time_point& _playTime,
 		                                         const size_t& _nbChunk,
-		                                         const std::vector<audio_algo_core::channel>& _map) {
+		                                         const std::vector<airtalgo::channel>& _map) {
 			std::vector<int32_t> data;
 			data.resize(_nbChunk*_map.size());
 			double baseCycle = 2.0*M_PI/(double)m_freq * (double)m_generateFreq;
-			//ROS_INFO("Get data ...");
+			APPL_VERBOSE("Get data ...");
 			
 			for (int32_t iii=0; iii<data.size()/_map.size(); iii++) {
 				for (int32_t jjj=0; jjj<_map.size(); jjj++) {
@@ -310,13 +346,13 @@ class testOutCallbackFloat {
 			return data;
 		}
 		
-		std::vector<int32_t> onDataNeededI32(const boost::chrono::system_clock::time_point& _playTime,
+		std::vector<int32_t> onDataNeededI32(const std::chrono::system_clock::time_point& _playTime,
 		                                         const size_t& _nbChunk,
-		                                         const std::vector<audio_algo_core::channel>& _map) {
+		                                         const std::vector<airtalgo::channel>& _map) {
 			std::vector<int32_t> data;
 			data.resize(_nbChunk*_map.size());
 			double baseCycle = 2.0*M_PI/(double)m_freq * (double)m_generateFreq;
-			//ROS_INFO("Get data ...");
+			APPL_VERBOSE("Get data ...");
 			
 			for (int32_t iii=0; iii<data.size()/_map.size(); iii++) {
 				for (int32_t jjj=0; jjj<_map.size(); jjj++) {
@@ -332,13 +368,13 @@ class testOutCallbackFloat {
 		
 		
 		
-		std::vector<float> onDataNeededFloat(const boost::chrono::system_clock::time_point& _playTime,
+		std::vector<float> onDataNeededFloat(const std::chrono::system_clock::time_point& _playTime,
 		                                     const size_t& _nbChunk,
-		                                     const std::vector<audio_algo_core::channel>& _map) {
+		                                     const std::vector<airtalgo::channel>& _map) {
 			std::vector<float> data;
 			data.resize(_nbChunk*_map.size());
 			double baseCycle = 2.0*M_PI/(double)m_freq * (double)m_generateFreq;
-			//ROS_INFO("Get data ...");
+			APPL_VERBOSE("Get data ...");
 			
 			for (int32_t iii=0; iii<data.size()/_map.size(); iii++) {
 				for (int32_t jjj=0; jjj<_map.size(); jjj++) {
@@ -359,22 +395,69 @@ class testOutCallbackFloat {
 				usleep(1000000);
 				m_interface->stop();
 			} else {
-				ROS_ERROR("Can not create interface !!!");
+				APPL_ERROR("Can not create interface !!!");
 			}
 		}
 };
+#endif
 
 
-
+TEST(TestALL, testOutputCallBack) {
+	std::shared_ptr<airtio::Manager> manager;
+	manager = airtio::Manager::create("testApplication");
+	
+	APPL_INFO("test output (callback mode)");
+	std::shared_ptr<testOutCallback> process = std::make_shared<testOutCallback>(manager);
+	process->run();
+	process.reset();
+	usleep(500000);
+}
 
 
 int main(int argc, char **argv) {
-	boost::shared_ptr<audio_base::Manager> manager;
-	manager = audio_base::Manager::create("testApplication");
+	// init Google test :
+	::testing::InitGoogleTest(&argc, const_cast<char **>(argv));
+	// the only one init for etk:
+	etk::log::setLevel(etk::log::logLevelNone);
+	for (int32_t iii=0; iii<argc ; ++iii) {
+		std::string data = argv[iii];
+		if (data == "-l0") {
+			etk::log::setLevel(etk::log::logLevelNone);
+		} else if (data == "-l1") {
+			etk::log::setLevel(etk::log::logLevelCritical);
+		} else if (data == "-l2") {
+			etk::log::setLevel(etk::log::logLevelError);
+		} else if (data == "-l3") {
+			etk::log::setLevel(etk::log::logLevelWarning);
+		} else if (data == "-l4") {
+			etk::log::setLevel(etk::log::logLevelInfo);
+		} else if (data == "-l5") {
+			etk::log::setLevel(etk::log::logLevelDebug);
+		} else if (data == "-l6") {
+			etk::log::setLevel(etk::log::logLevelVerbose);
+		} else if (    data == "-h"
+		            || data == "--help") {
+			APPL_INFO("Help : ");
+			APPL_INFO("    ./xxx [options]");
+			APPL_INFO("        -l0: debug None");
+			APPL_INFO("        -l1: debug Critical");
+			APPL_INFO("        -l2: debug Error");
+			APPL_INFO("        -l3: debug Warning");
+			APPL_INFO("        -l4: debug Info");
+			APPL_INFO("        -l5: debug Debug");
+			APPL_INFO("        -l6: debug Verbose");
+			APPL_INFO("        -h/--help: this help");
+			exit(0);
+		}
+	}
+	etk::setArgZero(argv[0]);
+	etk::initDefaultFolder("exml_test");
+	return RUN_ALL_TESTS();
+	
 	#if 0
-	ROS_INFO("test output (Write mode)");
+	APPL_INFO("test output (Write mode)");
 	{
-		boost::shared_ptr<testOutWrite> process = boost::make_shared<testOutWrite>(manager);
+		std::shared_ptr<testOutWrite> process = std::make_shared<testOutWrite>(manager);
 		process->run();
 		process.reset();
 	}
@@ -382,9 +465,9 @@ int main(int argc, char **argv) {
 	#endif
 	
 	#if 0
-	ROS_INFO("test output (callback mode)");
+	APPL_INFO("test input (Read mode)");
 	{
-		boost::shared_ptr<testOutCallback> process = boost::make_shared<testOutCallback>(manager);
+		std::shared_ptr<testInRead> process = std::make_shared<testInRead>(manager);
 		process->run();
 		process.reset();
 	}
@@ -392,27 +475,17 @@ int main(int argc, char **argv) {
 	#endif
 	
 	#if 0
-	ROS_INFO("test input (Read mode)");
+	APPL_INFO("test input (callback mode)");
 	{
-		boost::shared_ptr<testInRead> process = boost::make_shared<testInRead>(manager);
+		std::shared_ptr<testInCallback> process = std::make_shared<testInCallback>(manager);
 		process->run();
 		process.reset();
 	}
-	usleep(500000);
 	#endif
 	
+	
 	#if 0
-	ROS_INFO("test input (callback mode)");
-	{
-		boost::shared_ptr<testInCallback> process = boost::make_shared<testInCallback>(manager);
-		process->run();
-		process.reset();
-	}
-	#endif
-	
-	
-	#if 1
-	ROS_INFO("test convert flaot to output (callback mode)");
+	APPL_INFO("test convert flaot to output (callback mode)");
 	std::vector<float> listFreq;
 	listFreq.push_back(4000);
 	listFreq.push_back(8000);
@@ -431,18 +504,18 @@ int main(int argc, char **argv) {
 	listChannel.push_back(1);
 	listChannel.push_back(2);
 	listChannel.push_back(4);
-	std::vector<audio_algo_core::format> listFormat;
-	listFormat.push_back(audio_algo_core::format_int16);
-	listFormat.push_back(audio_algo_core::format_int16_on_int32);
-	listFormat.push_back(audio_algo_core::format_int32);
-	listFormat.push_back(audio_algo_core::format_float);
+	std::vector<airtalgo::format> listFormat;
+	listFormat.push_back(airtalgo::format_int16);
+	listFormat.push_back(airtalgo::format_int16_on_int32);
+	listFormat.push_back(airtalgo::format_int32);
+	listFormat.push_back(airtalgo::format_float);
 	for (int32_t iii=0; iii<listFreq.size(); ++iii) {
 		for (int32_t jjj=0; jjj<listChannel.size(); ++jjj) {
-			for (std::vector<audio_algo_core::format>::iterator formatIt = listFormat.begin(); formatIt != listFormat.end(); ++formatIt) {
+			for (std::vector<airtalgo::format>::iterator formatIt = listFormat.begin(); formatIt != listFormat.end(); ++formatIt) {
 				float freq = listFreq[iii];
 				int32_t channel = listChannel[jjj];
-				ROS_INFO("freq = %f channel=%d format=%s", freq, channel, getFormatString(*formatIt).c_str());
-				boost::shared_ptr<testOutCallbackFloat> process = boost::make_shared<testOutCallbackFloat>(manager, freq, channel, *formatIt);
+				APPL_INFO("freq=" << freq << " channel=" << channel << " format=" << getFormatString(*formatIt));
+				std::shared_ptr<testOutCallbackFloat> process = std::make_shared<testOutCallbackFloat>(manager, freq, channel, *formatIt);
 				process->run();
 				process.reset();
 				usleep(500000);
@@ -450,8 +523,5 @@ int main(int argc, char **argv) {
 		}
 	}
 	#endif
-	ROS_INFO("TEST ended");
-	
-	return 0;
 }