beeps 0.3.16 → 0.5.1

data/src/sound.cpp

@@ -5,6 +5,7 @@
 #include <assert.h>
 #include <memory>
 #include <algorithm>
+#include <xot/util.h>
 #include "Stk.h"
 #include "beeps/beeps.h"
 #include "beeps/generator.h"
@@ -57,11 +58,11 @@ namespace Beeps
 			if (!*this)
 				invalid_state_error(__FILE__, __LINE__);
 
-			double sample_rate = signals.sample_rate();
 			uint nchannels     = signals.nchannels();
+			double sample_rate = signals.sample_rate();
 			uint nsamples      = signals.nsamples();
 			uint size          = nsamples * nchannels;
-			assert(sample_rate > 0 && nchannels > 0);
+			assert(nchannels > 0 && sample_rate > 0);
 			if (nsamples <= 0) return 0;
 
 			std::unique_ptr<short[]> buffer(new short[size]);
@@ -91,6 +92,8 @@ namespace Beeps
 			alGetBufferi(self->id, AL_SIZE, &size);
 			alGetBufferi(self->id, AL_BITS, &bits);
 			alGetBufferi(self->id, AL_CHANNELS, &channels);
+			OpenAL_check_error(__FILE__, __LINE__);
+
 			if (bits <= 0 || channels <= 0)
 				return 0;
 
@@ -136,7 +139,7 @@ namespace Beeps
 
 			~Data ()
 			{
-				clear();
+				Xot::call_and_log_errors([&]() {clear();});
 			}
 
 			void clear ()
@@ -168,9 +171,14 @@ namespace Beeps
 	struct SoundSource
 	{
 
-		void create ()
+		bool create ()
 		{
-			self->create();
+			if (!self->create()) return false;
+
+			set_time_scale(self->time_scale);
+			set_gain(self->gain);
+			set_loop(self->loop);
+			return true;
 		}
 
 		void clear ()
@@ -179,18 +187,6 @@ namespace Beeps
 			self->clear();
 		}
 
-		SoundSource reuse ()
-		{
-			stop();
-			set_time_scale(1);
-			set_gain(1);
-			set_loop(false);
-
-			SoundSource source;
-			source.self.swap(self);
-			return source;
-		}
-
 		void attach (const SoundBuffer& buffer)
 		{
 			assert(buffer);
@@ -215,11 +211,7 @@ namespace Beeps
 
 		bool unqueue (SoundBuffer* buffer = NULL)
 		{
-			ALint count = 0;
-			alGetSourcei(self->id, AL_BUFFERS_PROCESSED, &count);
-			OpenAL_check_error(__FILE__, __LINE__);
-
-			if (count <= 0) return false;
+			if (count_processed_buffers() == 0) return false;
 
 			ALuint id = 0;
 			alSourceUnqueueBuffers(self->id, 1, &id);
@@ -234,8 +226,24 @@ namespace Beeps
 			if (!*this)
 				invalid_state_error(__FILE__, __LINE__);
 
+#if defined(OSX) || defined(IOS)
+			// macOS drops the offset set while the source is not playing,
+			// so set it again after the source starts to play
+			uint offset = state() == SoundPlayer::STATE_NONE ? position() : 0;
+#endif
+
 			alSourcePlay(self->id);
 			OpenAL_check_error(__FILE__, __LINE__);
+
+#if defined(OSX) || defined(IOS)
+			if (offset > 0)
+			{
+				pause();
+				set_position(offset);
+				alSourcePlay(self->id);
+				OpenAL_check_error(__FILE__, __LINE__);
+			}
+#endif
 		}
 
 		void pause ()
@@ -276,7 +284,7 @@ namespace Beeps
 
 		SoundPlayer::State state () const
 		{
-			if (!*this) return SoundPlayer::STATE_UNKNOWN;
+			if (!*this) return SoundPlayer::STATE_NONE;
 
 			ALint state = 0;
 			alGetSourcei(self->id, AL_SOURCE_STATE, &state);
@@ -287,7 +295,7 @@ namespace Beeps
 				case AL_PLAYING: return SoundPlayer::PLAYING;
 				case AL_PAUSED:  return SoundPlayer::PAUSED;
 				case AL_STOPPED: return SoundPlayer::STOPPED;
-				default:         return SoundPlayer::STATE_UNKNOWN;
+				default:         return SoundPlayer::STATE_NONE;
 			}
 		}
 
