beeps 0.1.32 → 0.1.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98505d3f9c70d9d29616b565fcbd496d4e30284e865f2e2ce59e54dbd28ae1ec
-  data.tar.gz: 123f653ee20e28c5b19f269385d6a61fccee19573976f55ab50551be31b9a176
+  metadata.gz: 0b9915b433d5e54ae45f1a6cc1fc0a922f558ed0133908c3d1bf30554fc348c3
+  data.tar.gz: 53f4a30891273bfcdd969ca408a963b6aa5c847055c3868701dc356e46a45b6e
 SHA512:
-  metadata.gz: 1a953ae17ed4ee72bc5f868f20fc16b214696a3f63cfe6b84358f2b74ce621653604538fa690aad1f11698802bcc8ca5a8e460c2f931adf7dfe197c0c5aa97c7
-  data.tar.gz: 9f2a42f22ce61b221c2c18140fc4b3ac7e4446248be7857d5de408da6f219d32029c4b221a8c9642f9a6f192a7b998af378ffcceab3a252462611023c0f8405c
+  metadata.gz: 90ed2a73165ea3106af0512fd0133bc587762944c0da07d70d5d1bb1a3815df7173417e528a5e9979677c5d8ccb0a60207ca855ea3eceff5f675010cd87bb13a
+  data.tar.gz: e8e6f3e6a1fb38ba2a45bae0aaa2a549097d726a6ae0f5ea2ba768351a354144f9d67a1f9f84ac2b3ff17451cbdb3e9a9209dfcd1f986b31ee850aae5b693b2e

data/.doc/ext/beeps/adsr.cpp

@@ -0,0 +1,139 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::ADSR>, klass);
+}
+
+static
+VALUE note_on(VALUE self, VALUE delay)
+{
+	CHECK;
+
+	THIS->note_on(to<float>(delay));
+}
+
+static
+VALUE note_off(VALUE self, VALUE delay)
+{
+	CHECK;
+
+	THIS->note_off(to<float>(delay));
+}
+
+static
+VALUE set_attack_time(VALUE self, VALUE time)
+{
+	CHECK;
+
+	THIS->set_attack_time(to<float>(time));
+	return time;
+}
+
+static
+VALUE get_attack_time(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->attack_time());
+}
+
+static
+VALUE set_decay_time(VALUE self, VALUE time)
+{
+	CHECK;
+
+	THIS->set_decay_time(to<float>(time));
+	return time;
+}
+
+static
+VALUE get_decay_time(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->decay_time());
+}
+
+static
+VALUE set_sustain_level(VALUE self, VALUE level)
+{
+	CHECK;
+
+	THIS->set_sustain_level(to<float>(level));
+	return level;
+}
+
+static
+VALUE get_sustain_level(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->sustain_level());
+}
+
+static
+VALUE set_release_time(VALUE self, VALUE time)
+{
+	CHECK;
+
+	THIS->set_release_time(to<float>(time));
+	return time;
+}
+
+static
+VALUE get_release_time(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->release_time());
+}
+
+
+static Class cADSR;
+
+void
+Init_beeps_adsr ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cADSR = mBeeps.define_class("ADSR", Beeps::processor_class());
+	rb_define_alloc_func(cADSR, alloc);
+	cADSR.define_private_method("note_on!",  note_on);
+	cADSR.define_private_method("note_off!", note_off);
+	rb_define_method(cADSR, "attack_time=", RUBY_METHOD_FUNC(set_attack_time), 1);
+	rb_define_method(cADSR, "attack_time", RUBY_METHOD_FUNC(get_attack_time), 0);
+	rb_define_method(cADSR, "decay_time=", RUBY_METHOD_FUNC(set_decay_time), 1);
+	rb_define_method(cADSR, "decay_time", RUBY_METHOD_FUNC(get_decay_time), 0);
+	rb_define_method(cADSR, "sustain_level=", RUBY_METHOD_FUNC(set_sustain_level), 1);
+	rb_define_method(cADSR, "sustain_level", RUBY_METHOD_FUNC(get_sustain_level), 0);
+	rb_define_method(cADSR, "release_time=", RUBY_METHOD_FUNC(set_release_time), 1);
+	rb_define_method(cADSR, "release_time", RUBY_METHOD_FUNC(get_release_time), 0);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	adsr_class ()
+	{
+		return cADSR;
+	}
+
+
+}// Beeps

