beeps 0.1.31 → 0.1.33

data/ext/beeps/adsr.cpp

@@ -0,0 +1,150 @@
+#include "beeps/ruby/filter.h"
+
+
+#include "beeps/ruby/processor.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Beeps::ADSR)
+
+#define THIS  to<Beeps::ADSR*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::ADSR, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::ADSR>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(note_on, delay)
+{
+	CHECK;
+
+	THIS->note_on(to<float>(delay));
+}
+RUCY_END
+
+static
+RUCY_DEF1(note_off, delay)
+{
+	CHECK;
+
+	THIS->note_off(to<float>(delay));
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_attack_time, time)
+{
+	CHECK;
+
+	THIS->set_attack_time(to<float>(time));
+	return time;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_attack_time)
+{
+	CHECK;
+
+	return value(THIS->attack_time());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_decay_time, time)
+{
+	CHECK;
+
+	THIS->set_decay_time(to<float>(time));
+	return time;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_decay_time)
+{
+	CHECK;
+
+	return value(THIS->decay_time());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_sustain_level, level)
+{
+	CHECK;
+
+	THIS->set_sustain_level(to<float>(level));
+	return level;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_sustain_level)
+{
+	CHECK;
+
+	return value(THIS->sustain_level());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_release_time, time)
+{
+	CHECK;
+
+	THIS->set_release_time(to<float>(time));
+	return time;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_release_time)
+{
+	CHECK;
+
+	return value(THIS->release_time());
+}
+RUCY_END
+
+
+static Class cADSR;
+
+void
+Init_beeps_adsr ()
+{
+	Module mBeeps = define_module("Beeps");
+
+	cADSR = mBeeps.define_class("ADSR", Beeps::processor_class());
+	cADSR.define_alloc_func(alloc);
+	cADSR.define_private_method("note_on!",  note_on);
+	cADSR.define_private_method("note_off!", note_off);
+	cADSR.define_method( "attack_time=",   set_attack_time);
+	cADSR.define_method( "attack_time",    get_attack_time);
+	cADSR.define_method(  "decay_time=",    set_decay_time);
+	cADSR.define_method(  "decay_time",     get_decay_time);
+	cADSR.define_method("sustain_level=", set_sustain_level);
+	cADSR.define_method("sustain_level",  get_sustain_level);
+	cADSR.define_method("release_time=",  set_release_time);
+	cADSR.define_method("release_time",   get_release_time);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	adsr_class ()
+	{
+		return cADSR;
+	}
+
+
+}// Beeps

data/ext/beeps/analyser.cpp

@@ -0,0 +1,134 @@
+#include "beeps/ruby/filter.h"
+
+
+#include "beeps/ruby/processor.h"
+#include "beeps/signals.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Beeps::Analyser)
+
+#define THIS  to<Beeps::Analyser*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::Analyser, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::Analyser>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_fft_size, size)
+{
+	CHECK;
+
+	THIS->set_fft_size(to<uint>(size));
+	return size;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_fft_size)
+{
+	CHECK;
+
+	return value(THIS->fft_size());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_resolution)
+{
+	CHECK;
+
+	return value(THIS->resolution());
+}
+RUCY_END
+
+static
+RUCY_DEF1(each_signal, nsamples_)
+{
+	CHECK;
+
+	if (!*THIS)
+		invalid_object_error(__FILE__, __LINE__);
+
+	const Beeps::Signals& sig = THIS->signals();
+
+	uint nsamples = to<uint>(nsamples_);
+	if (nsamples > sig.nsamples()) nsamples = sig.nsamples();
+
+	const double* samples = sig.samples();
+	uint nchannels        = sig.nchannels();
+	uint start            = (sig.nsamples() - nsamples) * nchannels;
+	switch (nchannels)
+	{
+		case 1:
+			for (uint i = start; i < nsamples; ++i)
+				rb_yield(value(samples[i]));
+			break;
+
+		case 2:
+			Value values[2];
+			Value args(2, values);
+			for (uint i = start; i < nsamples; i += 2)
+			{
+				args[0] = value(samples[i + 0]);
+				args[1] = value(samples[i + 1]);
+				rb_yield(args);
+			}
+			break;
+	}
+
+	return nil();
+}
+RUCY_END
+
+static
+RUCY_DEF0(each_spectrum)
+{
+	CHECK;
+
+	if (!*THIS)
+		invalid_object_error(__FILE__, __LINE__);
+
+	for (auto val : THIS->spectrum())
+		rb_yield(value(val));
+
+	return nil();
+}
+RUCY_END
+
+
+static Class cAnalyser;
+
+void
+Init_beeps_analyser ()
+{
+	Module mBeeps = define_module("Beeps");
+
+	cAnalyser = mBeeps.define_class("Analyser", Beeps::processor_class());
+	cAnalyser.define_alloc_func(alloc);
+	cAnalyser.define_method("fft_size=",  set_fft_size);
+	cAnalyser.define_method("fft_size",   get_fft_size);
+	cAnalyser.define_method("resolution", get_resolution);
+	cAnalyser.define_private_method("each_signal!",   each_signal);
+	cAnalyser.define_private_method("each_spectrum!", each_spectrum);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	analyser_class ()
+	{
+		return cAnalyser;
+	}
+
+
+}// Beeps

