beeps 0.1.32 → 0.1.33

data/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
@@ -19,11 +19,13 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEF2(initialize, processor, seconds)
+RUCY_DEF4(setup, processor, seconds, nchannels, 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;
 }
 RUCY_END
@@ -33,11 +35,92 @@ RUCY_DEF0(play)
 {
 	CHECK;
 
-	THIS->play();
+	return value(THIS->play());
+}
+RUCY_END
+
+static
+RUCY_DEF1(save, path)
+{
+	CHECK;
+
+	THIS->save(path.c_str());
 	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_seconds)
+{
+	CHECK;
+
+	return value(THIS->seconds());
+}
+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
+RUCY_DEF1(set_loop, loop)
+{
+	CHECK;
+
+	THIS->set_loop(to<bool>(loop));
+	return loop;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_loop)
+{
+	CHECK;
+
+	return value(THIS->loop());
+}
+RUCY_END
+
+static
+RUCY_DEF1(load, path)
+{
+	return value(Beeps::load_sound(to<const char*>(path)));
+}
+RUCY_END
+
 
 static Class cSound;
 
@@ -48,8 +131,17 @@ Init_beeps_sound ()
 
 	cSound = mBeeps.define_class("Sound");
 	cSound.define_alloc_func(alloc);
-	cSound.define_private_method("initialize", initialize);
-	cSound.define_method("play", play);
+	cSound.define_private_method("setup", setup);
+	cSound.define_private_method("play!", play);
+	cSound.define_method("save", save);
+	cSound.define_method("sample_rate", get_sample_rate);
+	cSound.define_method("nchannels",   get_nchannels);
+	cSound.define_method("seconds",     get_seconds);
+	cSound.define_method("gain=", set_gain);
+	cSound.define_method("gain",  get_gain);
+	cSound.define_method("loop=", set_loop);
+	cSound.define_method("loop",  get_loop);
+	cSound.define_singleton_method("load", load);
 }
 
 

data/ext/beeps/sound_player.cpp