@@ -315,6 +323,7 @@ namespace Beeps
 			if (scale <= 0)
 				argument_error(__FILE__, __LINE__);
 
+			self->time_scale = scale;
 			if (!*this) return;
 
 			alSourcef(self->id, AL_PITCH, scale);
@@ -323,13 +332,7 @@ namespace Beeps
 
 		float time_scale () const
 		{
-			if (!*this) return 1;
-
-			float scale = 1;
-			alGetSourcef(self->id, AL_PITCH, &scale);
-			OpenAL_check_error(__FILE__, __LINE__);
-
-			return scale;
+			return self->time_scale;
 		}
 
 		void set_gain (float gain)
@@ -337,6 +340,7 @@ namespace Beeps
 			if (gain < 0)
 				argument_error(__FILE__, __LINE__);
 
+			self->gain = gain;
 			if (!*this) return;
 
 			alSourcef(self->id, AL_GAIN, gain);
@@ -345,17 +349,12 @@ namespace Beeps
 
 		float gain () const
 		{
-			float gain = 1;
-			if (!*this) return gain;
-
-			alGetSourcef(self->id, AL_GAIN, &gain);
-			OpenAL_check_error(__FILE__, __LINE__);
-
-			return gain;
+			return self->gain;
 		}
 
 		void set_loop (bool loop)
 		{
+			self->loop = loop;
 			if (!*this) return;
 
 			alSourcei(self->id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
@@ -364,13 +363,16 @@ namespace Beeps
 
 		bool loop () const
 		{
-			if (!*this) return false;
+			return self->loop;
+		}
 
-			ALint loop = AL_FALSE;
-			alGetSourcei(self->id, AL_LOOPING, &loop);
+		uint count_processed_buffers () const
+		{
+			ALint count = 0;
+			alGetSourcei(self->id, AL_BUFFERS_PROCESSED, &count);
 			OpenAL_check_error(__FILE__, __LINE__);
 
-			return loop != AL_FALSE;
+			return count > 0 ? (uint) count : 0;
 		}
 
 		operator bool () const
@@ -386,23 +388,31 @@ namespace Beeps
 		struct Data
 		{
 
-			void* context = NULL;
+			void* context    = NULL;
 
-			ALint id      = -1;
+			ALint id         = -1;
+
+			float time_scale = 1;
+
+			float gain       = 1;
+
+			bool loop        = false;
 
 			~Data ()
 			{
-				clear();
+				Xot::call_and_log_errors([&]() {clear();});
 			}
 
-			void create ()
+			bool create ()
 			{
 				ALuint id_ = 0;
 				alGenSources(1, &id_);
-				if (!OpenAL_no_error()) return;
+				if (!OpenAL_no_error())
+					return false;
 
 				context = OpenAL_get_context();
 				id      = id_;
+				return true;
 			}
 
 			void clear ()
@@ -433,50 +443,83 @@ namespace Beeps
 	struct SoundPlayer::Data
 	{
 
-		double sample_rate = 0;
+		uint nchannels      = 0;
 
-		uint position      = 0;
+		double sample_rate  = 0;
 
-		SoundSource source;
+		uint position       = 0;
 
-		std::vector<SoundBuffer> buffers;
+		State pending_state = STATE_NONE;
+
+		Signals signals;
 
 		Processor::Ref processor;
 
 		std::unique_ptr<StreamContext> stream_context;
 
+		SoundSource source;
+
+		std::vector<SoundBuffer> buffers;
+
+		~Data ()
+		{
+			Xot::call_and_log_errors([&]() {clear();});
+		}
+
 		void clear ()
 		{
-			sample_rate = 0;
-			position    = 0;
+			position      = 0;
+			pending_state = STATE_NONE;
 
 			source.clear();
 
 			for (auto& buffer : buffers) buffer.clear();
 			buffers.clear();
+
+			stream_context.reset();
 		}
 
 		void attach_signals (const Signals& signals)
 		{
 			assert(signals);
 
-			sample_rate = signals.sample_rate();
+			this->signals     = signals;
+			this->sample_rate = signals.sample_rate();
+		}
+
+		void attach_stream (Processor* processor, uint nchannels, double sample_rate)
+		{
+			assert(processor && *processor && nchannels > 0 && sample_rate > 0);
+
+			this->processor   = processor;
+			this->nchannels   = nchannels;
+			this->sample_rate = sample_rate;
+		}
+
+		void load_signals ()
+		{
+			assert(signals);
 
 			SoundBuffer buffer(signals);
 			source.attach(buffer);
 			buffers.emplace_back(buffer);
+
+			source.set_position(position);
+			position = 0;
 		}
 
-		void attach_stream (
-			Processor* processor, uint nchannels, double sample_rate)
+		bool load_stream ()
 		{
 			assert(processor && *processor && nchannels > 0 && sample_rate > 0);
 
-			this->sample_rate = sample_rate;
-			this->processor   = processor;
 			stream_context.reset(
 				new StreamContext(sample_rate / 10, nchannels, sample_rate));
 
+			if (processor->seekable())
+				stream_context->seek(position);
+			else
+				position = 0;
+
 			for (int i = 0; i < 2; ++i)
 			{
 				SoundBuffer buffer(true);
@@ -489,6 +532,7 @@ namespace Beeps
 				source.queue(buffer);
 				buffers.emplace_back(buffer);
 			}
+			return !buffers.empty();
 		}
 
 		bool process_stream (SoundBuffer* buffer)
@@ -507,12 +551,12 @@ namespace Beeps
 
 		void process_and_queue_stream_buffers ()
 		{
-			SoundBuffer buffer;
-			while (is_streaming())
+			// a stopped source counts even the buffers queued after it stopped
+			// as processed, so read the count only once before queueing
+			for (uint n = source.count_processed_buffers(); n > 0 && is_streaming(); --n)
 			{
-				if (!source.unqueue(&buffer))
-					return;
-
+				SoundBuffer buffer;
+				source.unqueue(&buffer);
 				position += buffer.nsamples();
 
 				if (!process_stream(&buffer))
@@ -522,11 +566,17 @@ namespace Beeps
 				}
 
 				source.queue(buffer);
-				if (source.state() == STOPPED)
-				{
-					expand_buffer();
-					source.play();
-				}
+			}
+
+			if (source.state() == STOPPED)
+			{
+				expand_buffer();
+#if defined(OSX) || defined(IOS)
+				// play it on the next play_pending_players()
+				pending_state = PLAYING;
+#else
+				source.play();
+#endif
 			}
 		}
 
@@ -542,85 +592,113 @@ namespace Beeps
 			}
 		}
 
-		bool is_streaming () const
+		bool is_loaded () const
 		{
-			return processor && stream_context;
+			return source;
 		}
 
-	};// SoundPlayer::Data
+		bool is_active () const
+		{
+			if (!is_loaded())
+				return false;
 
+			if (is_pending())
+				return pending_state == PLAYING;
 
-	static SoundPlayer
-	create_player ()
-	{
-		SoundPlayer player;
-		player.self->source.create();
-		return player;
-	}
+			// a source can stay initial for a moment after it starts to play,
+			// so count the initial ones too
+			return source.state() != STOPPED;
+		}
 
