beeps 0.3.11 → 0.3.12

data/src/file_in.cpp

@@ -82,12 +82,18 @@ namespace Beeps
 		return self->signals;
 	}
 
+	bool
+	FileIn::seekable () const
+	{
+		return true;
+	}
+
 	void
 	FileIn::generate (Context* context, Signals* signals, uint* offset)
 	{
 		Super::generate(context, signals, offset);
 
-		*offset += Signals_copy(signals, self->signals, *offset);
+		*offset += signals->append(self->signals, *offset);
 	}
 
 

data/src/gain.cpp

@@ -39,6 +39,13 @@ namespace Beeps
 		return self->gain;
 	}
 
+	bool
+	Gain::seekable () const
+	{
+		const Processor* in = input();
+		return !in || in->seekable();
+	}
+
 	void
 	Gain::filter (Context* context, Signals* signals, uint* offset)
 	{

data/src/mixer.cpp

@@ -91,6 +91,19 @@ namespace Beeps
 		return true;
 	}
 
+	bool
+	Mixer::seekable () const
+	{
+		const auto* in = input();
+		if (in && !in->seekable())
+			return false;
+
+		for (auto& i : self->inputs)
+			if (!i->seekable()) return false;
+
+		return true;
+	}
+
 	static void
 	mix (
 		Mixer* mixer, Processor* input,
@@ -100,9 +113,9 @@ namespace Beeps
 
 		auto& insig = self->input_signals;
 		if (!insig)
-			insig = Signals_create(signals->capacity(), signals->nchannels());
+			insig = Signals(signals->capacity(), signals->nchannels());
 		else
-			Signals_clear(&insig, signals->capacity());
+			insig.clear(signals->capacity());
 
 		Processor_get_context(context)->process(input, &insig, &offset);
 
@@ -116,7 +129,7 @@ namespace Beeps
 	Mixer::filter (Context* context, Signals* signals, uint* offset)
 	{
 		Signals_fill(signals, signals->capacity(), 0);
-		Signals_clear(signals);
+		signals->clear();
 
 		Super::filter(context, signals, offset);
 

data/src/oscillator.cpp

@@ -493,6 +493,12 @@ namespace Beeps
 		return self->type != TYPE_NONE && self->osc;
 	}
 
+	bool
+	Oscillator::seekable () const
+	{
+		return true;
+	}
+
 	void
 	Oscillator::generate (Context* context, Signals* signals, uint* offset)
 	{
@@ -530,7 +536,7 @@ namespace Beeps
 	}
 
 	int
-	Oscillator::max_segment_size_for_process (
+	Oscillator::get_max_segment_size_for_process (
 		double sample_rate, uint nsamples) const
 	{
 		return std::clamp(

data/src/osx/signals.mm

@@ -41,7 +41,7 @@ namespace Beeps
 		if (!channels)
 			beeps_error(__FILE__, __LINE__, "failed to get channel data");
 
-		return Signals_create(
+		return Signals(
 			channels, nsamples, nchannels, (uint) buffer.format.sampleRate, capacity);
 	}
 
@@ -77,11 +77,11 @@ namespace Beeps
 		if (new_nsamples > to->capacity())
 			Signals_set_capacity(to, get_next_capacity(*to, new_nsamples));
 
-		for (uint channel = 0; channel < nchannels; ++channel)
+		for (uint ch = 0; ch < nchannels; ++ch)
 		{
-			Sample* p = Signals_at(to, to->nsamples(), channel);
+			Sample* p = Signals_at(to, to->nsamples(), ch);
 			for (uint i = 0; i < nsamples; ++i, p += nchannels)
-				*p = channels[channel][i];
+				*p = channels[ch][i];
 		}
 
 		Signals_set_nsamples(to, new_nsamples);

data/src/osx/text_in.mm

@@ -116,7 +116,7 @@ namespace Beeps
 					self->signals.sample_rate());
 			}
 
-			uint copied_size = Signals_copy(signals, self->signals);
+			uint copied_size = signals->append(self->signals);
 			Signals_shift(&self->signals, copied_size);
 			*offset += copied_size;
 		}

data/src/processor.cpp

@@ -111,6 +111,12 @@ namespace Beeps
 		return const_cast<Processor*>(this)->input();
 	}
 
+	bool
+	Processor::seekable () const
+	{
+		return false;
+	}
+
 	void
 	Processor::on_start ()
 	{
@@ -185,28 +191,6 @@ 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)
 	{
@@ -235,6 +219,36 @@ namespace Beeps
 			set_sub_input(index, NULL);
 	}
 
