beeps 0.3.8 → 0.3.10

data/src/sequencer.cpp

@@ -1,7 +1,6 @@
 #include "beeps/generator.h"
 
 
-#include <list>
 #include <algorithm>
 #include "beeps/exception.h"
 #include "beeps/debug.h"
@@ -16,21 +15,7 @@ namespace Beeps
 	struct Sequencer::Data
 	{
 
-		struct Note
-		{
-
-			Processor::Ref processor;
-
-			float offset, duration;
-
-			Note (Processor* processor, float offset, float duration)
-			:	processor(processor), offset(offset), duration(duration)
-			{
-			}
-
-		};// Note
-
-		std::list<Note> notes;
+		NoteList notes;
 
 		float time_scale = 1;
 
@@ -42,6 +27,12 @@ namespace Beeps
 	};// Sequencer::Data
 
 
+	Sequencer::Note::Note (Processor* processor, float offset, float duration)
+	:	processor(processor), offset(offset), duration(duration)
+	{
+	}
+
+
 	Sequencer::Sequencer ()
 	{
 	}
@@ -99,6 +90,30 @@ namespace Beeps
 		return self->time_scale;
 	}
 
+	Sequencer::iterator
+	Sequencer::begin ()
+	{
+		return self->notes.begin();
+	}
+
+	Sequencer::const_iterator
+	Sequencer::begin () const
+	{
+		return self->notes.begin();
+	}
+
+	Sequencer::iterator
+	Sequencer::end ()
+	{
+		return self->notes.end();
+	}
+
+	Sequencer::const_iterator
+	Sequencer::end () const
+	{
+		return self->notes.end();
+	}
+
 	Sequencer::operator bool () const
 	{
 		if (!Super::operator bool()) return false;

data/src/signals.cpp

@@ -116,13 +116,13 @@ namespace Beeps
 	Signals
 	Signals_create (
 		const float* const* channels,
-		uint nsamples, uint nchannels, double sample_rate)
+		uint nsamples, uint nchannels, double sample_rate, uint capacity)
 	{
 		if (!channels)
 			argument_error(__FILE__, __LINE__);
 
-		Signals s        = Signals_create(nsamples, nchannels, sample_rate);
-		s.self->nsamples = nsamples;
+		Signals s = Signals_create(
+			capacity > nsamples ? capacity : nsamples, nchannels, sample_rate);
 
 		for (uint channel = 0; channel < nchannels; ++channel)
 		{
@@ -131,32 +131,10 @@ namespace Beeps
 				*p = channels[channel][i];
 		}
 
+		s.self->nsamples = nsamples;
 		return s;
 	}
 
-	void
-	Signals_clear (Signals* signals)
-	{
-		if (!signals)
-			argument_error(__FILE__, __LINE__);
-
-		signals->self->nsamples = 0;
-	}
-
-	void
-	Signals_clear (Signals* signals, uint capacity)
-	{
-		if (!signals)
-			argument_error(__FILE__, __LINE__);
-		if (!*signals)
-			argument_error(__FILE__, __LINE__);
-		if (capacity <= 0)
-			argument_error(__FILE__, __LINE__);
-
-		Signals_clear(signals);
-		signals->self->frames->resize(capacity, signals->nchannels());
-	}
-
 	uint
 	Signals_tick (Signals* signals, std::function<void(stk::StkFrames*)> fun)
 	{
@@ -212,20 +190,70 @@ namespace Beeps
 	}
 
 	void
-	Signals_fill (Signals* signals, uint nsamples, Sample value)
+	Signals_clear (Signals* signals)
+	{
+		if (!signals)
+			argument_error(__FILE__, __LINE__);
+
+		signals->self->nsamples = 0;
+	}
+
+	void
+	Signals_clear (Signals* signals, uint capacity)
 	{
 		if (!signals)
 			argument_error(__FILE__, __LINE__);
 		if (!*signals)
 			argument_error(__FILE__, __LINE__);
+		if (capacity <= 0)
+			argument_error(__FILE__, __LINE__);
 
 		Signals_clear(signals);
-		Signals_set_nsamples(signals, nsamples);
+		signals->self->frames->resize(capacity, signals->nchannels());
+	}
 
