beeps 0.1.31 → 0.1.33

data/src/pitch_shift.cpp

@@ -0,0 +1,82 @@
+#include "beeps/filter.h"
+
+
+#include "PitShift.h"
+#include "signalsmith-stretch.h"
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct PitchShift::Data
+	{
+
+		signalsmith::stretch::SignalsmithStretch<float> stretch;
+
+		float shift = 1;
+
+	};// PitchShift::Data
+
+
+	PitchShift::PitchShift (Processor* input)
+	:	Super(input)
+	{
+		set_buffering_seconds(1);
+	}
+
+	PitchShift::~PitchShift ()
+	{
+	}
+
+	void
+	PitchShift::reset ()
+	{
+		Super::reset();
+
+		self->stretch.reset();
+	}
+
+	void
+	PitchShift::set_shift (float shift)
+	{
+		self->shift = shift;
+
+		set_updated();
+	}
+
+	float
+	PitchShift::shift () const
+	{
+		return self->shift;
+	}
+
+	void
+	PitchShift::filter (Context* context, Signals* signals, uint* offset)
+	{
+		Super::filter(context, signals, offset);
+
+		if (self->shift == 1 || signals->nsamples() <= 0)
+			return;
+
+		SignalSamples<float> input(*signals);
+		SignalSamples<float> output(input.nsamples(), signals->nchannels());
+
+		self->stretch.presetDefault(signals->nchannels(), signals->sample_rate());
+		self->stretch.setTransposeFactor(self->shift);
+		self->stretch.process(
+			 input.channels(),  input.nsamples(),
+			output.channels(), output.nsamples());
+
+		Signals_write_samples(signals, output, signals->nsamples());
+	}
+
+	PitchShift::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->shift > 0;
+	}
+
+
+}// Beeps

data/src/processor.cpp

@@ -1,200 +1,314 @@
-#include "beeps/processor.h"
+#include "processor.h"
 
 
-#include "SineWave.h"
-#include "BlitSaw.h"
-#include "BlitSquare.h"
-#include "FileWvIn.h"
+#include "xot/time.h"
 #include "beeps/exception.h"
-#include "signals.h"
 
 
 namespace Beeps
 {
 
 
-	Processor::Processor ()
+	static ProcessorContext*
+	get_context(Processor::Context* context)
 	{
+		return (ProcessorContext*) context;
 	}
 
-	Processor::~Processor ()
+
+	struct Processor::Data
 	{
-	}
 
-	void
-	Processor::process (Signals* signals)
+		bool generator = false;
+
+		float buffering_seconds = 0;
+
+		double last_update_time = 0;
+
+		Processor::Ref input;
+
+		bool has_generator () const
+		{
+			return generator || (input && input->self->has_generator());
+		}
+
+	};// Processor::Data
+
+
+	float
+	Processor_get_buffering_seconds (Processor* processor)
 	{
-		if (!signals || !*signals)
-			argument_error(__FILE__, __LINE__);
+		assert(processor);
 
-		if (!*this)
-			invalid_state_error(__FILE__, __LINE__);
+		return processor->self->buffering_seconds;
 	}
 
-	Processor::operator bool () const
+
+	Processor::Processor (bool generator)
 	{
-		return true;
+		self->generator = generator;
 	}
 
-	bool
-	Processor::operator ! () const
+	Processor::~Processor ()
 	{
-		return !operator bool();
 	}
 
-
-	struct SineWave::Data
+	void
+	Processor::reset ()
 	{
+		if (self->input) self->input->reset();
 
-		stk::SineWave oscillator;
+		set_updated();
+	}
 
-		float frequency;
+	void
+	Processor::set_input (Processor* input)
+	{
+		if (input && self->generator)
+			invalid_state_error(__FILE__, __LINE__, "generator cannot have inputs");
 
-	};// SineWave::Data
+		self->input = input;
 
+		set_updated();
+	}
 
-	SineWave::SineWave ()
+	Processor*
+	Processor::input ()
 	{
-		set_frequency(440);
+		return self->input;
 	}
 
-	SineWave::~SineWave ()
+	const Processor*
+	Processor::input () const
 	{
+		return const_cast<Processor*>(this)->input();
 	}
 
-	void
-	SineWave::set_frequency (float frequency)
+	Processor::operator bool () const
 	{
-		self->frequency = frequency;
-		self->oscillator.setFrequency(frequency);
+		return self->has_generator();
 	}
 
-	float
-	SineWave::frequency () const
+	bool
+	Processor::operator ! () const
 	{
-		return self->frequency;
+		return !operator bool();
 	}
 
 	void
