beeps 0.1.32 → 0.1.33

data/.doc/ext/beeps/pitch_shift.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::PitchShift)
+
+#define THIS  to<Beeps::PitchShift*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::PitchShift, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::PitchShift>, klass);
+}
+
+static
+VALUE set_shift(VALUE self, VALUE shift)
+{
+	CHECK;
+
+	THIS->set_shift(to<float>(shift));
+	return shift;
+}
+
+static
+VALUE get_shift(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->shift());
+}
+
+
+static Class cPitchShift;
+
+void
+Init_beeps_pitch_shift ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cPitchShift = mBeeps.define_class("PitchShift", Beeps::processor_class());
+	rb_define_alloc_func(cPitchShift, alloc);
+	rb_define_method(cPitchShift, "shift=", RUBY_METHOD_FUNC(set_shift), 1);
+	rb_define_method(cPitchShift, "shift", RUBY_METHOD_FUNC(get_shift), 0);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	pitch_shift_class ()
+	{
+		return cPitchShift;
+	}
+
+
+}// Beeps

data/.doc/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
@@ -18,6 +18,32 @@ VALUE alloc(VALUE klass)
 	Beeps::beeps_error(__FILE__, __LINE__);
 }
 
+static
+VALUE reset(VALUE self)
+{
+	CHECK;
+
+	THIS->reset();
+	return self;
+}
+
+static
+VALUE set_input(VALUE self, VALUE input)
+{
+	CHECK;
+
+	THIS->set_input(input ? to<Beeps::Processor*>(input) : NULL);
+	return input;
+}
+
+static
+VALUE get_input(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->input());
+}
+
 
 static Class cProcessor;
 
@@ -28,6 +54,9 @@ Init_beeps_processor ()
 
 	cProcessor = rb_define_class_under(mBeeps, "Processor", rb_cObject);
 	rb_define_alloc_func(cProcessor, alloc);
+	rb_define_method(cProcessor, "reset", RUBY_METHOD_FUNC(reset), 0);
+	rb_define_method(cProcessor, "input=", RUBY_METHOD_FUNC(set_input), 1);
+	rb_define_method(cProcessor, "input", RUBY_METHOD_FUNC(get_input), 0);
 }
 
 

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

@@ -8,7 +8,7 @@ RUCY_DEFINE_VALUE_FROM_TO(Beeps::Sound)
 
 #define THIS  to<Beeps::Sound*>(self)
 
-#define CHECK RUCY_CHECK_OBJECT(Beeps::Sound, self)
+#define CHECK RUCY_CHECK_OBJ(Beeps::Sound, self)
 
 
 static
@@ -18,11 +18,13 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self, VALUE processor, VALUE seconds)
+VALUE setup(VALUE self, VALUE processor, VALUE seconds, VALUE nchannels, VALUE sample_rate)
 {
-	RUCY_CHECK_OBJ(Beeps::Sound, self);
+	CHECK;
 
-	*THIS = Beeps::Sound(to<Beeps::Processor*>(processor), to<float>(seconds));
+	*THIS = Beeps::Sound(
+		to<Beeps::Processor*>(processor),
+		to<float>(seconds), to<uint>(nchannels), to<double>(sample_rate));
 	return self;
 }
 
@@ -31,10 +33,82 @@ VALUE play(VALUE self)
 {
 	CHECK;
 
-	THIS->play();
+	return value(THIS->play());
+}
+
+static
+VALUE save(VALUE self, VALUE path)
+{
+	CHECK;
+
+	THIS->save(path.c_str());
 	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_seconds(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->seconds());
+}
+
+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
+VALUE set_loop(VALUE self, VALUE loop)
+{
+	CHECK;
+
+	THIS->set_loop(to<bool>(loop));
+	return loop;
+}
+
+static
+VALUE get_loop(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->loop());
+}
+
+static
+VALUE load(VALUE self, VALUE path)
+{
+	return value(Beeps::load_sound(to<const char*>(path)));
+}
+
 
 static Class cSound;
 
@@ -45,8 +119,17 @@ Init_beeps_sound ()
 
 	cSound = rb_define_class_under(mBeeps, "Sound", rb_cObject);
 	rb_define_alloc_func(cSound, alloc);
