beeps 0.1.32 → 0.1.33

data/src/sound.cpp

@@ -1,11 +1,15 @@
-#include "beeps/sound.h"
+#include "sound.h"
 
 
 #include <limits.h>
+#include <memory>
+#include <algorithm>
 #include "Stk.h"
-#include "beeps/processor.h"
+#include "beeps/beeps.h"
 #include "beeps/exception.h"
+#include "beeps/generator.h"
 #include "openal.h"
+#include "processor.h"
 #include "signals.h"
 
 
@@ -20,55 +24,229 @@ namespace Beeps
 {
 
 
-	static ALuint get_buffer_id (const Sound& sound);
+	struct SoundBuffer
+	{
+
+		SoundBuffer (bool create = false)
+		{
+			if (create) self->create();
+		}
+
+		SoundBuffer (const Signals& signals)
+		{
+			self->create();
+			write(signals);
+		}
+
+		SoundBuffer (ALint id)
+		{
+			self->id = id;
+		}
+
+		void clear ()
+		{
+			self->clear();
+		}
+
+		uint write (const Signals& signals)
+		{
+			assert(signals);
+
+			if (!*this)
+				invalid_state_error(__FILE__, __LINE__);
+
+			double sample_rate = signals.sample_rate();
+			uint nchannels     = signals.nchannels();
+			uint nsamples      = signals.nsamples();
+			assert(sample_rate > 0 && nchannels > 0 && nsamples > 0);
+
+			const Frames* frames = Signals_get_frames(&signals);
+			assert(frames);
+
+			std::vector<short> buffer;
+			buffer.reserve(nsamples * nchannels);
+			for (uint sample = 0; sample < nsamples; ++sample)
+				for (uint channel = 0; channel < nchannels; ++channel)
+					buffer.push_back((*frames)(sample, channel) * SHRT_MAX);
+
+			alBufferData(
+				self->id,
+				nchannels == 2 ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16,
+				&buffer[0],
+				sizeof(short) * nsamples * nchannels,
+				sample_rate);
+			OpenAL_check_error(__FILE__, __LINE__);
+
+			return nsamples;
+		}
+
+		operator bool () const
+		{
+			return self->is_valid();
+		}
+
+		bool operator ! () const
+		{
+			return !operator bool();
+		}
+
+		struct Data
+		{
+
+			ALint id   = -1;
+
+			bool owner = false;
+
+			~Data ()
+			{
+				clear();
+			}
+
+			void create ()
+			{
+				clear();
+
+				ALuint id_ = 0;
+				alGenBuffers(1, &id_);
+				OpenAL_check_error(__FILE__, __LINE__);
+
+				id    = id_;
+				owner = true;
+			}
+
+			void clear ()
+			{
+				if (owner && id >= 0)
+				{
+					ALuint id_ = id;
+					alDeleteBuffers(1, &id_);
+					OpenAL_check_error(__FILE__, __LINE__);
+				}
+
+				id    = -1;
+				owner = false;
+			}
+
+			bool is_valid () const
+			{
+				return id >= 0;
+			}
+
+		};// Data
+
+		Xot::PSharedImpl<Data> self;
+
+	};// SoundBuffer
 
 
 	struct SoundSource
 	{
 
-		typedef SoundSource This;
+		void create ()
+		{
+			ALuint id_ = 0;
+			alGenSources(1, &id_);
+			if (OpenAL_no_error()) self->id = id_;
+		}
+
+		void clear ()
+		{
+			stop();
+			self->clear();
+		}
 
-		typedef std::shared_ptr<This> Ptr;
+		SoundSource reuse ()
+		{
+			stop();
+			set_gain(1);
+			set_loop(false);
 
-		ALint id;
+			SoundSource source;
+			source.self.swap(self);
+			return source;
+		}
 
-		static Ptr create ()
+		void attach (const SoundBuffer& buffer)
 		{
-			ALuint id_;
-			alGenSources(1, &id_);
-			if (!OpenAL_no_error()) return Ptr();
+			assert(buffer);
 
-			return Ptr(new This(id_));
+			if (!*this)
+				invalid_state_error(__FILE__, __LINE__);
+
+			alSourcei(self->id, AL_BUFFER, buffer.self->id);
+			OpenAL_check_error(__FILE__, __LINE__);
 		}
 
-		~SoundSource ()
+		void queue (const SoundBuffer& buffer)
 		{
-			if (!*this) return;
+			assert(buffer);
 
-			ALuint id_ = id;
-			alDeleteSources(1, &id_);
+			ALuint id = buffer.self->id;
+			alSourceQueueBuffers(self->id, 1, &id);
 			OpenAL_check_error(__FILE__, __LINE__);
+
+			LOG("queue: %d", buffer.self->id);
 		}
 
-		void play (const Sound& sound)
+		bool unqueue (SoundBuffer* buffer = NULL)
 		{
-			assert(sound);
+			ALint count = 0;
+			alGetSourcei(self->id, AL_BUFFERS_PROCESSED, &count);
+			OpenAL_check_error(__FILE__, __LINE__);
+
+			if (count <= 0) return false;
+
+			ALuint id = 0;
+			alSourceUnqueueBuffers(self->id, 1, &id);
+			OpenAL_check_error(__FILE__, __LINE__);
+
+			if (buffer) *buffer = SoundBuffer((ALint) id);
+			return true;
+		}
 
+		void play ()
+		{
 			if (!*this)
 				invalid_state_error(__FILE__, __LINE__);
 
-			alSourcei(id, AL_BUFFER, get_buffer_id(sound));
-			alSourcePlay(id);
+			alSourcePlay(self->id);
+			OpenAL_check_error(__FILE__, __LINE__);
+		}
+
+		void pause ()
+		{
+			if (!*this) return;
+
+			alSourcePause(self->id);
+			OpenAL_check_error(__FILE__, __LINE__);
+		}
+
+		void rewind ()
+		{
+			if (!*this) return;
+
+			alSourceRewind(self->id);
 			OpenAL_check_error(__FILE__, __LINE__);
 		}
 
 		void stop ()
 		{
-			if (!*this)
-				invalid_state_error(__FILE__, __LINE__);
+			if (!*this) return;
+
+			alSourceStop(self->id);
+			OpenAL_check_error(__FILE__, __LINE__);
 
-			alSourceStop(id);
+			ALint type = 0;
+			alGetSourcei(self->id, AL_SOURCE_TYPE, &type);
 			OpenAL_check_error(__FILE__, __LINE__);
+
+			if (type == AL_STREAMING)
+				while (unqueue());
+			else if (type == AL_STATIC)
+			{
+				alSourcei(self->id, AL_BUFFER, 0);
+				OpenAL_check_error(__FILE__, __LINE__);
+			}
 		}
 
 		bool is_playing () const
@@ -76,15 +254,78 @@ namespace Beeps
 			if (!*this) return false;
 
 			ALint state = 0;
-			alGetSourcei(id, AL_SOURCE_STATE, &state);
+			alGetSourcei(self->id, AL_SOURCE_STATE, &state);
 			OpenAL_check_error(__FILE__, __LINE__);
 
 			return state == AL_PLAYING;
 		}
 
+		bool is_paused () const
+		{
+			if (!*this) return false;
+
+			ALint state = 0;
+			alGetSourcei(self->id, AL_SOURCE_STATE, &state);
+			OpenAL_check_error(__FILE__, __LINE__);
+
+			return state == AL_PAUSED;
+		}
+
+		bool is_stopped () const
+		{
+			if (!*this) return true;
+
+			ALint state = 0;
+			alGetSourcei(self->id, AL_SOURCE_STATE, &state);
+			OpenAL_check_error(__FILE__, __LINE__);
+
+			return state == AL_STOPPED;
+		}
+
+		void set_gain (float gain)
+		{
+			if (gain < 0)
+				argument_error(__FILE__, __LINE__);
+
+			if (!*this) return;
+
+			alSourcef(self->id, AL_GAIN, gain);
+			OpenAL_check_error(__FILE__, __LINE__);
+		}
+
+		float gain () const
+		{
+			float gain = 1;
+			if (!*this) return gain;
+
+			alGetSourcef(self->id, AL_GAIN, &gain);
+			OpenAL_check_error(__FILE__, __LINE__);
+
+			return gain;
+		}
+
+		void set_loop (bool loop)
+		{
+			if (!*this) return;
+
+			alSourcei(self->id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
+			OpenAL_check_error(__FILE__, __LINE__);
+		}
+
+		bool loop () const
+		{
+			if (!*this) return false;
+
+			ALint loop = AL_FALSE;
+			alGetSourcei(self->id, AL_LOOPING, &loop);
+			OpenAL_check_error(__FILE__, __LINE__);
+
+			return loop != AL_FALSE;
+		}
+
 		operator bool () const
 		{
-			return id >= 0;
+			return self->id >= 0;
 		}
 
 		bool operator ! () const
@@ -92,181 +333,562 @@ namespace Beeps
 			return !operator bool();
 		}
 
-		private:
+		struct Data
+		{
+
+			ALint id = -1;
 
-			SoundSource (ALint id = -1)
-			:	id(id)
+			~Data ()
 			{
+				clear();
 			}
 
+			void clear ()
+			{
+				if (id < 0) return;
+
+				ALuint id_ = id;
+				alDeleteSources(1, &id_);
+				OpenAL_check_error(__FILE__, __LINE__);
+
+				id = -1;
+			}
+
+		};// Data
+
+		Xot::PSharedImpl<Data> self;
+
 	};// SoundSource
 
 