data/ext/beeps/beeps.cpp

@@ -21,6 +21,14 @@ RUCY_DEF0(fin)
 }
 RUCY_END
 
+static
+RUCY_DEF0(process_streams)
+{
+	Beeps::process_streams();
+	return self;
+}
+RUCY_END
+
 
 static Module mBeeps;
 
@@ -29,7 +37,8 @@ Init_beeps ()
 {
 	mBeeps = define_module("Beeps");
 	mBeeps.define_singleton_method("init!", init);
-	mBeeps.define_singleton_method("fin!", fin);
+	mBeeps.define_singleton_method("fin!",  fin);
+	mBeeps.define_singleton_method("process_streams!", process_streams);
 }
 
 

data/ext/beeps/extconf.rb

@@ -15,8 +15,7 @@ require 'beeps/extension'
 Xot::ExtConf.new Xot, Rucy, Beeps do
   setup do
     headers    << 'ruby.h' << 'OpenAL/al.h' << 'OpenAL/alc.h'
-    local_libs << 'rucy'
-    frameworks << 'OpenAL' if osx?
+    frameworks << 'OpenAL' << 'AVFoundation' if osx?
     $LDFLAGS   << ' -Wl,--out-implib=native.dll.a' if cygwin?
   end
 

data/ext/beeps/file_in.cpp

@@ -1,30 +1,76 @@
-#include "beeps/ruby/processor.h"
+#include "beeps/ruby/generator.h"
 
 
+#include "beeps/ruby/processor.h"
 #include "defs.h"
 
 
-RUCY_DEFINE_VALUE_FROM_TO(Beeps::FileIn)
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Beeps::FileIn)
 
 #define THIS  to<Beeps::FileIn*>(self)
 
-#define CHECK RUCY_CHECK_OBJECT(Beeps::FileIn, self)
+#define CHECK RUCY_CHECK_OBJ(Beeps::FileIn, self)
 
 
 static
 RUCY_DEF_ALLOC(alloc, klass)
 {
-	return new_type<Beeps::FileIn>(klass);
+	return value(new Beeps::RubyProcessor<Beeps::FileIn>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_path, path)
+{
+	CHECK;
+
+	THIS->set_path(path.c_str());
+	return path;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_path)
+{
+	CHECK;
+
+	return value(THIS->path());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_sample_rate)
+{
+	CHECK;
+
+	return value(THIS->sample_rate());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_nchannels)
+{
+	CHECK;
+
+	return value(THIS->nchannels());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_nsamples)
+{
+	CHECK;
+
+	return value(THIS->nsamples());
 }
 RUCY_END
 
 static
-RUCY_DEF1(initialize, path)
+RUCY_DEF0(get_seconds)
 {
-	RUCY_CHECK_OBJ(Beeps::FileIn, self);
+	CHECK;
 
-	*THIS = Beeps::FileIn(to<const char*>(path));
-	return self;
+	return value(THIS->seconds());
 }
 RUCY_END
 
@@ -38,7 +84,12 @@ Init_beeps_file_in ()
 
 	cFileIn = mBeeps.define_class("FileIn", Beeps::processor_class());
 	cFileIn.define_alloc_func(alloc);
-	cFileIn.define_private_method("initialize", initialize);
+	cFileIn.define_method("path=",       set_path);
+	cFileIn.define_method("path",        get_path);
+	cFileIn.define_method("sample_rate", get_sample_rate);
+	cFileIn.define_method("nchannels",   get_nchannels);
+	cFileIn.define_method("nsamples",    get_nsamples);
+	cFileIn.define_method("seconds",     get_seconds);
 }
 
 

data/ext/beeps/gain.cpp

@@ -0,0 +1,67 @@
+#include "beeps/ruby/filter.h"
+
+
+#include "beeps/ruby/processor.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Beeps::Gain)
+
+#define THIS  to<Beeps::Gain*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::Gain, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::Gain>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_gain, gain)
+{
+	CHECK;
+
+	THIS->set_gain(to<float>(gain));
+	return gain;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_gain)
+{
+	CHECK;
+
+	return value(THIS->gain());
+}
+RUCY_END
+
+
+static Class cGain;
+
+void
+Init_beeps_gain ()
+{
+	Module mBeeps = define_module("Beeps");
+
+	cGain = mBeeps.define_class("Gain", Beeps::processor_class());
+	cGain.define_alloc_func(alloc);
+	cGain.define_method("gain=", set_gain);
+	cGain.define_method("gain",  get_gain);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	gain_class ()
+	{
+		return cGain;
+	}
+
+
+}// Beeps

