beeps 0.3.6 → 0.3.7

data/src/processor.cpp

@@ -3,6 +3,7 @@
 
 #include <assert.h>
 #include <xot/time.h>
+#include "beeps/beeps.h"
 #include "beeps/exception.h"
 #include "beeps/debug.h"
 
@@ -14,7 +15,7 @@ namespace Beeps
 	struct Processor::Data
 	{
 
-		bool generator = false, started = false;
+		bool generator = false, started = false, processing = false;
 
 		float buffering_seconds = 0;
 
@@ -22,9 +23,33 @@ namespace Beeps
 
 		Processor::Ref input;
 
+		Processor::Map sub_inputs;
+
 	};// Processor::Data
 
 
+	Signals
+	get_signals (
+		Processor* processor, float seconds, uint nchannels, double sample_rate)
+	{
+		if (sample_rate == 0)
+			sample_rate = Beeps::sample_rate();
+
+		if (!processor)
+			argument_error(__FILE__, __LINE__);
+		if (!*processor)
+			argument_error(__FILE__, __LINE__);
+		if (seconds <= 0)
+			argument_error(__FILE__, __LINE__);
+		if (nchannels <= 0)
+			argument_error(__FILE__, __LINE__);
+		if (sample_rate <= 0)
+			argument_error(__FILE__, __LINE__);
+
+		StreamContext context(seconds * sample_rate, nchannels, sample_rate);
+		return context.process_next(processor);
+	}
+
 	ProcessorContext*
 	Processor_get_context(Processor::Context* context)
 	{
@@ -53,7 +78,12 @@ namespace Beeps
 	Processor::reset ()
 	{
 		self->started = false;
-		if (self->input) self->input->reset();
+
+		if (self->input)
+			self->input->reset();
+
+		for (auto& kv : self->sub_inputs)
+			kv.second->reset();
 
 		set_updated();
 	}
@@ -62,7 +92,7 @@ namespace Beeps
 	Processor::set_input (Processor* input)
 	{
 		if (input && self->generator)
-			invalid_state_error(__FILE__, __LINE__, "generator cannot have inputs");
+			invalid_state_error(__FILE__, __LINE__, "generator cannot have input");
 
 		self->input = input;
 
@@ -75,17 +105,17 @@ namespace Beeps
 		return self->input;
 	}
 
-	void
-	Processor::on_start ()
-	{
-	}
-
 	const Processor*
 	Processor::input () const
 	{
 		return const_cast<Processor*>(this)->input();
 	}
 
+	void
+	Processor::on_start ()
+	{
+	}
+
 	Processor::operator bool () const
 	{
 		return self->generator || (self->input && *self->input);
@@ -106,10 +136,14 @@ namespace Beeps
 			on_start();
 		}
 
+		self->processing = true;
+
 		if (self->generator)
 			generate(context, signals, offset);
 		else
 			filter(context, signals, offset);
+
+		self->processing = false;
 	}
 
 	void
@@ -151,6 +185,56 @@ namespace Beeps
 			Processor_get_context(context)->process(self->input, signals, offset);
 	}
 
