beeps 0.3.6 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7dce9dc1a2a39ed0468ce5feb1d2fa484d7016b5edd2a13139325aae7ceac9e
-  data.tar.gz: 74e09464f5e59d065165a42af78b8dab11a74ca8882857387323cf59b8495e63
+  metadata.gz: da80687e0b8f8943386ad2b822947ce6b25982ebe35c7eaaced3447baed524f5
+  data.tar.gz: bbc943dc74223cea8f78182fa01c6ae4f99f8f084aa168b1b5e6544e1d57f668
 SHA512:
-  metadata.gz: f9b5c8c34a46f98d2e643e04e471e724b76209d2638a7ec4c99fcf38b7c8ea48ff1796e6a9a74e60002ed8ea457ea549ab295421dd3a3b7bb4963f4db2cd345b
-  data.tar.gz: e058ebb8da481ad019e3626dddd32ca02eb853cc891a498bd76d5d628daed724b4da4cdd482235fb96ff7490b68c33760c92cfdc730f72778bb4d6cbea3dbd70
+  metadata.gz: 5e01e5556af238432d614c3c22166f0854d3564b9c4f6dbb954df89e25b277654b9146aaec68f7a7fa89beebf744bdcf3c254152df19e342746210b48ec085c1
+  data.tar.gz: 59273b85ece4e4031a7a4b8667e4efc5bb281ca7208de7c8335ecdfbec8631f8bd6d9f08900781d39ddc0766c6643c5e64d9feeecf27ae3e4d0f85d16345b7da

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

@@ -19,6 +19,12 @@ VALUE fin(VALUE self)
 	return self;
 }
 
+static
+VALUE get_sample_rate(VALUE self)
+{
+	return value(Beeps::sample_rate());
+}
+
 static
 VALUE process_streams(VALUE self)
 {
@@ -35,6 +41,7 @@ Init_beeps ()
 	mBeeps = rb_define_module("Beeps");
 	mBeeps.define_singleton_method("init!", init);
 	mBeeps.define_singleton_method("fin!",  fin);
+	rb_define_singleton_method(mBeeps, "sample_rate", RUBY_METHOD_FUNC(get_sample_rate), 0);
 	mBeeps.define_singleton_method("process_streams!", process_streams);
 }
 

data/.doc/ext/beeps/high_pass.cpp

@@ -0,0 +1,63 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::HighPass>, klass);
+}
+
+static
+VALUE set_cutoff_frequency(VALUE self, VALUE frequency)
+{
+	CHECK;
+
+	THIS->set_cutoff_frequency(to<float>(frequency));
+}
+
+static
+VALUE get_cutoff_frequency(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->cutoff_frequency());
+}
+
+
+static Class cHighPass;
+
+void
+Init_beeps_high_pass ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cHighPass = mBeeps.define_class("HighPass", Beeps::processor_class());
+	rb_define_alloc_func(cHighPass, alloc);
+	rb_define_method(cHighPass, "cutoff_frequency=", RUBY_METHOD_FUNC(set_cutoff_frequency), 1);
+	rb_define_method(cHighPass, "cutoff_frequency", RUBY_METHOD_FUNC(get_cutoff_frequency), 0);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	high_pass_class ()
+	{
+		return cHighPass;
+	}
+
+
+}// Beeps

data/.doc/ext/beeps/low_pass.cpp

@@ -0,0 +1,63 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::LowPass>, klass);
+}
+
+static
+VALUE set_cutoff_frequency(VALUE self, VALUE frequency)
+{
+	CHECK;
+
+	THIS->set_cutoff_frequency(to<float>(frequency));
+}
+
+static
+VALUE get_cutoff_frequency(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->cutoff_frequency());
+}
+
+
+static Class cLowPass;
+
+void
+Init_beeps_low_pass ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cLowPass = mBeeps.define_class("LowPass", Beeps::processor_class());
+	rb_define_alloc_func(cLowPass, alloc);
+	rb_define_method(cLowPass, "cutoff_frequency=", RUBY_METHOD_FUNC(set_cutoff_frequency), 1);
+	rb_define_method(cLowPass, "cutoff_frequency", RUBY_METHOD_FUNC(get_cutoff_frequency), 0);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	low_pass_class ()
+	{
+		return cLowPass;
+	}
+
+
+}// Beeps

data/.doc/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/.doc/ext/beeps/oscillator.cpp

@@ -43,12 +43,12 @@ VALUE set_samples(VALUE self, VALUE 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());
 }
 
 static
@@ -56,13 +56,13 @@ VALUE each_sample(VALUE self)
 {
 	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;
 }
 