data/ext/beeps/mic_in.cpp

@@ -0,0 +1,88 @@
+#include "beeps/ruby/generator.h"
+
+
+#include "beeps/ruby/processor.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Beeps::MicIn)
+
+#define THIS  to<Beeps::MicIn*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::MicIn, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::MicIn>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF0(start)
+{
+	CHECK;
+
+	THIS->start();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(stop)
+{
+	CHECK;
+
+	THIS->stop();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_sample_rate)
+{
+	CHECK;
+
+	return value(THIS->sample_rate());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_nchannels)
+{
+	CHECK;
+
+	return value(THIS->nchannels());
+}
+RUCY_END
+
+
+static Class cMicIn;
+
+void
+Init_beeps_mic_in ()
+{
+	Module mBeeps = define_module("Beeps");
+
+	cMicIn = mBeeps.define_class("MicIn", Beeps::processor_class());
+	cMicIn.define_alloc_func(alloc);
+	cMicIn.define_method("start", start);
+	cMicIn.define_method("stop",  stop);
+	cMicIn.define_method("sample_rate", get_sample_rate);
+	cMicIn.define_method("nchannels",   get_nchannels);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	mic_in_class ()
+	{
+		return cMicIn;
+	}
+
+
+}// Beeps

data/ext/beeps/native.cpp

@@ -4,13 +4,19 @@
 void Init_beeps ();
 void Init_beeps_exception ();
 
+void Init_beeps_sound ();
+void Init_beeps_sound_player ();
 void Init_beeps_processor ();
-void Init_beeps_sine_wave ();
-void Init_beeps_square_wave ();
-void Init_beeps_sawtooth_wave ();
+
+void Init_beeps_oscillator ();
 void Init_beeps_file_in ();
+void Init_beeps_mic_in ();
 
-void Init_beeps_sound ();
+void Init_beeps_gain ();
+void Init_beeps_adsr ();
+void Init_beeps_time_stretch ();
+void Init_beeps_pitch_shift ();
+void Init_beeps_analyser ();
 
 
 extern "C" void
@@ -27,13 +33,19 @@ extern "C" void
 	Init_beeps();
 	Init_beeps_exception();
 
+	Init_beeps_sound();
+	Init_beeps_sound_player();
 	Init_beeps_processor();
-	Init_beeps_sine_wave();
-	Init_beeps_square_wave();
-	Init_beeps_sawtooth_wave();
+
+	Init_beeps_oscillator();
 	Init_beeps_file_in();
+	Init_beeps_mic_in();
 
-	Init_beeps_sound();
+	Init_beeps_gain();
+	Init_beeps_adsr();
+	Init_beeps_time_stretch();
+	Init_beeps_pitch_shift();
+	Init_beeps_analyser();
 
 	RUCY_CATCH
 }

data/ext/beeps/oscillator.cpp

@@ -0,0 +1,93 @@
+#include "beeps/ruby/generator.h"
+
+
+#include "beeps/ruby/processor.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Beeps::Oscillator)
+
+#define THIS  to<Beeps::Oscillator*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::Oscillator, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::Oscillator>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_type, type)
+{
+	CHECK;
+
+	THIS->set_type((Beeps::Oscillator::Type) to<uint>(type));
+	return type;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_type)
+{
+	CHECK;
+
+	return value(THIS->type());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_frequency, frequency)
+{
+	CHECK;
+
+	THIS->set_frequency(to<float>(frequency));
+	return frequency;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_frequency)
+{
+	CHECK;
+
+	return value(THIS->frequency());
+}
+RUCY_END
+
+
+static Class cOscillator;
+
+void
+Init_beeps_oscillator ()
+{
+	Module mBeeps = define_module("Beeps");
+
+	cOscillator = mBeeps.define_class("Oscillator", Beeps::processor_class());
+	cOscillator.define_alloc_func(alloc);
+	cOscillator.define_method("type=", set_type);
+	cOscillator.define_method("type",  get_type);
+	cOscillator.define_method("frequency=", set_frequency);
+	cOscillator.define_method("frequency",  get_frequency);
+	cOscillator.define_const("NONE",     Beeps::Oscillator::NONE);
+	cOscillator.define_const("SINE",     Beeps::Oscillator::SINE);
+	cOscillator.define_const("TRIANGLE", Beeps::Oscillator::TRIANGLE);
+	cOscillator.define_const("SQUARE",   Beeps::Oscillator::SQUARE);
+	cOscillator.define_const("SAWTOOTH", Beeps::Oscillator::SAWTOOTH);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	oscillator_class ()
+	{
+		return cOscillator;
+	}
+
+
+}// Beeps