-		Sample* p   = Signals_at(signals, 0);
+	void
+	Signals_fill (Signals* signals, uint nsamples, Sample value, uint offset)
+	{
+		if (!signals)
+			argument_error(__FILE__, __LINE__);
+		if (!*signals)
+			argument_error(__FILE__, __LINE__);
+
+		uint new_nsamples = offset + nsamples;
+		if (new_nsamples > signals->capacity())
+			beeps_error(__FILE__, __LINE__);
+
+		Sample* p   = Signals_at(signals, offset);
 		size_t size = nsamples * signals->nchannels();
 		for (size_t i = 0; i < size; ++i)
 			*p++ = value;
+
+		Signals_set_nsamples(signals, new_nsamples);
+	}
+
+	void
+	Signals_shift (Signals* signals, uint nsamples)
+	{
+		if (!signals)
+			argument_error(__FILE__, __LINE__);
+		if (!*signals)
+			argument_error(__FILE__, __LINE__);
+
+		if (nsamples == 0)
+			return;
+
+		int new_nsamples = signals->nsamples() - nsamples;
+		if (new_nsamples < 0)
+			new_nsamples = 0;
+
+		Sample* from = Signals_at(signals, nsamples);
+		Sample* to   = Signals_at(signals, 0);
+		int size     = new_nsamples * signals->nchannels();
+		for (int i = 0; i < size; ++i)
+			*to++ = *from++;
+
+		Signals_set_nsamples(signals, new_nsamples);
 	}
 
 	static uint
@@ -450,6 +478,43 @@ namespace Beeps
 		write_samples(signals, samples, nsamples);
 	}
 