-	typedef std::vector<SoundSource::Ptr> SoundSourceList;
+	struct SoundPlayer::Data
+	{
+
+		SoundSource source;
+
+		std::vector<SoundBuffer> buffers;
+
+		Processor::Ref processor;
+
+		std::unique_ptr<ProcessorContext> processor_context;
+
+		void clear ()
+		{
+			source.clear();
+
+			for (auto& buffer : buffers) buffer.clear();
+			buffers.clear();
+		}
+
+		void attach_signals (const Signals& signals)
+		{
+			assert(signals);
+
+			SoundBuffer buffer(signals);
+			source.attach(buffer);
+			buffers.emplace_back(buffer);
+		}
+
+		void attach_stream (
+			Processor* processor, uint nchannels, double sample_rate)
+		{
+			assert(processor && *processor && nchannels > 0 && sample_rate > 0);
+
+			this->processor = processor;
+			processor_context.reset(
+				new ProcessorContext(sample_rate / 10, nchannels, sample_rate));
+
+			for (int i = 0; i < 2; ++i)
+			{
+				SoundBuffer buffer(true);
+				if (!process_stream(&buffer)) break;
+
+				source.queue(buffer);
+				buffers.emplace_back(buffer);
+			}
+		}
+
+		bool process_stream (SoundBuffer* buffer)
+		{
+			assert(buffer && processor && processor_context);
+
+			Signals signals = processor_context->process_signals(processor);
+			if (!signals) return false;
+
+			if (processor_context->is_finished())
+				processor_context.reset();
+
+			return buffer->write(signals) > 0;
+		}
+
+		void process_and_queue_stream_buffers ()
+		{
+			SoundBuffer buffer;
+			while (is_streaming())
+			{
+				if (!source.unqueue(&buffer))
+					return;
+
+				if (!process_stream(&buffer))
+					return;
+
+				source.queue(buffer);
+				if (source.is_stopped()) source.play();
+			}
+		}
+
+		bool is_streaming () const
+		{
+			return processor && processor_context && *processor_context;
+		}
+
+	};// SoundPlayer::Data
+
+
+	static SoundPlayer
+	create_player ()
+	{
+		SoundPlayer player;
+		player.self->source.create();
+		return player;
+	}
+
+	static SoundPlayer
+	reuse_player (SoundPlayer* player)
+	{
+		SoundPlayer newplayer;
+		newplayer.self->source = player->self->source.reuse();
+		player->self->clear();
+		return newplayer;
+	}
 
 
 	namespace global
 	{
 
-		static SoundSourceList sources;
+		static std::vector<SoundPlayer> players;
 
 	}// global
 
 
