[DEV] continue rework

audio/ess/LoadedFile.h

@@ -20,6 +20,12 @@
 namespace audio {
 	namespace ess {
 		class LoadedFile {
+			private:
+				int32_t m_uid;
+			public:
+				int32_t getUId() {
+					return m_uid;
+				}
 			private:
 				#if defined(__TARGET_OS__Android)
 					pthread_t m_thread;

audio/ess/effects.cpp

@@ -13,8 +13,132 @@
 #include <audio/ess/effects.h>
 #include <audio/ess/decWav.h>
 #include <math.h>
-#include <audio/ess/LoadedFile.h>
+
-#include <mutex>
+
+
+audio::ess::Effect::Effect(const std::shared_ptr<audio::river::Manager>& _manager) :
+  m_manager(_manager),
+  m_position(0) {
+	std::unique_lock<std::mutex> lock(m_mutex);
+	//Set stereo output:
+	std::vector<audio::channel> channelMap;
+	channelMap.push_back(audio::channel_frontLeft);
+	channelMap.push_back(audio::channel_frontRight);
+	m_interface = m_manager->createOutput(48000,
+	                                      channelMap,
+	                                      audio::format_int16,
+	                                      "speaker");
+	if (m_interface == nullptr) {
+		EWOLSA_ERROR("can not allocate output interface ... ");
+		return;
+	}
+	m_interface->setName("audio::ess::Effect");
+	m_interface->addVolumeGroup("EFFECT");
+	// set callback mode ...
+	m_interface->setOutputCallback(std::bind(&audio::ess::Effect::onDataNeeded,
+	                                         this,
+	                                         std::placeholders::_1,
+	                                         std::placeholders::_2,
+	                                         std::placeholders::_3,
+	                                         std::placeholders::_4,
+	                                         std::placeholders::_5,
+	                                         std::placeholders::_6));
+}
+
+audio::ess::Effect::~Effect() {
+	if (m_interface != nullptr) {
+		m_interface.stop();
+	}
+	m_interface.reset();
+	m_manager.reset();
+	m_list.clear();
+	m_playing.clear();
+}
+
+
+void audio::ess::Effect::onDataNeeded(void* _data,
+                                     const audio::Time& _playTime,
+                                     const size_t& _nbChunk,
+                                     enum audio::format _format,
+                                     uint32_t _sampleRate,
+                                     const std::vector<audio::channel>& _map){
+	if (_format != audio::format_int16) {
+		EWOLSA_ERROR("call wrong type ... (need int16_t)");
+	}
+	std::unique_lock<std::mutex> lck(localMutex);
+	if (m_current != m_next) {
+		EWOLSA_INFO("change track " << (m_curent!=nullptr?-1:m_current->getUId()) << " ==> " << (m_next!=nullptr?-1:m_next->getUId()));
+		m_curent = m_next;
+		m_position = 0;
+	}
+	if (m_curent == nullptr) {
+		// nothing to play ...
+		return;
+	}
+	if (m_current->m_data.size() == 0) {
+		return;
+	}
+	int32_t processTimeMax = std::min(_nbChunk*_map.size(), m_current->m_nbSamples - m_position);
+	processTimeMax = std::max(0, processTimeMax);
+	int16_t * pointer = static_cast<int16_t*>(_data);
+	int16_t * newData = &m_current->m_data[m_posiion];
+	EWOLSA_DEBUG("AUDIO : Play slot... nb sample : " << processTimeMax << " map=" << _map << " _nbChunk=" << _nbChunk);
+	for (int32_t iii=0; iii<processTimeMax; iii++) {
+		*pointer++ = *newData++;
+	}
+	m_position += processTimeMax;
+	// check end of playing ...
+	if (m_current->m_nbSamples <= m_position) {
+		m_position = 0;
+		m_current.reset();
+	}
+}
+
+void audio::ess::Effect::load(const std::string& _file, const std::string& _name) {
+	auto it = m_list.find(_name);
+	if (it != m_list.end()) {
+		return;
+	}
+	std::shared_ptr<audio::ess::LoadedFile> tmp = std::make_shared<audio::ess::LoadedFile>(_file, 2);
+	if (tmp == nullptr) {
+		EWOLSA_ERROR("can not load audio Effect = " << _file);
+		return;
+	}
+	std::unique_lock<std::mutex> lock(m_mutex);
+	m_list.insert(std::pair<std::string,std::shared_ptr<audio::ess::LoadedFile>>(_name,tmp));
+}
+
+void audio::ess::Effect::play(const std::string& _name) {
+	auto it = m_list.find(_name);
+	if (it != m_list.end()) {
+		EWOLSA_ERROR("Can not Play Effect : " << _name);
+		return;
+	}
+	// in all case we stop the current playing Effect ...
+	stop();
+	std::unique_lock<std::mutex> lock(m_mutex);
+	m_next = *it;
+	EWOLSA_INFO("Playing track " << (m_curent!=nullptr?-1:m_current->getUId()) << " request next : " << m_next->getUId());
+}
+
+void audio::ess::Effect::stop() {
+	if (m_curent == nullptr) {
+		EWOLSA_INFO("No current audio is playing");
+	}
+	std::unique_lock<std::mutex> lock(m_mutex);
+	m_curent.reset();
+}
+
+void audio::ess::Effect::clear() {
+	stop();
+	m_current.reset();
+	m_next.reset();
+	m_position = 0;
+	m_list.clear();
+}
+
+
+
 
 static std::mutex localMutex;
 static bool    effectsMute = false;
@@ -177,7 +301,7 @@ static void uptateEffectVolume() {
 void audio::ess::effects::volumeSet(float _newVolume) {
 	effectsVolume = _newVolume;
 	effectsVolume = std::avg(-100.0f, effectsVolume, 20.0f);
-	EWOLSA_INFO("Set music Volume at " << _newVolume << "dB  == > " << effectsVolume << "dB");
+	EWOLSA_INFO("Set Effect Volume at " << _newVolume << "dB  == > " << effectsVolume << "dB");
 	uptateEffectVolume();
 }
 

audio/ess/effects.h

@@ -11,24 +11,37 @@
 #define __EWOLSA_EFFECTS_H__
 
 #include <etk/types.h>
+#include <audio/river/Interface.h>
+#include <audio/river/Manager.h>
+#include <audio/ess/LoadedFile.h>
+#include <mutex>
 
 namespace audio {
 	namespace ess {
-		// note effect is loaded in memory (then don't create long effect) and unload only when requested
+		class Effect {
-		namespace effects {
+			private:
-			void init();
+				mutable std::mutex m_mutex;
-			void unInit();
+				std::shared_ptr<audio::river::Manager> m_manager;
-			// note : support file (Mono, 16bit, 48kHz) : .raw or .wav (no encodage) or .ogg (decoded with tremor lib)
+				std::shared_ptr<audio::river::Interface> m_interface;
-			int32_t add(const std::string& _file);
+			public:
-			void rm(int32_t _effectId);
+				Effect(const std::shared_ptr<audio::river::Manager>& _manager);
-			void play(int32_t _effectId, float _xxx=0, float _yyy=0);
+				~Effect();
-			// in db
+			private:
-			float volumeGet();
+				void onDataNeeded(void* _data,
-			void volumeSet(float _newVolume);
+				                  const audio::Time& _playTime,
-			bool muteGet();
+				                  const size_t& _nbChunk,
-			void muteSet(bool _newMute);
+				                  enum audio::format _format,
-			void getData(int16_t* _bufferInterlace, int32_t _nbSample, int32_t _nbChannels);
+				                  uint32_t _sampleRate,
-			
+				                  const std::vector<audio::channel>& _map);
+				std::vector<std::pair<std::shared_ptr<audio::ess::LoadedFile>, int32_t>> m_playing; //!< current music read
+				std::vector<std::pair<std::string, std::shared_ptr<audio::ess::LoadedFile>>> m_list; //!< list of all effect loaded
+			public:
+				void load(const std::string& _file, const std::string& _name);
+				int32_t getId(const std::string& _name);
+				void play(const std::string& _name, const vec3& pos = vec3(0,0,0));
+				void play(int32_t _id, const vec3& pos = vec3(0,0,0));
+				void stop();
+				void clear();
 		};
 	}
 }

audio/ess/music.cpp

@@ -13,18 +13,6 @@
 #include <audio/ess/debug.h>
 #include <audio/ess/LoadedFile.h>
 #include <math.h>
-#include <mutex>
-
-static std::mutex localMutex;
-
-static bool    musicMute = false;
-static float   musicVolume = 0;
-static int32_t musicVolumeApply = 1<<16;
-static int32_t musicFadingTime = 0;
-static int32_t musicPositionReading = 0;
-static std::vector<audio::ess::LoadedFile*> musicListRead;
-static int32_t musicCurrentRead = -1;
-static int32_t musicNextRead = -1;
 
 audio::ess::Music::Music(const std::shared_ptr<audio::river::Manager>& _manager) :
   m_manager(_manager),
@@ -67,156 +55,83 @@ audio::ess::Music::~Music() {
 }
 
 
-void audio::ess::music::fading(int32_t _timeMs) {
+void audio::ess::Music::onDataNeeded(void* _data,
-	musicFadingTime = _timeMs;
+                                     const audio::Time& _playTime,
-	musicFadingTime = std::avg(-100, musicFadingTime, 20);
+                                     const size_t& _nbChunk,
-	EWOLSA_INFO("Set music fading time at " << _timeMs << "ms  == > " << musicFadingTime << "ms");
+                                     enum audio::format _format,
-}
+                                     uint32_t _sampleRate,
-
+                                     const std::vector<audio::channel>& _map){
-
+	if (_format != audio::format_int16) {
-void audio::ess::music::preLoad(const std::string& _file) {
+		EWOLSA_ERROR("call wrong type ... (need int16_t)");
-	// check if music already existed ...
-	for (size_t iii=0; iii<musicListRead.size(); ++iii) {
-		if (musicListRead[iii] == nullptr) {
-			continue;
-		}
-		if (musicListRead[iii]->getName() == _file) {
-			return;
-		}
 	}
-	audio::ess::LoadedFile* tmp = new audio::ess::LoadedFile(_file, 2);
+	std::unique_lock<std::mutex> lock(m_mutex);
-	if (tmp != nullptr) {
+	if (m_current != m_next) {
-		/*
+		EWOLSA_INFO("change track " << (m_curent!=nullptr?-1:m_current->getUId()) << " ==> " << (m_next!=nullptr?-1:m_next->getUId()));
-		if (tmp->m_data == nullptr) {
+		m_curent = m_next;
-			EWOLSA_ERROR("Music has no data ... : " << _file);
+		m_position = 0;
-			delete(tmp);
-			return;
-		}*/
-		std::unique_lock<std::mutex> lck(localMutex);
-		musicListRead.push_back(tmp);
-	} else {
-		EWOLSA_ERROR("can not preload audio Music");
 	}
-}
+	if (m_curent == nullptr) {
-
-
-bool audio::ess::music::play(const std::string& _file) {
-	preLoad(_file);
-	// in all case we stop the current playing music ...
-	stop();
-	int32_t idMusic = -1;
-	// check if music already existed ...
-	for (size_t iii=0; iii<musicListRead.size(); ++iii) {
-		if (musicListRead[iii] == nullptr) {
-			continue;
-		}
-		if (musicListRead[iii]->getName() == _file) {
-			idMusic = iii;
-			break;
-		}
-	}
-	if (idMusic == -1) {
-		return false;
-	}
-	std::unique_lock<std::mutex> lck(localMutex);
-	musicNextRead = idMusic;
-	EWOLSA_INFO("Playing track " << musicCurrentRead << " request next : " << idMusic);
-	return true;
-}
-
-
-bool audio::ess::music::stop() {
-	if (musicCurrentRead == -1) {
-		EWOLSA_INFO("No current audio is playing");
-		return false;
-	}
-	std::unique_lock<std::mutex> lck(localMutex);
-	musicNextRead = -1;
-	return true;
-}
-
-
-
-float audio::ess::music::volumeGet() {
-	return musicVolume;
-}
-
-
-static void uptateMusicVolume() {
-	if (musicMute == true) {
-		musicVolumeApply = 0;
-	} else {
-		// convert in an fixpoint value
-		// V2 = V1*10^(db/20)
-		double coef = pow(10, (musicVolume/20) );
-		std::unique_lock<std::mutex> lck(localMutex);
-		musicVolumeApply = (int32_t)(coef * (double)(1<<16));
-	}
-}
-
-void audio::ess::music::volumeSet(float _newVolume) {
-	musicVolume = _newVolume;
-	musicVolume = std::avg(-1000.0f, musicVolume, 40.0f);
-	EWOLSA_INFO("Set music Volume at " << _newVolume << "dB  == > " << musicVolume << "dB");
-	uptateMusicVolume();
-}
-
-
-bool audio::ess::music::muteGet() {
-	return musicMute;
-}
-
-
-void audio::ess::music::muteSet(bool _newMute) {
-	musicMute = _newMute;
-	EWOLSA_INFO("Set music Mute at " << _newMute);
-	uptateMusicVolume();
-}
-
-
-void audio::ess::music::getData(int16_t * _bufferInterlace, int32_t _nbSample, int32_t _nbChannels) {
-	EWOLSA_VERBOSE("Music !!! " << musicCurrentRead << " ... " << musicNextRead << " pos: " << musicPositionReading);
-	std::unique_lock<std::mutex> lck(localMutex);
-	if (musicCurrentRead != musicNextRead) {
-		EWOLSA_DEBUG("change track " << musicCurrentRead << " ==> " << musicNextRead);
-		// TODO : create fading ....
-		musicCurrentRead = musicNextRead;
-		musicPositionReading = 0;
-	}
-	if (musicCurrentRead < 0) {
 		// nothing to play ...
 		return;
 	}
-	if (   musicCurrentRead >= musicListRead.size()
+	if (m_current->m_data.size() == 0) {
-	    || musicListRead[musicCurrentRead] == nullptr) {
-		musicCurrentRead = -1;
-		musicPositionReading = 0;
-		EWOLSA_ERROR("request read an unexisting audio track ... : " << musicCurrentRead << "/" << musicListRead.size());
 		return;
 	}
-	if (musicListRead[musicCurrentRead]->m_data.size() == 0) {
+	int32_t processTimeMax = std::min(_nbChunk*_map.size(), m_current->m_nbSamples - m_position);
-		return;
-	}
-	int32_t processTimeMax = std::min(_nbSample*_nbChannels, musicListRead[musicCurrentRead]->m_nbSamples - musicPositionReading);
 	processTimeMax = std::max(0, processTimeMax);
-	int16_t * pointer = _bufferInterlace;
+	int16_t * pointer = static_cast<int16_t*>(_data);
-	int16_t * newData = &musicListRead[musicCurrentRead]->m_data[musicPositionReading];
+	int16_t * newData = &m_current->m_data[m_posiion];
-	EWOLSA_DEBUG("AUDIO : Play slot... nb sample : " << processTimeMax << " nbCannels=" << _nbChannels << " chunkRequest=" << _nbSample);
+	EWOLSA_DEBUG("AUDIO : Play slot... nb sample : " << processTimeMax << " map=" << _map << " _nbChunk=" << _nbChunk);
 	for (int32_t iii=0; iii<processTimeMax; iii++) {
-		/*
+		*pointer++ = *newData++;
-		int32_t tmppp = ((int32_t)*pointer) + ((((int32_t)*newData)*musicVolumeApply)>>16);
-		*pointer = std::avg(-32767, tmppp, 32766);
-		*/
-		*pointer = *newData;
-		//EWOLSA_DEBUG("AUDIO : element : " << *pointer);
-		pointer++;
-		newData++;
 	}
-	musicPositionReading += processTimeMax;
+	m_position += processTimeMax;
 	// check end of playing ...
-	if (musicListRead[musicCurrentRead]->m_nbSamples <= musicPositionReading) {
+	if (m_current->m_nbSamples <= m_position) {
-		musicPositionReading = 0;
+		m_position = 0;
-		musicCurrentRead = -1;
+		m_current.reset();
 	}
-	
+}
+
+void audio::ess::Music::load(const std::string& _file, const std::string& _name) {
+	auto it = m_list.find(_name);
+	if (it != m_list.end()) {
+		return;
+	}
+	std::shared_ptr<audio::ess::LoadedFile> tmp = std::make_shared<audio::ess::LoadedFile>(_file, 2);
+	if (tmp == nullptr) {
+		EWOLSA_ERROR("can not load audio Music = " << _file);
+		return;
+	}
+	std::unique_lock<std::mutex> lock(m_mutex);
+	m_list.insert(std::pair<std::string,std::shared_ptr<audio::ess::LoadedFile>>(_name,tmp));
+}
+
+void audio::ess::Music::play(const std::string& _name) {
+	auto it = m_list.find(_name);
+	if (it != m_list.end()) {
+		EWOLSA_ERROR("Can not Play music : " << _name);
+		return;
+	}
+	// in all case we stop the current playing music ...
+	stop();
+	std::unique_lock<std::mutex> lock(m_mutex);
+	m_next = *it;
+	EWOLSA_INFO("Playing track " << (m_curent!=nullptr?-1:m_current->getUId()) << " request next : " << m_next->getUId());
+}
+
+void audio::ess::Music::stop() {
+	if (m_curent == nullptr) {
+		EWOLSA_INFO("No current audio is playing");
+	}
+	std::unique_lock<std::mutex> lock(m_mutex);
+	m_curent.reset();
+}
+
+void audio::ess::Music::clear() {
+	stop();
+	m_current.reset();
+	m_next.reset();
+	m_position = 0;
+	m_list.clear();
 }

audio/ess/music.h

@@ -13,13 +13,15 @@
 #include <etk/types.h>
 #include <audio/river/Interface.h>
 #include <audio/river/Manager.h>
+#include <audio/ess/LoadedFile.h>
 #include <mutex>
 
+
 namespace audio {
 	namespace ess {
 		class Music {
 			private:
-				std::mutex m_mutex;
+				mutable std::mutex m_mutex;
 				std::shared_ptr<audio::river::Manager> m_manager;
 				std::shared_ptr<audio::river::Interface> m_interface;
 			public:
@@ -34,7 +36,7 @@ namespace audio {
 				                  const std::vector<audio::channel>& _map);
 				std::shared_ptr<audio::ess::LoadedFile> m_current; //!< current music read
 				int32_t m_position; //!< current position of music read
-				std::vector<std::shared_ptr<audio::ess::LoadedFile>> m_list; //!< list of all music loaded
+				std::map<std::string, std::shared_ptr<audio::ess::LoadedFile> > m_list; //!< list of all music loaded
 				std::shared_ptr<audio::ess::LoadedFile> m_next; //!< next music to read
 			public:
 				void load(const std::string& _file, const std::string& _name);