beeps 0.1.32 → 0.1.33

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

data/ext/beeps/pitch_shift.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::PitchShift)
+
+#define THIS  to<Beeps::PitchShift*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::PitchShift, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::PitchShift>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_shift, shift)
+{
+	CHECK;
+
+	THIS->set_shift(to<float>(shift));
+	return shift;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_shift)
+{
+	CHECK;
+
+	return value(THIS->shift());
+}
+RUCY_END
+
+
+static Class cPitchShift;
+
+void
+Init_beeps_pitch_shift ()
+{
+	Module mBeeps = define_module("Beeps");
+
+	cPitchShift = mBeeps.define_class("PitchShift", Beeps::processor_class());
+	cPitchShift.define_alloc_func(alloc);
+	cPitchShift.define_method("shift=", set_shift);
+	cPitchShift.define_method("shift",  get_shift);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	pitch_shift_class ()
+	{
+		return cPitchShift;
+	}
+
+
+}// Beeps

data/ext/beeps/processor.cpp

@@ -5,11 +5,11 @@
 #include "defs.h"
 
 
-RUCY_DEFINE_VALUE_FROM_TO(Beeps::Processor)
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Beeps::Processor)
 
 #define THIS  to<Beeps::Processor*>(self)
 
-#define CHECK RUCY_CHECK_OBJECT(Beeps::Processor, self)
+#define CHECK RUCY_CHECK_OBJ(Beeps::Processor, self)
 
 
 static
@@ -19,6 +19,35 @@ RUCY_DEF_ALLOC(alloc, klass)
 }
 RUCY_END
 
+static
+RUCY_DEF0(reset)
+{
+	CHECK;
+
+	THIS->reset();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_input, input)
+{
+	CHECK;
+
+	THIS->set_input(input ? to<Beeps::Processor*>(input) : NULL);
+	return input;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_input)
+{
+	CHECK;
+
+	return value(THIS->input());
+}
+RUCY_END
+
 
 static Class cProcessor;
 
@@ -29,6 +58,9 @@ Init_beeps_processor ()
 
 	cProcessor = mBeeps.define_class("Processor");
 	cProcessor.define_alloc_func(alloc);
+	cProcessor.define_method("reset", reset);
+	cProcessor.define_method("input=", set_input);
+	cProcessor.define_method("input",  get_input);
 }