beeps 0.1.10

data/src/exception.cpp

@@ -0,0 +1,43 @@
+#include "beeps/exception.h"
+
+
+#include <xot/string.h>
+
+
+namespace Beeps
+{
+
+
+	BeepsError::BeepsError (const char* str)
+	:	Super(str)
+	{
+	}
+
+
+	OpenALError::OpenALError (const char* str)
+	:	Super(str)
+	{
+	}
+
+
+	namespace ErrorFunctions
+	{
+
+		void
+		beeps_error (const char* file, int line, const char* format, ...)
+		{
+			XOT_STRINGF(format, s);
+			throw BeepsError(Xot::error_text(file, line, s));
+		}
+
+		void
+		openal_error (const char* file, int line, const char* format, ...)
+		{
+			XOT_STRINGF(format, s);
+			throw OpenALError(Xot::error_text(file, line, s));
+		}
+
+	}// ErrorFunctions
+
+
+}// Beeps

data/src/openal.cpp

@@ -0,0 +1,216 @@
+#include "beeps/openal.h"
+
+
+#include <vector>
+#include <xot/debug.h>
+#include "beeps/defs.h"
+#include "beeps/sound.h"
+#include "beeps/exception.h"
+#include "openal.h"
+
+
+#if 0
+#define LOG(...) doutln(__VA_ARGS__)
+#else
+#define LOG(...)
+#endif
+
+
+namespace Beeps
+{
+
+
+	ALCdevice* get_device ();
+
+
+	ALCenum
+	get_error ()
+	{
+		return alcGetError(get_device());
+	}
+
+	bool
+	no_error ()
+	{
+		return get_error() == ALC_NO_ERROR;
+	}
+
+	bool
+	is_error (ALCenum err)
+	{
+		return get_error() == err;
+	}
+
+	static String
+	get_error_name (ALenum error)
+	{
+		switch (error)
+		{
+			case ALC_NO_ERROR:        return "ALC_NO_ERROR";
+			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_OUT_OF_MEMORY:   return "ALC_OUT_OF_MEMORY";
+		}
+		return "UNKNOWN ERROR";
+	}
+
+	void
+	check_error (const char* file, int line)
+	{
+		ALCenum e = get_error();
+		if (e != ALC_NO_ERROR)
+			openal_error(file, line, "OpenAL error %s", get_error_name(e).c_str());
+	}
+
+	void
+	clear_error ()
+	{
+		get_error();
+	}
+
+
+	struct SoundSource
+	{
+
+		typedef SoundSource This;
+
+		typedef boost::shared_ptr<This> Ptr;
+
+		ALint id;
+
+		static Ptr create ()
+		{
+			ALuint id_;
+			alGenSources(1, &id_);
+			if (!no_error()) return Ptr();
+
+			This* p = new This;
+			p->id = id_;
+			return Ptr(p);
+		}
+
+		SoundSource ()
+		:	id(-1)
+		{
+		}
+
+		~SoundSource ()
+		{
+			if (!*this) return;
+
+			ALuint id_ = id;
+			alDeleteSources(1, &id_);
+			check_error(__FILE__, __LINE__);
+		}
+
+		void play (const Sound& sound)
+		{
+			if (!sound)
+				argument_error(__FILE__, __LINE__);
+
+			if (!*this)
+				invalid_state_error(__FILE__, __LINE__);
+
+			alSourcei(id, AL_BUFFER, get_sound_buffer_id(sound));
+			alSourcePlay(id);
+			check_error(__FILE__, __LINE__);
+		}
+
+		void stop ()
+		{
+			if (!*this)
+				invalid_state_error(__FILE__, __LINE__);
+
+			alSourceStop(id);
+			check_error(__FILE__, __LINE__);
+		}
+
+		bool is_playing () const
+		{
+			if (!*this) return false;
+
+			ALint state = 0;
+			alGetSourcei(id, AL_SOURCE_STATE, &state);
+			check_error(__FILE__, __LINE__);
+
+			return state == AL_PLAYING;
+		}
+
+		operator bool () const
+		{
+			return id >= 0;
+		}
+
+		bool operator ! () const
+		{
+			return !operator bool();
+		}
+
+	};// SoundSource
+
+
+	typedef std::vector<SoundSource::Ptr> SoundSourceList;
+
+	static SoundSourceList sources;
+
+
+	static SoundSource*
+	next_source ()
+	{
+		SoundSource::Ptr source;
+		for (SoundSourceList::iterator it = sources.begin(); it != sources.end(); ++it)
+		{
+			const SoundSource::Ptr& p = *it;
+			if (p && *p && !p->is_playing())
+			{
+				source = p;
+				sources.erase(it);
+				LOG("reuse source");
+				break;
+			}
+		}
+
+		if (!source)
+		{
+			source = SoundSource::create();
+			LOG("new source");
+		}
+
+		if (!source)
+		{
+			source = *sources.begin();
+			if (source) source->stop();
+			sources.erase(sources.begin());
+			LOG("stop and reuse oldest source");
+		}
+
+		if (!source)
+			return NULL;
+
+		sources.push_back(source);
+		return source.get();
+	}
+
+	void
+	play_sound (const Sound& sound)
+	{
+		if (!sound)
+			argument_error(__FILE__, __LINE__);
+
+		SoundSource* source = next_source();
+		if (!source || !*source)
+			invalid_state_error(__FILE__, __LINE__);
+
+		source->play(sound);
+
+#if 0
+		std::string ox = "";
+		for (size_t i = 0; i < sources.size(); ++i)
+			ox += sources[i]->is_playing() ? 'o' : 'x';
+		LOG("playing with %d sources. (%s)", sources.size(), ox.c_str());
+#endif
+	}
+
+
+}// Beeps

