beeps 0.3.6 → 0.3.7

data/src/signals.h

@@ -5,9 +5,11 @@
 
 
 #include <assert.h>
+#include <functional>
 #include <vector>
 #include <Stk.h>
 #include <xot/pimpl.h>
+#include "beeps/beeps.h"
 #include "beeps/signals.h"
 #include "beeps/exception.h"
 
@@ -16,11 +18,6 @@ namespace Beeps
 {
 
 
-	typedef stk::StkFloat Float;
-
-
-	class Frames;
-
 	template <typename T> class SignalSamples;
 
 
@@ -31,11 +28,23 @@ namespace Beeps
 		const float* const* channels,
 		uint nsamples, uint nchannels, double sample_rate = 0);
 
+	uint Signals_tick (
+		Signals* signals,
+		std::function<void(stk::StkFrames*)> fun);
+
+	uint Signals_tick (
+		Signals* output, const Signals& input,
+		std::function<void(stk::StkFrames*, const stk::StkFrames&)> fun);
+
+	uint Signals_tick (
+		Signals* signals, uint start, uint length,
+		std::function<void(stk::StkFrames*)> fun);
+
 	void Signals_clear (Signals* signals);
 
 	void Signals_clear (Signals* signals, uint capacity);
 
-	void Signals_resize (Signals* signals, uint nsamples, Float value);
+	void Signals_fill (Signals* signals, uint nsamples, Sample value);
 
 	uint Signals_copy (Signals* to, const Signals& from, uint from_offset);
 
@@ -43,98 +52,30 @@ namespace Beeps
 
 	void Signals_multiply (Signals* signals, const Signals& multiplier);
 
+	void Signals_offset_and_scale (
+		Signals* signals, float offset, float scale,
+		int channel = -1, uint start = 0, int end = -1);
+
 	template <typename T>
 	void Signals_write_samples (
 		Signals* signals, const SignalSamples<T>& samples, long nsamples = -1);
 
 	void  Signals_set_nsamples (Signals* signals, uint nsamples);
 
-	float Signals_get_seconds (const Signals& signals);
+	      Sample* Signals_at (      Signals* signals, uint index, uint channel = 0);
+
+	const Sample* Signals_at (const Signals* signals, uint index, uint channel = 0);
 
-	      Frames* Signals_get_frames (      Signals* signals);
+	const Sample* Signals_at (const Signals& signals, uint index, uint channel = 0);
 
-	const Frames* Signals_get_frames (const Signals* signals);
+	float Signals_get_seconds (const Signals& signals);
 
 	void    Signals_save (const Signals& signals, const char* path);
 
 	Signals Signals_load (const char* path);
 
 