@@ -71,7 +71,11 @@ VALUE set_frequency(VALUE self, VALUE 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;
 }
 
@@ -88,7 +92,11 @@ VALUE set_phase(VALUE self, VALUE 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;
 }
 
@@ -100,6 +108,69 @@ VALUE get_phase(VALUE self)
 	return value(THIS->phase());
 }
 
+static
+VALUE set_gain(VALUE self, VALUE 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;
+}
+
+static
+VALUE get_gain(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->gain());
+}
+
+static
+VALUE set_offset(VALUE self, VALUE 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;
+}
+
+static
+VALUE get_offset(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->offset());
+}
+
+static
+VALUE set_duty(VALUE self, VALUE 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;
+}
+
+static
+VALUE get_duty(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->duty());
+}
+
 
 static Class cOscillator;
 
@@ -118,6 +189,12 @@ Init_beeps_oscillator ()
 	rb_define_method(cOscillator, "frequency", RUBY_METHOD_FUNC(get_frequency), 0);
 	rb_define_method(cOscillator, "phase=", RUBY_METHOD_FUNC(set_phase), 1);
 	rb_define_method(cOscillator, "phase", RUBY_METHOD_FUNC(get_phase), 0);
+	rb_define_method(cOscillator, "gain=", RUBY_METHOD_FUNC(set_gain), 1);
+	rb_define_method(cOscillator, "gain", RUBY_METHOD_FUNC(get_gain), 0);
+	rb_define_method(cOscillator, "offset=", RUBY_METHOD_FUNC(set_offset), 1);
+	rb_define_method(cOscillator, "offset", RUBY_METHOD_FUNC(get_offset), 0);
+	rb_define_method(cOscillator, "duty=", RUBY_METHOD_FUNC(set_duty), 1);
+	rb_define_method(cOscillator, "duty", RUBY_METHOD_FUNC(get_duty), 0);
 
 	cOscillator.define_const("TYPE_NONE", Beeps::Oscillator::TYPE_NONE);
 	cOscillator.define_const("SINE",      Beeps::Oscillator::SINE);

data/.doc/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
 VALUE alloc(VALUE klass)
 {
-	Beeps::beeps_error(__FILE__, __LINE__);
+	Beeps::beeps_error(__FILE__, __LINE__, "can not instantiate Processor class.");
 }
 
 static
@@ -53,6 +54,16 @@ VALUE on_start(VALUE self)
 	CALL(on_start());
 }
 
+static
+VALUE get_signals(VALUE self, VALUE processor, VALUE seconds, VALUE nchannels, VALUE sample_rate)
+{
+	return value(Beeps::get_signals(
+		to<Beeps::Processor*>(processor),
+		to<float>            (seconds),
+		to<uint>             (nchannels),
+		to<double>           (sample_rate)));
+}
+
 
 static Class cProcessor;
 
@@ -67,6 +78,8 @@ Init_beeps_processor ()
 	rb_define_method(cProcessor, "input=", RUBY_METHOD_FUNC(set_input), 1);
 	rb_define_method(cProcessor, "input", RUBY_METHOD_FUNC(get_input), 0);
 	rb_define_method(cProcessor, "on_start", RUBY_METHOD_FUNC(on_start), 0);
+
+	cProcessor.define_singleton_method("get_signals!", get_signals);
 }
 
 

data/.doc/ext/beeps/reverb.cpp

@@ -0,0 +1,99 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::Reverb>, klass);
+}
+
+static
+VALUE set_mix(VALUE self, VALUE mix)
+{
+	CHECK;
+
+	THIS->set_mix(to<float>(mix));
+}
+
+static
+VALUE get_mix(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->mix());
+}
+
+static
+VALUE set_room_size(VALUE self, VALUE size)
+{
+	CHECK;
+
+	THIS->set_room_size(to<float>(size));
+}
+
+static
+VALUE get_room_size(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->room_size());
+}
+
+static
+VALUE set_damping(VALUE self, VALUE damping)
+{
+	CHECK;
+
+	THIS->set_damping(to<float>(damping));
+}
+
+static
+VALUE get_damping(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->damping());
+}
+
+
+static Class cReverb;
+
+void
+Init_beeps_reverb ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cReverb = mBeeps.define_class("Reverb", Beeps::processor_class());
+	rb_define_alloc_func(cReverb, alloc);
+	rb_define_method(cReverb, "mix=", RUBY_METHOD_FUNC(set_mix), 1);
+	rb_define_method(cReverb, "mix", RUBY_METHOD_FUNC(get_mix), 0);
+	rb_define_method(cReverb, "room_size=", RUBY_METHOD_FUNC(set_room_size), 1);
+	rb_define_method(cReverb, "room_size", RUBY_METHOD_FUNC(get_room_size), 0);
+	rb_define_method(cReverb, "damping=", RUBY_METHOD_FUNC(set_damping), 1);
+	rb_define_method(cReverb, "damping", RUBY_METHOD_FUNC(get_damping), 0);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	reverb_class ()
+	{
+		return cReverb;
+	}
+
+
+}// Beeps

