beeps 0.3.11 → 0.3.12

data/src/signals.cpp

@@ -104,37 +104,6 @@ namespace Beeps
 	};// Signals::Data
 
 
-	Signals
-	Signals_create (uint capacity, uint nchannels, double sample_rate)
-	{
-		Signals s;
-		s.self->frames.reset(
-			new Frames(capacity * nchannels, nchannels, sample_rate));
-		return s;
-	}
-
-	Signals
-	Signals_create (
-		const float* const* channels,
-		uint nsamples, uint nchannels, double sample_rate, uint capacity)
-	{
-		if (!channels)
-			argument_error(__FILE__, __LINE__);
-
-		Signals s = Signals_create(
-			capacity > nsamples ? capacity : nsamples, nchannels, sample_rate);
-
-		for (uint channel = 0; channel < nchannels; ++channel)
-		{
-			Sample* p = Signals_at(&s, 0, channel);
-			for (uint i = 0; i < nsamples; ++i, p += nchannels)
-				*p = channels[channel][i];
-		}
-
-		s.self->nsamples = nsamples;
-		return s;
-	}
-
 	uint
 	Signals_tick (Signals* signals, std::function<void(stk::StkFrames*)> fun)
 	{
@@ -160,7 +129,7 @@ namespace Beeps
 		if (!input)
 			argument_error(__FILE__, __LINE__);
 
-		Signals_clear(output, input.nsamples());
+		output->clear(input.nsamples());
 		Signals_set_nsamples(output, output->capacity());
 
 		fun(output->self->frames.get(), *input.self->frames);
@@ -189,29 +158,6 @@ namespace Beeps
 		return end;
 	}
 
-	void
-	Signals_clear (Signals* signals)
-	{
-		if (!signals)
-			argument_error(__FILE__, __LINE__);
-
-		signals->self->nsamples = 0;
-	}
-
-	void
-	Signals_clear (Signals* signals, uint capacity)
-	{
-		if (!signals)
-			argument_error(__FILE__, __LINE__);
-		if (!*signals)
-			argument_error(__FILE__, __LINE__);
-		if (capacity <= 0)
-			argument_error(__FILE__, __LINE__);
-
-		Signals_clear(signals);
-		signals->self->frames->resize(capacity, signals->nchannels());
-	}
-
 	void
 	Signals_fill (Signals* signals, uint nsamples, Sample value, uint offset)
 	{
@@ -256,109 +202,6 @@ namespace Beeps
 		Signals_set_nsamples(signals, new_nsamples);
 	}
 