data/.doc/ext/beeps/analyser.cpp

@@ -0,0 +1,128 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::Analyser>, klass);
+}
+
+static
+VALUE set_fft_size(VALUE self, VALUE size)
+{
+	CHECK;
+
+	THIS->set_fft_size(to<uint>(size));
+	return size;
+}
+
+static
+VALUE get_fft_size(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->fft_size());
+}
+
+static
+VALUE get_resolution(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->resolution());
+}
+
+static
+VALUE each_signal(VALUE self, VALUE 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();
+}
+
+static
+VALUE each_spectrum(VALUE self)
+{
+	CHECK;
+
+	if (!*THIS)
+		invalid_object_error(__FILE__, __LINE__);
+
+	for (auto val : THIS->spectrum())
+		rb_yield(value(val));
+
+	return nil();
+}
+
+
+static Class cAnalyser;
+
+void
+Init_beeps_analyser ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cAnalyser = mBeeps.define_class("Analyser", Beeps::processor_class());
+	rb_define_alloc_func(cAnalyser, alloc);
+	rb_define_method(cAnalyser, "fft_size=", RUBY_METHOD_FUNC(set_fft_size), 1);
+	rb_define_method(cAnalyser, "fft_size", RUBY_METHOD_FUNC(get_fft_size), 0);
+	rb_define_method(cAnalyser, "resolution", RUBY_METHOD_FUNC(get_resolution), 0);
+	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/.doc/ext/beeps/beeps.cpp

@@ -19,6 +19,13 @@ VALUE fin(VALUE self)
 	return self;
 }
 
+static
+VALUE process_streams(VALUE self)
+{
+	Beeps::process_streams();
+	return self;
+}
+
 
 static Module mBeeps;
 
@@ -27,7 +34,8 @@ Init_beeps ()
 {
 	mBeeps = rb_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/.doc/ext/beeps/file_in.cpp

@@ -1,29 +1,70 @@
-#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
 VALUE alloc(VALUE klass)
 {
-	return new_type<Beeps::FileIn>(klass);
+	return value(new Beeps::RubyProcessor<Beeps::FileIn>, klass);
+}
+
+static
+VALUE set_path(VALUE self, VALUE path)
+{
+	CHECK;
+
+	THIS->set_path(path.c_str());
+	return path;
+}
+
+static
+VALUE get_path(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->path());
+}
+
+static
+VALUE get_sample_rate(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->sample_rate());
+}
+
+static
+VALUE get_nchannels(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->nchannels());
+}
+
+static
+VALUE get_nsamples(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->nsamples());
 }
 
 static
-VALUE initialize(VALUE self, VALUE path)
+VALUE get_seconds(VALUE self)
 {
-	RUCY_CHECK_OBJ(Beeps::FileIn, self);
+	CHECK;
 
-	*THIS = Beeps::FileIn(to<const char*>(path));
-	return self;
+	return value(THIS->seconds());
 }
 
 
@@ -36,7 +77,12 @@ Init_beeps_file_in ()
 
 	cFileIn = mBeeps.define_class("FileIn", Beeps::processor_class());
 	rb_define_alloc_func(cFileIn, alloc);
