beeps 0.3.2 → 0.3.4

data/lib/beeps/processor.rb

@@ -1,6 +1,7 @@
 require 'xot/setter'
 require 'xot/const_symbol_accessor'
 require 'xot/universal_accessor'
+require 'xot/hookable'
 require 'xot/block_util'
 require 'beeps/ext'
 
@@ -11,55 +12,76 @@ module Beeps
   class Processor
 
     include Xot::Setter
+    include Xot::Hookable
 
-    def initialize(**options, &block)
+    def initialize(*inputs, **options, &block)
       super()
+      add_input(*inputs)
       set options unless options.empty?
       Xot::BlockUtil.instance_eval_or_block_call self, &block if block
     end
 
-    def >>(o)
-      o.input = self
-      o
+    universal_accessor :input
+
+    def add_input(*inputs)
+      last       = inputs.flatten.compact.last
+      self.input = last if last
     end
 
-    def <<(o)
-      self.input = o
-      o
+    def >>(processor)
+      processor.add_input self
+      processor
     end
 
-    universal_accessor :input
+    #def <<(processors)
+    #  self.add_input(*processors)
+    #  self
+    #end
 
   end# Processor
 
 
   class Oscillator
 
+    include Enumerable
+
     const_symbol_accessor :type, **{
       none:     TYPE_NONE,
       sine:     SINE,
       triangle: TRIANGLE,
       square:   SQUARE,
-      sawtooth: SAWTOOTH
+      sawtooth: SAWTOOTH,
+      noise:    NOISE,
+      samples:  SAMPLES
     }
 
-    def initialize(type = :sine, *args, **kwargs, &block)
-      super(*args, **kwargs, &block)
-      self.type = type
+    def initialize(type = :sine, samples: nil, **kwargs, &block)
+      super(**kwargs, &block)
+      if samples
+        self.samples = samples
+      else
+        self.type = type
+      end
     end
 
+    universal_accessor :type, :frequency, :phase
+
     alias freq= frequency=
     alias freq  frequency
 
-    universal_accessor :type, :frequency, :freq
+    def each_sample(&block)
+      block ? each_sample!(&block) : enum_for(:each_sample!)
+    end
+
+    alias each each_sample
 
   end# Oscillator
 
 
   class FileIn
 
-    def initialize(path = nil, *args, **kwargs, &block)
-      super(*args, **kwargs, &block)
+    def initialize(path = nil, **kwargs, &block)
+      super(**kwargs, &block)
       self.path = path if path
     end
 
@@ -70,13 +92,50 @@ module Beeps
 
   class Gain
 
+    def initialize(gain = 1, **kwargs, &block)
+      super(gain: gain, **kwargs, &block)
+    end
+
     universal_accessor :gain
 
   end# Gain
 
 
+  class Mixer
+
+    include Enumerable
+
+    def add_input(*inputs)
+      add_input! inputs.flatten.compact
+    end
+
+    def remove_input(*inputs)
+      remove_input! inputs.flatten.compact
+    end
+
+    def each_input(&block)
+      block ? each_input!(&block) : enum_for(:each_input!)
+    end
+
+    alias each each_input
+
+  end# Mixer
+
+
   class Envelope
 
+    def initialize(
+      attack = nil, decay = nil, sustain = nil, release = nil,
+      *args, **kwargs, &block)
+
+      attack_time   attack  if attack
+      decay_time    decay   if decay
+      sustain_level sustain if sustain
+      release_time  release if release
+
+      super(*args, **kwargs, &block)
+    end
+
     def note_on(delay = 0)
       note_on! delay
     end
@@ -115,6 +174,8 @@ module Beeps
 
   class Analyser
 
+    universal_accessor :fft_size
+
     def each_signal(nsamples = fft_size, &block)
       return enum_for(:each_signal, nsamples) unless block
       each_signal!(nsamples, &block)
@@ -125,8 +186,6 @@ module Beeps
       each_spectrum!(&block)
     end
 