-	class Frames : public stk::StkFrames
-	{
-
-		public:
-
-			Frames (unsigned int nframes = 0, unsigned int nchannels = 1)
-			:	stk::StkFrames(nframes, nchannels)
-			{
-			}
-
-			size_t slice (size_t start, size_t length)
-			{
-				assert(!saved_data_);
-
-				size_t end = start + length;
-				assert(start <= nFrames_ && end <= nFrames_);
-
-				saved_data_       = data_;
-				saved_nFrames_    = nFrames_;
-				saved_size_       = size_;
-				saved_bufferSize_ = bufferSize_;
-
-				data_      += start * nChannels_;
-				nFrames_    = length;
-				size_       = length * nChannels_;
-				bufferSize_ = size_;
-
-				return end;
-			}
-
-			void unslice ()
-			{
-				assert(saved_data_);
-
-				data_       = saved_data_;
-				nFrames_    = saved_nFrames_;
-				size_       = saved_size_;
-				bufferSize_ = saved_bufferSize_;
-
-				saved_data_       = NULL;
-				saved_nFrames_    = 0;
-				saved_size_       = 0;
-				saved_bufferSize_ = 0;
-			}
-
-			uint sample_rate () const
-			{
-				return dataRate();
-			}
-
-			uint nchannels () const
-			{
-				return nChannels_;
-			}
-
-			uint nframes () const
-			{
-				return (uint) nFrames_;
-			}
-
-			const Float* data () const
-			{
-				return data_;
-			}
-
-		private:
-
-			Float* saved_data_ = NULL;
-
-			size_t saved_nFrames_ = 0, saved_size_ = 0, saved_bufferSize_ = 0;
-
-	};// Frames
-
-
-	template <typename T>
+	template <typename T = Sample>
 	class SignalSamples
 	{
 
@@ -154,9 +95,6 @@ namespace Beeps
 				if (!signals)
 					argument_error(__FILE__, __LINE__);
 
-				const Frames* f = Signals_get_frames(&signals);
-				assert(f);
-
 				uint nsamples  = signals.nsamples();
 				uint nchannels = signals.nchannels();
 
@@ -165,8 +103,9 @@ namespace Beeps
 
 				for (uint channel = 0; channel < nchannels; ++channel)
 				{
-					for (uint sample = 0; sample < nsamples; ++sample)
-						samples.push_back((*f)(sample, channel));
+					const Sample* p = Signals_at(signals, 0);
+					for (uint i = 0; i < nsamples; ++i, p += nchannels)
+						samples.push_back(*p);
 				}
 
 				self->nsamples = nsamples;

data/src/sound.cpp

@@ -7,8 +7,8 @@
 #include <algorithm>
 #include "Stk.h"
 #include "beeps/beeps.h"
-#include "beeps/exception.h"
 #include "beeps/generator.h"
+#include "beeps/exception.h"
 #include "beeps/debug.h"
 #include "openal.h"
 #include "processor.h"
@@ -60,25 +60,23 @@ namespace Beeps
 			double sample_rate = signals.sample_rate();
 			uint nchannels     = signals.nchannels();
 			uint nsamples      = signals.nsamples();
+			uint size          = nsamples * nchannels;
 			assert(sample_rate > 0 && nchannels > 0);
 			if (nsamples <= 0) return 0;
 
-			const Frames* frames = Signals_get_frames(&signals);
-			assert(frames);
-
-			std::vector<short> buffer;
-			buffer.reserve(nsamples * nchannels);
-			for (uint sample = 0; sample < nsamples; ++sample)
+			std::unique_ptr<short[]> buffer(new short[size]);
+			for (uint channel = 0; channel < nchannels; ++channel)
 			{
-				for (uint channel = 0; channel < nchannels; ++channel)
-					buffer.push_back((*frames)(sample, channel) * SHRT_MAX);
+				const Sample* p = Signals_at(signals, 0, channel);
+				for (uint i = channel; i < size; i += nchannels, p += nchannels)
+					buffer[i] = *p * SHRT_MAX;
 			}
 
 			alBufferData(
 				self->id,
 				nchannels == 2 ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16,
 				&buffer[0],
-				sizeof(short) * nsamples * nchannels,
+				sizeof(short) * size,
 				sample_rate);
 			OpenAL_check_error(__FILE__, __LINE__);
 
@@ -416,7 +414,11 @@ namespace Beeps
 			for (int i = 0; i < 2; ++i)
 			{
 				SoundBuffer buffer(true);
-				if (!process_stream(&buffer)) break;
+				if (!process_stream(&buffer))
+				{
+					source.stop();
+					break;
+				}
 
 				source.queue(buffer);
 				buffers.emplace_back(buffer);
@@ -425,7 +427,10 @@ namespace Beeps
 
 		bool process_stream (SoundBuffer* buffer)
 		{
-			assert(buffer && processor && stream_context);
+			assert(buffer && processor);
+
+			if (!stream_context)
+				return false;
 
 			Signals signals = stream_context->process_next(processor);
 			if (stream_context->is_finished())
@@ -443,7 +448,10 @@ namespace Beeps
 					return;
 
 				if (!process_stream(&buffer))
+				{
+					source.stop();
 					return;
+				}
 
 				source.queue(buffer);
 				if (source.state() == STOPPED) source.play();
@@ -687,13 +695,8 @@ namespace Beeps
 
 		SoundData (
 			Processor* processor, float seconds, uint nchannels, double sample_rate)
+		:	signals(get_signals(processor, seconds, nchannels, sample_rate))
 		{
-			assert(
-				processor && *processor &&
-				seconds > 0 && nchannels > 0 && sample_rate > 0);
-
-			StreamContext context(seconds * sample_rate, nchannels, sample_rate);
-			this->signals = context.process_next(processor);
 		}
 
 		void attach_to (SoundPlayer* player) override
@@ -799,12 +802,17 @@ namespace Beeps
 	{
 		Processor::Ref ref = processor;
 
+		if (sample_rate == 0)
+			sample_rate = Beeps::sample_rate();
+
 		if (!processor)
 			argument_error(__FILE__, __LINE__);
 		if (!*processor)
 			argument_error(__FILE__, __LINE__);
-
-		if (sample_rate <= 0) sample_rate = Beeps::sample_rate();
+		if (nchannels <= 0)
+			argument_error(__FILE__, __LINE__);
+		if (sample_rate <= 0)
+			argument_error(__FILE__, __LINE__);
 
 		if (seconds > 0)
 			self.reset(new SoundData(processor, seconds, nchannels, sample_rate));

data/src/time_stretch.cpp

@@ -54,6 +54,12 @@ namespace Beeps
 		return self->scale;
 	}
 
+	TimeStretch::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->scale > 0;
+	}
+
 	void
 	TimeStretch::filter (Context* context, Signals* signals, uint* offset)
 	{
@@ -81,11 +87,5 @@ namespace Beeps
 		Signals_write_samples(signals, output);
 	}
 
-	TimeStretch::operator bool () const
-	{
-		if (!Super::operator bool()) return false;
-		return self->scale > 0;
-	}
-
 
 }// Beeps

data/src/win32/signals.cpp

@@ -154,7 +154,6 @@ namespace Beeps
 		uint nchannels  = format.nChannels;
 		uint nsamples   = bytes.size() / Bps / nchannels;
 		Signals signals = Signals_create(nsamples, nchannels, format.nSamplesPerSec);
-		Frames* frames  = Signals_get_frames(&signals);
 
 		for (uint channel = 0; channel < nchannels; ++channel)
 		{
@@ -162,17 +161,19 @@ namespace Beeps
 			{
 				case 1:
 				{
-					const uchar* p = ((uchar*) &bytes[0]) + channel;
-					for (uint sample = 0; sample < nsamples; ++sample, p += nchannels)
-						(*frames)(sample, channel) = (*p - 128) / 128.f;
+					Sample*        to_p = Signals_at(&signals, 0, channel);
+					const uchar* from_p = ((uchar*) &bytes[0]) + channel;
+					for (uint i = 0; i < nsamples; ++i, to_p += nchannels, from_p += nchannels)
+						*to_p = (*to_p - 128) / 128.f;
 					break;
 				}
 
 				case 2:
 				{
-					const ushort* p = ((ushort*) &bytes[0]) + channel;
-					for (uint sample = 0; sample < nsamples; ++sample, p += nchannels)
-						(*frames)(sample, channel) = *p / 32768.f;
+					Sample*         to_p = Signals_at(&signals, 0, channel);
+					const ushort* from_p = ((ushort*) &bytes[0]) + channel;
+					for (uint i = 0; i < nsamples; ++i, to_p += nchannels, from_p += nchannels)
+						*to_p = *from_p / 32768.f;
 					break;
 				}
 			}

data/src/x_pass.h

@@ -0,0 +1,51 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __BEEPS_SRC_X_PASS_H__
+#define __BEEPS_SRC_X_PASS_H__
+
+
+#include <BiQuad.h>
+#include "beeps/filter.h"
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct xPassFilterData
+	{
+
+		stk::BiQuad biquad;
+
+		float cutoff_freq;
+
+		xPassFilterData (float cutoff_frequency)
+		:	cutoff_freq(cutoff_frequency)
+		{
+		}
+
+		void tick (Signals* signals)
+		{
+			uint nchannels   = signals->nchannels();
+			Signals filtered = Signals_create(
+				signals->nsamples(), nchannels, signals->sample_rate());
+
+			Signals_tick(
+				&filtered, *signals,
+				[&](stk::StkFrames* out, const stk::StkFrames& in)
+				{
+					for (uint ch = 0; ch < nchannels; ++ch)
+						biquad.tick(const_cast<stk::StkFrames&>(in), *out, ch, ch);
+				});
+
+			*signals = filtered;
+		}
+
+	};// xPassFilterData
+
+
+}// Beeps
+
+
+#endif//EOH

data/test/helper.rb

@@ -8,3 +8,17 @@ require 'beeps'
 require 'test/unit'
 
 include Xot::Test
+
+
+def get_samples(resolution_per_sec, processor, *a, seconds: 1, **k, &b)
+  resolution = resolution_per_sec * seconds
+  nsamples   = Beeps.sample_rate  * seconds
+  samples    =
+    Beeps::Processor.get_signals(processor, *a, seconds: seconds, **k, &b).to_a
+  (0..resolution).to_a
+    .map {_1 / resolution.to_f}
+    .map {(nsamples * _1).to_i}
+    .map {_1 == 0 ? 0 : _1 - 1}
+    .map {samples[_1]}
+    .reverse.drop_while {_1.nil?}.reverse
+end

data/test/test_analyser.rb

@@ -0,0 +1,26 @@
+require_relative 'helper'
+
+
+class TestAnalyser < Test::Unit::TestCase
+
+  B = Beeps
+
+  def analyser(...)
+    B::Analyser.new(...)
+  end
+
+  def osc(...)
+    B::Oscillator.new(...)
+  end
+
+  def test_initialize()
+    assert_equal 1024, analyser.fft_size
+  end
+
+  def test_process()
+    assert_equal(
+      get_samples(1000, osc(:sine)),
+      get_samples(1000, osc(:sine) >> analyser))
+  end
+
+end# TestAnalyser

data/test/test_envelope.rb

@@ -0,0 +1,55 @@
+require_relative 'helper'
+
+
+class TestEnvelope < Test::Unit::TestCase
+
+  B = Beeps
+
+  def envelope(on_sec = 0, off_sec, a: 0, d: 0, s: 1, r: 0)
+    B::Envelope.new attack: a, decay: d, sustain: s, release: r do
+      note_on   on_sec
+      note_off off_sec
+    end
+  end
+
+  def const(value = 1)
+    B::Oscillator.new samples: [value]
+  end
+
+  def test_attack()
+    o = const(1) >> envelope(1, a: 0.1)
+    assert_each_in_delta [0] + [1] * 10, get_samples(10, o)
+  end
+
+  def test_decay_sustain()
+    o = const(1) >> envelope(1, d: 0.2, s: 0.8)
+    assert_each_in_delta [1, 0.9] + [0.8] * 9, get_samples(10, o)
+  end
+
+  def test_release()
+    o = const(1) >> envelope(0.8, r: 0.1)
+    assert_each_in_delta [1] * 9 + [0], get_samples(10, o)
+  end
+
+  def test_adsr()
+    o = const(1) >> envelope(1, a: 0.1, d: 0.2, s: 0.8, r: 0.4)
+    assert_each_in_delta(
+      [0, 1, 0.9] + [0.8] * 8 + [0.6, 0.4, 0.2, 0],
+      get_samples(10, o, seconds: 2))
+  end
+
+  def test_duration()
+    o = const(1) >> envelope(0.1)
+    assert_each_in_epsilon [1] * 2,  get_samples(10, o, seconds: 2)
+
+    o = const(1) >> envelope(1)
+    assert_each_in_epsilon [1] * 11, get_samples(10, o, seconds: 2)
+
+    o = const(1) >> envelope(2)
+    assert_each_in_epsilon [1] * 21, get_samples(10, o, seconds: 2)
+
+    o = const(1) >> envelope(3)
+    assert_each_in_epsilon [1] * 21, get_samples(10, o, seconds: 2)
+  end
+
+end# TestEnvelope

data/test/test_file_in.rb

@@ -1,3 +1,4 @@
+require 'tempfile'
 require_relative 'helper'
 
 
@@ -5,7 +6,27 @@ class TestFileIn < Test::Unit::TestCase
 
   B = Beeps
 
-  def test_initialize()
+  def filein(path)
+    B::FileIn.new path
+  end
+
+  def osc(...)
+    B::Oscillator.new(...)
+  end
+
+  def test_load_file()
+    Tempfile.create 'tmp.wav' do |file|
+      file.close
+
+      B::Sound.new(osc(:sine), 3).save(file.path)
+
+      assert_each_in_delta(
+        get_samples(100, osc(:sine)),
+        get_samples(100, filein(file.path)))
+    end
+  end
+
+  def test_file_not_found()
     assert_raise(B::BeepsError) {B::FileIn.new 'nofile.wav'}
   end
 

data/test/test_gain.rb

@@ -0,0 +1,28 @@
+require_relative 'helper'
+
+
+class TestGain < Test::Unit::TestCase
+
+  B = Beeps
+
+  def gain(...)
+    B::Gain.new(...)
+  end
+
+  def const(value = 1)
+    B::Oscillator.new samples: [value]
+  end
+
+  def test_initialize()
+    assert_equal 1, gain   .gain
+    assert_equal 2, gain(2).gain
+  end
+
+  def test_process()
+    assert_equal [2]   * 4, get_samples(3, const(1) >> gain(2))
+    assert_equal [0.5] * 4, get_samples(3, const(1) >> gain(0.5))
+    assert_equal [0]   * 4, get_samples(3, const(1) >> gain(0))
+    assert_equal [-1]  * 4, get_samples(3, const(1) >> gain(-1))
+  end
+
+end# TestGain

data/test/test_high_pass.rb

@@ -0,0 +1,41 @@
+require_relative 'helper'
+
+
+class TestHighPass < Test::Unit::TestCase
+
+  B = Beeps
+
+  def hpass(...)
+    B::HighPass.new(...)
+  end
+
+  def test_initialize()
+    assert_equal 100, hpass   .cutoff
+    assert_equal 1,   hpass(1).cutoff
+  end
+
+  def test_cutoff_freqneucy()
+    f = hpass    1
+    assert_equal 1, f.cutoff_frequency
+    assert_equal 1, f.cutoff
+
+    f.cutoff_frequency = 2
+    assert_equal         2, f.cutoff_frequency
+    assert_equal         2, f.cutoff
+
+    f.cutoff_frequency   3
+    assert_equal         3, f.cutoff_frequency
+    assert_equal         3, f.cutoff
+
+    f.cutoff =   4
+    assert_equal 4, f.cutoff_frequency
+    assert_equal 4, f.cutoff
+
+    f.cutoff     5
+    assert_equal 5, f.cutoff_frequency
+    assert_equal 5, f.cutoff
+
+    assert_raise(ArgumentError) {f.cutoff 0}
+  end
+
+end# TestHighPass

data/test/test_low_pass.rb

@@ -0,0 +1,41 @@
+require_relative 'helper'
+
+
+class TestLowPass < Test::Unit::TestCase
+
+  B = Beeps
+
+  def lpass(...)
+    B::LowPass.new(...)
+  end
+
+  def test_initialize()
+    assert_equal 1000, lpass   .cutoff
+    assert_equal 1,    lpass(1).cutoff
+  end
+
+  def test_cutoff_freqneucy()
+    f = lpass    1
+    assert_equal 1, f.cutoff_frequency
+    assert_equal 1, f.cutoff
+
+    f.cutoff_frequency = 2
+    assert_equal         2, f.cutoff_frequency
+    assert_equal         2, f.cutoff
+
+    f.cutoff_frequency   3
+    assert_equal         3, f.cutoff_frequency
+    assert_equal         3, f.cutoff
+
+    f.cutoff =   4
+    assert_equal 4, f.cutoff_frequency
+    assert_equal 4, f.cutoff
+
+    f.cutoff     5
+    assert_equal 5, f.cutoff_frequency
+    assert_equal 5, f.cutoff
+
+    assert_raise(ArgumentError) {f.cutoff 0}
+  end
+
+end# TestLowPass