data/src/openal.h

@@ -0,0 +1,25 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __BEEPS_SRC_OPENAL_H__
+#define __BEEPS_SRC_OPENAL_H__
+
+
+#include <beeps/openal.h>
+
+
+namespace Beeps
+{
+
+
+	class Sound;
+
+
+	void play_sound (const Sound& sound);
+
+	ALuint get_sound_buffer_id (const Sound& sound);
+
+
+}// Beeps
+
+
+#endif//EOH

data/src/processor.cpp

@@ -0,0 +1,201 @@
+#include "beeps/processor.h"
+
+
+#include "SineWave.h"
+#include "BlitSaw.h"
+#include "BlitSquare.h"
+#include "FileWvIn.h"
+#include "beeps/signals.h"
+#include "beeps/exception.h"
+
+
+namespace Beeps
+{
+
+
+	Processor::Processor ()
+	{
+	}
+
+	Processor::~Processor ()
+	{
+	}
+
+	void
+	Processor::process (Signals* signals)
+	{
+		if (!signals || !*signals)
+			argument_error(__FILE__, __LINE__);
+
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+	}
+
+	Processor::operator bool () const
+	{
+		return true;
+	}
+
+	bool
+	Processor::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+	struct SineWave::Data
+	{
+
+		stk::SineWave oscillator;
+
+		float frequency;
+
+	};// SineWave::Data
+
+
+	SineWave::SineWave ()
+	{
+		set_frequency(440);
+	}
+
+	SineWave::~SineWave ()
+	{
+	}
+
+	void
+	SineWave::set_frequency (float frequency)
+	{
+		self->frequency = frequency;
+		self->oscillator.setFrequency(frequency);
+	}
+
+	float
+	SineWave::frequency () const
+	{
+		return self->frequency;
+	}
+
+	void
+	SineWave::process (Signals* signals)
+	{
+		Super::process(signals);
+
+		self->oscillator.tick(*signals->frames());
+	}
+
+
+	struct SquareWave::Data
+	{
+
+		stk::BlitSquare oscillator;
+
+		float frequency;
+
+	};// SquareWave::Data
+
+
+	SquareWave::SquareWave ()
+	{
+		set_frequency(440);
+	}
+
+	SquareWave::~SquareWave ()
+	{
+	}
+
+	void
+	SquareWave::set_frequency (float frequency)
+	{
+		self->frequency = frequency;
+		self->oscillator.setFrequency(frequency);
+	}
+
+	float
+	SquareWave::frequency () const
+	{
+		return self->frequency;
+	}
+
+	void
+	SquareWave::process (Signals* signals)
+	{
+		Super::process(signals);
+
+		self->oscillator.tick(*signals->frames());
+	}
+
+
+	struct SawtoothWave::Data
+	{
+
+		stk::BlitSaw oscillator;
+
+		float frequency;
+
+	};// SawtoothWave::Data
+
+
+	SawtoothWave::SawtoothWave ()
+	{
+		set_frequency(440);
+	}
+
+	SawtoothWave::~SawtoothWave ()
+	{
+	}
+
+	void
+	SawtoothWave::set_frequency (float frequency)
+	{
+		self->frequency = frequency;
+		self->oscillator.setFrequency(frequency);
+	}
+
+	float
+	SawtoothWave::frequency () const
+	{
+		return self->frequency;
+	}
+
+	void
+	SawtoothWave::process (Signals* signals)
+	{
+		Super::process(signals);
+
+		self->oscillator.tick(*signals->frames());
+	}
+
+
+	struct FileIn::Data
+	{
+
+		stk::FileWvIn input;
+
+	};// FileIn::Data
+
+
+	FileIn::FileIn (const char* path)
+	{
+		if (path)
+			self->input.openFile(path);
+	}
+
+	FileIn::~FileIn ()
+	{
+	}
+
+	void
+	FileIn::process (Signals* signals)
+	{
+		Super::process(signals);
+
+		self->input.tick(*signals->frames());
+	}
+
+	FileIn::operator bool () const
+	{
+		return self->input.isOpen();
+	}
+
+
+}// Beeps