@@ -0,0 +1,169 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Beeps::SoundPlayer>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF0(play)
+{
+	CHECK;
+
+	THIS->play();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(pause)
+{
+	CHECK;
+
+	THIS->pause();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(rewind)
+{
+	CHECK;
+
+	THIS->rewind();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(stop)
+{
+	CHECK;
+
+	THIS->stop();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_playing)
+{
+	CHECK;
+
+	return value(THIS->is_playing());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_paused)
+{
+	CHECK;
+
+	return value(THIS->is_paused());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_stopped)
+{
+	CHECK;
+
+	return value(THIS->is_stopped());
+}
+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
+RUCY_DEF1(set_loop, loop)
+{
+	CHECK;
+
+	THIS->set_loop(to<bool>(loop));
+	return loop;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_loop)
+{
+	CHECK;
+
+	return value(THIS->loop());
+}
+RUCY_END
+
+static
+RUCY_DEF0(stop_all)
+{
+	Beeps::stop_all_sound_players();
+}
+RUCY_END
+
+
+static Class cSoundPlayer;
+
+void
+Init_beeps_sound_player ()
+{
+	Module mBeeps = define_module("Beeps");
+
+	cSoundPlayer = mBeeps.define_class("SoundPlayer");
+	cSoundPlayer.define_alloc_func(alloc);
+	cSoundPlayer.define_method("play",   play);
+	cSoundPlayer.define_method("pause",  pause);
+	cSoundPlayer.define_method("rewind", rewind);
+	cSoundPlayer.define_method("stop",   stop);
+	cSoundPlayer.define_method("playing?", is_playing);
+	cSoundPlayer.define_method("paused?",  is_paused);
+	cSoundPlayer.define_method("stopped?", is_stopped);
+	cSoundPlayer.define_method("gain=", set_gain);
+	cSoundPlayer.define_method("gain",  get_gain);
+	cSoundPlayer.define_method("loop=", set_loop);
+	cSoundPlayer.define_method("loop",  get_loop);
+	cSoundPlayer.define_singleton_method("stop_all", stop_all);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	sound_player_class ()
+	{
+		return cSoundPlayer;
+	}
+
+
+}// Beeps

data/ext/beeps/time_stretch.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::TimeStretch)
+
+#define THIS  to<Beeps::TimeStretch*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Beeps::TimeStretch, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Beeps::RubyProcessor<Beeps::TimeStretch>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_scale, scale)
+{
+	CHECK;
+
+	THIS->set_scale(to<float>(scale));
+	return scale;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_scale)
+{
+	CHECK;
+
+	return value(THIS->scale());
+}
+RUCY_END
+
+
+static Class cTimeStretch;
+
+void
+Init_beeps_time_stretch ()
+{
+	Module mBeeps = define_module("Beeps");
+
+	cTimeStretch = mBeeps.define_class("TimeStretch", Beeps::processor_class());
+	cTimeStretch.define_alloc_func(alloc);
+	cTimeStretch.define_method("scale=", set_scale);
+	cTimeStretch.define_method("scale",  get_scale);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	time_stretch_class ()
+	{
+		return cTimeStretch;
+	}
+
+
+}// Beeps

data/include/beeps/beeps.h

@@ -15,8 +15,9 @@ namespace Beeps
 
 	void fin ();
 
+	void process_streams ();
 
-	uint sampling_rate ();
+	double sample_rate ();
 
 
 }// Beeps

data/include/beeps/filter.h

@@ -0,0 +1,179 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __BEEPS_FILTER_H__
+#define __BEEPS_FILTER_H__
+
+
+#include <vector>
+#include <beeps/processor.h>
+
+
+namespace Beeps
+{
+
+
+	class Gain : public Filter
+	{
+
+		typedef Filter Super;
+
+		public:
+
+			Gain (Processor* input = NULL);
+
+			virtual ~Gain ();
+
+			virtual void set_gain (float gain);
+
+			virtual float    gain () const;
+
+			virtual void filter (
+				Context* context, Signals* signals, uint* offset) override;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// Gain
+
+
+	class ADSR : public Filter
+	{
+
+		typedef Filter Super;
+
+		public:
+
+			ADSR (Processor* input = NULL);
+
+			virtual ~ADSR ();
+
+			virtual void note_on  (float delay = 0);
+
+			virtual void note_off (float delay = 0);
+
+			virtual void set_attack_time (float time);
+
+			virtual float    attack_time () const;
+
+			virtual void set_decay_time (float time);
+
+			virtual float    decay_time () const;
+
+			virtual void set_sustain_level (float level);
+
+			virtual float    sustain_level () const;
+
+			virtual void set_release_time (float time);
+
+			virtual float    release_time () const;
+
+			virtual void filter (
+				Context* context, Signals* signals, uint* offset) override;
+
+			virtual operator bool () const override;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// ADSR
+
+
+	class TimeStretch : public Filter
+	{
+
+		typedef Filter Super;
+
+		public:
+
+			TimeStretch (Processor* input = NULL);
+
+			virtual ~TimeStretch ();
+
+			virtual void reset () override;
+
+			virtual void set_scale (float scale);
+
+			virtual float    scale () const;
+
+			virtual void filter (
+				Context* context, Signals* signals, uint* offset) override;
+
+			virtual operator bool () const override;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// TimeStretch
+
+
+	class PitchShift : public Filter
+	{
+
+		typedef Filter Super;
+
+		public:
+
+			PitchShift (Processor* input = NULL);
+
+			virtual ~PitchShift ();
+
+			virtual void reset () override;
+
+			virtual void set_shift (float shift);
+
+			virtual float    shift () const;
+
+			virtual void filter (
+				Context* context, Signals* signals, uint* offset) override;
+
+			virtual operator bool () const override;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// PitchShift
+
+
+	class Analyser : public Filter
+	{
+
+		typedef Filter Super;
+
+		public:
+
+			typedef std::vector<float> Spectrum;
+
+			Analyser (uint fft_size = 1024, Processor* input = NULL);
+
+			virtual ~Analyser ();
+
+			virtual void set_fft_size (uint size);
+
+			virtual uint     fft_size () const;
+
+			virtual float resolution () const;
+
+			virtual const Signals&  signals () const;
+
+			virtual const Spectrum& spectrum () const;
+
+			virtual void filter (
+				Context* context, Signals* signals, uint* offset) override;
+
+			virtual operator bool () const override;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// Analyser
+
+
+}// Beeps
+
+
+#endif//EOH

data/include/beeps/generator.h

@@ -0,0 +1,120 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __BEEPS_GENERATOR_H__
+#define __BEEPS_GENERATOR_H__
+
+
+#include <beeps/processor.h>
+
+
+namespace Beeps
+{
+
+
+	class Oscillator : public Generator
+	{
+
+		typedef Generator Super;
+
+		public:
+
+			enum Type {NONE = 0, SINE, TRIANGLE, SQUARE, SAWTOOTH};
+
+			Oscillator (Type type = SINE);
+
+			virtual ~Oscillator ();
+
+			virtual void reset () override;
+
+			virtual void set_type (Type type);
+
+			virtual Type     type () const;
+
+			virtual void set_frequency (float frequency);
+
+			virtual float    frequency () const;
+
+			virtual void generate (
+				Context* context, Signals* signals, uint* offset) override;
+
+			virtual operator bool () const override;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// Oscillator
+
+
+	class FileIn : public Generator
+	{
+
+		typedef Generator Super;
+
+		public:
+
+			FileIn (const char* path = NULL);
+
+			virtual ~FileIn ();
+
+			virtual void reset () override;
+
+			virtual void    set_path(const char* path);
+
+			virtual const char* path () const;
+
+			virtual double sample_rate () const;
+
+			virtual uint nchannels () const;
+
+			virtual uint nsamples () const;
+
+			virtual float seconds () const;
+
+			virtual void generate (
+				Context* context, Signals* signals, uint* offset) override;
+
+			virtual operator bool () const override;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// FileIn
+
+
+	class MicIn : public Generator
+	{
+
+		typedef Generator Super;
+
+		public:
+
+			MicIn (uint nchannels = 1, double sample_rate = 0);
+
+			virtual ~MicIn ();
+
+			virtual void start ();
+
+			virtual void stop ();
+
+			virtual double sample_rate () const;
+
+			virtual uint nchannels () const;
+
+			virtual void generate (
+				Context* context, Signals* signals, uint* offset) override;
+
+			virtual operator bool () const override;
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// MicIn
+
+
+}// Beeps
+
+
+#endif//EOH