beeps 0.1.31 → 0.1.33

data/lib/beeps/processor.rb

@@ -2,6 +2,7 @@
 
 
 require 'xot/setter'
+require 'xot/const_symbol_accessor'
 require 'xot/universal_accessor'
 require 'xot/block_util'
 require 'beeps/ext'
@@ -14,43 +15,122 @@ module Beeps
 
     include Xot::Setter
 
-    def initialize(options = nil, &block)
+    def initialize(**options, &block)
       super()
-      set options if options
+      set options unless options.empty?
       Xot::BlockUtil.instance_eval_or_block_call self, &block if block
     end
 
+    def >>(o)
+      o.input = self
+      o
+    end
+
+    def <<(o)
+      self.input = o
+      o
+    end
+
+    universal_accessor :input
+
   end# Processor
 
 
-  class SineWave
+  class Oscillator
+
+    const_symbol_accessor :type, **{
+      none:     NONE,
+      sine:     SINE,
+      triangle: TRIANGLE,
+      square:   SQUARE,
+      sawtooth: SAWTOOTH
+    }
+
+    def initialize(type = :sine, *args, **kwargs, &block)
+      super(*args, **kwargs, &block)
+      self.type = type
+    end
 
     alias freq= frequency=
     alias freq  frequency
 
-    universal_accessor :frequency, :freq
+    universal_accessor :type, :frequency, :freq
 
-  end# SineWave
+  end# Oscillator
 
 
-  class SquareWave
+  class FileIn
 
-    alias freq= frequency=
-    alias freq  frequency
+    def initialize(path = nil, *args, **kwargs, &block)
+      super(*args, **kwargs, &block)
+      self.path = path if path
+    end
 
-    universal_accessor :frequency, :freq
+    universal_accessor :path
 
-  end# SquareWave
+  end# FileIn
 
 
-  class SawtoothWave
+  class Gain
 
-    alias freq= frequency=
-    alias freq  frequency
+    universal_accessor :gain
+
+  end# Gain
+
+
+  class ADSR
+
+    def note_on(delay = 0)
+      note_on! delay
+    end
+
+    def note_off(delay = 0)
+      note_off! delay
+    end
+
+    universal_accessor :attack_time, :decay_time, :sustain_level, :release_time
+
+    alias  attack=  attack_time=
+    alias  attack   attack_time
+    alias   decay=   decay_time=
+    alias   decay    decay_time
+    alias sustain= sustain_level=
+    alias sustain  sustain_level
+    alias release= release_time=
+    alias release  release_time
+
+  end# ADSR
+
+
+  class TimeStretch
+
+    universal_accessor :scale
+
+  end# TimeStretch
+
+
+  class PitchShift
+
+    universal_accessor :shift
+
+  end# PitchShift
+
+
+  class Analyser
+
+    def each_signal(nsamples = fft_size, &block)
+      return enum_for(:each_signal, nsamples) unless block
+      each_signal!(nsamples, &block)
+    end
+
+    def each_spectrum(&block)
+      return enum_for(:each_spectrum) unless block
+      each_spectrum!(&block)
+    end
 
-    universal_accessor :frequency, :freq
+    universal_accessor :fft_size
 
-  end# SawtoothWave
+  end# Analyser
 
 
 end# Beeps

data/lib/beeps/sound.rb

@@ -1,6 +1,9 @@
 # -*- coding: utf-8 -*-
 
 
+require 'xot/setter'
+require 'xot/universal_accessor'
+require 'xot/block_util'
 require 'beeps/ext'
 
 
@@ -9,11 +12,35 @@ module Beeps
 
   class Sound
 
-    def self.load(path)
-      Sound.new FileIn.new(path), 1
+    include Xot::Setter
+
+    def initialize(
+      processor, seconds = 0, nchannels: 1, sample_rate: 0, **options, &block)
+
+      setup processor, seconds, nchannels, sample_rate
+      set(**options) unless options.empty?
+      Xot::BlockUtil.instance_eval_or_block_call self, &block if block
     end
 
+    def play(**options, &block)
+      play!.tap do |player|
+        player.set(**options) unless options.empty?
+        Xot::BlockUtil.instance_eval_or_block_call player, &block if block
+      end
+    end
+
+    universal_accessor :gain, :loop
+
   end# Sound
 
 