-	static SoundPlayer
-	reuse_player (SoundPlayer* player)
-	{
-		SoundPlayer newplayer;
-		newplayer.self->source = player->self->source.reuse();
-		player->self->clear();
-		return newplayer;
-	}
+		bool is_pending () const
+		{
+			return pending_state != STATE_NONE;
+		}
+
+		bool is_streaming () const
+		{
+			return processor && stream_context;
+		}
+
+	};// SoundPlayer::Data
 
 
 	namespace global
 	{
 
-		static std::vector<SoundPlayer> players;
+		static std::vector<SoundPlayer> players, pending_players;
 
 	}// global
 
 
+	static bool
+	stop_oldest_player ()
+	{
+		for (auto& player : global::players)
+		{
+			if (
+				!player.self->is_loaded() ||
+				player.self->is_pending() ||
+				player.self->is_streaming())
+			{
+				continue;
+			}
+
+			if (player.self->source.state() == SoundPlayer::PLAYING)
+			{
+				player.stop();
+				LOG("stop oldest player");
+				return true;
+			}
+		}
+		return false;
+	}
+
 	static void
-	remove_inactive_players ()
+	stop_players_over_limit ()
 	{
-		auto it = std::remove_if(
+		uint max = OpenAL_get_max_playing_sources();
+		if (max == 0) return;
+
+		// a source stopped right after it starts can play again on macOS,
+		// so count them on each call
+		uint count = (uint) std::count_if(
 			global::players.begin(), global::players.end(),
-			[](auto& player)
-			{
-				return !player || player.state() == SoundPlayer::STOPPED;
-			});
+			[](auto& p) {return p.self->is_active();});
 
-		global::players.erase(it, global::players.end());
+		for (uint i = max; i < count; ++i)
+		{
+			if (!stop_oldest_player())
+				break;
+		}
 	}
 