+	void
+	Signals_set_capacity (Signals* signals, uint capacity)
+	{
+		if (!signals)
+			argument_error(__FILE__, __LINE__);
+		if (!*signals)
+			argument_error(__FILE__, __LINE__);
+		if (capacity == 0)
+			argument_error(__FILE__, __LINE__);
+
+		if (capacity == signals->capacity())
+			return;
+
+		uint nsamples  = signals->nsamples();
+		uint nchannels = signals->nchannels();
+
+		if (capacity < signals->capacity())
+		{
+			signals->self->frames->resize(capacity, nchannels);
+			if (capacity < nsamples) Signals_set_nsamples(signals, capacity);
+		}
+		else
+		{
+			double sample_rate = signals->sample_rate();
+			const Sample* from = Signals_at(signals, 0);
+
+			std::unique_ptr<Frames> old = std::move(signals->self->frames);
+			signals->self->frames.reset(
+				new Frames(capacity * nchannels, nchannels, sample_rate));
+
+			Sample* to = Signals_at(signals, 0);
+			uint size  = nsamples * nchannels;
+			for (uint i = 0; i < size; ++i)
+				*to++ = *from++;
+		}
+	}
+
 	void
 	Signals_set_nsamples (Signals* signals, uint nsamples)
 	{
@@ -568,7 +633,16 @@ namespace Beeps
 	bool
 	Signals::empty () const
 	{
-		return self->nsamples == 0;
+		return nsamples() == 0;
+	}
+
+	bool
+	Signals::full () const
+	{
+		uint n = nsamples();
+		if (n == 0) return false;
+
+		return n == capacity();
 	}
 
 	const Sample*

data/src/signals.h

@@ -26,7 +26,7 @@ namespace Beeps
 
 	Signals Signals_create (
 		const float* const* channels,
-		uint nsamples, uint nchannels, double sample_rate = 0);
+		uint nsamples, uint nchannels, double sample_rate = 0, uint capacity = 0);
 
 	uint Signals_tick (
 		Signals* signals,
@@ -44,9 +44,13 @@ namespace Beeps
 
 	void Signals_clear (Signals* signals, uint capacity);
 
-	void Signals_fill (Signals* signals, uint nsamples, Sample value);
+	void Signals_fill (
+		Signals* signals, uint nsamples, Sample value,
+		uint offset = 0);
 
-	uint Signals_copy (Signals* to, const Signals& from, uint from_offset);
+	void Signals_shift (Signals* signals, uint nsamples);
+
+	uint Signals_copy (Signals* to, const Signals& from, uint from_offset = 0);
 
 	void Signals_add (     Signals* signals, const Signals& add);
 
@@ -60,7 +64,9 @@ namespace Beeps
 	void Signals_write_samples (
 		Signals* signals, const SignalSamples<T>& samples, long nsamples = -1);
 
-	void  Signals_set_nsamples (Signals* signals, uint nsamples);
+	void Signals_set_capacity (Signals* signals, uint capacity);
+
+	void Signals_set_nsamples (Signals* signals, uint nsamples);
 
 	      Sample* Signals_at (      Signals* signals, uint index, uint channel = 0);
 

data/src/value.cpp

@@ -0,0 +1,181 @@
+#include "beeps/generator.h"
+
+
+#include <algorithm>
+#include "beeps/exception.h"
+#include "processor.h"
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct Value::Data
+	{
+
+		Type type = TYPE_NONE;
+
+		PointList points;
+
+	};// Value::Data
+
+
+	Value::Point::Point (float value, float time)
+	:	value(value), time(time)
+	{
+	}
+
+
+	Value::Value (float value, Type type)
+	{
+		self->type = type;
+		set_value(value);
+	}
+
+	Value::~Value ()
+	{
+	}
+
+	void
+	Value::set_type (Type type)
+	{
+		self->type = type;
+
+		set_updated();
+	}
+
+	Value::Type
+	Value::type () const
+	{
+		return self->type;
+	}
+
+	void
+	Value::set_value (float value)
+	{
+		self->points.clear();
+		self->points.push_back(Point(value, 0));
+
+		set_updated();
+	}
+
+	void
+	Value::insert (float value, float time)
+	{
+		if (time < 0)
+			argument_error(__FILE__, __LINE__, "time must be >= 0");
+
+		auto& points = self->points;
+		auto it      = std::find_if(
+			points.begin(), points.end(),
+			[&](const auto& p) {return time <= p.time;});
+		if (it != points.end() && it->time == time)
+		{
+			if (it->value == value) return;
+			it->value = value;
+		}
+		else
+			points.emplace(it, value, time);
+
+		set_updated();
+	}
+
+	void
+	Value::clear ()
+	{
+		self->points.clear();
+
+		set_updated();
+	}
+
+	Value::iterator
+	Value::begin ()
+	{
+		return self->points.begin();
+	}
+
+	Value::const_iterator
+	Value::begin () const
+	{
+		return self->points.begin();
+	}
+
+	Value::iterator
+	Value::end ()
+	{
+		return self->points.end();
+	}
+
+	Value::const_iterator
+	Value::end () const
+	{
+		return self->points.end();
+	}
+
+	static float
+	interpolate_linear (const Value::PointList& points, float time)
+	{
+		if (points.empty())         return 0;
+		if (time <= points[0].time) return points[0].value;
+
+		for (size_t i = 0; i + 1 < points.size(); ++i)
+		{
+			const auto& p0 = points[i];
+			const auto& p1 = points[i + 1];
+			if (time < p1.time)
+			{
+				float t = (time - p0.time) / (p1.time - p0.time);
+				return p0.value + (p1.value - p0.value) * t;
+			}
+		}
+		return points.back().value;
+	}
+
+	static decltype(&interpolate_linear)
+	get_interpolate_func (Value::Type type)
+	{
+		switch (type)
+		{
+			case Value::LINEAR: return interpolate_linear;
+			default:            return NULL;
+		}
+	}
+
+	void
+	Value::generate (Context* context, Signals* signals, uint* offset)
+	{
+		Super::generate(context, signals, offset);
+
+		auto& points  = self->points;
+		uint nsamples = signals->capacity();
+
+		if (points.size() == 1)
+			Signals_fill(signals, nsamples, points[0].value);
+		else
+		{
+			auto interpolate = get_interpolate_func(self->type);
+			if (!interpolate)
+				invalid_state_error(__FILE__, __LINE__);
+
+			double sample_rate = signals->sample_rate();
+			Sample* p          = Signals_at(signals, 0);
+			for (uint i = 0; i < nsamples; ++i)
+				p[i] = interpolate(points, (*offset + i) / sample_rate);
+			Signals_set_nsamples(signals, nsamples);
+		}
+
+		*offset += signals->nsamples();
+	}
+
+	int
+	Value::max_segment_size_for_process (
+		double sample_rate, uint nsamples) const
+	{
+		if (self->points.size() == 1)
+			return Super::max_segment_size_for_process(sample_rate, nsamples);
+		return sample_rate / 256;
+	}
+
+
+}// Beeps

