beeps 0.3.6 → 0.3.7

data/ext/beeps/high_pass.cpp

@@ -0,0 +1,66 @@
+#include "beeps/ruby/filter.h"
+
+
+#include "beeps/ruby/processor.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::HighPass)
+
+#define THIS  to<Beeps::HighPass*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::HighPass, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::HighPass>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_cutoff_frequency, frequency)
+{
+	CHECK;
+
+	THIS->set_cutoff_frequency(to<float>(frequency));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_cutoff_frequency)
+{
+	CHECK;
+
+	return value(THIS->cutoff_frequency());
+}
+RUCY_END
+
+
+static Class cHighPass;
+
+void
+Init_beeps_high_pass ()
+{
+	Module mBeeps = define_module("Beeps");
+
+	cHighPass = mBeeps.define_class("HighPass", Beeps::processor_class());
+	cHighPass.define_alloc_func(alloc);
+	cHighPass.define_method("cutoff_frequency=", set_cutoff_frequency);
+	cHighPass.define_method("cutoff_frequency",  get_cutoff_frequency);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	high_pass_class ()
+	{
+		return cHighPass;
+	}
+
+
+}// Beeps

data/ext/beeps/low_pass.cpp

@@ -0,0 +1,66 @@
+#include "beeps/ruby/filter.h"
+
+
+#include "beeps/ruby/processor.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::LowPass)
+
+#define THIS  to<Beeps::LowPass*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::LowPass, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::LowPass>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_cutoff_frequency, frequency)
+{
+	CHECK;
+
+	THIS->set_cutoff_frequency(to<float>(frequency));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_cutoff_frequency)
+{
+	CHECK;
+
+	return value(THIS->cutoff_frequency());
+}
+RUCY_END
+
+
+static Class cLowPass;
+
+void
+Init_beeps_low_pass ()
+{
+	Module mBeeps = define_module("Beeps");
+
+	cLowPass = mBeeps.define_class("LowPass", Beeps::processor_class());
+	cLowPass.define_alloc_func(alloc);
+	cLowPass.define_method("cutoff_frequency=", set_cutoff_frequency);
+	cLowPass.define_method("cutoff_frequency",  get_cutoff_frequency);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	low_pass_class ()
+	{
+		return cLowPass;
+	}
+
+
+}// Beeps

data/ext/beeps/native.cpp

@@ -4,6 +4,7 @@
 void Init_beeps ();
 void Init_beeps_exception ();
 
+void Init_beeps_signals ();
 void Init_beeps_sound ();
 void Init_beeps_sound_player ();
 void Init_beeps_processor ();
@@ -16,6 +17,9 @@ void Init_beeps_mic_in ();
 void Init_beeps_gain ();
 void Init_beeps_mixer ();
 void Init_beeps_envelope ();
+void Init_beeps_low_pass ();
+void Init_beeps_high_pass ();
+void Init_beeps_reverb ();
 void Init_beeps_time_stretch ();
 void Init_beeps_pitch_shift ();
 void Init_beeps_analyser ();
@@ -35,6 +39,7 @@ extern "C" void
 	Init_beeps();
 	Init_beeps_exception();
 
+	Init_beeps_signals();
 	Init_beeps_sound();
 	Init_beeps_sound_player();
 	Init_beeps_processor();
@@ -47,6 +52,9 @@ extern "C" void
 	Init_beeps_gain();
 	Init_beeps_mixer();
 	Init_beeps_envelope();
+	Init_beeps_low_pass();
+	Init_beeps_high_pass();
+	Init_beeps_reverb();
 	Init_beeps_time_stretch();
 	Init_beeps_pitch_shift();
 	Init_beeps_analyser();

data/ext/beeps/oscillator.cpp

@@ -46,12 +46,12 @@ RUCY_DEF1(set_samples, samples)
 	Value* array = samples.as_array();
 	size_t size  = samples.size();
 
-	std::vector<float> floats;
-	floats.reserve(size);
+	std::vector<Beeps::Sample> data;
+	data.reserve(size);
 	for (size_t i = 0; i < size; ++i)
-		floats.push_back(to<float>(array[i]));
+		data.push_back(to<Beeps::Sample>(array[i]));
 
-	THIS->set_samples(&floats[0], floats.size());
+	THIS->set_samples(&data[0], data.size());
 }
 RUCY_END
 
