beeps 0.1.31 → 0.1.33

data/src/file_in.cpp

@@ -0,0 +1,94 @@
+#include "beeps/generator.h"
+
+
+#include "beeps/exception.h"
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct FileIn::Data
+	{
+
+		String path;
+
+		Signals signals;
+
+	};// FileIn::Data
+
+
+	FileIn::FileIn (const char* path)
+	{
+		if (path) set_path(path);
+	}
+
+	FileIn::~FileIn ()
+	{
+	}
+
+	void
+	FileIn::reset ()
+	{
+		Super::reset();
+	}
+
+	void
+	FileIn::set_path (const char* path)
+	{
+		if (*this)
+			invalid_state_error(__FILE__, __LINE__, "path is already set");
+
+		self->signals = Signals_load(path);
+		self->path    = path;
+
+		set_updated();
+	}
+
+	const char*
+	FileIn::path () const
+	{
+		return self->path;
+	}
+
+	double
+	FileIn::sample_rate () const
+	{
+		return self->signals.sample_rate();
+	}
+
+	uint
+	FileIn::nchannels () const
+	{
+		return self->signals.nchannels();
+	}
+
+	uint
+	FileIn::nsamples () const
+	{
+		return self->signals.nsamples();
+	}
+
+	float
+	FileIn::seconds () const
+	{
+		return Signals_get_seconds(self->signals);
+	}
+
+	void
+	FileIn::generate (Context* context, Signals* signals, uint* offset)
+	{
+		Super::generate(context, signals, offset);
+
+		*offset += Signals_copy(signals, self->signals, *offset);
+	}
+
+	FileIn::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->signals;
+	}
+
+
+}// Beeps

data/src/gain.cpp

@@ -0,0 +1,55 @@
+#include "beeps/filter.h"
+
+
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct Gain::Data
+	{
+
+		float gain = 1;
+
+	};// Gain::Data
+
+
+	Gain::Gain (Processor* input)
+	:	Super(input)
+	{
+	}
+
+	Gain::~Gain ()
+	{
+	}
+
+	void
+	Gain::set_gain (float gain)
+	{
+		self->gain = gain;
+
+		set_updated();
+	}
+
+	float
+	Gain::gain () const
+	{
+		return self->gain;
+	}
+
+	void
+	Gain::filter (Context* context, Signals* signals, uint* offset)
+	{
+		Super::filter(context, signals, offset);
+
+		Frames* frames = Signals_get_frames(signals);
+		if (!frames)
+			argument_error(__FILE__, __LINE__);
+
+		*frames *= self->gain;
+	}
+
+
+}// Beeps

data/src/mic_in.cpp