-	static SoundPlayer
-	get_next_player ()
+	static void
+	play_pending_players ()
 	{
-		SoundPlayer player = create_player();
-		if (player)
-			LOG("new player");
+		stop_players_over_limit();
 
-		if (!player)
+		auto& pendings = global::pending_players;
+		while (!pendings.empty())
 		{
-			for (auto& p : global::players)
+			SoundPlayer& player = pendings.front();
+			if (player.self->pending_state == SoundPlayer::PLAYING)
 			{
-				if (p && p.state() == SoundPlayer::STOPPED)
+				// try again on the next call
+				try
 				{
-					player = reuse_player(&p);
-					LOG("reuse stopped player");
-					break;
+					player.self->source.play();
+				}
+				catch (const OpenALError&)
+				{
+					return;
 				}
+
+				player.self->pending_state = SoundPlayer::STATE_NONE;
 			}
-		}
 
-		if (!player && !global::players.empty())
-		{
-			player = reuse_player(&global::players.front());
-			LOG("reuse oldest player");
+			pendings.erase(pendings.begin());
 		}
-
-		remove_inactive_players();
-
-		if (player)
-			global::players.emplace_back(player);
-
-		return player;
 	}
 
 	void
@@ -628,9 +706,22 @@ namespace Beeps
 	{
 		for (auto& player : global::players)
 		{
-			if (player.self->is_streaming())
-				player.self->process_and_queue_stream_buffers();
+			SoundPlayer::Data* self = player.self.get();
+			if (!self->is_streaming() || self->is_pending())
+				continue;
+
+			bool processed = Xot::call_and_log_errors<OpenALError>([&]()
+			{
+				self->process_and_queue_stream_buffers();
+			});
+
+			if (!processed)
+				self->clear();
+			else if (self->is_pending())
+				global::pending_players.emplace_back(player);
 		}
+
+		play_pending_players();
 	}
 
 	void
@@ -640,6 +731,7 @@ namespace Beeps
 			player.self->clear();
 
 		global::players.clear();
+		global::pending_players.clear();
 	}
 
 	void
@@ -658,15 +750,109 @@ namespace Beeps
 	{
 	}
 