@@ -60,13 +60,13 @@ RUCY_DEF0(each_sample)
 {
 	CHECK;
 
-	const float* floats = THIS->samples();
-	size_t size         = THIS->nsamples();
-	if (!floats || size == 0) return Qnil;
+	const Beeps::Sample* samples = THIS->samples();
+	size_t size                  = THIS->nsamples();
+	if (!samples || size == 0) return Qnil;
 
 	Value ret;
 	for (size_t i = 0; i < size; ++i)
-		ret = rb_yield(value(floats[i]));
+		ret = rb_yield(value((float) samples[i]));
 	return ret;
 }
 RUCY_END
@@ -76,7 +76,11 @@ RUCY_DEF1(set_frequency, frequency)
 {
 	CHECK;
 
-	THIS->set_frequency(to<float>(frequency));
+	if (frequency.is_a(Beeps::processor_class()))
+		THIS->set_frequency(to<Beeps::Processor*>(frequency));
+	else
+		THIS->set_frequency(to<float>(frequency));
+
 	return frequency;
 }
 RUCY_END
@@ -95,7 +99,11 @@ RUCY_DEF1(set_phase, phase)
 {
 	CHECK;
 
-	THIS->set_phase(to<float>(phase));
+	if (phase.is_a(Beeps::processor_class()))
+		THIS->set_phase(to<Beeps::Processor*>(phase));
+	else
+		THIS->set_phase(to<float>(phase));
+
 	return phase;
 }
 RUCY_END
@@ -109,6 +117,75 @@ RUCY_DEF0(get_phase)
 }
 RUCY_END
 
+static
+RUCY_DEF1(set_gain, gain)
+{
+	CHECK;
+
+	if (gain.is_a(Beeps::processor_class()))
+		THIS->set_gain(to<Beeps::Processor*>(gain));
+	else
+		THIS->set_gain(to<float>(gain));
+
+	return gain;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_gain)
+{
+	CHECK;
+
+	return value(THIS->gain());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_offset, offset)
+{
+	CHECK;
+
+	if (offset.is_a(Beeps::processor_class()))
+		THIS->set_offset(to<Beeps::Processor*>(offset));
+	else
+		THIS->set_offset(to<float>(offset));
+
+	return offset;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_offset)
+{
+	CHECK;
+
+	return value(THIS->offset());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_duty, duty)
+{
+	CHECK;
+
+	if (duty.is_a(Beeps::processor_class()))
+		THIS->set_duty(to<Beeps::Processor*>(duty));
+	else
+		THIS->set_duty(to<float>(duty));
+
+	return duty;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_duty)
+{
+	CHECK;
+
+	return value(THIS->duty());
+}
+RUCY_END
+
 
 static Class cOscillator;
 
@@ -125,8 +202,14 @@ Init_beeps_oscillator ()
 	cOscillator.define_method("each_sample!", each_sample);
 	cOscillator.define_method("frequency=", set_frequency);
 	cOscillator.define_method("frequency",  get_frequency);
-	cOscillator.define_method("phase=", set_phase);
-	cOscillator.define_method("phase",  get_phase);
+	cOscillator.define_method("phase=",     set_phase);
+	cOscillator.define_method("phase",      get_phase);
+	cOscillator.define_method("gain=",      set_gain);
+	cOscillator.define_method("gain",       get_gain);
+	cOscillator.define_method("offset=",    set_offset);
+	cOscillator.define_method("offset",     get_offset);
+	cOscillator.define_method("duty=",      set_duty);
+	cOscillator.define_method("duty",       get_duty);
 
 	cOscillator.define_const("TYPE_NONE", Beeps::Oscillator::TYPE_NONE);
 	cOscillator.define_const("SINE",      Beeps::Oscillator::SINE);

data/ext/beeps/processor.cpp

@@ -1,6 +1,7 @@
 #include "beeps/ruby/processor.h"
 
 
+#include "beeps/ruby/signals.h"
 #include "beeps/exception.h"
 #include "defs.h"
 
@@ -17,7 +18,7 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::Processor)
 static
 RUCY_DEF_ALLOC(alloc, klass)
 {
-	Beeps::beeps_error(__FILE__, __LINE__);
+	Beeps::beeps_error(__FILE__, __LINE__, "can not instantiate Processor class.");
 }
 RUCY_END
 
@@ -58,6 +59,17 @@ RUCY_DEF0(on_start)
 }
 RUCY_END
 
+static
+RUCY_DEF4(get_signals, processor, seconds, nchannels, sample_rate)
+{
+	return value(Beeps::get_signals(
+		to<Beeps::Processor*>(processor),
+		to<float>            (seconds),
+		to<uint>             (nchannels),
+		to<double>           (sample_rate)));
+}
+RUCY_END
+
 
 static Class cProcessor;
 