-    universal_accessor :fft_size
-
   end# Analyser
 
 

data/src/envelope.cpp

@@ -11,6 +11,9 @@ namespace Beeps
 {
 
 
+	static const float TIME_ZERO = 0.0000001;
+
+
 	struct Envelope::Data
 	{
 
@@ -18,16 +21,19 @@ namespace Beeps
 
 		Signals adsr_signals;
 
-		float attack_time = 0, decay_time = 0, sustain_level = 1, release_time = 0;
+		float attack_time   = 0.005;
+		float decay_time    = 0.005;
+		float sustain_level = 1;
+		float release_time  = 0.005;
 
 		float time = 0, note_on_time = -1, note_off_time = -1;
 
 		void update_envelope ()
 		{
-			adsr.setAttackTime(   attack_time == 0 ? 0.01 :  attack_time);
 			adsr.setSustainLevel(sustain_level);
-			adsr.setDecayTime(     decay_time == 0 ? 0.01 :   decay_time);
-			adsr.setReleaseTime( release_time == 0 ? 0.01 : release_time);
+			adsr.setAttackTime(  attack_time == 0 ? TIME_ZERO :  attack_time);
+			adsr.setDecayTime(    decay_time == 0 ? TIME_ZERO :   decay_time);
+			adsr.setReleaseTime(release_time == 0 ? TIME_ZERO : release_time);
 		}
 
 	};// Envelope::Data
@@ -167,6 +173,9 @@ namespace Beeps
 		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
+
 		float start = self->time;
 		float end   = start + Signals_get_seconds(*signals);
 		self->time  = end;
@@ -175,7 +184,7 @@ namespace Beeps
 		float off = self->note_off_time;
 		assert(on <= off);
 
-		bool has_on =  0 <= on  && start <= on  && on  < end;
+		bool has_on  = 0 <= on  && start <= on  && on  < end;
 		bool has_off = 0 <= off && start <= off && off < end;
 
 		if (!has_on && !has_off)

data/src/mixer.cpp

@@ -0,0 +1,112 @@
+#include "beeps/filter.h"
+
+
+#include <algorithm>
+#include <vector>
+#include "processor.h"
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct Mixer::Data
+	{
+
+		std::vector<Processor::Ref> inputs;
+
+	};// Mixer::Data
+
+
+	Mixer::Mixer (Processor* input)
+	{
+		if (input) add_input(input);
+	}
+
+	Mixer::~Mixer ()
+	{
+	}
+
+	void
+	Mixer::add_input (Processor* input)
+	{
+		auto it = std::find(self->inputs.begin(), self->inputs.end(), input);
+		if (it != self->inputs.end()) return;
+
+		self->inputs.emplace_back(input);
+
+		set_updated();
+	}
+
+	void
+	Mixer::remove_input (Processor* input)
+	{
+		auto it = std::find(self->inputs.begin(), self->inputs.end(), input);
+		if (it == self->inputs.end()) return;
+
+		self->inputs.erase(it);
+
+		set_updated();
+	}
+
+	Mixer::iterator
+	Mixer::begin ()
+	{
+		return self->inputs.begin();
+	}
+
+	Mixer::const_iterator
+	Mixer::begin () const
+	{
+		return self->inputs.begin();
+	}
+
+	Mixer::iterator
+	Mixer::end ()
+	{
+		return self->inputs.end();
+	}
+
+	Mixer::const_iterator
+	Mixer::end () const
+	{
+		return self->inputs.end();
+	}
+
+	void
+	Mixer::filter (Context* context, Signals* signals, uint* offset)
+	{
+		Super::filter(context, signals, offset);
+
+		Signals_resize(signals, signals->capacity(), 0);
+
+		Signals sig   = Signals_create(signals->capacity(), signals->nchannels());
+		uint min_size = signals->capacity();
+		for (auto& input : self->inputs)
+		{
+			Signals_clear(&sig);
+
+			uint sig_offset = *offset;
+			Processor_get_context(context)->process(input, &sig, &sig_offset);
+
+			uint size = sig_offset - *offset;
+			if (size < min_size) min_size = size;
+
+			Signals_add(signals, sig);
+		}
+
+		*offset += min_size;
+	}
+
+	Mixer::operator bool () const
+	{
+		if (self->inputs.empty()) return false;
+
+		for (auto& input : self->inputs)
+			if (!*input) return false;
+		return true;
+	}
+
+
+}// Beeps

