beeps 0.1.32 → 0.1.33

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();
 	}

data/src/file_in.cpp

@@ -0,0 +1,94 @@
+#include "beeps/generator.h"
+
+
+#include "beeps/exception.h"
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct FileIn::Data
+	{
+
+		String path;
+
+		Signals signals;
+
+	};// FileIn::Data
+
+
+	FileIn::FileIn (const char* path)
+	{
+		if (path) set_path(path);
+	}
+
+	FileIn::~FileIn ()
+	{
+	}
+
+	void
+	FileIn::reset ()
+	{
+		Super::reset();
+	}
+
+	void
+	FileIn::set_path (const char* path)
+	{
+		if (*this)
+			invalid_state_error(__FILE__, __LINE__, "path is already set");
+
+		self->signals = Signals_load(path);
+		self->path    = path;
+
+		set_updated();
+	}
+
+	const char*
+	FileIn::path () const
+	{
+		return self->path;
+	}
+
+	double
+	FileIn::sample_rate () const
+	{
+		return self->signals.sample_rate();
+	}
+
+	uint
+	FileIn::nchannels () const
+	{
+		return self->signals.nchannels();
+	}
+
+	uint
+	FileIn::nsamples () const
+	{
+		return self->signals.nsamples();
+	}
+
+	float
+	FileIn::seconds () const
+	{
+		return Signals_get_seconds(self->signals);
+	}
+
+	void
+	FileIn::generate (Context* context, Signals* signals, uint* offset)
+	{
+		Super::generate(context, signals, offset);
+
+		*offset += Signals_copy(signals, self->signals, *offset);
+	}
+
+	FileIn::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->signals;
+	}
+
+
+}// Beeps

data/src/gain.cpp

@@ -0,0 +1,55 @@
+#include "beeps/filter.h"
+
+
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct Gain::Data
+	{
+
+		float gain = 1;
+
+	};// Gain::Data
+
+
+	Gain::Gain (Processor* input)
+	:	Super(input)
+	{
+	}
+
+	Gain::~Gain ()
+	{
+	}
+
+	void
+	Gain::set_gain (float gain)
+	{
+		self->gain = gain;
+
+		set_updated();
+	}
+
+	float
+	Gain::gain () const
+	{
+		return self->gain;
+	}
+
+	void
+	Gain::filter (Context* context, Signals* signals, uint* offset)
+	{
+		Super::filter(context, signals, offset);
+
+		Frames* frames = Signals_get_frames(signals);
+		if (!frames)
+			argument_error(__FILE__, __LINE__);
+
+		*frames *= self->gain;
+	}
+
+
+}// Beeps