@@ -72,6 +84,8 @@ Init_beeps_processor ()
 	cProcessor.define_method("input=", set_input);
 	cProcessor.define_method("input",  get_input);
 	cProcessor.define_method("on_start", on_start);
+
+	cProcessor.define_singleton_method("get_signals!", get_signals);
 }
 
 

data/ext/beeps/reverb.cpp

@@ -0,0 +1,106 @@
+#include "beeps/ruby/filter.h"
+
+
+#include "beeps/ruby/processor.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::Reverb)
+
+#define THIS  to<Beeps::Reverb*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::Reverb, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::Reverb>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_mix, mix)
+{
+	CHECK;
+
+	THIS->set_mix(to<float>(mix));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_mix)
+{
+	CHECK;
+
+	return value(THIS->mix());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_room_size, size)
+{
+	CHECK;
+
+	THIS->set_room_size(to<float>(size));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_room_size)
+{
+	CHECK;
+
+	return value(THIS->room_size());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_damping, damping)
+{
+	CHECK;
+
+	THIS->set_damping(to<float>(damping));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_damping)
+{
+	CHECK;
+
+	return value(THIS->damping());
+}
+RUCY_END
+
+
+static Class cReverb;
+
+void
+Init_beeps_reverb ()
+{
+	Module mBeeps = define_module("Beeps");
+
+	cReverb = mBeeps.define_class("Reverb", Beeps::processor_class());
+	cReverb.define_alloc_func(alloc);
+	cReverb.define_method("mix=",       set_mix);
+	cReverb.define_method("mix",        get_mix);
+	cReverb.define_method("room_size=", set_room_size);
+	cReverb.define_method("room_size",  get_room_size);
+	cReverb.define_method("damping=",   set_damping);
+	cReverb.define_method("damping",    get_damping);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	reverb_class ()
+	{
+		return cReverb;
+	}
+
+
+}// Beeps

data/ext/beeps/signals.cpp

@@ -0,0 +1,136 @@
+#include "beeps/ruby/signals.h"
+
+
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(BEEPS_EXPORT, Beeps::Signals)
+
+#define THIS  to<Beeps::Signals*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::Signals, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Beeps::Signals>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Beeps::Signals*>(obj)->dup();
+	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
+RUCY_DEF0(get_nsamples)
+{
+	CHECK;
+
+	return value(THIS->nsamples());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_capacity)
+{
+	CHECK;
+
+	return value(THIS->capacity());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_empty)
+{
+	CHECK;
+
+	return value(THIS->empty());
+}
+RUCY_END
+
+static
+RUCY_DEF1(each, channel_)
+{
+	CHECK;
+
+	uint nchannels      = THIS->nchannels();
+	uint       nsamples = THIS->nsamples();
+	const auto* samples = THIS->samples();
+
+	if (channel_)
+	{
+		int channel = to<int>(channel_);
+		if (channel < 0)
+			argument_error(__FILE__, __LINE__);
+		if (channel >= nchannels)
+			argument_error(__FILE__, __LINE__);
+
+		const auto* p = samples + channel;
+		for (uint i = 0; i < nsamples; ++i, p += nchannels)
+			rb_yield(value(*p));
+	}
+	else
+	{
+		uint size = nsamples * nchannels;
+		for (uint i = 0; i < size; ++i)
+			rb_yield(value(samples[i]));
+	}
+}
+RUCY_END
+
+
+static Class cSignals;
+
+void
+Init_beeps_signals ()
+{
+	Module mBeeps = define_module("Beeps");
+
+	cSignals = mBeeps.define_class("Signals");
+	cSignals.define_alloc_func(alloc);
+	cSignals.define_private_method("initialize_copy", initialize_copy);
+	cSignals.define_method("sample_rate", get_sample_rate);
+	cSignals.define_method("nchannels",   get_nchannels);
+	cSignals.define_method("nsamples",    get_nsamples);
+	cSignals.define_method("capacity",    get_capacity);
+	cSignals.define_method("empty?", is_empty);
+	cSignals.define_method("each!", each);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	signals_class ()
+	{
+		return cSignals;
+	}
+
+
+}// Beeps

data/include/beeps/beeps.h

@@ -15,10 +15,10 @@ namespace Beeps
 
 	void fin ();
 
-	void process_streams ();
-
 	double sample_rate ();
 
+	void process_streams ();
+
 
 }// Beeps
 

data/include/beeps/defs.h

@@ -24,6 +24,9 @@ namespace Beeps
 	using Xot::String;
 
 
+	typedef double Sample;
+
+
 }// Beeps