+	static void
+	remove_stopped_players ()
+	{
+		for (auto& player : global::players)
+		{
+			if (player.self->is_loaded() && player.state() == SoundPlayer::STOPPED)
+				player.self->clear();
+		}
+
+		auto it = std::remove_if(
+			global::players.begin(), global::players.end(),
+			[](auto& player) {return !player.self->is_loaded();});
+
+		global::players.erase(it, global::players.end());
+	}
+
+	static void
+	create_source (SoundSource* source)
+	{
+		remove_stopped_players();
+		if (source->create())
+			return;
+
+		if (!stop_oldest_player())
+			openal_error(__FILE__, __LINE__, "too many sound players");
+
+		remove_stopped_players();
+		if (!source->create())
+			openal_error(__FILE__, __LINE__, "failed to create a source");
+	}
+
+	static bool
+	attach_source (SoundPlayer* player)
+	{
+		SoundPlayer::Data* self = player->self.get();
+
+		bool loaded = false;
+		try
+		{
+			Xot::call_and_log_errors<OpenALError>([&]()
+			{
+				create_source(&self->source);
+				if (self->signals)
+					self->load_signals();
+				else if (!self->load_stream())
+					return;
+
+				loaded = true;
+			});
+		}
+		catch (...)
+		{
+			self->clear();
+			throw;
+		}
+
+		if (!loaded)
+		{
+			self->clear();
+			return false;
+		}
+
+		global::players.emplace_back(*player);
+		return true;
+	}
+
 	void
 	SoundPlayer::play ()
 	{
-		self->source.play();
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		if (self->is_loaded() && state() == STOPPED)
+			self->clear();
+
+		if (!self->is_loaded() && !attach_source(this))
+			return;
+
+#if defined(OSX) || defined(IOS)
+		// on macOS, a source fails to play when too many sources are playing,
+		// and a stopped source still counts as playing for a moment,
+		// so stop the oldest one and let the new one wait in the order
+		if (self->pending_state == PLAYING) return;
+
+		self->pending_state = PLAYING;
+		global::pending_players.emplace_back(*this);
+
+		play_pending_players();
+#else
+		if (!Xot::call_and_log_errors<OpenALError>([&]() {self->source.play();}))
+			self->clear();
+#endif
 	}
 
 	void
 	SoundPlayer::pause ()
 	{
+		if (self->pending_state == PLAYING)
+		{
+			self->pending_state = PAUSED;
+			return;
+		}
+
 		self->source.pause();
 	}
 
