beeps 0.3.6 → 0.3.7

data/src/oscillator.cpp

@@ -3,12 +3,11 @@
 
 #include <assert.h>
 #include <cmath>
+#include <algorithm>
 #include <vector>
-#include "SineWave.h"
-#include "Blit.h"
-#include "BlitSquare.h"
-#include "BlitSaw.h"
 #include "beeps/exception.h"
+#include "beeps/debug.h"
+#include "processor.h"
 #include "signals.h"
 
 
@@ -16,40 +15,9 @@ namespace Beeps
 {
 
 
-	class SineWave : public stk::SineWave
-	{
-
-		public:
-
-			void setPhase (stk::StkFloat phase)
-			{
-				time_ = std::fmod(phase, 1.f) * TABLE_SIZE;
-			}
+	static const uint NSEGMENTS_PER_WAVEFORM_CYCLE = 32;
 
-			stk::StkFloat getPhase () const
-			{
-				return time_ / TABLE_SIZE;
-			}
-
-	};// SineWave
-
-
-	class BlitSaw : public stk::BlitSaw
-	{
-
-		public:
-
-			void setPhase (stk::StkFloat phase)
-			{
-				phase_ = M_PI * phase;
-			}
-
-			stk::StkFloat getPhase () const
-			{
-				return phase_ / M_PI;
-			}
-
-	};// BlitSaw
+	static const uint MIN_BUFFER_SIZE              = 64;
 
 
 	class Osc
@@ -61,10 +29,12 @@ namespace Beeps
 
 			virtual void reset () = 0;
 
-			virtual void tick (Frames* frames) = 0;
+			virtual void tick (stk::StkFrames* frames) = 0;
 
 			virtual void set_frequency (float freq) = 0;
 
+			virtual float    frequency () const = 0;
+
 			virtual void set_phase (float phase) = 0;
 
 			virtual float    phase () const = 0;
@@ -72,74 +42,6 @@ namespace Beeps
 	};// Osc
 
 
-	template <typename OSC, uint DROP_MSEC>
-	class StkOsc : public Osc
-	{
-
-		public:
-
-			void reset () override
-			{
-				osc.reset();
-				drop_msec = DROP_MSEC;
-			}
-
-			void tick (Frames* frames) override
-			{
-				if (drop_msec > 0)
-				{
-					Frames f((uint) (frames->dataRate() * (drop_msec / 1000.0)));
-					osc.tick(f);
-					drop_msec = 0;
-				}
-
-				osc.tick(*frames);
-			}
-
-			void set_frequency (float freq) override
-			{
-				osc.setFrequency(freq);
-			}
-
-			void set_phase (float phase) override
-			{
-				osc.setPhase(phase);
-			}
-
-			float phase () const override
-			{
-				return osc.getPhase();
-			}
-
-		protected:
-
-			OSC osc;
-
-			uint drop_msec = DROP_MSEC;
-
-	};// StkOsc
-
-
-	typedef StkOsc<SineWave,          0> SineOsc;
-
-	typedef StkOsc<stk::BlitSquare, 100> SquareOsc;
-
-	typedef StkOsc<BlitSaw,         200> SawtoothOsc;
-
-
-	class TriangleOsc : public StkOsc<stk::Blit, 0>
-	{
-
-		public:
-
-			TriangleOsc ()
-			{
-				osc.setHarmonics(10);
-			}
-
-	};// TriangleOsc
-
-
 	class NoiseOsc : public Osc
 	{
 
@@ -150,9 +52,9 @@ namespace Beeps
 				time = 0;
 			}
 
-			void tick (Frames* frames) override
+			void tick (stk::StkFrames* frames) override
 			{
-				if (0 < freq && (freq * 2) <= frames->sample_rate())
+				if (0 < freq && (freq * 2) <= frames->dataRate())
 					tick_with_freq(frames);
 				else
 					tick_without_freq(frames);
@@ -163,6 +65,11 @@ namespace Beeps
 				this->freq = freq;
 			}
 