-	void
-	Sound_cleanup_sources ()
+	static void
+	remove_inactive_players ()
 	{
-		global::sources.clear();
+		auto it = std::remove_if(
+			global::players.begin(), global::players.end(),
+			[](auto& player) {return !player || player.is_stopped();});
+
+		for (auto jt = it; jt != global::players.end(); ++jt)
+			jt->self->clear();
+
+		global::players.erase(it, global::players.end());
 	}
 
-	static SoundSource*
-	get_next_source ()
+	static SoundPlayer
+	get_next_player ()
 	{
-		SoundSource::Ptr source;
+		SoundPlayer player = create_player();
+
+		if (player)
+			LOG("new player");
 
-		auto end = global::sources.end();
-		for (auto it = global::sources.begin(); it != end; ++it)
+		if (!player)
 		{
-			const SoundSource::Ptr& p = *it;
-			if (p && *p && !p->is_playing())
+			for (auto& p : global::players)
 			{
-				source = p;
-				global::sources.erase(it);
-				LOG("reuse source");
-				break;
+				if (p && p.is_stopped())
+				{
+					player = reuse_player(&p);
+					LOG("reuse stopped player");
+					break;
+				}
 			}
 		}
 
-		if (!source)
+		if (!player && !global::players.empty())
 		{
-			source = SoundSource::create();
-			LOG("new source");
+			player = reuse_player(&global::players.front());
+			LOG("reuse oldest player");
 		}
 
-		if (!source)
+		remove_inactive_players();
+
+		if (player)
+			global::players.emplace_back(player);
+
+		return player;
+	}
+
+	void
+	SoundPlayer_process_streams ()
+	{
+		for (auto& player : global::players)
 		{
-			source = *global::sources.begin();
-			if (source) source->stop();
-			global::sources.erase(global::sources.begin());
-			LOG("stop and reuse oldest source");
+			if (player.self->is_streaming())
+				player.self->process_and_queue_stream_buffers();
 		}
+	}
+
+	void
+	SoundPlayer_clear_all ()
+	{
+		for (auto& player : global::players)
+			player.self->clear();
+
+		global::players.clear();
+	}
 
