beeps 0.3.6 → 0.3.8

data/src/analyser.cpp

@@ -186,48 +186,46 @@ namespace Beeps
 		return self->spectrum;
 	}
 
+	Analyser::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->is_valid();
+	}
+
 	static void
 	shift (Signals* signals, uint nsamples)
 	{
+		if (nsamples == 0)
+			return;
+
 		if (nsamples > signals->nsamples())
 			return Signals_clear(signals);
 
-		Frames* frames = Signals_get_frames(signals);
-		assert(frames);
-
-		Float* from = &(*frames)(nsamples, 0);
-		Float* to   = &(*frames)(0, 0);
-		uint size   = (signals->nsamples() - nsamples) * signals->nchannels();
+		Sample* from         = Signals_at(signals, nsamples);
+		Sample* to           = Signals_at(signals, 0);
+		uint nsamples_remain = signals->nsamples() - nsamples;
+		uint size            = nsamples_remain * signals->nchannels();
 		for (uint i = 0; i < size; ++i)
 			*to++ = *from++;
 
-		Signals_set_nsamples(signals, signals->nsamples() - nsamples);
+		Signals_set_nsamples(signals, nsamples_remain);
 	}
 
 	static void
 	append (Signals* to, const Signals& from)
 	{
-		assert(to);
-
-		      Frames* tof   = Signals_get_frames(to);
-		const Frames* fromf = Signals_get_frames(&from);
-		assert(fromf && tof);
+		assert(to->nchannels() == from.nchannels());
+		assert(to->nsamples() + from.nsamples() <= to->capacity());
 
-		uint   to_cap      =  to->capacity();
-		uint   to_nsamples =  to->nsamples();
-		uint from_nsamples = from.nsamples();
-		uint from_start    = from_nsamples > to_cap ? from_nsamples - to_cap : 0;
-		uint nsamples      = from_nsamples - from_start;
-		assert(to_nsamples + nsamples <= to_cap);
-
-		for (uint ch = 0; ch < tof->nchannels(); ++ch)
-		{
-			uint from_ch = ch < fromf->nchannels() ? ch : 0;
-			for (uint i = 0; i < nsamples; ++i)
-				(*tof)(to_nsamples + i, ch) = (*fromf)(from_start + i, from_ch);
-		}
+		uint nchannels       =  to->nchannels();
+		uint nsamples        = std::min(from.nsamples(), to->capacity() - to->nsamples());
+		uint size            = nsamples * nchannels;
+		      Sample*   to_p = Signals_at(to,   to->nsamples());
+		const Sample* from_p = Signals_at(from, 0);
+		for (uint i = 0; i < size; ++i)
+			*to_p++ = *from_p++;
 
-		Signals_set_nsamples(to, to_nsamples + nsamples);
+		Signals_set_nsamples(to, to->nsamples() + nsamples);
 	}
 
 	void
@@ -235,20 +233,19 @@ namespace Beeps
 	{
 		Super::filter(context, signals, offset);
 
-		Signals& sig  = self->signals;
-		uint nsamples = sig.nsamples() + signals->nsamples();
-		if (nsamples > sig.capacity())
-			shift(&sig, nsamples - sig.capacity());
+		auto& in =      *signals;
+		auto& my = self->signals;
 
-		append(&sig, *signals);
+		if (my.nchannels() != in.nchannels() || my.sample_rate() != in.sample_rate())
+			my = Signals_create(my.capacity(), in.nchannels(), in.sample_rate());
 
-		self->spectrum.clear();
-	}
+		uint total_nsamples = my.nsamples() + in.nsamples();
+		if (total_nsamples > my.capacity())
+			shift(&my, total_nsamples - my.capacity());
 
-	Analyser::operator bool () const
-	{
-		if (!Super::operator bool()) return false;
-		return self->is_valid();
+		append(&my, in);
+
+		self->spectrum.clear();
 	}
 
 

data/src/beeps.cpp

@@ -4,6 +4,7 @@
 
 #include "Stk.h"
 #include "beeps/exception.h"
+#include "beeps/debug.h"
 #include "openal.h"
 #include "sound.h"
 #include "mic_in.h"
@@ -32,6 +33,12 @@ namespace Beeps
 		Beeps_fin();
 	}
 
+	double
+	sample_rate ()
+	{
+		return stk::Stk::sampleRate();
+	}
+
 	void
 	process_streams ()
 	{
@@ -39,11 +46,5 @@ namespace Beeps
 		SoundPlayer_process_streams();
 	}
 
-	double
-	sample_rate ()
-	{
-		return stk::Stk::sampleRate();
-	}
-
 
 }// Beeps

data/src/envelope.cpp