-	static uint
-	copy_samples (Signals* to, const Signals& from, uint from_offset)
-	{
-		assert(to && *to && from);
-
-		if (from_offset >= from.nsamples())
-			return 0;
-
-		uint   to_nchannels = to->nchannels();
-		uint from_nchannels = from.nchannels();
-		uint   to_offset    = to->nsamples();
-		uint   to_nsamples  = to->capacity() - to_offset;
-		uint from_nsamples  = from.nsamples();
-		uint copy_nsamples  =
-			std::min(from_offset + to_nsamples, from_nsamples) - from_offset;
-
-		for (uint channel = 0; channel < to_nchannels; ++channel)
-		{
-			uint from_channel    = channel < from_nchannels ? channel : 0;
-			      Sample*   to_p = Signals_at(to,     to_offset,      channel);
-			const Sample* from_p = Signals_at(from, from_offset, from_channel);
-			for (uint i = 0; i < copy_nsamples; ++i)
-			{
-				 *to_p  = *from_p;
-				  to_p +=    to_nchannels;
-				from_p +=  from_nchannels;
-			}
-		}
-
-		Signals_set_nsamples(to, to->self->nsamples + copy_nsamples);
-		return copy_nsamples;
-	}
-
-	static uint
-	resample (Signals* to, const Signals& from, uint from_offset)
-	{
-		assert(to && *to && from);
-
-		if (from_offset >= from.nsamples())
-			return 0;
-
-		uint    to_offset     = to->nsamples();
-		float          to_sec = (to->capacity() - to_offset) /  to->sample_rate();
-		float from_offset_sec = from_offset                  / from.sample_rate();
-		float        from_sec = from.nsamples()              / from.sample_rate();
-
-		float copy_seconds =
-			std::min(from_offset_sec + to_sec, from_sec) - from_offset_sec;
-
-		uint to_nsamples = 0, from_nsamples = 0;
-		if (from_offset_sec + to_sec <= from_sec)
-		{
-			  to_nsamples = to->capacity() - to->nsamples();
-			from_nsamples = copy_seconds * from.sample_rate();
-		}
-		else
-		{
-			to_nsamples = copy_seconds * to->sample_rate();
-			from_nsamples = from.nsamples() - from_offset;
-		}
-
-		r8b::CDSPResampler24 resampler(
-			from.sample_rate(), to->sample_rate(), from_nsamples);
-		r8b::CFixedBuffer<double> from_buf(from_nsamples), to_buf(to_nsamples);
-
-		for (uint channel = 0; channel < to->nchannels(); ++channel)
-		{
-			uint from_channel = channel < from.nchannels() ? channel : 0;
-
-			for (uint i = 0; i < from_nsamples; ++i)
-				from_buf[i] = *Signals_at(from, from_offset + i, from_channel);
-
-			resampler.clear();
-			resampler.oneshot(
-				(const double*) from_buf, from_nsamples,
-				      (double*)   to_buf,   to_nsamples);
-
-			for (uint i = 0; i < to_nsamples; ++i)
-				*Signals_at(to, to_offset + i, channel) = to_buf[i];
-		}
-
-		Signals_set_nsamples(to, to->self->nsamples + to_nsamples);
-		return from_nsamples;
-	}
-
-	uint
-	Signals_copy (Signals* to, const Signals& from, uint from_offset)
-	{
-		if (!to)
-			argument_error(__FILE__, __LINE__);
-		if (!*to)
-			argument_error(__FILE__, __LINE__);
-		if (!from)
-			argument_error(__FILE__, __LINE__);
-
-		Signals_clear(to);
-
-		if (to->sample_rate() == from.sample_rate())
-			return copy_samples(to, from, from_offset);
-		else
-			return resample(to, from, from_offset);
-	}
-
 	void
 	Signals_add (Signals* signals, const Signals& add)
 	{
@@ -451,10 +294,10 @@ namespace Beeps
 		if (signals->capacity() < nsamples)
 			argument_error(__FILE__, __LINE__);
 
-		for (uint channel = 0; channel < nchannels; ++channel)
+		for (uint ch = 0; ch < nchannels; ++ch)
 		{
-			Sample* sig_p = Signals_at(signals, 0, channel);
-			const T* buf  = samples.channel(channel);
+			Sample* sig_p = Signals_at(signals, 0, ch);
+			const T* buf  = samples.channel(ch);
 			for (uint i = 0; i < nsamples; ++i, sig_p += nchannels)
 				*sig_p = buf[i];
 		}
@@ -592,10 +435,184 @@ namespace Beeps
 	{
 	}
 
+	Signals::Signals (uint capacity, uint nchannels, double sample_rate)
+	{
+		self->frames.reset(
+			new Frames(capacity * nchannels, nchannels, sample_rate));
+	}
+
+	Signals::Signals (
+		const float* const* channels,
+		uint nsamples, uint nchannels, double sample_rate, uint capacity)
+	{
+		if (!channels)
+			argument_error(__FILE__, __LINE__);
+
+		self->frames.reset(new Frames(
+			std::max(capacity, nsamples) * nchannels, nchannels, sample_rate));
+
+		for (uint ch = 0; ch < nchannels; ++ch)
+		{
+			Sample* p = Signals_at(this, 0, ch);
+			for (uint i = 0; i < nsamples; ++i, p += nchannels)
+				*p = channels[ch][i];
+		}
+
+		self->nsamples = nsamples;
+	}
+
 	Signals::~Signals ()
 	{
 	}
 
+	void
+	Signals::clear (uint capacity)
+	{
+		if (!*this)
+			argument_error(__FILE__, __LINE__);
+
+		self->nsamples = 0;
+		if (capacity > 0)
+			self->frames->resize(capacity, nchannels());
+	}
+
+	template <typename T>
+	static uint
+	copy_samples (
+		Signals* to,
+		const T* const* from_channels, uint from_nsamples, uint from_nchannels,
+		uint from_offset, uint from_stride)
+	{
+		assert(to && *to && from_channels);
+
+		if (from_offset >= from_nsamples)
+			return 0;
+
+		uint to_nchannels = to->nchannels();
+		uint to_offset    = to->nsamples();
+		uint to_nsamples  = to->capacity() - to_offset;
+		uint copy_nsamples =
+			std::min(from_offset + to_nsamples, from_nsamples) - from_offset;
+
+		for (uint ch = 0; ch < to_nchannels; ++ch)
+		{
+			uint from_channel = ch < from_nchannels ? ch : 0;
+			Sample*      to_p = Signals_at(to, to_offset, ch);
+			const T*   from_p = from_channels[from_channel] + from_offset * from_stride;
+			for (uint i = 0; i < copy_nsamples; ++i)
+			{
+				 *to_p  = *from_p;
+				  to_p += to_nchannels;
+				from_p += from_stride;
+			}
+		}
+
+		Signals_set_nsamples(to, to->self->nsamples + copy_nsamples);
+		return copy_nsamples;
+	}
+
+	template <typename T>
+	static uint
+	resample (
+		Signals* to,
+		const T* const* from_channels, uint from_nsamples, uint from_nchannels,
+		double from_sample_rate, uint from_offset, uint from_stride)
+	{
+		assert(to && *to && from_channels);
+
+		if (from_offset >= from_nsamples)
+			return 0;
+
+		uint    to_offset     = to->nsamples();
+		float          to_sec = (to->capacity() - to_offset) /  to->sample_rate();
+		float from_offset_sec = from_offset                  / from_sample_rate;
+		float        from_sec = from_nsamples                / from_sample_rate;
+		float copy_seconds    =
+			std::min(from_offset_sec + to_sec, from_sec) - from_offset_sec;
+
+		uint to_nsamples = 0, copy_nsamples = 0;
+		if (from_offset_sec + to_sec <= from_sec)
+		{
+			  to_nsamples = to->capacity() - to->nsamples();
+			copy_nsamples = copy_seconds * from_sample_rate;
+		}
+		else
+		{
+			  to_nsamples = copy_seconds * to->sample_rate();
+			copy_nsamples = from_nsamples - from_offset;
+		}
+
+		r8b::CDSPResampler24 resampler(
+			from_sample_rate, to->sample_rate(), copy_nsamples);
+		r8b::CFixedBuffer<double> from_buf(copy_nsamples), to_buf(to_nsamples);
+
+		for (uint ch = 0; ch < to->nchannels(); ++ch)
+		{
+			uint from_ch  = ch < from_nchannels ? ch : 0;
+			const T* base = from_channels[from_ch] + from_offset * from_stride;
+
+			for (uint i = 0; i < copy_nsamples; ++i)
+				from_buf[i] = base[i * from_stride];
+
+			resampler.clear();
+			resampler.oneshot(
+				(const double*) from_buf, copy_nsamples,
+				      (double*)   to_buf,   to_nsamples);
+
+			for (uint i = 0; i < to_nsamples; ++i)
+				*Signals_at(to, to_offset + i, ch) = to_buf[i];
+		}
+
+		Signals_set_nsamples(to, to->self->nsamples + to_nsamples);
+		return copy_nsamples;
+	}
+
+	uint
+	Signals::append (
+		const float* const* channels,
+		uint nsamples, uint nchannels, double sample_rate)
+	{
+		if (!*this)
+			argument_error(__FILE__, __LINE__);
+		if (!channels)
+			argument_error(__FILE__, __LINE__);
+
+		if (sample_rate == 0)
+			sample_rate = this->sample_rate();
+
+		if (sample_rate == this->sample_rate())
+			return copy_samples(this, channels, nsamples, nchannels, 0, 1);
+		else
+			return resample(this, channels, nsamples, nchannels, sample_rate, 0, 1);
+	}
+
+	uint
+	Signals::append (const Signals& source, uint source_offset)
+	{
+		if (!*this)
+			argument_error(__FILE__, __LINE__);
+		if (!source)
+			argument_error(__FILE__, __LINE__);
+
+		uint nchannels = source.nchannels();
+		std::vector<const Sample*> channels(nchannels);
+		for (uint ch = 0; ch < nchannels; ++ch)
+			channels[ch] = Signals_at(source, 0, ch);
+
+		if (sample_rate() == source.sample_rate())
+		{
+			return copy_samples(
+				this, channels.data(), source.nsamples(), nchannels,
+				source_offset, nchannels);
+		}
+		else
+		{
+			return resample(
+				this, channels.data(), source.nsamples(), nchannels, source.sample_rate(),
+				source_offset, nchannels);
+		}
+	}
+
 	Signals
 	Signals::dup () const
 	{

data/src/signals.h

@@ -21,13 +21,6 @@ namespace Beeps
 	template <typename T> class SignalSamples;
 
 
-	Signals Signals_create (
-		uint capacity, uint nchannels = 1, double sample_rate = 0);
-
-	Signals Signals_create (
-		const float* const* channels,
-		uint nsamples, uint nchannels, double sample_rate = 0, uint capacity = 0);
-
 	uint Signals_tick (
 		Signals* signals,
 		std::function<void(stk::StkFrames*)> fun);
@@ -40,18 +33,12 @@ namespace Beeps
 		Signals* signals, uint start, uint length,
 		std::function<void(stk::StkFrames*)> fun);
 
-	void Signals_clear (Signals* signals);
-
-	void Signals_clear (Signals* signals, uint capacity);
-
 	void Signals_fill (
 		Signals* signals, uint nsamples, Sample value,
 		uint offset = 0);
 
 	void Signals_shift (Signals* signals, uint nsamples);
 
-	uint Signals_copy (Signals* to, const Signals& from, uint from_offset = 0);
-
 	void Signals_add (     Signals* signals, const Signals& add);
 
 	void Signals_multiply (Signals* signals, const Signals& multiplier);
@@ -107,9 +94,9 @@ namespace Beeps
 				auto& samples = self->samples;
 				samples.reserve(nsamples * nchannels);
 
-				for (uint channel = 0; channel < nchannels; ++channel)
+				for (uint ch = 0; ch < nchannels; ++ch)
 				{
-					const Sample* p = Signals_at(signals, 0);
+					const Sample* p = Signals_at(signals, 0, ch);
 					for (uint i = 0; i < nsamples; ++i, p += nchannels)
 						samples.push_back(*p);
 				}

data/src/sound.cpp

@@ -65,10 +65,10 @@ namespace Beeps
 			if (nsamples <= 0) return 0;
 
 			std::unique_ptr<short[]> buffer(new short[size]);
-			for (uint channel = 0; channel < nchannels; ++channel)
+			for (uint ch = 0; ch < nchannels; ++ch)
 			{
-				const Sample* p = Signals_at(signals, 0, channel);
-				for (uint i = channel; i < size; i += nchannels, p += nchannels)
+				const Sample* p = Signals_at(signals, 0, ch);
+				for (uint i = ch; i < size; i += nchannels, p += nchannels)
 					buffer[i] = *p * SHRT_MAX;
 			}
 
@@ -83,6 +83,20 @@ namespace Beeps
 			return nsamples;
 		}
 