-		if (!source)
-			return NULL;
+	void
+	stop_all_sound_players ()
+	{
+		for (auto& player : global::players)
+			player.stop();
+	}
+
+
+	SoundPlayer::SoundPlayer ()
+	{
+	}
+
+	SoundPlayer::~SoundPlayer ()
+	{
+	}
+
+	void
+	SoundPlayer::play ()
+	{
+		self->source.play();
+	}
 
-		global::sources.push_back(source);
-		return source.get();
+	void
+	SoundPlayer::pause ()
+	{
+		self->source.pause();
 	}
 
+	void
+	SoundPlayer::rewind ()
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
 
-	struct Sound::Data
+	void
+	SoundPlayer::stop ()
 	{
+		self->source.stop();
+	}
 
-		ALint id;
+	bool
+	SoundPlayer::is_playing () const
+	{
+		return
+			self->source.is_playing() ||
+			(self->is_streaming() && self->source.is_stopped());
+	}
 
-		Data ()
-		:	id(-1)
+	bool
+	SoundPlayer::is_paused () const
+	{
+		return self->source.is_paused();
+	}
+
+	bool
+	SoundPlayer::is_stopped () const
+	{
+		return self->source.is_stopped() && !self->is_streaming();
+	}
+
+	void
+	SoundPlayer::set_gain (float gain)
+	{
+		self->source.set_gain(gain);
+	}
+
+	float
+	SoundPlayer::gain () const
+	{
+		return self->source.gain();
+	}
+
+	void
+	SoundPlayer::set_loop (bool loop)
+	{
+		self->source.set_loop(loop);
+	}
+
+	bool
+	SoundPlayer::loop () const
+	{
+		return self->source.loop();
+	}
+
+	SoundPlayer::operator bool () const
+	{
+		return self->source;
+	}
+
+	bool
+	SoundPlayer::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+	struct Sound::Data {
+
+		float gain = 1;
+
+		bool loop  = false;
+
+		virtual ~Data ()
 		{
 		}
 
-		~Data ()
+		virtual void attach_to (SoundPlayer* player)
 		{
-			clear();
+			not_implemented_error(__FILE__, __LINE__);
 		}
 
-		void create ()
+		virtual void save (const char* path) const
 		{
-			if (is_valid()) return;
-
-			ALuint id_ = 0;
-			alGenBuffers(1, &id_);
-			OpenAL_check_error(__FILE__, __LINE__);
+			not_implemented_error(__FILE__, __LINE__);
+		}
 
-			id = id_;
+		virtual double sample_rate () const
+		{
+			return 0;
 		}
 
-		void clear ()
+		virtual uint nchannels () const
 		{
-			if (id >= 0)
-			{
-				ALuint id_ = id;
-				alDeleteBuffers(1, &id_);
-				OpenAL_check_error(__FILE__, __LINE__);
-			}
+			return 0;
+		}
 
-			id = -1;
+		virtual float seconds () const
+		{
+			return 0;
 		}
 
-		bool is_valid () const
+		virtual bool is_valid () const
 		{
-			return id >= 0;
+			return false;
 		}
 
 	};// Sound::Data
 
 