+			float frequency () const override
+			{
+				return freq;
+			}
+
 			void set_phase (float phase) override
 			{
 				time = freq == 0 ? 0 : phase * (1.f / freq);
@@ -179,32 +86,32 @@ namespace Beeps
 
 			double time = 0;
 
-			void tick_without_freq (Frames* frames)
+			void tick_without_freq (stk::StkFrames* frames)
 			{
-				uint nchannels = frames->nchannels();
-				uint nframes   = frames->nframes();
-				Float* pframe  = &(*frames)(0, 0);
-				for (uint i = 0; i < nframes; ++i, ++pframe)
+				uint nchannels = frames->channels();
+				uint nframes   = frames->frames();
+				Sample* p      = &(*frames)(0, 0);
+				for (uint i = 0; i < nframes; ++i, ++p)
 				{
 					uint ch = i % nchannels;
-					*pframe = ch == 0 ? noise() : pframe[-ch];
+					*p      = ch == 0 ? noise() : p[-ch];
 				}
 			}
 
-			void tick_with_freq (Frames* frames)
+			void tick_with_freq (stk::StkFrames* frames)
 			{
-				float time_per_sample = 1.f / frames->sample_rate();
+				float time_per_sample = 1.f / frames->dataRate();
 				float time_per_freq   = 1.f / (freq * 2);
 
-				uint nchannels = frames->nchannels();
-				uint nframes   = frames->nframes();
-				Float* pframe  = &(*frames)(0, 0);
+				uint nchannels = frames->channels();
+				uint nframes   = frames->frames();
+				Sample* p      = &(*frames)(0, 0);
 				float value    = noise();
-				for (uint i = 0; i < nframes; ++i, ++pframe)
+				for (uint i = 0; i < nframes; ++i, ++p)
 				{
 					if (i % nchannels == 0)
 					{
-						*pframe = value;
+						*p = value;
 
 						time += time_per_sample;
 						while (time >= time_per_freq)
@@ -214,7 +121,7 @@ namespace Beeps
 						}
 					}
 					else
-						*pframe = value;
+						*p = value;
 				}
 			}
 
@@ -231,10 +138,10 @@ namespace Beeps
 
 		public:
 
-			typedef std::vector<float> Table;
+			typedef std::vector<Sample> Table;
 
-			WaveformOsc (float* samples, size_t nsamples, float frequency)
-			:	table(samples, samples + nsamples), freq(frequency), time(0)
+			WaveformOsc (const Sample* samples, size_t nsamples)
+			:	table(samples, samples + nsamples), freq(1), time(0)
 			{
 			}
 
@@ -243,15 +150,16 @@ namespace Beeps
 				time = 0;
 			}
 
-			void tick (Frames* frames) override
+			void tick (stk::StkFrames* frames) override
 			{
 				size_t size = table.size();
-				float dt    = size * freq / frames->sample_rate();
+				float dt    = size * freq / frames->dataRate();
 
-				uint nchannels = frames->nchannels();
-				uint nframes   = frames->nframes();
-				Float* pframe  = &(*frames)(0, 0);
-				for (uint i = 0; i < nframes; ++i, ++pframe)
+				uint nchannels = frames->channels();
+				uint nframes   = frames->frames();
+				Sample* p      = &(*frames)(0, 0);
+				Sample prev    = 0;
+				for (uint i = 0; i < nframes; ++i, ++p)
 				{
 					uint ch = i % nchannels;
 					if (ch == 0)
@@ -259,13 +167,13 @@ namespace Beeps
 						size_t index0 = (size_t) time;
 						size_t index1 = index0 == size - 1 ? 0 : index0 + 1;
 						float frac    = time - index0;
-						*pframe       = table[index0] * (1.f - frac) + table[index1] * frac;
+						*p            = table[index0] * (1.f - frac) + table[index1] * frac;
+						prev          = *p;
 
 						time += dt;
 						while (time >= size) time -= size;
 					}
-					else
-						*pframe = pframe[-ch];
+					else *p = prev;
 				}
 			}
 
@@ -274,6 +182,11 @@ namespace Beeps
 				this->freq = freq;
 			}
 