-	rb_define_private_method(cFileIn, "initialize", RUBY_METHOD_FUNC(initialize), 1);
+	rb_define_method(cFileIn, "path=", RUBY_METHOD_FUNC(set_path), 1);
+	rb_define_method(cFileIn, "path", RUBY_METHOD_FUNC(get_path), 0);
+	rb_define_method(cFileIn, "sample_rate", RUBY_METHOD_FUNC(get_sample_rate), 0);
+	rb_define_method(cFileIn, "nchannels", RUBY_METHOD_FUNC(get_nchannels), 0);
+	rb_define_method(cFileIn, "nsamples", RUBY_METHOD_FUNC(get_nsamples), 0);
+	rb_define_method(cFileIn, "seconds", RUBY_METHOD_FUNC(get_seconds), 0);
 }
 
 

data/.doc/ext/beeps/gain.cpp

@@ -0,0 +1,64 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::Gain>, klass);
+}
+
+static
+VALUE set_gain(VALUE self, VALUE gain)
+{
+	CHECK;
+
+	THIS->set_gain(to<float>(gain));
+	return gain;
+}
+
+static
+VALUE get_gain(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->gain());
+}
+
+
+static Class cGain;
+
+void
+Init_beeps_gain ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cGain = mBeeps.define_class("Gain", Beeps::processor_class());
+	rb_define_alloc_func(cGain, alloc);
+	rb_define_method(cGain, "gain=", RUBY_METHOD_FUNC(set_gain), 1);
+	rb_define_method(cGain, "gain", RUBY_METHOD_FUNC(get_gain), 0);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	gain_class ()
+	{
+		return cGain;
+	}
+
+
+}// Beeps

data/.doc/ext/beeps/mic_in.cpp

@@ -0,0 +1,83 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::MicIn>, klass);
+}
+
+static
+VALUE start(VALUE self)
+{
+	CHECK;
+
+	THIS->start();
+	return self;
+}
+
+static
+VALUE stop(VALUE self)
+{
+	CHECK;
+
+	THIS->stop();
+	return self;
+}
+
+static
+VALUE get_sample_rate(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->sample_rate());
+}
+
+static
+VALUE get_nchannels(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->nchannels());
+}
+
+
+static Class cMicIn;
+
+void
+Init_beeps_mic_in ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cMicIn = mBeeps.define_class("MicIn", Beeps::processor_class());
+	rb_define_alloc_func(cMicIn, alloc);
+	rb_define_method(cMicIn, "start", RUBY_METHOD_FUNC(start), 0);
+	rb_define_method(cMicIn, "stop", RUBY_METHOD_FUNC(stop), 0);
+	rb_define_method(cMicIn, "sample_rate", RUBY_METHOD_FUNC(get_sample_rate), 0);
+	rb_define_method(cMicIn, "nchannels", RUBY_METHOD_FUNC(get_nchannels), 0);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	mic_in_class ()
+	{
+		return cMicIn;
+	}
+
+
+}// Beeps

data/.doc/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/.doc/ext/beeps/oscillator.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::Oscillator)
+
+#define THIS  to<Beeps::Oscillator*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::Oscillator, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::Oscillator>, klass);
+}
+
+static
+VALUE set_type(VALUE self, VALUE type)
+{
+	CHECK;
+
+	THIS->set_type((Beeps::Oscillator::Type) to<uint>(type));
+	return type;
+}
+
+static
+VALUE get_type(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->type());
+}
+
+static
+VALUE set_frequency(VALUE self, VALUE frequency)
+{
+	CHECK;
+
+	THIS->set_frequency(to<float>(frequency));
+	return frequency;
+}
+
+static
+VALUE get_frequency(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->frequency());
+}
+
+
+static Class cOscillator;
+
+void
+Init_beeps_oscillator ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cOscillator = mBeeps.define_class("Oscillator", Beeps::processor_class());
+	rb_define_alloc_func(cOscillator, alloc);
+	rb_define_method(cOscillator, "type=", RUBY_METHOD_FUNC(set_type), 1);
+	rb_define_method(cOscillator, "type", RUBY_METHOD_FUNC(get_type), 0);
+	rb_define_method(cOscillator, "frequency=", RUBY_METHOD_FUNC(set_frequency), 1);
+	rb_define_method(cOscillator, "frequency", RUBY_METHOD_FUNC(get_frequency), 0);
+	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