-	ALuint
-	get_buffer_id (const Sound& sound)
+	struct SoundData : public Sound::Data
 	{
-		return sound.self->id;
-	}
 
+		typedef Sound::Data Super;
 
-	Sound::Sound ()
+		Signals signals;
+
+		SoundData (
+			Processor* processor, float seconds, uint nchannels, double sample_rate)
+		{
+			assert(
+				processor && *processor &&
+				seconds > 0 && nchannels > 0 && sample_rate > 0);
+
+			ProcessorContext context(seconds * sample_rate, nchannels, sample_rate);
+			Signals signals = context.process_signals(processor);
+			if (!signals)
+				beeps_error(__FILE__, __LINE__, "failed to process signals");
+
+			this->signals = signals;
+		}
+
+		void attach_to (SoundPlayer* player) override
+		{
+			assert(player && *player);
+
+			player->self->attach_signals(signals);
+		}
+
+		void save (const char* path) const override
+		{
+			if (!signals)
+				invalid_state_error(__FILE__, __LINE__);
+
+			Signals_save(signals, path);
+		}
+
+		double sample_rate () const override
+		{
+			return signals ? signals.sample_rate() : Super::sample_rate();
+		}
+
+		uint nchannels () const override
+		{
+			return signals ? signals.nchannels() : Super::nchannels();
+		}
+
+		float seconds () const override
+		{
+			return signals ? Signals_get_seconds(signals) : Super::seconds();
+		}
+
+		bool is_valid () const override
+		{
+			return signals;
+		}
+
+	};// SoundData
+
+
+	struct StreamSoundData : public Sound::Data
 	{
-	}
 
