beeps 0.2.1 → 0.3.1

data/src/oscillator.cpp

@@ -3,6 +3,7 @@
 
 #include <assert.h>
 #include "SineWave.h"
+#include "Blit.h"
 #include "BlitSquare.h"
 #include "BlitSaw.h"
 #include "beeps/exception.h"
@@ -13,6 +14,70 @@ namespace Beeps
 {
 
 
+	class Osc
+	{
+
+		public:
+
+			virtual ~Osc () {}
+
+			virtual void reset () = 0;
+
+			virtual void tick (Frames* frames) = 0;
+
+			virtual void set_frequency (float freq) = 0;
+
+	};// Osc
+
+
+	template <typename OSC>
+	class StkOsc : public Osc
+	{
+
+		public:
+
+			void reset () override
+			{
+				osc.reset();
+			}
+
+			void tick (Frames* frames) override
+			{
+				osc.tick(*frames);
+			}
+
+			void set_frequency (float freq) override
+			{
+				osc.setFrequency(freq);
+			}
+
+		protected:
+
+			OSC osc;
+
+	};// StkOsc
+
+
+	typedef StkOsc<stk::SineWave>   SineOsc;
+
+	typedef StkOsc<stk::BlitSquare> SquareOsc;
+
+	typedef StkOsc<stk::BlitSaw>    SawtoothOsc;
+
+
+	class TriangleOsc : public StkOsc<stk::Blit>
+	{
+
+		public:
+
+			TriangleOsc ()
+			{
+				osc.setHarmonics(10);
+			}
+
+	};// TriangleOsc
+
+
 	struct Oscillator::Data
 	{
 
@@ -20,11 +85,7 @@ namespace Beeps
 
 		float frequency = 440;
 
-		std::unique_ptr<stk::SineWave> sine;
-
-		std::unique_ptr<stk::BlitSquare> square;
-
-		std::unique_ptr<stk::BlitSaw> saw;
+		std::unique_ptr<Osc> osc;
 
 	};// Oscillator::Data
 
@@ -42,10 +103,7 @@ namespace Beeps
 	Oscillator::reset ()
 	{
 		Super::reset();
-
-		if (self->sine)   self->sine->reset();
-		if (self->square) self->square->reset();
-		if (self->saw)    self->saw->reset();
+		self->osc->reset();
 	}
 
 	void
@@ -54,16 +112,14 @@ namespace Beeps
 		if (type == self->type) return;
 
 		self->type = type;
-
-		self->sine  .reset();
-		self->square.reset();
-		self->saw   .reset();
+		self->osc.reset();
 
 		switch (self->type)
 		{
-			case SINE:     self->sine  .reset(new stk::SineWave());   break;
-			case SQUARE:   self->square.reset(new stk::BlitSquare()); break;
-			case SAWTOOTH: self->saw   .reset(new stk::BlitSaw());    break;
+			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;
 			default:
 				argument_error(
 					__FILE__, __LINE__, "unknown oscilator type '%d'", self->type);
@@ -105,31 +161,8 @@ namespace Beeps
 		if (!frames)
 			argument_error(__FILE__, __LINE__);
 
-		switch (self->type)
-		{
-			case SINE:
-				assert(self->sine);
-				self->sine->setFrequency(self->frequency);
-				self->sine->tick(*frames);
-				break;
-
-			case SQUARE:
-				assert(self->square);
-				self->square->setFrequency(self->frequency);
-				self->square->tick(*frames);
-				break;
-
-			case SAWTOOTH:
-				assert(self->saw);
-				self->saw->setFrequency(self->frequency);
-				self->saw->tick(*frames);
-				break;
-
-			default:
-				invalid_state_error(
-					__FILE__, __LINE__, "unknown oscilator type '%d'", self->type);
-				break;
-		}
+		self->osc->set_frequency(self->frequency);
+		self->osc->tick(frames);
 
 		Signals_set_nsamples(signals, frames->nframes());
 	}
@@ -137,9 +170,7 @@ namespace Beeps
 	Oscillator::operator bool () const
 	{
 		if (!Super::operator bool()) return false;
-		return
-			self->type != TYPE_NONE && self->frequency > 0 &&
-			(self->sine || self->square || self->saw);
+		return self->type != TYPE_NONE && self->frequency > 0 && self->osc;
 	}
 
 

data/src/osx/beeps.mm

@@ -0,0 +1,19 @@
+#include "../beeps.h"
+
+
+namespace Beeps
+{
+
+
+	void
+	Beeps_init ()
+	{
+	}
+
+	void
+	Beeps_fin ()
+	{
+	}
+
+
+}// Beeps

data/src/processor.cpp

@@ -4,19 +4,13 @@
 #include <assert.h>
 #include <xot/time.h>
 #include "beeps/exception.h"
+#include "beeps/debug.h"
 
 
 namespace Beeps
 {
 
 
-	static ProcessorContext*
-	get_context(Processor::Context* context)
-	{
-		return (ProcessorContext*) context;
-	}
-
-
 	struct Processor::Data
 	{
 
@@ -36,6 +30,12 @@ namespace Beeps
 	};// Processor::Data
 
 
+	ProcessorContext*
+	Processor_get_context(Processor::Context* context)
+	{
+		return (ProcessorContext*) context;
+	}
+
 	float
 	Processor_get_buffering_seconds (Processor* processor)
 	{
@@ -108,24 +108,40 @@ namespace Beeps
 	void
 	Processor::generate (Context* context, Signals* signals, uint* offset)
 	{
-		if (!context || !signals || !*signals || signals->nsamples() > 0 || !offset)
+		if (!context)
+			argument_error(__FILE__, __LINE__);
+		if (!signals)
+			argument_error(__FILE__, __LINE__);
+		if (!*signals)
+			argument_error(__FILE__, __LINE__);
+		if (signals->nsamples() > 0)
+			argument_error(__FILE__, __LINE__);
+		if (!offset)
 			argument_error(__FILE__, __LINE__);
 
-		if (!*this || self->input)
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+		if (self->input)
 			invalid_state_error(__FILE__, __LINE__);
 	}
 
 	void
 	Processor::filter (Context* context, Signals* signals, uint* offset)
 	{
-		if (!context || !signals || !*signals || !offset)
+		if (!context)
+			argument_error(__FILE__, __LINE__);
+		if (!signals)
+			argument_error(__FILE__, __LINE__);
+		if (!*signals)
+			argument_error(__FILE__, __LINE__);
+		if (!offset)
 			argument_error(__FILE__, __LINE__);
 
 		if (!*this)
 			invalid_state_error(__FILE__, __LINE__);
 
 		if (self->input)
-			get_context(context)->process(self->input, signals, offset);
+			Processor_get_context(context)->process(self->input, signals, offset);
 	}
 
 	void
@@ -235,25 +251,9 @@ namespace Beeps
 	}
 
 
-	ProcessorContext::ProcessorContext (
-		uint nsamples_per_process, uint nchannels, double sample_rate)
-	:	signals(Signals_create(nsamples_per_process, nchannels, sample_rate))
-	{
-		assert(*this);
-	}
-
-	Signals
-	ProcessorContext::process_signals (Processor* processor)
+	ProcessorContext::ProcessorContext (uint nchannels, double sample_rate)
+	:	sample_rate(sample_rate), nchannels(nchannels)
 	{
-		assert(processor);
-
-		Signals_clear(&signals);
-		process(processor, &signals, &offset);
-
-		if (signals.nsamples() < signals.capacity())
-			finished = true;
-
-		return signals.nsamples() > 0 ? signals : Signals();
 	}
 
 	void
@@ -269,23 +269,6 @@ namespace Beeps
 			processor->process(this, signals, offset);
 	}
 
-	bool
-	ProcessorContext::is_finished () const
-	{
-		return finished;
-	}
-
-	ProcessorContext::operator bool () const
-	{
-		return signals && !finished;
-	}
-
-	bool
-	ProcessorContext::operator ! () const
-	{
-		return !operator bool();
-	}
-
 	static uintptr_t
 	get_buffer_key (Processor* processor)
 	{
@@ -304,13 +287,40 @@ namespace Beeps
 		auto it       = buffers.find(key);
 		if (it != buffers.end()) return it->second.get();
 
-		SignalsBuffer* buffer = new SignalsBuffer(
-			buffering_sec * signals.sample_rate(),
-			signals.nchannels(), signals.sample_rate());
+		SignalsBuffer* buffer =
+			new SignalsBuffer(buffering_sec * sample_rate, nchannels, sample_rate);
 
 		buffers.emplace(key, buffer);
 		return buffer;
 	}
 
 
+	StreamContext::StreamContext (
+		uint nsamples_per_process, uint nchannels, double sample_rate)
+	:	context(nchannels, sample_rate),
+		signals(Signals_create(nsamples_per_process, nchannels, sample_rate))
+	{
+	}
+
+	Signals
+	StreamContext::process_next (Processor* processor)
+	{
+		assert(processor);
+
+		Signals_clear(&signals);
+		context.process(processor, &signals, &offset);
+
+		if (signals.nsamples() < signals.capacity())
+			finished = true;
+
+		return signals;
+	}
+
+	bool
+	StreamContext::is_finished () const
+	{
+		return finished;
+	}
+
+
 }// Beeps