@@ -682,13 +868,18 @@ namespace Beeps
 	void
 	SoundPlayer::stop ()
 	{
-		self->source.stop();
-		self->position = 0;
+		self->clear();
 	}
 
 	SoundPlayer::State
 	SoundPlayer::state () const
 	{
+		if (self->is_pending())
+			return self->pending_state;
+
+		if (!self->is_loaded())
+			return *this ? STOPPED : STATE_NONE;
+
 		State s = self->source.state();
 		if (s == STOPPED && self->is_streaming())
 			return PLAYING;
@@ -698,7 +889,15 @@ namespace Beeps
 	void
 	SoundPlayer::set_position (uint position)
 	{
-		if (self->is_streaming())
+		if (self->signals && position >= self->signals.nsamples())
+			argument_error(__FILE__, __LINE__);
+
+		if (self->is_loaded() && state() == STOPPED)
+			self->clear();
+
+		if (!self->is_loaded())
+			self->position = position;
+		else if (self->is_streaming())
 		{
 			if (!self->processor || !self->processor->seekable())
 				invalid_state_error(__FILE__, __LINE__, "processor is not seekable");
@@ -782,7 +981,7 @@ namespace Beeps
 
 	SoundPlayer::operator bool () const
 	{
-		return self->source;
+		return self->signals || self->processor;
 	}
 
 	bool
@@ -802,14 +1001,19 @@ namespace Beeps
 		{
 		}
 
+		virtual Data* dup () const
+		{
+			return new Data(*this);
+		}
+
 		virtual void attach_to (SoundPlayer* player)
 		{
 			not_implemented_error(__FILE__, __LINE__);
 		}
 
-		virtual double sample_rate () const
+		virtual void save (const char* path) const
 		{
-			return 0;
+			not_implemented_error(__FILE__, __LINE__);
 		}
 
 		virtual uint nchannels () const
@@ -817,14 +1021,14 @@ namespace Beeps
 			return 0;
 		}
 
-		virtual float seconds () const
+		virtual double sample_rate () const
 		{
 			return 0;
 		}
 
-		virtual void save (const char* path) const
+		virtual float seconds () const
 		{
-			not_implemented_error(__FILE__, __LINE__);
+			return 0;
 		}
 
 		virtual bool is_valid () const
@@ -848,16 +1052,24 @@ namespace Beeps
 		{
 		}
 
+		Data* dup () const override
+		{
+			return new SoundData(*this);
+		}
+
 		void attach_to (SoundPlayer* player) override
 		{
-			assert(player && *player);
+			assert(player && !*player);
 
 			player->self->attach_signals(signals);
 		}
 
-		double sample_rate () const override
+		void save (const char* path) const override
 		{
-			return signals ? signals.sample_rate() : Super::sample_rate();
+			if (!signals)
+				invalid_state_error(__FILE__, __LINE__);
+
+			Signals_save(signals, path);
 		}
 
 		uint nchannels () const override
@@ -865,17 +1077,14 @@ namespace Beeps
 			return signals ? signals.nchannels() : Super::nchannels();
 		}
 
-		float seconds () const override
+		double sample_rate () const override
 		{
-			return signals ? Signals_get_seconds(signals) : Super::seconds();
+			return signals ? signals.sample_rate() : Super::sample_rate();
 		}
 
-		void save (const char* path) const override
+		float seconds () const override
 		{
-			if (!signals)
-				invalid_state_error(__FILE__, __LINE__);
-
-			Signals_save(signals, path);
+			return signals ? Signals_get_seconds(signals) : Super::seconds();
 		}
 
 		bool is_valid () const override
@@ -891,34 +1100,40 @@ namespace Beeps
 
 		Processor::Ref processor;
 
-		double sample_rate_ = 0;
+		uint nchannels_     = 0;
 
-		uint  nchannels_ = 0;
+		double sample_rate_ = 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;
+			this->sample_rate_ = sample_rate;
+		}
+
+		Data* dup () const override
+		{
+			invalid_state_error(
+				__FILE__, __LINE__, "can not duplicate a streaming sound");
 		}
 
 		void attach_to (SoundPlayer* player) override
 		{
-			assert(player && *player);
+			assert(player && !*player);
 
 			player->self->attach_stream(processor, nchannels_, sample_rate_);
 		}
 
-		double sample_rate () const override
+		uint nchannels () const override
 		{
-			return sample_rate_;
+			return nchannels_;
 		}
 
-		uint nchannels () const override
+		double sample_rate () const override
 		{
-			return nchannels_;
+			return sample_rate_;
 		}
 
 		float seconds () const override
@@ -928,7 +1143,7 @@ namespace Beeps
 
 		bool is_valid () const override
 		{
-			return processor && sample_rate_ > 0 && nchannels_ > 0;
+			return processor && nchannels_ > 0 && sample_rate_ > 0;
 		}
 
 	};// StreamSoundData
@@ -969,21 +1184,28 @@ namespace Beeps
 			self.reset(new StreamSoundData(processor, nchannels, sample_rate));
 	}
 
+	Sound::Sound (Data* data)
+	:	self(data)
+	{
+	}
+
 	Sound::~Sound ()
 	{
 	}
 
+	Sound
+	Sound::dup () const
+	{
+		return Sound(self->dup());
+	}
+
 	SoundPlayer
 	Sound::play ()
 	{
-		SoundPlayer player = get_next_player();
-		if (!player)
-			invalid_state_error(__FILE__, __LINE__);
-
+		SoundPlayer player;
+		self->attach_to(&player);
 		player.set_gain(gain());
 		player.set_loop(loop());
-
-		self->attach_to(&player);
 		player.play();
 
 #if 0
@@ -996,18 +1218,18 @@ namespace Beeps
 		return player;
 	}
 
-	double
-	Sound::sample_rate () const
-	{
-		return self->sample_rate();
-	}
-
 	uint
 	Sound::nchannels () const
 	{
 		return self->nchannels();
 	}
 
+	double
+	Sound::sample_rate () const
+	{
+		return self->sample_rate();
+	}
+
 	float
 	Sound::seconds () const
 	{