+  class SoundPlayer
+
+    include Xot::Setter
+
+    universal_accessor :gain, :loop
+
+  end# SoundPlayer
+
+
 end# Beeps

data/src/adsr.cpp

@@ -0,0 +1,245 @@
+#include "beeps/filter.h"
+
+
+#include <ADSR.h>
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct ADSR::Data
+	{
+
+		stk::ADSR adsr;
+
+		Signals adsr_signals;
+
+		float attack_time = 0, decay_time = 0, sustain_level = 1, release_time = 0;
+
+		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::Data
+
+
+	ADSR::ADSR (Processor* input)
+	:	Super(input)
+	{
+		self->update_envelope();
+	}
+
+	ADSR::~ADSR ()
+	{
+	}
+
+	void
+	ADSR::note_on (float delay)
+	{
+		if (delay < 0)
+			argument_error(__FILE__, __LINE__);
+
+		float on = self->time + delay, off = self->note_off_time;
+		if (0 <= off && off < on)
+			self->note_off_time = -1;
+
+		self->note_on_time = on;
+
+		set_updated();
+	}
+
+	void
+	ADSR::note_off (float delay)
+	{
+		if (delay < 0)
+			argument_error(__FILE__, __LINE__);
+
+		float off = self->time + delay, on = self->note_on_time;
+		if (0 <= on && off < on)
+			argument_error(__FILE__, __LINE__);
+
+		self->note_off_time = off;
+
+		set_updated();
+	}
+
+	void
+	ADSR::set_attack_time (float time)
+	{
+		if (time < 0)
+			argument_error(__FILE__, __LINE__);
+
+		self->attack_time = time;
+		self->update_envelope();
+
+		set_updated();
+	}
+
+	float
+	ADSR::attack_time () const
+	{
+		return self->attack_time;
+	}
+
+	void
+	ADSR::set_decay_time (float time)
+	{
+		if (time < 0)
+			argument_error(__FILE__, __LINE__);
+
+		self->decay_time = time;
+		self->update_envelope();
+
+		set_updated();
+	}
+
+	float
+	ADSR::decay_time () const
+	{
+		return self->decay_time;
+	}
+
+	void
+	ADSR::set_sustain_level (float level)
+	{
+		if (level < 0)
+			argument_error(__FILE__, __LINE__);
+
+		self->sustain_level = level;
+		self->update_envelope();
+
+		set_updated();
+	}
+
+	float
+	ADSR::sustain_level () const
+	{
+		return self->sustain_level;
+	}
+
+	void
+	ADSR::set_release_time (float time)
+	{
+		if (time < 0)
+			argument_error(__FILE__, __LINE__);
+
+		self->release_time = time;
+		self->update_envelope();
+
+		set_updated();
+	}
+
+	float
+	ADSR::release_time () const
+	{
+		return self->release_time;
+	}
+
+	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->nsamples());
+
+		return frames->slice(start, len);
+	}
+
+	static void
+	process_envelope_signals (ADSR* adsr, Signals* signals)
+	{
+		assert(adsr && signals && signals->nchannels() == 1);
+
+		ADSR::Data* self = adsr->self.get();
+
+		Frames* frames = Signals_get_frames(signals);
+		assert(frames);
+
+		float start = self->time;
+		float end   = start + Signals_get_seconds(*signals);
+		self->time  = end;
+
+		float on  = self->note_on_time;
+		float off = self->note_off_time;
+		assert(on <= off);
+
+		bool has_on =  0 <= on  && start <= on  && on  < end;
+		bool has_off = 0 <= off && start <= off && off < end;
+
+		if (!has_on && !has_off)
+		{
+			self->adsr.tick(*frames);
+			return;
+		}
+
+		size_t last = 0;
+		if (has_on)
+		{
+			if (start < on)
+			{
+				last = slice(frames, 0, on - start);
+				self->adsr.tick(*frames);
+				frames->unslice();
+			}
+			self->adsr.keyOn();
+		}
+		if (has_on || has_off)
+		{
+			float len = has_off ? off - (has_on ? on : start) : -1;
+			last = slice(frames, last, len);
+			self->adsr.tick(*frames);
+			frames->unslice();
+		}
+		if (has_off)
+		{
+			self->adsr.keyOff();
+			if (off < end)
+			{
+				slice(frames, last, -1);
+				self->adsr.tick(*frames);
+				frames->unslice();
+			}
+		}
+	}
+
+	void
+	ADSR::filter (Context* context, Signals* signals, uint* offset)
+	{
+		Super::filter(context, signals, offset);
+
+		if (!self->adsr_signals)
+		{
+			self->adsr_signals =
+				Signals_create(signals->nsamples(), 1, signals->sample_rate());
+		}
+
+		if (self->adsr_signals.nsamples() != signals->nsamples())
+			Signals_resize(&self->adsr_signals, signals->nsamples(), 0);
+
+		process_envelope_signals(this, &self->adsr_signals);
+		Signals_apply(signals, self->adsr_signals);
+	}
+
+	ADSR::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return
+			self->attack_time   >= 0 &&
+			self->decay_time    >= 0 &&
+			self->sustain_level >= 0 &&
+			self->release_time  >= 0 &&
+			self->time          >= 0;
+	}
+
+
+}// Beeps