data/src/processor.h

@@ -16,6 +16,8 @@ namespace Beeps
 	class ProcessorContext;
 
 
+	ProcessorContext* Processor_get_context (Processor::Context* context);
+
 	float Processor_get_buffering_seconds (Processor* processor);
 
 
@@ -56,40 +58,54 @@ namespace Beeps
 
 		public:
 
-			ProcessorContext (
-				uint nsamples_per_process, uint nchannels, double sample_rate);
-
-			Signals process_signals (Processor* processor);
+			ProcessorContext (uint nchannels, double sample_rate);
 
 			void process (
 				Processor* processor, Signals* signals, uint* offset,
 				bool ignore_buffer = false);
 
+		private:
+
+			double sample_rate;
+
+			uint nchannels;
+
+			std::map<uintptr_t, std::unique_ptr<SignalsBuffer>> buffers;
+
+			SignalsBuffer* get_buffer (Processor* processor);
+
+	};// ProcessorContext
+
+
+	class StreamContext
+	{
+
+		public:
+
+			StreamContext (
+				uint nsamples_per_process, uint nchannels, double sample_rate);
+
+			Signals process_next (Processor* processor);
+
 			//void push_offset (uint offset);
 
 			//uint pop_offset ();
 
 			bool is_finished () const;
 
-			operator bool () const;
-
-			bool operator ! () const;
-
 		private:
 
+			ProcessorContext context;
+
 			Signals signals;
 
-			uint offset = 0;
+			uint offset   = 0;
 
 			bool finished = false;
 
 			//std::vector<uint> offset_stack;
 
-			std::map<uintptr_t, std::unique_ptr<SignalsBuffer>> buffers;
-
-			SignalsBuffer* get_buffer (Processor* processor);
-
-	};// ProcessorContext
+	};// StreamContext
 
 
 }// Beeps