data/.doc/ext/beeps/signals.cpp

@@ -0,0 +1,128 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return new_type<Beeps::Signals>(klass);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Beeps::Signals*>(obj)->dup();
+	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
+VALUE get_nsamples(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->nsamples());
+}
+
+static
+VALUE get_capacity(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->capacity());
+}
+
+static
+VALUE is_empty(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->empty());
+}
+
+static
+VALUE each(VALUE self, VALUE 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]));
+	}
+}
+
+
+static Class cSignals;
+
+void
+Init_beeps_signals ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cSignals = rb_define_class_under(mBeeps, "Signals", rb_cObject);
+	rb_define_alloc_func(cSignals, alloc);
+	rb_define_private_method(cSignals, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cSignals, "sample_rate", RUBY_METHOD_FUNC(get_sample_rate), 0);
+	rb_define_method(cSignals, "nchannels", RUBY_METHOD_FUNC(get_nchannels), 0);
+	rb_define_method(cSignals, "nsamples", RUBY_METHOD_FUNC(get_nsamples), 0);
+	rb_define_method(cSignals, "capacity", RUBY_METHOD_FUNC(get_capacity), 0);
+	cSignals.define_method("empty?", is_empty);
+	cSignals.define_method("each!", each);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	signals_class ()
+	{
+		return cSignals;
+	}
+
+
+}// Beeps

data/ChangeLog.md

@@ -1,6 +1,30 @@
 # beeps ChangeLog
 
 
+## [v0.3.7] - 2025-05-11
+
+- Add LowPass and HighPass classes
+- Add Reverb class
+- Add Signals class for ruby extension
+- Add Beeps.sample_rate()
+- Add Processor.get_signals!() method
+- Add Oscillator#gain, Oscillator#offset, and Oscillator#duty
+- Add more tests for processors
+
+- Update STK
+- Processor has sub inputs
+- Reimplement oscillators without STK wave generators
+- Oscillator#frequency= can take another processor like low frequency oscillator for frequency modulation
+- Oscillator: phase, gain, offset, and duty can also accept a processor as input
+- Make process segment size variable based on the frequency of the sub-input
+- Sequencer: Call set_updated()
+
+- Refactor: hide Beeps::Frames class
+
+- Fix the issue where the sound player with a streaming source does not stop when the envelope's note_off is called
+- Fix crashes
+
+
 ## [v0.3.6] - 2025-04-08
 
 - Update dependencies: xot, rucy

data/Rakefile

@@ -17,7 +17,7 @@ TESTS_ALONE = ['test/test_beeps_init.rb']
 install_packages win32: %w[MINGW_PACKAGE_PREFIX-openal]
 
 use_external_library 'https://github.com/thestk/stk',
-  tag:      '4.6.2',
+  tag:      '5.0.1',
   incdirs:  'include',
   srcdirs:  'src',
   excludes: %w[stk/src/include Tcp Udp Socket Thread Mutex InetWv /Rt]

data/VERSION

@@ -1 +1 @@
-0.3.6
+0.3.7

data/beeps.gemspec

@@ -25,8 +25,8 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 3.0.0'
 
-  s.add_dependency 'xot',  '~> 0.3.6', '>= 0.3.6'
-  s.add_dependency 'rucy', '~> 0.3.6', '>= 0.3.6'
+  s.add_dependency 'xot',  '~> 0.3.7', '>= 0.3.7'
+  s.add_dependency 'rucy', '~> 0.3.7', '>= 0.3.7'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/ext/beeps/beeps.cpp

@@ -21,6 +21,13 @@ RUCY_DEF0(fin)
 }
 RUCY_END
 
+static
+RUCY_DEF0(get_sample_rate)
+{
+	return value(Beeps::sample_rate());
+}
+RUCY_END
+
 static
 RUCY_DEF0(process_streams)
 {
@@ -38,6 +45,7 @@ Init_beeps ()
 	mBeeps = define_module("Beeps");
 	mBeeps.define_singleton_method("init!", init);
 	mBeeps.define_singleton_method("fin!",  fin);
+	mBeeps.define_singleton_method("sample_rate", get_sample_rate);
 	mBeeps.define_singleton_method("process_streams!", process_streams);
 }