+	int
+	Processor::max_segment_size_for_process (
+		double sample_rate, uint nsamples) const
+	{
+		return -1;
+	}
+
+	uint
+	Processor::get_segment_size (double sample_rate, uint nsamples) const
+	{
+		uint size = nsamples;
+		for (const auto& kv : self->sub_inputs)
+		{
+			const auto& processor = kv.second;
+
+			int max = processor->max_segment_size_for_process(sample_rate, nsamples);
+			if (max > 0 && (uint) max < size)
+				size = (uint) max;
+		}
+		return size;
+	}
+
+	void
+	Processor::set_sub_input (uint index, Processor* input)
+	{
+		if (input)
+			self->sub_inputs[index] = input;
+		else
+			self->sub_inputs.erase(index);
+
+		set_updated();
+	}
+
+	Processor*
+	Processor::sub_input (uint index) const
+	{
+		auto it = self->sub_inputs.find(index);
+		if (it == self->sub_inputs.end())
+			return NULL;
+
+		return it->second;
+	}
+
+	void
+	Processor::clear_sub_input_unless_processing (uint index)
+	{
+		if (!self->processing)
+			set_sub_input(index, NULL);
+	}
+
 	void
 	Processor::set_updated ()
 	{
@@ -263,6 +347,28 @@ namespace Beeps
 	{
 	}
 
+	Sample
+	ProcessorContext::process (
+		Processor* processor, uint nsamples, uint offset, bool ignore_buffer)
+	{
+		assert(processor);
+
+		if (!signal) signal = Signals_create(nsamples, 1, sample_rate);
+		Signals_clear(&signal, nsamples);
+
+		SignalsBuffer* buffer = NULL;
+		uint offset_          = offset;
+		if (!ignore_buffer && (buffer = get_buffer(processor)))
+			buffer->process(this, processor, &signal, &offset_);
+		else
+			processor->process(this, &signal, &offset_);
+
+		if (offset_ == offset || signal.empty())
+			return 0;
+
+		return *signal.samples();
+	}
+
 	void
 	ProcessorContext::process (
 		Processor* processor, Signals* signals, uint* offset, bool ignore_buffer)
@@ -305,7 +411,8 @@ namespace Beeps
 	StreamContext::StreamContext (
 		uint nsamples_per_process, uint nchannels, double sample_rate)
 	:	context(nchannels, sample_rate),
-		signals(Signals_create(nsamples_per_process, nchannels, sample_rate))
+		signals(Signals_create(nsamples_per_process, nchannels, sample_rate)),
+		nsamples_per_process(nsamples_per_process)
 	{
 	}
 
@@ -314,10 +421,10 @@ namespace Beeps
 	{
 		assert(processor);
 
-		Signals_clear(&signals);
+		Signals_clear(&signals, nsamples_per_process);
 		context.process(processor, &signals, &offset);
 
-		if (signals.nsamples() < signals.capacity())
+		if (signals.nsamples() < nsamples_per_process)
 			finished = true;
 
 		return signals;

data/src/processor.h

@@ -60,6 +60,10 @@ namespace Beeps
 
 			ProcessorContext (uint nchannels, double sample_rate);
 
+			Sample process (
+				Processor* processor, uint nsamples, uint offset = 0,
+				bool ignore_buffer = false);
+
 			void process (
 				Processor* processor, Signals* signals, uint* offset,
 				bool ignore_buffer = false);
@@ -70,6 +74,8 @@ namespace Beeps
 
 			uint nchannels;
 
+			Signals signal;
+
 			std::map<uintptr_t, std::unique_ptr<SignalsBuffer>> buffers;
 
 			SignalsBuffer* get_buffer (Processor* processor);
@@ -99,6 +105,8 @@ namespace Beeps
 
 			Signals signals;
 
+			uint nsamples_per_process;
+
 			uint offset   = 0;
 
 			bool finished = false;

data/src/reverb.cpp

@@ -0,0 +1,124 @@
+#include "beeps/filter.h"
+
+
+#include <FreeVerb.h>
+#include "beeps/exception.h"
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct Reverb::Data
+	{
+
+		stk::FreeVerb freeverb;
+
+		float mix       = 0.75;
+
+		float room_size = 0.75;
+
+		float damping   = 0.25;
+
+	};// Reverb::Data
+
+
+	Reverb::Reverb (Processor* input)
+	:	Super(input)
+	{
+	}
+
+	Reverb::~Reverb ()
+	{
+	}
+
+	void
+	Reverb::set_mix (float mix)
+	{
+		if (mix < 0)
+			argument_error(__FILE__, __LINE__);
+		if (mix > 1)
+			argument_error(__FILE__, __LINE__);
+
+		if (mix == self->mix)
+			return;
+
+		self->mix = mix;
+		set_updated();
+	}
+
+	float
+	Reverb::mix () const
+	{
+		return self->mix;
+	}
+
+	void
+	Reverb::set_room_size (float size)
+	{
+		if (size < 0)
+			argument_error(__FILE__, __LINE__);
+		if (size > 1)
+			argument_error(__FILE__, __LINE__);
+
+		if (size == self->room_size)
+			return;
+
+		self->room_size = size;
+		set_updated();
+	}
+
+	float
+	Reverb::room_size () const
+	{
+		return self->room_size;
+	}
+
+	void
+	Reverb::set_damping (float damping)
+	{
+		if (damping < 0)
+			argument_error(__FILE__, __LINE__);
+		if (damping > 1)
+			argument_error(__FILE__, __LINE__);
+
+		if (damping == self->damping)
+			return;
+
+		self->damping = damping;
+		set_updated();
+	}
+
+	float
+	Reverb::damping () const
+	{
+		return self->damping;
+	}
+
+	void
+	Reverb::filter (Context* context, Signals* signals, uint* offset)
+	{
+		Super::filter(context, signals, offset);
+
+		self->freeverb.setEffectMix(self->mix);
+		self->freeverb.setRoomSize( self->room_size);
+		self->freeverb.setDamping(  self->damping);
+
+		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)
+					self->freeverb.tick(const_cast<stk::StkFrames&>(in), *out, ch, ch);
+			});
+
+		*signals = filtered;
+	}
+
+
+}// Beeps