-	rb_define_private_method(cSound, "initialize", RUBY_METHOD_FUNC(initialize), 2);
-	rb_define_method(cSound, "play", RUBY_METHOD_FUNC(play), 0);
+	rb_define_private_method(cSound, "setup", RUBY_METHOD_FUNC(setup), 4);
+	cSound.define_private_method("play!", play);
+	rb_define_method(cSound, "save", RUBY_METHOD_FUNC(save), 1);
+	rb_define_method(cSound, "sample_rate", RUBY_METHOD_FUNC(get_sample_rate), 0);
+	rb_define_method(cSound, "nchannels", RUBY_METHOD_FUNC(get_nchannels), 0);
+	rb_define_method(cSound, "seconds", RUBY_METHOD_FUNC(get_seconds), 0);
+	rb_define_method(cSound, "gain=", RUBY_METHOD_FUNC(set_gain), 1);
+	rb_define_method(cSound, "gain", RUBY_METHOD_FUNC(get_gain), 0);
+	rb_define_method(cSound, "loop=", RUBY_METHOD_FUNC(set_loop), 1);
+	rb_define_method(cSound, "loop", RUBY_METHOD_FUNC(get_loop), 0);
+	rb_define_singleton_method(cSound, "load", RUBY_METHOD_FUNC(load), 1);
 }
 
 

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

@@ -0,0 +1,156 @@
+#include "beeps/ruby/sound.h"
+
+
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Beeps::SoundPlayer)
+
+#define THIS  to<Beeps::SoundPlayer*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::SoundPlayer, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Beeps::SoundPlayer>(klass);
+}
+
+static
+VALUE play(VALUE self)
+{
+	CHECK;
+
+	THIS->play();
+	return self;
+}
+
+static
+VALUE pause(VALUE self)
+{
+	CHECK;
+
+	THIS->pause();
+	return self;
+}
+
+static
+VALUE rewind(VALUE self)
+{
+	CHECK;
+
+	THIS->rewind();
+	return self;
+}
+
+static
+VALUE stop(VALUE self)
+{
+	CHECK;
+
+	THIS->stop();
+	return self;
+}
+
+static
+VALUE is_playing(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->is_playing());
+}
+
+static
+VALUE is_paused(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->is_paused());
+}
+
+static
+VALUE is_stopped(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->is_stopped());
+}
+
+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
+VALUE set_loop(VALUE self, VALUE loop)
+{
+	CHECK;
+
+	THIS->set_loop(to<bool>(loop));
+	return loop;
+}
+
+static
+VALUE get_loop(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->loop());
+}
+
+static
+VALUE stop_all(VALUE self)
+{
+	Beeps::stop_all_sound_players();
+}
+
+
+static Class cSoundPlayer;
+
+void
+Init_beeps_sound_player ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cSoundPlayer = rb_define_class_under(mBeeps, "SoundPlayer", rb_cObject);
+	rb_define_alloc_func(cSoundPlayer, alloc);
+	rb_define_method(cSoundPlayer, "play", RUBY_METHOD_FUNC(play), 0);
+	rb_define_method(cSoundPlayer, "pause", RUBY_METHOD_FUNC(pause), 0);
+	rb_define_method(cSoundPlayer, "rewind", RUBY_METHOD_FUNC(rewind), 0);
+	rb_define_method(cSoundPlayer, "stop", RUBY_METHOD_FUNC(stop), 0);
+	cSoundPlayer.define_method("playing?", is_playing);
+	cSoundPlayer.define_method("paused?",  is_paused);
+	cSoundPlayer.define_method("stopped?", is_stopped);
+	rb_define_method(cSoundPlayer, "gain=", RUBY_METHOD_FUNC(set_gain), 1);
+	rb_define_method(cSoundPlayer, "gain", RUBY_METHOD_FUNC(get_gain), 0);
+	rb_define_method(cSoundPlayer, "loop=", RUBY_METHOD_FUNC(set_loop), 1);
+	rb_define_method(cSoundPlayer, "loop", RUBY_METHOD_FUNC(get_loop), 0);
+	rb_define_singleton_method(cSoundPlayer, "stop_all", RUBY_METHOD_FUNC(stop_all), 0);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	sound_player_class ()
+	{
+		return cSoundPlayer;
+	}
+
+
+}// Beeps