@@ -14,10 +14,25 @@ namespace Beeps
 	static const float TIME_ZERO = 0.0000001;
 
 
+	class ADSR : public stk::ADSR
+	{
+
+		public:
+
+			void skipAttackPhase()
+			{
+				value_  = 1;
+				target_ = 1;
+				state_  = DECAY;
+			}
+
+	};// ADSR
+
+
 	struct Envelope::Data
 	{
 
-		stk::ADSR adsr;
+		ADSR adsr;
 
 		Signals adsr_signals;
 
@@ -151,15 +166,28 @@ namespace Beeps
 		return self->release_time;
 	}
 
-	static size_t
-	slice (Frames* frames, size_t start, float length_sec = -1)
+	Envelope::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return
+			self->attack_time   >= 0 &&
+			self->decay_time    >= 0 &&
+			self->sustain_level >= 0 &&
+			self->release_time  >= 0 &&
+			self->time          >= 0;
+	}
+
+	static uint
+	tick (Envelope* envelope, Signals* signals, uint start, float length_sec = -1)
 	{
-		size_t max = frames->nframes() - start;
-		size_t len = length_sec >= 0 ? length_sec * frames->sample_rate() : max;
+		uint max = signals->capacity() - start;
+		uint len = length_sec >= 0 ? length_sec * signals->sample_rate() : max;
 		if (len > max) len = max;
-		assert(0 < len && (start + len) <= frames->nframes());
+		assert(0 < len && (start + len) <= signals->nsamples());
 
-		return frames->slice(start, len);
+		return Signals_tick(
+			signals, start, start + len,
+			[&](stk::StkFrames* frames) {envelope->self->adsr.tick(*frames);});
 	}
 
 	static void
@@ -169,57 +197,62 @@ namespace Beeps
 
 		Envelope::Data* self = envelope->self.get();
 
-		Frames* frames = Signals_get_frames(signals);
-		assert(frames);
-
 		if (self->time == 0 && self->attack_time == 0)
-			self->adsr.setValue(self->sustain_level);// skip attack phase
+			self->adsr.skipAttackPhase();
 
-		float start = self->time;
-		float end   = start + Signals_get_seconds(*signals);
-		self->time  = end;
+		if (
+			self->note_on_time  >= 0 &&
+			self->note_off_time <  0 &&
+			self->sustain_level == 0)
+		{
+			envelope->note_off(
+				self->note_on_time + self->attack_time + self->decay_time
+				- self->time);
+		}
+
+		float on          = self->note_on_time;
+		float off         = self->note_off_time;
+		float start       = self->time;
+		float end         = start + signals->capacity() / signals->sample_rate();
+		float release_end = off >= 0 ? off + self->release_time : -1;
+		bool has_on       = 0 <= on  && start <= on  && on  < end;
+		bool has_off      = 0 <= off && start <= off && off < end;
 
-		float on  = self->note_on_time;
-		float off = self->note_off_time;
-		assert(on <= off);
+		if (release_end >= 0 && release_end < end)
+			end = release_end;
 
-		bool has_on  = 0 <= on  && start <= on  && on  < end;
-		bool has_off = 0 <= off && start <= off && off < end;
+		self->time = end;
 
 		if (!has_on && !has_off)
 		{
-			self->adsr.tick(*frames);
+			float len = end == release_end ? end - start : -1;
+			tick(envelope, signals, 0, len);
 			return;
 		}
 
-		size_t last = 0;
+		uint pos = 0;
 		if (has_on)
 		{
 			if (start < on)
-			{
-				last = slice(frames, 0, on - start);
-				self->adsr.tick(*frames);
-				frames->unslice();
-			}
+				pos = tick(envelope, signals, pos, on - start);
 			self->adsr.keyOn();
 		}
 		if (has_on || has_off)
 		{
 			float len = has_off ? off - (has_on ? on : start) : -1;
-			last = slice(frames, last, len);
-			self->adsr.tick(*frames);
-			frames->unslice();
+			pos = tick(envelope, signals, pos, len);
 		}
 		if (has_off)
 		{
 			self->adsr.keyOff();
 			if (off < end)
 			{
-				slice(frames, last, -1);
-				self->adsr.tick(*frames);
-				frames->unslice();
+				float len = end == release_end ? end - off : -1;
+				pos = tick(envelope, signals, pos, len);
 			}
 		}
+
+		Signals_set_nsamples(signals, pos);
 	}
 
 	void
@@ -232,23 +265,14 @@ namespace Beeps
 			self->adsr_signals =
 				Signals_create(signals->nsamples(), 1, signals->sample_rate());
 		}