data/src/sequencer.cpp

@@ -63,6 +63,8 @@ namespace Beeps
 			}
 		}
 		notes.emplace_back(processor, offset, duration);
+
+		set_updated();
 	}
 
 	void
@@ -76,6 +78,8 @@ namespace Beeps
 		if (it == self->notes.end()) return;
 
 		self->notes.erase(it);
+
+		set_updated();
 	}
 
 	void
@@ -85,6 +89,8 @@ namespace Beeps
 			argument_error(__FILE__, __LINE__, "time_scale must be greater than 0");
 
 		self->time_scale = time_scale;
+
+		set_updated();
 	}
 
 	float
@@ -93,16 +99,20 @@ namespace Beeps
 		return self->time_scale;
 	}
 
+	Sequencer::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->time_scale > 0;
+	}
+
 	static void
 	mix (Signals* mixed, const Signals& source, uint source_offset)
 	{
-		Frames* mixf = Signals_get_frames(mixed);
-		Frames* srcf = Signals_get_frames(const_cast<Signals*>(&source));
-		Float* mixp  = &(*mixf)(source_offset, 0);
-		Float* srcp  = &(*srcf)(0, 0);
-		uint size    = source.nsamples() * source.nchannels();
-		for (uint i = 0; i < size; ++i, ++mixp, ++srcp)
-			*mixp += *srcp;
+		      Sample* mix_p = Signals_at(mixed,  source_offset);
+		const Sample* src_p = Signals_at(source, 0);
+		uint size     = source.nsamples() * source.nchannels();
+		for (uint i = 0; i < size; ++i, ++mix_p, ++src_p)
+			*mix_p += *src_p;
 	}
 
 	void
@@ -112,7 +122,7 @@ namespace Beeps
 
 		auto& context = *Processor_get_context(pcontext);
 		auto& signals = *psignals;
-		Signals_resize(&signals, signals.capacity(), 0);
+		Signals_fill(&signals, signals.capacity(), 0);
 
 		uint generate_begin  = *offset;
 		uint generate_end    = *offset + signals.capacity();
@@ -150,11 +160,5 @@ namespace Beeps
 		*offset += nsamples;
 	}
 
-	Sequencer::operator bool () const
-	{
-		if (!Super::operator bool()) return false;
-		return self->time_scale > 0;
-	}
-
 
 }// Beeps