-	Sound::Sound (Processor* processor, float seconds)
+		Processor::Ref processor;
+
+		double sample_rate_ = 0;
+
+		uint  nchannels_ = 0;
+
+		StreamSoundData (Processor* processor, uint nchannels, double sample_rate)
+		{
+			assert(processor && *processor && nchannels > 0 && sample_rate > 0);
+
+			this->processor    = processor;
+			this->sample_rate_ = sample_rate;
+			this->nchannels_   = nchannels;
+		}
+
+		void attach_to (SoundPlayer* player) override
+		{
+			assert(player && *player);
+
+			player->self->attach_stream(processor, nchannels_, sample_rate_);
+		}
+
+		double sample_rate () const override
+		{
+			return sample_rate_;
+		}
+
+		uint nchannels () const override
+		{
+			return nchannels_;
+		}
+
+		float seconds () const override
+		{
+			return -1;
+		}
+
+		bool is_valid () const override
+		{
+			return processor && sample_rate_ > 0 && nchannels_ > 0;
+		}
+
+	};// StreamSoundData
+
+
+	Sound
+	load_sound (const char* path)
 	{
-		if (!processor || !*processor || seconds <= 0)
-			return;
+		FileIn* f = new FileIn(path);
+		return Sound(f, f->seconds(), f->nchannels(), f->sample_rate());
+	}
 
-		self->create();
 
-		Signals signals(seconds, 1);
-		processor->process(&signals);
+	Sound::Sound ()
+	{
+	}
 
-		stk::StkFrames* frames = Signals_get_frames(&signals);
-		if (!frames)
-			return;
+	Sound::Sound (
+		Processor* processor, float seconds, uint nchannels, double sample_rate)
+	{
+		Processor::Ref ref = processor;
 
-		ALsizei size = frames->frames();
-		if (size <= 0)
-			return;
+		if (!processor || !*processor)
+			argument_error(__FILE__, __LINE__);
 
-		std::vector<short> buffer;
-		buffer.reserve(size);
-		for (ALsizei i = 0; i < size; ++i)
-			buffer.push_back((*frames)[i] * SHRT_MAX);
+		if (sample_rate <= 0) sample_rate = Beeps::sample_rate();
 
-		alBufferData(
-			self->id, AL_FORMAT_MONO16, &buffer[0], sizeof(short) * size,
-			frames->dataRate());
-		OpenAL_check_error(__FILE__, __LINE__);
+		if (seconds > 0)
+			self.reset(new SoundData(processor, seconds, nchannels, sample_rate));
+		else
+			self.reset(new StreamSoundData(processor, nchannels, sample_rate));
 	}
 
 	Sound::~Sound ()
 	{
 	}
 
-	void
+	SoundPlayer
 	Sound::play ()
 	{
-		if (!*this)
+		SoundPlayer player = get_next_player();
+		if (!player)
 			invalid_state_error(__FILE__, __LINE__);
 
-		SoundSource* source = get_next_source();
-		if (!source || !*source)
-			invalid_state_error(__FILE__, __LINE__);
+		player.set_gain(gain());
+		player.set_loop(loop());
 
-		source->play(*this);
+		self->attach_to(&player);
+		player.play();
 
 #if 0
 		std::string ox = "";
-		for (size_t i = 0; i < global::sources.size(); ++i)
-			ox += global::sources[i]->is_playing() ? 'o' : 'x';
-		LOG("playing with %d sources. (%s)", global::sources.size(), ox.c_str());
+		for (auto& player : global::players)
+			ox += player.is_playing() ? 'o' : 'x';
+		LOG("%d players. (%s)", global::players.size(), ox.c_str());
 #endif
+
+		return player;
+	}
+
+	void
+	Sound::save (const char* path) const
+	{
+		self->save(path);
+	}
+
+	double
+	Sound::sample_rate () const
+	{
+		return self->sample_rate();
+	}
+
+	uint
+	Sound::nchannels () const
+	{
+		return self->nchannels();
+	}
+
+	float
+	Sound::seconds () const
+	{
+		return self->seconds();
+	}
+
+	void
+	Sound::set_gain (float gain)
+	{
+		if (gain < 0)
+			argument_error(__FILE__, __LINE__);
+
+		self->gain = gain;
+	}
+
+	float
+	Sound::gain () const
+	{
+		return self->gain;
+	}
+
+	void
+	Sound::set_loop (bool loop)
+	{
+		self->loop = loop;
+	}
+
+	bool
+	Sound::loop () const
+	{
+		return self->loop;
 	}
 
 	Sound::operator bool () const