-
-		if (self->adsr_signals.nsamples() != signals->nsamples())
-			Signals_resize(&self->adsr_signals, signals->nsamples(), 0);
+		else
+			Signals_clear(&self->adsr_signals, signals->nsamples());
 
 		process_envelope_signals(this, &self->adsr_signals);
-		Signals_multiply(signals, self->adsr_signals);
-	}
+		if (self->adsr_signals.nsamples() < signals->nsamples())
+			Signals_set_nsamples(signals, self->adsr_signals.nsamples());
 
-	Envelope::operator bool () const
-	{
-		if (!Super::operator bool()) return false;
-		return
-			self->attack_time   >= 0 &&
-			self->decay_time    >= 0 &&
-			self->sustain_level >= 0 &&
-			self->release_time  >= 0 &&
-			self->time          >= 0;
+		Signals_multiply(signals, self->adsr_signals);
 	}
 
 

data/src/file_in.cpp

@@ -76,6 +76,12 @@ namespace Beeps
 		return Signals_get_seconds(self->signals);
 	}
 
+	FileIn::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->signals;
+	}
+
 	void
 	FileIn::generate (Context* context, Signals* signals, uint* offset)
 	{
@@ -84,11 +90,5 @@ namespace Beeps
 		*offset += Signals_copy(signals, self->signals, *offset);
 	}
 
-	FileIn::operator bool () const
-	{
-		if (!Super::operator bool()) return false;
-		return self->signals;
-	}
-
 
 }// Beeps

data/src/gain.cpp

@@ -44,11 +44,11 @@ namespace Beeps
 	{
 		Super::filter(context, signals, offset);
 
-		Frames* frames = Signals_get_frames(signals);
-		if (!frames)
-			argument_error(__FILE__, __LINE__);
-
-		*frames *= self->gain;
+		float gain = self->gain;
+		uint size  = signals->nsamples() * signals->nchannels();
+		Sample* p  = Signals_at(signals, 0);
+		for (uint i = 0; i < size; ++i)
+			*p++ *= gain;
 	}
 
 

data/src/high_pass.cpp

@@ -0,0 +1,57 @@
+#include "x_pass.h"
+
+
+namespace Beeps
+{
+
+
+	struct HighPass::Data : public xPassFilterData
+	{
+
+		Data ()
+		:	xPassFilterData(100)
+		{
+		}
+
+	};// HighPass::Data
+
+
+	HighPass::HighPass (Processor* input)
+	:	Super(input)
+	{
+	}
+
+	HighPass::~HighPass ()
+	{
+	}
+
+	void
+	HighPass::set_cutoff_frequency (float frequency)
+	{
+		if (frequency <= 0)
+			argument_error(__FILE__, __LINE__);
+
+		if (frequency == self->cutoff_freq)
+			return;
+
+		self->cutoff_freq = frequency;
+		set_updated();
+	}
+
+	float
+	HighPass::cutoff_frequency () const
+	{
+		return self->cutoff_freq;
+	}
+
+	void
+	HighPass::filter (Context* context, Signals* signals, uint* offset)
+	{
+		Super::filter(context, signals, offset);
+
+		self->biquad.setHighPass(self->cutoff_freq);
+		self->tick(signals);
+	}
+
+
+}// Beeps

data/src/low_pass.cpp

@@ -0,0 +1,57 @@
+#include "x_pass.h"
+
+
+namespace Beeps
+{
+
+
+	struct LowPass::Data : public xPassFilterData
+	{
+
+		Data ()
+		:	xPassFilterData(1000)
+		{
+		}
+
+	};// LowPass::Data
+
+
+	LowPass::LowPass (Processor* input)
+	:	Super(input)
+	{
+	}
+
+	LowPass::~LowPass ()
+	{
+	}
+
+	void
+	LowPass::set_cutoff_frequency (float frequency)
+	{
+		if (frequency <= 0)
+			argument_error(__FILE__, __LINE__);
+
+		if (frequency == self->cutoff_freq)
+			return;
+
+		self->cutoff_freq = frequency;
+		set_updated();
+	}
+
+	float
+	LowPass::cutoff_frequency () const
+	{
+		return self->cutoff_freq;
+	}
+
+	void
+	LowPass::filter (Context* context, Signals* signals, uint* offset)
+	{
+		Super::filter(context, signals, offset);
+
+		self->biquad.setLowPass(self->cutoff_freq);
+		self->tick(signals);
+	}
+
+
+}// Beeps

data/src/mic_in.cpp

@@ -86,22 +86,19 @@ namespace Beeps
 
 			if (!is_valid()) return;
 