-	SineWave::process (Signals* signals)
+	Processor::process (Context* context, Signals* signals, uint* offset)
 	{
-		Super::process(signals);
-
-		self->oscillator.tick(*Signals_get_frames(signals));
+		if (self->generator)
+			generate(context, signals, offset);
+		else
+			filter(context, signals, offset);
 	}
 
-
-	struct SquareWave::Data
+	void
+	Processor::generate (Context* context, Signals* signals, uint* offset)
 	{
+		if (!context || !signals || !*signals || signals->nsamples() > 0 || !offset)
+			argument_error(__FILE__, __LINE__);
 
-		stk::BlitSquare oscillator;
+		if (!*this || self->input)
+			invalid_state_error(__FILE__, __LINE__);
+	}
 
-		float frequency;
+	void
+	Processor::filter (Context* context, Signals* signals, uint* offset)
+	{
+		if (!context || !signals || !*signals || !offset)
+			argument_error(__FILE__, __LINE__);
 
-	};// SquareWave::Data
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
 
+		if (self->input)
+			get_context(context)->process(self->input, signals, offset);
+	}
 
-	SquareWave::SquareWave ()
+	void
+	Processor::set_updated ()
 	{
-		set_frequency(440);
+		self->last_update_time = Xot::time();
 	}
 
-	SquareWave::~SquareWave ()
+
+	Generator::Generator ()
+	:	Super(true)
 	{
 	}
 
 	void
-	SquareWave::set_frequency (float frequency)
+	Generator::filter (Context* context, Signals* signals, uint* offset)
 	{
-		self->frequency = frequency;
-		self->oscillator.setFrequency(frequency);
+		beeps_error(__FILE__, __LINE__);
 	}
 
-	float
-	SquareWave::frequency () const
+
+	Filter::Filter (Processor* input)
+	:	Super(false)
 	{
-		return self->frequency;
+		if (input) set_input(input);
 	}
 
 	void
-	SquareWave::process (Signals* signals)
+	Filter::set_buffering_seconds (float seconds)
 	{
-		Super::process(signals);
+		Super::self->buffering_seconds = seconds;
+
+		set_updated();
+	}
 
-		self->oscillator.tick(*Signals_get_frames(signals));
+	void
+	Filter::generate (Context* context, Signals* signals, uint* offset)
+	{
+		beeps_error(__FILE__, __LINE__);
 	}
 
 
-	struct SawtoothWave::Data
+	SignalsBuffer::SignalsBuffer (
+		uint nsamples_per_block, uint nchannels, double sample_rate)
 	{
+		buffer = Signals_create(nsamples_per_block, nchannels, sample_rate);
+		assert(*this);
+	}
 
-		stk::BlitSaw oscillator;
+	void
+	SignalsBuffer::process (
+		ProcessorContext* context,
+		Processor* processor, Signals* signals, uint* offset)
+	{
+		assert(processor && context && signals && offset);
 
-		float frequency;
+		if (
+			last_update_time < processor->self->last_update_time ||
+			*offset < buffer_offset)
+		{
+			clear();
+		}
 
-	};// SawtoothWave::Data
+		if (buffer.nsamples() == 0)
+			buffer_next(context, processor, *offset);
 
+		while (true)
+		{
+			*offset += Signals_copy(signals, buffer, *offset - buffer_offset);
 
-	SawtoothWave::SawtoothWave ()
-	{
-		set_frequency(440);
+			bool signals_full = signals->nsamples() == signals->capacity();
+			bool  buffer_full =   buffer.nsamples() ==   buffer.capacity();
+			if (signals_full || !buffer_full)
+				break;
+
+			buffer_next(context, processor, buffer_offset + buffer.nsamples());
+		}
 	}
 
-	SawtoothWave::~SawtoothWave ()
+	SignalsBuffer::operator bool () const
 	{
+		return buffer;
 	}
 
-	void
-	SawtoothWave::set_frequency (float frequency)
+	bool
+	SignalsBuffer::operator ! () const
 	{
-		self->frequency = frequency;
-		self->oscillator.setFrequency(frequency);
+		return !operator bool();
 	}
 
-	float
-	SawtoothWave::frequency () const
+	void
+	SignalsBuffer::buffer_next (
+		ProcessorContext* context, Processor* processor, uint offset)
 	{
-		return self->frequency;
+		Signals_clear(&buffer);
+		buffer_offset = offset;
+		context->process(processor, &buffer, &offset, true);
+
+		last_update_time = Xot::time();
 	}
 
 	void