data/src/oscillator.cpp

@@ -2,6 +2,8 @@
 
 
 #include <assert.h>
+#include <cmath>
+#include <vector>
 #include "SineWave.h"
 #include "Blit.h"
 #include "BlitSquare.h"
@@ -14,6 +16,42 @@ namespace Beeps
 {
 
 
+	class SineWave : public stk::SineWave
+	{
+
+		public:
+
+			void setPhase (stk::StkFloat phase)
+			{
+				time_ = std::fmod(phase, 1.f) * TABLE_SIZE;
+			}
+
+			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
+
+
 	class Osc
 	{
 
@@ -27,10 +65,14 @@ namespace Beeps
 
 			virtual void set_frequency (float freq) = 0;
 
+			virtual void set_phase (float phase) = 0;
+
+			virtual float    phase () const = 0;
+
 	};// Osc
 
 
-	template <typename OSC>
+	template <typename OSC, uint DROP_MSEC>
 	class StkOsc : public Osc
 	{
 
@@ -39,10 +81,18 @@ namespace Beeps
 			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);
 			}
 
@@ -51,21 +101,33 @@ namespace Beeps
 				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<stk::SineWave>   SineOsc;
+	typedef StkOsc<SineWave,          0> SineOsc;
 
-	typedef StkOsc<stk::BlitSquare> SquareOsc;
+	typedef StkOsc<stk::BlitSquare, 100> SquareOsc;
 
-	typedef StkOsc<stk::BlitSaw>    SawtoothOsc;
+	typedef StkOsc<BlitSaw,         200> SawtoothOsc;
 
 
-	class TriangleOsc : public StkOsc<stk::Blit>
+	class TriangleOsc : public StkOsc<stk::Blit, 0>
 	{
 
 		public:
@@ -78,6 +140,164 @@ namespace Beeps
 	};// TriangleOsc
 
 
+	class NoiseOsc : public Osc
+	{
+
+		public:
+
+			void reset () override
+			{
+				time = 0;
+			}
+
+			void tick (Frames* frames) override
+			{
+				if (0 < freq && (freq * 2) <= frames->sample_rate())
+					tick_with_freq(frames);
+				else
+					tick_without_freq(frames);
+			}
+
+			void set_frequency (float freq) override
+			{
+				this->freq = freq;
+			}
+
+			void set_phase (float phase) override
+			{
+				time = freq == 0 ? 0 : phase * (1.f / freq);
+			}
+
+			float phase () const override
+			{
+				return freq == 0 ? 0 : time / (1.f / freq);
+			}
+
+		private:
+
+			float freq  = 0;
+
+			double time = 0;
+
+			void tick_without_freq (Frames* frames)
+			{
+				uint nchannels = frames->nchannels();
+				uint nframes   = frames->nframes();
+				Float* pframe  = &(*frames)(0, 0);
+				for (uint i = 0; i < nframes; ++i, ++pframe)
+				{
+					uint ch = i % nchannels;
+					*pframe = ch == 0 ? noise() : pframe[-ch];
+				}
+			}
+
+			void tick_with_freq (Frames* frames)
+			{
+				float time_per_sample = 1.f / frames->sample_rate();
+				float time_per_freq   = 1.f / (freq * 2);
+
+				uint nchannels = frames->nchannels();
+				uint nframes   = frames->nframes();
+				Float* pframe  = &(*frames)(0, 0);
+				float value    = noise();
+				for (uint i = 0; i < nframes; ++i, ++pframe)
+				{
+					if (i % nchannels == 0)
+					{
+						*pframe = value;
+
+						time += time_per_sample;
+						while (time >= time_per_freq)
+						{
+							value = noise();
+							time -= time_per_freq;
+						}
+					}
+					else
+						*pframe = value;
+				}
+			}
+
+			double noise () const
+			{
+				return rand() / ((double) RAND_MAX + 1) * 2 - 1;
+			}
+
+	};// NoiseOsc
+
+
+	class WaveformOsc : public Osc
+	{
+
+		public:
+
+			typedef std::vector<float> Table;
+
+			WaveformOsc (float* samples, size_t nsamples, float frequency)
+			:	table(samples, samples + nsamples), freq(frequency), time(0)
+			{
+			}
+
+			void reset () override
+			{
+				time = 0;
+			}
+
+			void tick (Frames* frames) override
+			{
+				size_t size = table.size();
+				float dt    = size * freq / frames->sample_rate();
+
+				uint nchannels = frames->nchannels();
+				uint nframes   = frames->nframes();
+				Float* pframe  = &(*frames)(0, 0);
+				for (uint i = 0; i < nframes; ++i, ++pframe)
+				{
+					uint ch = i % nchannels;
+					if (ch == 0)
+					{
+						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;
+
+						time += dt;
+						while (time >= size) time -= size;
+					}
+					else
+						*pframe = pframe[-ch];
+				}
+			}
+
+			void set_frequency (float freq) override
+			{
+				this->freq = freq;
+			}
+
+			void set_phase (float phase) override
+			{
+				this->time = std::fmod(phase, 1.f) * table.size();
+			}
+
+			float phase () const override
+			{
+				return time / table.size();
+			}
+
+			const Table& samples () const
+			{
+				return table;
+			}
+
+		private:
+
+			Table table;
+
+			float freq, time;
+
+	};// WaveformOsc
+
+
 	struct Oscillator::Data
 	{
 
@@ -95,6 +315,11 @@ namespace Beeps
 		set_type(type);
 	}
 
+	Oscillator::Oscillator (float* samples, size_t size)
+	{
+		set_samples(samples, size);
+	}
+
 	Oscillator::~Oscillator ()
 	{
 	}
@@ -111,6 +336,8 @@ namespace Beeps
 	{
 		if (type == self->type) return;
 
+		float phase = self->osc ? self->osc->phase() : 0;
+
 		self->type = type;
 		self->osc.reset();
 
@@ -120,12 +347,15 @@ namespace Beeps
 			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);
 				break;
 		}
 