@@ -0,0 +1,262 @@
+#include "mic_in.h"
+
+
+#include <limits.h>
+#include <vector>
+#include <memory>
+#include <algorithm>
+#include "beeps/beeps.h"
+#include "beeps/exception.h"
+#include "openal.h"
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct Mic
+	{
+
+		void start ()
+		{
+			if (self->started) return;
+
+			self->create();
+			if (!is_valid())
+				invalid_state_error(__FILE__, __LINE__);
+
+			alcCaptureStart(self->device);
+			OpenAL_check_error(__FILE__, __LINE__);
+
+			self->started = true;
+		}
+
+		void stop ()
+		{
+			if (!self->started) return;
+
+			if (!is_valid())
+				invalid_state_error(__FILE__, __LINE__);
+
+			alcCaptureStop(self->device);
+			OpenAL_check_error(__FILE__, __LINE__);
+
+			self->started = false;
+		}
+
+		bool is_started () const
+		{
+			return self->started;
+		}
+
+		void buffer_samples ()
+		{
+			if (!is_valid())
+				invalid_state_error(__FILE__, __LINE__);
+
+			ALint nsamples = 0;
+			alcGetIntegerv(
+				self->device, ALC_CAPTURE_SAMPLES, sizeof(nsamples), &nsamples);
+			OpenAL_check_error(__FILE__, __LINE__);
+			if (nsamples <= 0) return;
+
+			auto& buffer = self->buffer;
+			if (buffer.size() < (size_t) nsamples) buffer.resize(nsamples);
+
+			alcCaptureSamples(self->device, (ALCvoid*) &buffer[0], nsamples);
+			OpenAL_check_error(__FILE__, __LINE__);
+
+			auto& samples = self->samples;
+			samples.reserve(samples.size() + nsamples);
+			samples.insert(samples.end(), &buffer[0], &buffer[0] + nsamples);
+
+			if (samples.size() > samples_size_max())
+			{
+				size_t size = samples.size() - samples_size_max();
+				samples.erase(samples.begin(), samples.begin() + size);
+				self->offset += (uint) size;
+			}
+		}
+
+		void get_signals (Signals* signals, uint* gen_offset)
+		{
+			assert(signals && signals->empty() && generate_offset);
+
+			if (!is_valid()) return;
+
+			Frames* frames = Signals_get_frames(signals);
+			assert(frames);
+
+			auto& samples  = self->samples;
+			uint nchannels = self->nchannels;
+			uint nsamples  = (uint) (samples.size() / nchannels);
+			uint offset    = *gen_offset < self->offset ? 0 : *gen_offset - self->offset;
+			if (offset >= nsamples) return;
+
+			nsamples = std::min(frames->nframes(), nsamples - offset);
+			for (uint ch = 0; ch < frames->nchannels(); ++ch)
+			{
+				uint samples_ch = ch < nchannels ? ch : 0;
+				float div       = 1.0f / SHRT_MAX;
+				for (uint i = 0; i < nsamples; ++i)
+					(*frames)(i, ch) = samples[(offset + i) * nchannels + samples_ch] * div;
+			}
+			Signals_set_nsamples(signals, nsamples);
+
+			*gen_offset = self->offset + offset + nsamples;
+		}
+
+		uint samples_size_max () const
+		{
+			assert(self->sample_rate > 0);
+
+			return self->sample_rate * 1;
+		}
+
+		bool is_valid () const
+		{
+			return self->sample_rate > 0 && self->nchannels > 0 && self->device;
+		}
+
+		struct Data
+		{
+
+			double sample_rate = 0;
+
+			uint nchannels     = 0;
+
+			uint offset        = 0;
+
+			bool started       = false;
+
+			ALCdevice* device  = NULL;
+
+			std::vector<ALshort> samples, buffer;
+
+			~Data ()
+			{
+				clear();
+			}
+
+			void create ()
+			{
+				assert(sample_rate > 0 && nchannels > 0);
+
+				if (device) return;
+
+				device = alcCaptureOpenDevice(
+					NULL,
+					sample_rate,
+					nchannels == 2 ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16,
+					sample_rate / 10);
+				if (!device)
+					openal_error(__FILE__, __LINE__, "failed to create a mic device");
+			}
+
+			void clear ()
+			{
+				if (!device) return;
+
+				if (alcCaptureCloseDevice(device) == ALC_FALSE)
+					openal_error(__FILE__, __LINE__, "failed to close the mic device");
+
+				device = NULL;
+			}
+
+		};// Data
+
+		Xot::PSharedImpl<Data> self;
+
+	};// Mic
+
+
+	struct MicIn::Data
+	{
+
+		Mic mic;
+
+	};// MicIn::Data
+
+
+	namespace global
+	{
+
+		static std::vector<Mic> mics;
+
+	};// global
+
+
+	void
+	MicIn_process_streams ()
+	{
+		for (Mic& mic : global::mics)
+			mic.buffer_samples();
+	}
+
+
+	MicIn::MicIn (uint nchannels, double sample_rate)
+	{
+		if (nchannels > 2)
+			argument_error(__FILE__, __LINE__);
+
+		if (sample_rate <= 0) sample_rate = Beeps::sample_rate();
+
+		self->mic.self->sample_rate = sample_rate;
+		self->mic.self->nchannels   = nchannels;
+	}
+
+	MicIn::~MicIn ()
+	{
+	}
+
+	void
+	MicIn::start ()
+	{
+		if (self->mic.is_started()) return;
+
+		self->mic.start();
+
+		global::mics.emplace_back(self->mic);
+	}
+
+	void
+	MicIn::stop ()
+	{
+		if (!self->mic.is_started()) return;
+
+		std::erase_if(
+			global::mics,
+			[&](auto& mic) {return mic.self.get() == self->mic.self.get();});
+
+		self->mic.stop();
+	}
+
+	double
+	MicIn::sample_rate () const
+	{
+		return self->mic.self->sample_rate;
+	}
+
+	uint
+	MicIn::nchannels () const
+	{
+		return self->mic.self->nchannels;
+	}
+
+	void
+	MicIn::generate (Context* context, Signals* signals, uint* offset)
+	{
+		Super::generate(context, signals, offset);
+
+		self->mic.get_signals(signals, offset);
+	}
+
+	MicIn::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return self->mic.is_valid();
+	}
+
+
+}// Beeps