-			Frames* frames = Signals_get_frames(signals);
-			assert(frames);
-
 			auto& samples  = self->samples;
 			uint nchannels = self->nchannels;
 			uint nsamples  = (uint) (samples.size() / nchannels);
 			uint offset    = *gen_offset < self->offset ? 0 : *gen_offset - self->offset;
 			if (offset >= nsamples) return;
 
-			nsamples = std::min(frames->nframes(), nsamples - offset);
-			for (uint ch = 0; ch < frames->nchannels(); ++ch)
+			nsamples = std::min(signals->capacity(), nsamples - offset);
+			for (uint ch = 0; ch < signals->nchannels(); ++ch)
 			{
 				uint samples_ch = ch < nchannels ? ch : 0;
 				float div       = 1.0f / SHRT_MAX;
 				for (uint i = 0; i < nsamples; ++i)
-					(*frames)(i, ch) = samples[(offset + i) * nchannels + samples_ch] * div;
+					*Signals_at(signals, i, ch) = samples[(offset + i) * nchannels + samples_ch] * div;
 			}
 			Signals_set_nsamples(signals, nsamples);
 
@@ -207,10 +204,15 @@ namespace Beeps
 
 	MicIn::MicIn (uint nchannels, double sample_rate)
 	{
+		if (sample_rate == 0)
+			sample_rate = Beeps::sample_rate();
+
+		if (nchannels <= 0)
+			argument_error(__FILE__, __LINE__);
 		if (nchannels > 2)
 			argument_error(__FILE__, __LINE__);
-
-		if (sample_rate <= 0) sample_rate = Beeps::sample_rate();
+		if (sample_rate <= 0)
+			argument_error(__FILE__, __LINE__);
 
 		self->mic.self->sample_rate = sample_rate;
 		self->mic.self->nchannels   = nchannels;
@@ -254,6 +256,12 @@ namespace Beeps
 		return self->mic.self->nchannels;
 	}
 
+	MicIn::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->mic.is_valid();
+	}
+
 	void
 	MicIn::generate (Context* context, Signals* signals, uint* offset)
 	{
@@ -262,11 +270,5 @@ namespace Beeps
 		self->mic.get_signals(signals, offset);
 	}
 
-	MicIn::operator bool () const
-	{
-		if (!Super::operator bool()) return false;
-		return self->mic.is_valid();
-	}
-
 
 }// Beeps

data/src/mixer.cpp

@@ -16,6 +16,8 @@ namespace Beeps
 
 		std::vector<Processor::Ref> inputs;
 
+		Signals input_signals;
+
 	};// Mixer::Data
 
 
@@ -74,38 +76,54 @@ namespace Beeps
 		return self->inputs.end();
 	}
 
-	void
-	Mixer::filter (Context* context, Signals* signals, uint* offset)
+	Mixer::operator bool () const
 	{
-		Super::filter(context, signals, offset);
+		const auto* input = this->input();
+		if (input && !*input)
+			return false;
 
-		Signals_resize(signals, signals->capacity(), 0);
+		if (!input && self->inputs.empty())
+			return false;
 
-		Signals sig   = Signals_create(signals->capacity(), signals->nchannels());
-		uint min_size = signals->capacity();
-		for (auto& input : self->inputs)
-		{
-			Signals_clear(&sig);
+		for (auto& i : self->inputs)
+			if (!*i) return false;
+
+		return true;
+	}
 
-			uint sig_offset = *offset;
-			Processor_get_context(context)->process(input, &sig, &sig_offset);
+	static void
+	mix (
+		Mixer* mixer, Processor* input,
+		Processor::Context* context, Signals* signals, uint offset)
+	{
+		Mixer::Data* self = mixer->self.get();
+
+		auto& insig = self->input_signals;
+		if (!insig)
+			insig = Signals_create(signals->capacity(), signals->nchannels());
+		else
+			Signals_clear(&insig, signals->capacity());
 
-			uint size = sig_offset - *offset;
-			if (size < min_size) min_size = size;
+		Processor_get_context(context)->process(input, &insig, &offset);
 
-			Signals_add(signals, sig);
-		}
+		if (insig.nsamples() > signals->nsamples())
+			Signals_set_nsamples(signals, insig.nsamples());
 
-		*offset += min_size;
+		Signals_add(signals, insig);
 	}
 
-	Mixer::operator bool () const
+	void
+	Mixer::filter (Context* context, Signals* signals, uint* offset)
 	{
-		if (self->inputs.empty()) return false;
+		Signals_fill(signals, signals->capacity(), 0);
+		Signals_clear(signals);
+
+		Super::filter(context, signals, offset);
 
 		for (auto& input : self->inputs)
-			if (!*input) return false;
-		return true;
+			mix(this, input.get(), context, signals, *offset);
+
+		*offset += signals->nsamples();
 	}