+		ALint nsamples () const
+		{
+			if (!*this) return 0;
+
+			ALint size = 0, bits = 0, channels = 0;
+			alGetBufferi(self->id, AL_SIZE, &size);
+			alGetBufferi(self->id, AL_BITS, &bits);
+			alGetBufferi(self->id, AL_CHANNELS, &channels);
+			if (bits <= 0 || channels <= 0)
+				return 0;
+
+			return size / (bits / 8) / channels;
+		}
+
 		operator bool () const
 		{
 			return self->is_valid();
@@ -168,6 +182,7 @@ namespace Beeps
 		SoundSource reuse ()
 		{
 			stop();
+			set_time_scale(1);
 			set_gain(1);
 			set_loop(false);
 
@@ -276,6 +291,47 @@ namespace Beeps
 			}
 		}
 
+		void set_position (uint position)
+		{
+			if (!*this) return;
+
+			alSourcei(self->id, AL_SAMPLE_OFFSET, (ALint) position);
+			OpenAL_check_error(__FILE__, __LINE__);
+		}
+
+		uint position () const
+		{
+			if (!*this) return 0;
+
+			ALint pos = 0;
+			alGetSourcei(self->id, AL_SAMPLE_OFFSET, &pos);
+			OpenAL_check_error(__FILE__, __LINE__);
+
+			return (uint) pos;
+		}
+
+		void set_time_scale (float scale)
+		{
+			if (scale <= 0)
+				argument_error(__FILE__, __LINE__);
+
+			if (!*this) return;
+
+			alSourcef(self->id, AL_PITCH, scale);
+			OpenAL_check_error(__FILE__, __LINE__);
+		}
+
+		float time_scale () const
+		{
+			if (!*this) return 1;
+
+			float scale = 1;
+			alGetSourcef(self->id, AL_PITCH, &scale);
+			OpenAL_check_error(__FILE__, __LINE__);
+
+			return scale;
+		}
+
 		void set_gain (float gain)
 		{
 			if (gain < 0)
@@ -377,6 +433,10 @@ namespace Beeps
 	struct SoundPlayer::Data
 	{
 
+		double sample_rate = 0;
+
+		uint position      = 0;
+
 		SoundSource source;
 
 		std::vector<SoundBuffer> buffers;
@@ -387,6 +447,9 @@ namespace Beeps
 
 		void clear ()
 		{
+			sample_rate = 0;
+			position    = 0;
+
 			source.clear();
 
 			for (auto& buffer : buffers) buffer.clear();
@@ -397,6 +460,8 @@ namespace Beeps
 		{
 			assert(signals);
 
+			sample_rate = signals.sample_rate();
+
 			SoundBuffer buffer(signals);
 			source.attach(buffer);
 			buffers.emplace_back(buffer);
@@ -407,7 +472,8 @@ namespace Beeps
 		{
 			assert(processor && *processor && nchannels > 0 && sample_rate > 0);
 
-			this->processor = processor;
+			this->sample_rate = sample_rate;
+			this->processor   = processor;
 			stream_context.reset(
 				new StreamContext(sample_rate / 10, nchannels, sample_rate));
 
@@ -447,6 +513,8 @@ namespace Beeps
 				if (!source.unqueue(&buffer))
 					return;
 
+				position += buffer.nsamples();
+
 				if (!process_stream(&buffer))
 				{
 					source.stop();
@@ -454,7 +522,23 @@ namespace Beeps
 				}
 
 				source.queue(buffer);
-				if (source.state() == STOPPED) source.play();
+				if (source.state() == STOPPED)
+				{
+					expand_buffer();
+					source.play();
+				}
+			}
+		}
+
+		void expand_buffer ()
+		{
+			if (buffers.size() >= 10) return;
+
+			SoundBuffer extra(true);
+			if (process_stream(&extra))
+			{
+				source.queue(extra);
+				buffers.emplace_back(extra);
 			}
 		}
 
@@ -586,16 +670,20 @@ namespace Beeps
 		self->source.pause();
 	}
 
+	#pragma GCC diagnostic push
+	#pragma GCC diagnostic ignored "-Wmissing-noreturn"
 	void
 	SoundPlayer::rewind ()
 	{
 		not_implemented_error(__FILE__, __LINE__);
 	}
+	#pragma GCC diagnostic pop
 
 	void
 	SoundPlayer::stop ()
 	{
 		self->source.stop();
+		self->position = 0;
 	}
 
 	SoundPlayer::State
@@ -607,6 +695,67 @@ namespace Beeps
 		return s;
 	}
 
+	void
+	SoundPlayer::set_position (uint position)
+	{
+		if (self->is_streaming())
+		{
+			if (!self->processor || !self->processor->seekable())
+				invalid_state_error(__FILE__, __LINE__, "processor is not seekable");
+
+			State state = this->state();
+			self->source.stop();
+
+			self->position = position;
+			self->stream_context->seek(position);
+			for (auto& buffer : self->buffers)
+			{
+				if (!self->process_stream(&buffer)) break;
+				self->source.queue(buffer);
+			}
+
+			if (state != STOPPED) self->source.play();
+			if (state == PAUSED)  self->source.pause();
+		}
+		else
+		{
+			self->position = 0;
+			self->source.set_position(position);
+		}
+	}
+
+	uint
+	SoundPlayer::position () const
+	{
+		return self->position + self->source.position();
+	}
+
+	void
+	SoundPlayer::set_time (float time)
+	{
+		if (self->sample_rate <= 0) return;
+		set_position((uint) (time * self->sample_rate));
+	}
+
+	float
+	SoundPlayer::time () const
+	{
+		if (self->sample_rate <= 0) return 0;
+		return (float) ((double) position() / self->sample_rate);
+	}
+
+	void
+	SoundPlayer::set_time_scale (float scale)
+	{
+		self->source.set_time_scale(scale);
+	}
+
+	float
+	SoundPlayer::time_scale () const
+	{
+		return self->source.time_scale();
+	}
+
 	void
 	SoundPlayer::set_gain (float gain)
 	{

data/src/time_stretch.cpp

@@ -66,8 +66,8 @@ namespace Beeps
 		if (self->scale == 1)
 			return Super::filter(context, signals, offset);
 
-		uint nsamples  = signals->capacity();
-		Signals source = Signals_create(
+		uint nsamples = signals->capacity();
+		Signals source(
 			nsamples / self->scale, signals->nchannels(), signals->sample_rate());
 
 		Super::filter(context, &source, offset);

data/src/value.cpp

@@ -113,6 +113,12 @@ namespace Beeps
 		return self->points.end();
 	}
 
+	bool
+	Value::seekable () const
+	{
+		return true;
+	}
+
 	static float
 	interpolate_linear (const Value::PointList& points, float time)
 	{
@@ -169,11 +175,11 @@ namespace Beeps
 	}
 
 	int
-	Value::max_segment_size_for_process (
+	Value::get_max_segment_size_for_process (
 		double sample_rate, uint nsamples) const
 	{
 		if (self->points.size() == 1)
-			return Super::max_segment_size_for_process(sample_rate, nsamples);
+			return Super::get_max_segment_size_for_process(sample_rate, nsamples);
 		return sample_rate / 256;
 	}