+		self->osc->set_phase(phase);
+
 		set_updated();
 	}
 
@@ -135,6 +365,38 @@ namespace Beeps
 		return self->type;
 	}
 
+	void
+	Oscillator::set_samples (float* 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);
+
+		set_updated();
+	}
+
+	const float*
+	Oscillator::samples () const
+	{
+		if (self->type != SAMPLES)
+			return NULL;
+
+		auto* osc = (const WaveformOsc*) self->osc.get();
+		return &osc->samples()[0];
+	}
+
+	size_t
+	Oscillator::nsamples () const
+	{
+		if (self->type != SAMPLES)
+			return 0;
+
+		auto* osc = (WaveformOsc*) self->osc.get();
+		return osc->samples().size();
+	}
+
 	void
 	Oscillator::set_frequency (float frequency)
 	{
@@ -142,7 +404,6 @@ namespace Beeps
 			argument_error(__FILE__, __LINE__);
 
 		self->frequency = frequency;
-
 		set_updated();
 	}
 
@@ -152,6 +413,19 @@ namespace Beeps
 		return self->frequency;
 	}
 
+	void
+	Oscillator::set_phase (float phase)
+	{
+		self->osc->set_phase(phase);
+		set_updated();
+	}
+
+	float
+	Oscillator::phase () const
+	{
+		return self->osc->phase();
+	}
+
 	void
 	Oscillator::generate (Context* context, Signals* signals, uint* offset)
 	{