data/.doc/ext/beeps/time_stretch.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::TimeStretch)
+
+#define THIS  to<Beeps::TimeStretch*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::TimeStretch, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::TimeStretch>, klass);
+}
+
+static
+VALUE set_scale(VALUE self, VALUE scale)
+{
+	CHECK;
+
+	THIS->set_scale(to<float>(scale));
+	return scale;
+}
+
+static
+VALUE get_scale(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->scale());
+}
+
+
+static Class cTimeStretch;
+
+void
+Init_beeps_time_stretch ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cTimeStretch = mBeeps.define_class("TimeStretch", Beeps::processor_class());
+	rb_define_alloc_func(cTimeStretch, alloc);
+	rb_define_method(cTimeStretch, "scale=", RUBY_METHOD_FUNC(set_scale), 1);
+	rb_define_method(cTimeStretch, "scale", RUBY_METHOD_FUNC(get_scale), 0);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	time_stretch_class ()
+	{
+		return cTimeStretch;
+	}
+
+
+}// Beeps

data/.github/workflows/release-gem.yml

@@ -20,8 +20,11 @@ jobs:
       - name: setup dependencies
         run: "ruby -I.github/workflows -rutils -e 'setup_dependencies'"
 
+      - name: install gems
+        run: gem install yard
+
       - name: test
-        run: rake test
+        run: rake quiet test
 
       - name: create gem
         id: gem

data/ChangeLog.md

@@ -1,6 +1,14 @@
 # beeps ChangeLog
 
 
+## [v0.1.33] - 2023-04-22
+
+- Stream playback is now supported.
+- Pause, resume, and stop after playback, as well as methods to check the status of the playback.
+- Support for saving and loading sound files
+- Added Oscillator, MicIn, Gain, ADSR, TimeStretch, PitchShift, and Analyser classes.
+
+
 ## [v0.1.32] - 2023-03-01
 
 - fix bugs

data/Rakefile

@@ -13,14 +13,36 @@ require 'beeps/extension'
 
 
 EXTENSIONS  = [Xot, Rucy, Beeps]
-TESTS_ALONE = ['test/test_beeps.rb']
+TESTS_ALONE = ['test/test_beeps_init.rb']
 
 use_external_library 'https://github.com/thestk/stk',
-  tag:      'v4.6.0',
-  incdir:   'include',
-  srcdir:   'src',
+  tag:      '4.6.2',
+  incdirs:  'include',
+  srcdirs:  'src',
   excludes: %w[stk/src/include Tcp Udp Socket Thread Mutex InetWv /Rt]
 
+use_external_library 'https://github.com/adamstark/AudioFile',
+  tag:      '1.1.1',
+  srcdirs:  'NOSRC',
+  excludes: %w[examples/ tests/]
+
+use_external_library 'https://github.com/avaneev/r8brain-free-src',
+  tag: 'version-6.2',
+  excludes: %w[DLL/ bench/ other/ pffft_double example.cpp],
+  &proc {
+    filter_file('r8bconf.h') do |conf|
+      <<~EOS + conf
+        #ifndef R8B_PFFFT
+        #define R8B_PFFFT 1
+        #endif
+      EOS
+    end
+  }
+
+use_external_library 'https://github.com/Signalsmith-Audio/signalsmith-stretch',
+  commit:  'fddcdb628f326ef187b7e5694f285f35a528aba3',
+  srcdirs: 'NOSRC'
+
 default_tasks :ext
 build_native_library
 build_ruby_extension

data/VERSION

@@ -1 +1 @@
-0.1.32
+0.1.33

data/beeps.gemspec

@@ -28,8 +28,8 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 2.7.0'
 
-  s.add_runtime_dependency 'xot',  '~> 0.1.32'
-  s.add_runtime_dependency 'rucy', '~> 0.1.32'
+  s.add_runtime_dependency 'xot',  '~> 0.1.33'
+  s.add_runtime_dependency 'rucy', '~> 0.1.33'
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'test-unit'

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