beeps 0.3.3 → 0.3.5

data/include/beeps/ruby/filter.h

@@ -11,6 +11,8 @@
 
 RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::Gain)
 
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::Mixer)
+
 RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::Envelope)
 
 RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::TimeStretch)
@@ -27,6 +29,9 @@ namespace Beeps
 	BEEPS_EXPORT Rucy::Class gain_class ();
 	// class Beeps::Gain
 
+	BEEPS_EXPORT Rucy::Class mixer_class ();
+	// class Beeps::Mixer
+
 	BEEPS_EXPORT Rucy::Class envelope_class ();
 	// class Beeps::Envelope
 
@@ -53,6 +58,12 @@ namespace Rucy
 		return Beeps::gain_class();
 	}
 
+	template <> inline Class
+	get_ruby_class<Beeps::Mixer> ()
+	{
+		return Beeps::mixer_class();
+	}
+
 	template <> inline Class
 	get_ruby_class<Beeps::Envelope> ()
 	{

data/include/beeps/ruby/processor.h

@@ -21,7 +21,23 @@ namespace Beeps
 
 
 	template <typename T>
-	class RubyProcessor : public Rucy::ClassWrapper<T> {};
+	class RubyProcessor : public Rucy::ClassWrapper<T>
+	{
+
+		typedef Rucy::ClassWrapper<T> Super;
+
+		public:
+
+			virtual void on_start ()
+			{
+				RUCY_SYM(on_start);
+				if (this->is_overridable())
+					this->value.call(on_start);
+				else
+					Super::on_start();
+			}
+
+	};// RubyProcessor
 
 
 }// Beeps

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
@@ -148,11 +154,10 @@ namespace Beeps
 	static size_t
 	slice (Frames* frames, size_t start, float length_sec = -1)
 	{
-		Float sample_rate = frames->dataRate();
-		size_t len        = length_sec >= 0
-			?	length_sec * sample_rate
-			:	frames->nframes() - start;
-		assert(0 < len && (start + len) < frames->nframes());
+		size_t max = frames->nframes() - start;
+		size_t len = length_sec >= 0 ? length_sec * frames->sample_rate() : max;
+		if (len > max) len = max;
+		assert(0 < len && (start + len) <= frames->nframes());
 
 		return frames->slice(start, len);
 	}
@@ -167,6 +172,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 +183,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