+			float frequency () const override
+			{
+				return freq;
+			}
+
 			void set_phase (float phase) override
 			{
 				this->time = std::fmod(phase, 1.f) * table.size();
@@ -301,21 +214,28 @@ namespace Beeps
 	struct Oscillator::Data
 	{
 
-		Type type       = TYPE_NONE;
+		Type type    = TYPE_NONE;
+
+		float gain   = 1;
 
-		float frequency = 440;
+		float offset = 0;
+
+		float duty   = 0.5;
 
 		std::unique_ptr<Osc> osc;
 
 	};// Oscillator::Data
 
 
+	enum InputIndex {FREQUENCY = 0, PHASE, GAIN, OFFSET, DUTY};
+
+
 	Oscillator::Oscillator (Type type)
 	{
 		set_type(type);
 	}
 
-	Oscillator::Oscillator (float* samples, size_t size)
+	Oscillator::Oscillator (const Sample* samples, size_t size)
 	{
 		set_samples(samples, size);
 	}
@@ -329,32 +249,77 @@ namespace Beeps
 	{
 		Super::reset();
 		self->osc->reset();
+
+		set_updated();
 	}
 
-	void
-	Oscillator::set_type (Type type)
+	static Osc*
+	create_osc (Oscillator::Type type, size_t size, float duty)
 	{
-		if (type == self->type) return;
+		std::function<Sample(float)> fun;
+		switch (type)
+		{
+			case Oscillator::SINE:
+				fun = [](float t) {return std::sin(t * M_PI * 2);};
+				break;
 
-		float phase = self->osc ? self->osc->phase() : 0;
+			case Oscillator::TRIANGLE:
+				fun = [](float t) {return t < 0.5 ? t * 4 - 1 : 3 - t * 4;};
+				break;
 
-		self->type = type;
-		self->osc.reset();
+			case Oscillator::SAWTOOTH:
+				fun = [](float t) {return t * 2 - 1;};
+				break;
+
+			case Oscillator::SQUARE:
+				fun = [=](float t) {return t < duty ? 1 : -1;};
+				break;
+
+			case Oscillator::NOISE:
+				return new NoiseOsc();
 
-		switch (self->type)
-		{
-			case SINE:     self->osc.reset(new SineOsc());     break;
-			case TRIANGLE: self->osc.reset(new TriangleOsc()); break;
-			case SQUARE:   self->osc.reset(new SquareOsc());   break;
-			case SAWTOOTH: self->osc.reset(new SawtoothOsc()); break;
-			case NOISE:    self->osc.reset(new NoiseOsc());    break;
 			default:
 				argument_error(
-					__FILE__, __LINE__, "unknown oscilator type '%d'", self->type);
+					__FILE__, __LINE__, "unknown oscilator type '%d'", type);
 				break;
 		}
 
+		std::vector<Sample> samples;
+		samples.resize(size);
+		for (size_t i = 0; i < size; ++i)
+			samples[i] = fun(i / (float) size);
+
+		return new WaveformOsc(&samples[0], samples.size());
+	}
+
+	static void
+	update_osc (Oscillator* pthis, std::function<Osc*()> fun)
+	{
+		Oscillator::Data* self = pthis->self.get();
+
+		float freq  = self->osc ? self->osc->frequency() : 440;
+		float phase = self->osc ? self->osc->phase()     : 0;
+
+		self->osc.reset(fun());
+
+		self->osc->set_frequency(freq);
 		self->osc->set_phase(phase);
+	}
+
+	static void
+	update_waveform (Oscillator* pthis)
+	{
+		update_osc(pthis, [&]()
+		{
+			return create_osc(pthis->type(), 32, pthis->duty());
+		});
+	}
+
+	void
+	Oscillator::set_type (Type type)
+	{
+		self->type = type;
+		update_waveform(this);
 
 		set_updated();
 	}
@@ -366,18 +331,18 @@ namespace Beeps
 	}
 
 	void
-	Oscillator::set_samples (float* samples, size_t size)
+	Oscillator::set_samples (const Sample* samples, size_t size)
 	{
-		float phase = self->osc ? self->osc->phase() : 0;
-
 		self->type = SAMPLES;
-		self->osc.reset(new WaveformOsc(samples, size, frequency()));
-		self->osc->set_phase(phase);
+		update_osc(this, [=]()
+		{
+			return new WaveformOsc(samples, size);
+		});
 
 		set_updated();
 	}
 
-	const float*
+	const Sample*
 	Oscillator::samples () const
 	{
 		if (self->type != SAMPLES)
@@ -403,21 +368,37 @@ namespace Beeps
 		if (frequency <= 0)
 			argument_error(__FILE__, __LINE__);
 
-		self->frequency = frequency;
+		self->osc->set_frequency(frequency);
+
 		set_updated();
+		clear_sub_input_unless_processing(FREQUENCY);
+	}
+
+	void
+	Oscillator::set_frequency (Processor* frequency)
+	{
+		set_sub_input(FREQUENCY, frequency);
 	}
 
 	float
 	Oscillator::frequency () const
 	{
-		return self->frequency;
+		return self->osc->frequency();
 	}
 
 	void
 	Oscillator::set_phase (float phase)
 	{
 		self->osc->set_phase(phase);
+
 		set_updated();
+		clear_sub_input_unless_processing(PHASE);
+	}
+
+	void
+	Oscillator::set_phase (Processor* phase)
+	{
+		set_sub_input(PHASE, phase);
 	}
 
 	float
@@ -427,24 +408,135 @@ namespace Beeps
 	}
 
 	void