+	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->get_max_segment_size_for_process(sample_rate, nsamples);
+			if (max > 0 && (uint) max < size)
+				size = (uint) max;
+		}
+		return size;
+	}
+
+	int
+	Processor::get_max_segment_size_for_process (
+		double sample_rate, uint nsamples) const
+	{
+		return -1;
+	}
+
+	void
+	Processor::set_buffering_seconds (float seconds)
+	{
+		self->buffering_seconds = seconds;
+
+		set_updated();
+	}
+
 	void
 	Processor::set_updated ()
 	{
@@ -260,14 +274,6 @@ namespace Beeps
 		if (input) set_input(input);
 	}
 
-	void
-	Filter::set_buffering_seconds (float seconds)
-	{
-		Super::self->buffering_seconds = seconds;
-
-		set_updated();
-	}
-
 	void
 	Filter::generate (Context* context, Signals* signals, uint* offset)
 	{
@@ -278,7 +284,7 @@ namespace Beeps
 	SignalsBuffer::SignalsBuffer (
 		uint nsamples_per_block, uint nchannels, double sample_rate)
 	{
-		buffer = Signals_create(nsamples_per_block, nchannels, sample_rate);
+		buffer = Signals(nsamples_per_block, nchannels, sample_rate);
 		assert(*this);
 	}
 
@@ -301,7 +307,7 @@ namespace Beeps
 
 		while (true)
 		{
-			*offset += Signals_copy(signals, buffer, *offset - buffer_offset);
+			*offset += signals->append(buffer, *offset - buffer_offset);
 
 			bool signals_full = signals->nsamples() == signals->capacity();
 			bool  buffer_full =   buffer.nsamples() ==   buffer.capacity();
@@ -327,7 +333,7 @@ namespace Beeps
 	SignalsBuffer::buffer_next (
 		ProcessorContext* context, Processor* processor, uint offset)
 	{
-		Signals_clear(&buffer);
+		buffer.clear();
 		buffer_offset = offset;
 		context->process(processor, &buffer, &offset, true);
 
@@ -337,7 +343,7 @@ namespace Beeps
 	void
 	SignalsBuffer::clear ()
 	{
-		Signals_clear(&buffer);
+		buffer.clear();
 		buffer_offset = 0;
 	}
 
@@ -353,8 +359,8 @@ namespace Beeps
 	{
 		assert(processor);
 
-		if (!signal) signal = Signals_create(nsamples, 1, sample_rate);
-		Signals_clear(&signal, nsamples);
+		if (!signal) signal = Signals(nsamples, 1, sample_rate);
+		signal.clear(nsamples);
 
 		SignalsBuffer* buffer = NULL;
 		uint offset_          = offset;
@@ -411,7 +417,7 @@ 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(nsamples_per_process, nchannels, sample_rate),
 		nsamples_per_process(nsamples_per_process)
 	{
 	}
@@ -421,7 +427,7 @@ namespace Beeps
 	{
 		assert(processor);
 
-		Signals_clear(&signals, nsamples_per_process);
+		signals.clear(nsamples_per_process);
 		context.process(processor, &signals, &offset);
 
 		if (signals.nsamples() < nsamples_per_process)
@@ -430,6 +436,13 @@ namespace Beeps
 		return signals;
 	}
 
+	void
+	StreamContext::seek (uint offset)
+	{
+		this->offset   = offset;
+		this->finished = false;
+	}
+
 	bool
 	StreamContext::is_finished () const
 	{

data/src/processor.h

@@ -93,9 +93,7 @@ namespace Beeps
 
 			Signals process_next (Processor* processor);
 
-			//void push_offset (uint offset);
-
-			//uint pop_offset ();
+			void seek (uint offset);
 
 			bool is_finished () const;
 
@@ -111,8 +109,6 @@ namespace Beeps
 
 			bool finished = false;
 
-			//std::vector<uint> offset_stack;
-
 	};// StreamContext
 
 

data/src/reverb.cpp

@@ -105,9 +105,8 @@ namespace Beeps
 		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());
+		uint nchannels = signals->nchannels();
+		Signals filtered(signals->nsamples(), nchannels, signals->sample_rate());
 
 		Signals_tick(
 			&filtered, *signals,

data/src/sequencer.cpp

@@ -139,9 +139,9 @@ namespace Beeps
 		auto& signals = *psignals;
 		Signals_fill(&signals, signals.capacity(), 0);
 
-		uint generate_begin  = *offset;
-		uint generate_end    = *offset + signals.capacity();
-		Signals note_signals = Signals_create(
+		uint generate_begin = *offset;
+		uint generate_end   = *offset + signals.capacity();
+		Signals note_signals(
 			signals.capacity(), signals.nchannels(), signals.sample_rate());
 
 		uint nsamples = 0;
@@ -161,7 +161,7 @@ namespace Beeps
 			assert(begin != end);
 
 			uint note_offset = begin - note_begin;
-			Signals_clear(&note_signals, end - begin);
+			note_signals.clear(end - begin);
 			context.process(note.processor.get(), &note_signals, &note_offset);
 
 			uint mix_offset  = begin - generate_begin;