data/src/mic_in.h

@@ -0,0 +1,20 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __BEEPS_SRC_MIC_IN_H__
+#define __BEEPS_SRC_MIC_IN_H__
+
+
+#include <beeps/generator.h>
+
+
+namespace Beeps
+{
+
+
+	void MicIn_process_streams ();
+
+
+}// Beeps
+
+
+#endif//EOH

data/src/openal.cpp

@@ -23,7 +23,7 @@ namespace Beeps
 	static void
 	cleanup ()
 	{
-		Sound_cleanup_sources();
+		SoundPlayer_clear_all();
 
 		alcMakeContextCurrent(NULL);
 
@@ -94,6 +94,7 @@ namespace Beeps
 			case ALC_INVALID_DEVICE:  return "ALC_INVALID_DEVICE";
 			case ALC_INVALID_CONTEXT: return "ALC_INVALID_CONTEXT";
 			case ALC_INVALID_ENUM:    return "ALC_INVALID_ENUM";
+			case ALC_INVALID_VALUE:   return "ALC_INVALID_VALUE";
 			case ALC_OUT_OF_MEMORY:   return "ALC_OUT_OF_MEMORY";
 			default:                  return "UNKNOWN ERROR";
 		}

data/src/oscillator.cpp

@@ -0,0 +1,145 @@
+#include "beeps/generator.h"
+
+
+#include "SineWave.h"
+#include "BlitSquare.h"
+#include "BlitSaw.h"
+#include "beeps/exception.h"
+#include "signals.h"
+
+
+namespace Beeps
+{
+
+
+	struct Oscillator::Data
+	{
+
+		Type type       = NONE;
+
+		float frequency = 440;
+
+		std::unique_ptr<stk::SineWave> sine;
+
+		std::unique_ptr<stk::BlitSquare> square;
+
+		std::unique_ptr<stk::BlitSaw> saw;
+
+	};// Oscillator::Data
+
+
+	Oscillator::Oscillator (Type type)
+	{
+		set_type(type);
+	}
+
+	Oscillator::~Oscillator ()
+	{
+	}
+
+	void
+	Oscillator::reset ()
+	{
+		Super::reset();
+
+		if (self->sine)   self->sine->reset();
+		if (self->square) self->square->reset();
+		if (self->saw)    self->saw->reset();
+	}
+
+	void
+	Oscillator::set_type (Type type)
+	{
+		if (type == self->type) return;
+
+		self->type = type;
+
+		self->sine  .reset();
+		self->square.reset();
+		self->saw   .reset();
+
+		switch (self->type)
+		{
+			case SINE:     self->sine  .reset(new stk::SineWave());   break;
+			case SQUARE:   self->square.reset(new stk::BlitSquare()); break;
+			case SAWTOOTH: self->saw   .reset(new stk::BlitSaw());    break;
+			default:
+				argument_error(
+					__FILE__, __LINE__, "unknown oscilator type '%d'", self->type);
+				break;
+		}
+
+		set_updated();
+	}
+
+	Oscillator::Type
+	Oscillator::type () const
+	{
+		return self->type;
+	}
+
+	void
+	Oscillator::set_frequency (float frequency)
+	{
+		if (frequency <= 0)
+			argument_error(__FILE__, __LINE__);
+
+		self->frequency = frequency;
+
+		set_updated();
+	}
+
+	float
+	Oscillator::frequency () const
+	{
+		return self->frequency;
+	}
+
+	void
+	Oscillator::generate (Context* context, Signals* signals, uint* offset)
+	{
+		Super::generate(context, signals, offset);
+
+		Frames* frames = Signals_get_frames(signals);
+		if (!frames)
+			argument_error(__FILE__, __LINE__);
+
+		switch (self->type)
+		{
+			case SINE:
+				assert(self->sine);
+				self->sine->setFrequency(self->frequency);
+				self->sine->tick(*frames);
+				break;
+
+			case SQUARE:
+				assert(self->square);
+				self->square->setFrequency(self->frequency);
+				self->square->tick(*frames);
+				break;
+
+			case SAWTOOTH:
+				assert(self->saw);
+				self->saw->setFrequency(self->frequency);
+				self->saw->tick(*frames);
+				break;
+
+			default:
+				invalid_state_error(
+					__FILE__, __LINE__, "unknown oscilator type '%d'", self->type);
+				break;
+		}
+
+		Signals_set_nsamples(signals, frames->nframes());
+	}
+
+	Oscillator::operator bool () const
+	{
+		if (!Super::operator bool()) return false;
+		return
+			self->type != NONE && self->frequency > 0 &&
+			(self->sine || self->square || self->saw);
+	}
+
+
+}// Beeps