-	SawtoothWave::process (Signals* signals)
+	SignalsBuffer::clear ()
 	{
-		Super::process(signals);
-
-		self->oscillator.tick(*Signals_get_frames(signals));
+		Signals_clear(&buffer);
+		buffer_offset = 0;
 	}
 
 
-	struct FileIn::Data
+	ProcessorContext::ProcessorContext (
+		uint nsamples_per_process, uint nchannels, double sample_rate)
+	:	signals(Signals_create(nsamples_per_process, nchannels, sample_rate))
+	{
+		assert(*this);
+	}
+
+	Signals
+	ProcessorContext::process_signals (Processor* processor)
 	{
+		assert(result && processor);
 
-		stk::FileWvIn input;
+		Signals_clear(&signals);
+		process(processor, &signals, &offset);
 
-	};// FileIn::Data
+		if (signals.nsamples() < signals.capacity())
+			finished = true;
 
+		return signals.nsamples() > 0 ? signals : Signals();
+	}
 
-	FileIn::FileIn (const char* path)
+	void
+	ProcessorContext::process (
+		Processor* processor, Signals* signals, uint* offset, bool ignore_buffer)
 	{
-		if (path)
-			self->input.openFile(path);
+		assert(processor);
+
+		SignalsBuffer* buffer = NULL;
+		if (!ignore_buffer && (buffer = get_buffer(processor)))
+			buffer->process(this, processor, signals, offset);
+		else
+			processor->process(this, signals, offset);
 	}
 
-	FileIn::~FileIn ()
+	bool
+	ProcessorContext::is_finished () const
 	{
+		return finished;
 	}
 
-	void
-	FileIn::process (Signals* signals)
+	ProcessorContext::operator bool () const
 	{
-		Super::process(signals);
+		return signals && !finished;
+	}
 
-		self->input.tick(*Signals_get_frames(signals));
+	bool
+	ProcessorContext::operator ! () const
+	{
+		return !operator bool();
+	}
+
+	static uintptr_t
+	get_buffer_key (Processor* processor)
+	{
+		assert(processor);
+
+		return (uintptr_t) processor->self.get();
 	}
 
-	FileIn::operator bool () const
+	SignalsBuffer*
+	ProcessorContext::get_buffer (Processor* processor)
 	{
-		return self->input.isOpen();
+		float buffering_sec = Processor_get_buffering_seconds(processor);
+		if (buffering_sec <= 0) return NULL;
+
+		uintptr_t key = get_buffer_key(processor);
+		auto it       = buffers.find(key);
+		if (it != buffers.end()) return it->second.get();
+
+		SignalsBuffer* buffer = new SignalsBuffer(
+			buffering_sec * signals.sample_rate(),
+			signals.nchannels(), signals.sample_rate());
+
+		buffers.emplace(key, buffer);
+		return buffer;
 	}
 
 

data/src/processor.h

@@ -0,0 +1,98 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __BEEPS_SRC_PROCESSOR_H__
+#define __BEEPS_SRC_PROCESSOR_H__
+
+
+#include <map>
+#include <beeps/processor.h>
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	class ProcessorContext;
+
+
+	float Processor_get_buffering_seconds (Processor* processor);
+
+
+	class SignalsBuffer
+	{
+
+		public:
+
+			SignalsBuffer (
+				uint nsamples_per_block, uint nchannels, double sample_rate);
+
+			void process (
+				ProcessorContext* context,
+				Processor* processor, Signals* signals, uint* offset);
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+		private:
+
+			Signals buffer;
+
+			uint buffer_offset = 0;
+
+			double last_update_time = 0;
+
+			void buffer_next (
+				ProcessorContext* context, Processor* processor, uint offset);
+
+			void clear ();
+
+	};// SignalsBuffer
+
+
+	class ProcessorContext : public Processor::Context
+	{
+
+		public:
+
+			ProcessorContext (
+				uint nsamples_per_process, uint nchannels, double sample_rate);
+
+			Signals process_signals (Processor* processor);
+
+			void process (
+				Processor* processor, Signals* signals, uint* offset,
+				bool ignore_buffer = false);
+
+			//void push_offset (uint offset);
+
+			//uint pop_offset ();
+
+			bool is_finished () const;
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+		private:
+
+			Signals signals;
+
+			uint offset = 0;
+
+			bool finished = false;
+
+			//std::vector<uint> offset_stack;
+
+			std::map<uintptr_t, std::unique_ptr<SignalsBuffer>> buffers;
+
+			SignalsBuffer* get_buffer (Processor* processor);
+
+	};// ProcessorContext
+
+
+}// Beeps
+
+
+#endif//EOH