beeps 0.3 → 0.3.1

data/src/{adsr.cpp → envelope.cpp}

@@ -3,6 +3,7 @@
 
 #include <assert.h>
 #include <ADSR.h>
+#include "beeps/debug.h"
 #include "signals.h"
 
 
@@ -10,7 +11,7 @@ namespace Beeps
 {
 
 
-	struct ADSR::Data
+	struct Envelope::Data
 	{
 
 		stk::ADSR adsr;
@@ -29,21 +30,21 @@ namespace Beeps
 			adsr.setReleaseTime( release_time == 0 ? 0.01 : release_time);
 		}
 
-	};// ADSR::Data
+	};// Envelope::Data
 
 
-	ADSR::ADSR (Processor* input)
+	Envelope::Envelope (Processor* input)
 	:	Super(input)
 	{
 		self->update_envelope();
 	}
 
-	ADSR::~ADSR ()
+	Envelope::~Envelope ()
 	{
 	}
 
 	void
-	ADSR::note_on (float delay)
+	Envelope::note_on (float delay)
 	{
 		if (delay < 0)
 			argument_error(__FILE__, __LINE__);
@@ -58,7 +59,7 @@ namespace Beeps
 	}
 
 	void
-	ADSR::note_off (float delay)
+	Envelope::note_off (float delay)
 	{
 		if (delay < 0)
 			argument_error(__FILE__, __LINE__);
@@ -73,7 +74,7 @@ namespace Beeps
 	}
 
 	void
-	ADSR::set_attack_time (float time)
+	Envelope::set_attack_time (float time)
 	{
 		if (time < 0)
 			argument_error(__FILE__, __LINE__);
@@ -85,13 +86,13 @@ namespace Beeps
 	}
 
 	float
-	ADSR::attack_time () const
+	Envelope::attack_time () const
 	{
 		return self->attack_time;
 	}
 
 	void
-	ADSR::set_decay_time (float time)
+	Envelope::set_decay_time (float time)
 	{
 		if (time < 0)
 			argument_error(__FILE__, __LINE__);
@@ -103,13 +104,13 @@ namespace Beeps
 	}
 
 	float
-	ADSR::decay_time () const
+	Envelope::decay_time () const
 	{
 		return self->decay_time;
 	}
 
 	void
-	ADSR::set_sustain_level (float level)
+	Envelope::set_sustain_level (float level)
 	{
 		if (level < 0)
 			argument_error(__FILE__, __LINE__);
@@ -121,13 +122,13 @@ namespace Beeps
 	}
 
 	float
-	ADSR::sustain_level () const
+	Envelope::sustain_level () const
 	{
 		return self->sustain_level;
 	}
 
 	void
-	ADSR::set_release_time (float time)
+	Envelope::set_release_time (float time)
 	{
 		if (time < 0)
 			argument_error(__FILE__, __LINE__);
@@ -139,7 +140,7 @@ namespace Beeps
 	}
 
 	float
-	ADSR::release_time () const
+	Envelope::release_time () const
 	{
 		return self->release_time;
 	}
@@ -157,11 +158,11 @@ namespace Beeps
 	}
 
 	static void
-	process_envelope_signals (ADSR* adsr, Signals* signals)
+	process_envelope_signals (Envelope* envelope, Signals* signals)
 	{
-		assert(adsr && signals && signals->nchannels() == 1);
+		assert(envelope && signals && signals->nchannels() == 1);
 
-		ADSR::Data* self = adsr->self.get();
+		Envelope::Data* self = envelope->self.get();
 
 		Frames* frames = Signals_get_frames(signals);
 		assert(frames);
@@ -214,7 +215,7 @@ namespace Beeps
 	}
 
 	void
-	ADSR::filter (Context* context, Signals* signals, uint* offset)
+	Envelope::filter (Context* context, Signals* signals, uint* offset)
 	{
 		Super::filter(context, signals, offset);
 
@@ -228,10 +229,10 @@ namespace Beeps
 			Signals_resize(&self->adsr_signals, signals->nsamples(), 0);
 
 		process_envelope_signals(this, &self->adsr_signals);
-		Signals_apply(signals, self->adsr_signals);
+		Signals_multiply(signals, self->adsr_signals);
 	}
 
-	ADSR::operator bool () const
+	Envelope::operator bool () const
 	{
 		if (!Super::operator bool()) return false;
 		return

data/src/openal.cpp

@@ -42,7 +42,9 @@ namespace Beeps
 	void
 	OpenAL_init ()
 	{
-		if (global::device || global::context)
+		if (global::device)
+			beeps_error(__FILE__, __LINE__, "already initialized.");
+		if (global::context)
 			beeps_error(__FILE__, __LINE__, "already initialized.");
 
 		global::device = alcOpenDevice(NULL);

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/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