data/src/osx/signals.mm

@@ -0,0 +1,83 @@
+// -*- c++ -*-
+#include "../signals.h"
+
+
+#import <AVFoundation/AVFoundation.h>
+#include <beeps/exception.h>
+
+
+namespace Beeps
+{
+
+
+	[[noreturn]]
+	void
+	objc_error (const char* file, int line, NSError* error, const char* format = NULL, ...)
+	{
+		if (!error)
+			argument_error(__FILE__, __LINE__);
+
+		XOT_STRINGF(format, s);
+		beeps_error(
+			file, line,
+			Xot::stringf("%s (%s)", s.c_str(), error.localizedDescription.UTF8String));
+	}
+
+
+	static AVAudioPCMBuffer*
+	load_buffer (const char* path)
+	{
+		if (!path)
+			argument_error(__FILE__, __LINE__);
+
+		NSURL* url = [NSURL fileURLWithPath: [NSString stringWithUTF8String:path]];
+		if (!url)
+			system_error(__FILE__, __LINE__, "failed to get url object for path");
+
+		NSError* error = nil;
+
+		AVAudioFile* file =
+			[[[AVAudioFile alloc] initForReading:url error:&error] autorelease];
+		if (error)
+			objc_error(__FILE__, __LINE__, error, "failed to open file '%s'", path);
+
+		AVAudioFormat* format = file.processingFormat;
+		if (format.channelCount <= 0)
+			beeps_error(__FILE__, __LINE__, "invalid channel count %d", format.channelCount);
+
+		AVAudioPCMBuffer* buffer = [[[AVAudioPCMBuffer alloc]
+			initWithPCMFormat:format frameCapacity:(AVAudioFrameCount) file.length]
+			autorelease];
+
+		BOOL result = [file readIntoBuffer:buffer error:&error];
+		if (error)
+			objc_error(__FILE__, __LINE__, error, "failed to read into the buffer");
+		if (!result)
+			system_error(__FILE__, __LINE__, "failed to read into the buffer");
+
+		return buffer;
+	}
+
+	Signals
+	Signals_load (const char* path)
+	{
+		AVAudioPCMBuffer* buffer = load_buffer(path);
+		if (!buffer) return Signals();
+
+		uint nchannels = buffer.format.channelCount;
+		if (nchannels <= 0)
+			beeps_error(__FILE__, __LINE__, "invalid nchannels %d", nchannels);
+
+		uint len = buffer.frameLength;
+		if (len <= 0)
+			beeps_error(__FILE__, __LINE__, "invalid buffer length %d", len);
+
+		const float* const* data = buffer.floatChannelData;
+		if (!data)
+			beeps_error(__FILE__, __LINE__, "failed to get channel data");
+
+		return Signals_create(data, len, nchannels, (uint) buffer.format.sampleRate);
+	}
+
+
+}// Beeps