data/src/analyser.cpp

@@ -0,0 +1,254 @@
+#include "beeps/filter.h"
+
+
+#include <math.h>
+#include <algorithm>
+#include "pffft.h"
+#include "beeps/beeps.h"
+#include "beeps/exception.h"
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct PFFFTDestroySetup
+	{
+		void operator () (PFFFT_Setup* ptr)
+		{
+			pffft_destroy_setup(ptr);
+		}
+	};
+
+	struct PFFFTAlignedFree
+	{
+		void operator () (float* ptr)
+		{
+			pffft_aligned_free(ptr);
+		}
+	};
+
+
+	struct Analyser::Data
+	{
+
+		Signals signals;
+
+		Spectrum spectrum;
+
+		std::unique_ptr<PFFFT_Setup, PFFFTDestroySetup> pffft;
+
+		std::unique_ptr<float[], PFFFTAlignedFree> fft_buffer;
+
+		uint fft_size = 0;
+
+		~Data ()
+		{
+			clear();
+		}
+
+		void setup (uint size)
+		{
+			if (size == fft_size) return;
+
+			clear();
+
+			signals   = Signals_create(std::min(size, (uint) Beeps::sample_rate()));
+			pffft     .reset(pffft_new_setup(size, PFFFT_REAL));
+			fft_buffer.reset((float*) pffft_aligned_malloc(sizeof(float) * size));
+			fft_size  = size;
+		}
+
+		void clear ()
+		{
+			if (!pffft) return;
+
+			signals   = Signals();
+			spectrum  .clear();
+			pffft     .reset();
+			fft_buffer.reset();
+			fft_size  = 0;
+		}
+
+		bool is_valid () const
+		{
+			return signals && pffft && fft_buffer && fft_size > 0;
+		}
+
+	};// Analyser::Data
+
+
+	Analyser::Analyser (uint fft_size, Processor* input)
+	:	Super(input)
+	{
+		set_fft_size(fft_size);
+	}
+
+	Analyser::~Analyser ()
+	{
+	}
+
+	static bool
+	is_valid_fft_size (uint size)
+	{
+		if (size < 32) return false;
+
+		while (size > 1)
+		{
+			     if (size % 2 == 0) size /= 2;
+			else if (size % 3 == 0) size /= 3;
+			else if (size % 5 == 0) size /= 5;
+			else break;
+		}
+		return size == 1;
+	}
+
+	void
+	Analyser::set_fft_size (uint size)
+	{
+		if (!is_valid_fft_size(size))
+			beeps_error(__FILE__, __LINE__, "fft_size must be divisible by 2, 3, or 5");
+
+		self->setup(size);
+	}
+
+	uint
+	Analyser::fft_size () const
+	{
+		return self->fft_size;
+	}
+
+	float
+	Analyser::resolution () const
+	{
+		if (self->fft_size == 0) return 0;
+		return self->signals.sample_rate() / self->fft_size;
+	}
+
+	const Signals&
+	Analyser::signals () const
+	{
+		return self->signals;
+	}
+
+	static void
+	copy_signals_to_fft_buffer (float* buffer, uint size, const Signals& signals)
+	{
+		const double* samples = signals.samples();
+		uint nsamples         = size > signals.nsamples() ? signals.nsamples() : size;
+
+		switch (signals.nchannels())
+		{
+			case 1:
+				for (uint i = 0; i < nsamples; ++i)
+					buffer[i] = samples[i];
+				break;
+
+			case 2:
+				for (uint i = 0; i < nsamples; ++i, samples += 2)
+					buffer[i] = (samples[0] + samples[1]) * 0.5;
+				break;
+
+			default:
+				beeps_error(__FILE__, __LINE__);
+		}
+
+		for (uint i = nsamples; i < size; ++i)
+			buffer[i] = 0;
+	}
+
+	static void
+	update_spectrum (Analyser::Spectrum* spectrum, float* buffer, uint buffer_size)
+	{
+		assert(spectrum && spectrum->empty() && buffer && (buffer_size % 2) == 0);
+
+		uint size  = buffer_size / 2;
+		float div = 1.0 / size;
+		float* p  = buffer;
+
+		spectrum->reserve(size);
+		for (uint i = 0; i < size; ++i, p += 2)
+			spectrum->push_back(sqrt(p[0] * p[0] + p[1] * p[1]) * div);
+	}
+
+	const Analyser::Spectrum&
+	Analyser::spectrum () const
+	{
+		if (self->spectrum.empty() && *this)
+		{
+			float* p = &self->fft_buffer[0];
+			copy_signals_to_fft_buffer(p, self->fft_size, self->signals);
+			pffft_transform_ordered(self->pffft.get(), p, p, NULL, PFFFT_FORWARD);
+			update_spectrum(&self->spectrum, p, self->fft_size);
+		}
+		return self->spectrum;
+	}
+
+	static void
+	shift (Signals* signals, uint nsamples)
+	{
+		if (nsamples > signals->nsamples())
+			return Signals_clear(signals);
+
+		Frames* frames = Signals_get_frames(signals);
+		assert(frames);
+
+		Float* from = &(*frames)(nsamples, 0);
+		Float* to   = &(*frames)(0, 0);
+		uint size   = (signals->nsamples() - nsamples) * signals->nchannels();
+		for (uint i = 0; i < size; ++i)
+			*to++ = *from++;
+
+		Signals_set_nsamples(signals, signals->nsamples() - nsamples);
+	}
+
+	static void
+	append (Signals* to, const Signals& from)
+	{
+		assert(to);
+
+		      Frames* tof   = Signals_get_frames(to);
+		const Frames* fromf = Signals_get_frames(&from);
+		assert(fromf && tof);
+
+		uint   to_cap      =  to->capacity();
+		uint   to_nsamples =  to->nsamples();
+		uint from_nsamples = from.nsamples();
+		uint from_start    = from_nsamples > to_cap ? from_nsamples - to_cap : 0;
+		uint nsamples      = from_nsamples - from_start;
+		assert(to_nsamples + nsamples <= to_capacity);
+
+		for (uint ch = 0; ch < tof->nchannels(); ++ch)
+		{
+			uint from_ch = ch < fromf->nchannels() ? ch : 0;
+			for (uint i = 0; i < nsamples; ++i)
+				(*tof)(to_nsamples + i, ch) = (*fromf)(from_start + i, from_ch);
+		}
+
+		Signals_set_nsamples(to, to_nsamples + nsamples);
+	}
+
+	void
+	Analyser::filter (Context* context, Signals* signals, uint* offset)
+	{
+		Super::filter(context, signals, offset);
+
+		Signals& sig  = self->signals;
+		uint nsamples = sig.nsamples() + signals->nsamples();
+		if (nsamples > sig.capacity())
+			shift(&sig, nsamples - sig.capacity());
+
+		append(&sig, *signals);
+
+		self->spectrum.clear();
+	}
+
+	Analyser::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->is_valid();
+	}
+
+
+}// Beeps

data/src/beeps.cpp

@@ -5,6 +5,8 @@
 #include "Stk.h"
 #include "beeps/exception.h"
 #include "openal.h"
+#include "sound.h"
+#include "mic_in.h"
 
 
 namespace Beeps
@@ -25,8 +27,15 @@ namespace Beeps
 		OpenAL_fin();
 	}
 
-	uint
-	sampling_rate ()
+	void
+	process_streams ()
+	{
+		MicIn_process_streams();
+		SoundPlayer_process_streams();
+	}
+
+	double
+	sample_rate ()
 	{
 		return stk::Stk::sampleRate();
 	}