data/src/win32/text_in.cpp

@@ -0,0 +1,62 @@
+// -*- c++ -*-
+#include "beeps/generator.h"
+
+
+#include "beeps/exception.h"
+#include "../signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct TextIn::Data
+	{
+
+		double sample_rate = 0;
+
+	};// TextIn::Data
+
+
+	TextIn::TextIn (const char* text, double sample_rate)
+	{
+		if (sample_rate == 0)
+			sample_rate = Beeps::sample_rate();
+		if (sample_rate <= 0)
+			argument_error(__FILE__, __LINE__);
+
+		self->sample_rate = sample_rate;
+
+		if (text) synthesize(text);
+	}
+
+	TextIn::~TextIn ()
+	{
+	}
+
+	void
+	TextIn::synthesize (const char* text)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	double
+	TextIn::sample_rate () const
+	{
+		return self->sample_rate;
+	}
+
+	TextIn::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->sample_rate > 0;
+	}
+
+	void
+	TextIn::generate (Context* context, Signals* signals, uint* offset)
+	{
+		Super::generate(context, signals, offset);
+	}
+
+
+}// Beeps

data/test/test_oscillator.rb

@@ -23,12 +23,12 @@ class TestOscillator < Test::Unit::TestCase
   def test_offset()
     assert_in_delta  0, get_samples(10000, osc(offset:  0)).sum / 10000
     assert_in_delta  3, get_samples(10000, osc(offset:  3)).sum / 10000
-    assert_in_delta -3, get_samples(10000, osc(offset: -3)).sum / 10000
+    assert_in_delta(-3, get_samples(10000, osc(offset: -3)).sum / 10000)
   end
 
   def test_gain()
     assert_in_delta  3, get_samples(100, osc(gain: 3)).max
-    assert_in_delta -3, get_samples(100, osc(gain: 3)).min
+    assert_in_delta(-3, get_samples(100, osc(gain: 3)).min)
   end
 
   def test_offset_and_gain()

data/test/test_sequencer.rb

@@ -0,0 +1,25 @@
+require_relative 'helper'
+
+
+class TestSequencer < Test::Unit::TestCase
+
+  B = Beeps
+
+  def seq(&b)
+    B::Sequencer.new.tap {b.call _1}
+  end
+
+  def osc(type = :sine, samples: nil, freq: 1, **kwargs)
+    B::Oscillator.new(type, samples: samples, freq: freq, **kwargs)
+  end
+
+  def test_each_note()
+    assert_equal(
+      [[B::Oscillator,  0, 1]],
+      seq {_1.add osc, 0, 1}.map {|p, *args| [p.class, *args]})
+
+    assert_equal [0],    seq {_1.add osc, 0, 1}                  .map {_2}
+    assert_equal [0, 2], seq {_1.add osc, 0, 1; _1.add osc, 2, 3}.map {_2}
+  end
+
+end# TestSequencer

data/test/test_value.rb

@@ -0,0 +1,47 @@
+require_relative 'helper'
+
+
+class TestValue < Test::Unit::TestCase
+
+  B = Beeps
+
+  def val(...) = B::Value.new(...)
+
+  def test_constant()
+    assert_each_in_delta [5] * 3, get_samples(2, val(5))
+  end
+
+  def test_linear_interpolation()
+    v = val 0
+    v.insert 2, 1
+    v.insert 1, 2
+    assert_each_in_delta [0, 1, 2, 1.5, 1], get_samples(2, v, seconds: 2)
+  end
+
+  def test_insert()
+    v = val 0
+    v.insert 1, 1
+    assert_equal [[0, 0], [1, 1]], v.to_a
+
+    v.insert 2, 1
+    assert_equal [[0, 0], [2, 1]], v.to_a
+
+    assert_raise(ArgumentError) {v.insert 1, -1}
+  end
+
+  def test_clear()
+    v = val 0
+    assert_equal 1, v.to_a.size
+
+    v.clear
+    assert_equal 0, v.to_a.size
+  end
+
+  def test_each()
+    v = val 0
+    v.insert 1, 1
+    v.insert 2, 2
+    assert_equal [[0, 0], [1, 1], [2, 2]], v.to_a
+  end
+
+end# TestValue