data/src/sequencer.cpp

@@ -0,0 +1,160 @@
+#include "beeps/generator.h"
+
+
+#include <list>
+#include <algorithm>
+#include "beeps/exception.h"
+#include "beeps/debug.h"
+#include "processor.h"
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct Sequencer::Data
+	{
+
+		struct Note
+		{
+
+			Processor::Ref processor;
+
+			float offset, duration;
+
+			Note (Processor* processor, float offset, float duration)
+			:	processor(processor), offset(offset), duration(duration)
+			{
+			}
+
+		};// Note
+
+		std::list<Note> notes;
+
+		float time_scale = 1;
+
+		uint sec2nsample (const Signals& signals, float sec) const
+		{
+			return sec * signals.sample_rate() / time_scale;
+		}
+
+	};// Sequencer::Data
+
+
+	Sequencer::Sequencer ()
+	{
+	}
+
+	Sequencer::~Sequencer ()
+	{
+	}
+
+	void
+	Sequencer::add (Processor* processor, float offset, float duration)
+	{
+		auto& notes = self->notes;
+		for (auto it = notes.begin(), end = notes.end(); it != end; ++it)
+		{
+			if (offset < it->offset)
+			{
+				notes.emplace(it, processor, offset, duration);
+				return;
+			}
+		}
+		notes.emplace_back(processor, offset, duration);
+	}
+
+	void
+	Sequencer::remove (Processor* processor, float offset)
+	{
+		auto it =
+			std::find_if(self->notes.begin(), self->notes.end(), [&](auto& note)
+			{
+				return note.processor == processor && note.offset == offset;
+			});
+		if (it == self->notes.end()) return;
+
+		self->notes.erase(it);
+	}
+
+	void
+	Sequencer::set_time_scale (float time_scale)
+	{
+		if (time_scale <= 0)
+			argument_error(__FILE__, __LINE__, "time_scale must be greater than 0");
+
+		self->time_scale = time_scale;
+	}
+
+	float
+	Sequencer::time_scale () const
+	{
+		return self->time_scale;
+	}
+
+	static void
+	mix (Signals* mixed, const Signals& source, uint source_offset)
+	{
+		Frames* mixf = Signals_get_frames(mixed);
+		Frames* srcf = Signals_get_frames(const_cast<Signals*>(&source));
+		Float* mixp  = &(*mixf)(source_offset, 0);
+		Float* srcp  = &(*srcf)(0, 0);
+		uint size    = source.nsamples() * source.nchannels();
+		for (uint i = 0; i < size; ++i, ++mixp, ++srcp)
+			*mixp += *srcp;
+	}
+
+	void
+	Sequencer::generate (Context* pcontext, Signals* psignals, uint* offset)
+	{
+		Super::generate(pcontext, psignals, offset);
+
+		auto& context = *Processor_get_context(pcontext);
+		auto& signals = *psignals;
+		Signals_resize(&signals, signals.capacity(), 0);
+
+		uint generate_begin  = *offset;
+		uint generate_end    = *offset + signals.capacity();
+		Signals note_signals = Signals_create(
+			signals.capacity(), signals.nchannels(), signals.sample_rate());
+
+		uint nsamples = 0;
+		for (auto& note : self->notes)
+		{
+			uint note_begin = self->sec2nsample(signals, note.offset);
+			uint note_end   = self->sec2nsample(signals, note.offset + note.duration);
+			if (note_end <= generate_begin) continue;
+			if (generate_end <= note_begin)
+			{
+				nsamples = generate_end - generate_begin;
+				break;
+			}
+
+			uint begin = std::max(generate_begin, note_begin);
+			uint end   = std::min(generate_end,   note_end);
+			assert(begin != end);
+
+			uint note_offset = begin - note_begin;
+			Signals_clear(&note_signals, end - begin);
+			context.process(note.processor.get(), &note_signals, &note_offset);
+
+			uint mix_offset  = begin - generate_begin;
+			mix(&signals, note_signals, mix_offset);
+
+			if (mix_offset + note_signals.nsamples() > nsamples)
+				nsamples = mix_offset + note_signals.nsamples();
+		}
+
+		Signals_set_nsamples(&signals, nsamples);
+		*offset += nsamples;
+	}
+
+	Sequencer::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->time_scale > 0;
+	}
+
+
+}// Beeps