-	Oscillator::generate (Context* context, Signals* signals, uint* offset)
+	Oscillator::set_gain (float gain)
 	{
-		Super::generate(context, signals, offset);
+		if (gain == self->gain)
+			return;
+
+		self->gain = gain;
+
+		set_updated();
+		clear_sub_input_unless_processing(GAIN);
+	}
+
+	void
+	Oscillator::set_gain (Processor* gain)
+	{
+		set_sub_input(GAIN, gain);
+	}
 
-		Frames* frames = Signals_get_frames(signals);
-		if (!frames)
+	float
+	Oscillator::gain () const
+	{
+		return self->gain;
+	}
+
+	void
+	Oscillator::set_offset (float offset)
+	{
+		if (offset == self->offset)
+			return;
+
+		self->offset = offset;
+
+		set_updated();
+		clear_sub_input_unless_processing(OFFSET);
+	}
+
+	void
+	Oscillator::set_offset (Processor* offset)
+	{
+		set_sub_input(OFFSET, offset);
+	}
+
+	float
+	Oscillator::offset () const
+	{
+		return self->offset;
+	}
+
+	void
+	Oscillator::set_duty (float duty)
+	{
+		if (duty <= 0)
+			argument_error(__FILE__, __LINE__);
+		if (duty >= 1)
 			argument_error(__FILE__, __LINE__);
 
-		self->osc->set_frequency(self->frequency);
-		self->osc->tick(frames);
+		if (duty == self->duty)
+			return;
+
+		self->duty = duty;
+		if (type() == SQUARE) update_waveform(this);
+
+		set_updated();
+		clear_sub_input_unless_processing(DUTY);
+	}
+
+	void
+	Oscillator::set_duty (Processor* duty)
+	{
+		set_sub_input(DUTY, duty);
+	}
 
-		Signals_set_nsamples(signals, frames->nframes());
+	float
+	Oscillator::duty () const
+	{
+		return self->duty;
 	}
 
 	Oscillator::operator bool () const
 	{
-		if (!Super::operator bool()) return false;
-		return self->type != TYPE_NONE && self->frequency > 0 && self->osc;
+		if (!Super::operator bool())
+			return false;
+
+		return self->type != TYPE_NONE && self->osc;
+	}
+
+	void
+	Oscillator::generate (Context* context, Signals* signals, uint* offset)
+	{
+		Super::generate(context, signals, offset);
+
+		Processor* pfreq   = sub_input(FREQUENCY);
+		Processor* pphase  = sub_input(PHASE);
+		Processor* pgain   = sub_input(GAIN);
+		Processor* poffset = sub_input(OFFSET);
+		Processor* pduty   = sub_input(DUTY);
+
+		auto* pcontext     = Processor_get_context(context);
+		double sample_rate = signals->sample_rate();
+		uint nsamples      = signals->capacity();
+		uint seg_size      = get_segment_size(sample_rate, nsamples);
+
+		for (uint start = 0; start < nsamples; start += seg_size)
+		{
+			uint seg_offset = *offset + start;
+			if (pfreq)   set_frequency(pcontext->process(pfreq,   seg_size, seg_offset));
+			if (pphase)  set_phase(    pcontext->process(pphase,  seg_size, seg_offset));
+			if (pgain)   set_gain(     pcontext->process(pgain,   seg_size, seg_offset));
+			if (poffset) set_offset(   pcontext->process(poffset, seg_size, seg_offset));
+			if (pduty)   set_duty(     pcontext->process(pduty,   seg_size, seg_offset));
+
+			uint end = std::min(start + seg_size, nsamples);
+			Signals_tick(signals, start, end, [&](stk::StkFrames* frames)
+			{
+				self->osc->tick(frames);
+			});
+			Signals_offset_and_scale(signals, self->offset, self->gain, -1, start, end);
+		}
+
+		*offset += signals->nsamples();
+	}
+
+	int
+	Oscillator::max_segment_size_for_process (
+		double sample_rate, uint nsamples) const
+	{
+		return std::clamp(
+			(uint) (sample_rate / frequency() / NSEGMENTS_PER_WAVEFORM_CYCLE),
+			MIN_BUFFER_SIZE,
+			nsamples);
 	}
 
 

data/src/pitch_shift.cpp

@@ -52,6 +52,12 @@ namespace Beeps
 		return self->shift;
 	}
 
+	PitchShift::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->shift > 0;
+	}
+
 	void
 	PitchShift::filter (Context* context, Signals* signals, uint* offset)
 	{
@@ -72,11 +78,5 @@ namespace Beeps
 		Signals_write_samples(signals, output, signals->nsamples());
 	}
 
-	PitchShift::operator bool () const
-	{
-		if (!Super::operator bool()) return false;
-		return self->shift > 0;
-	}
-
 
 }// Beeps