beeps 0.2.1 → 0.3.1

data/src/signals.cpp

@@ -27,7 +27,9 @@ namespace Beeps
 	Signals
 	Signals_create (uint capacity, uint nchannels, double sample_rate)
 	{
-		if (capacity <= 0 || nchannels <= 0)
+		if (capacity <= 0)
+			argument_error(__FILE__, __LINE__);
+		if (nchannels <= 0)
 			argument_error(__FILE__, __LINE__);
 
 		if (sample_rate <= 0) sample_rate = Beeps::sample_rate();
@@ -43,7 +45,11 @@ namespace Beeps
 		const float* const* channels,
 		uint nsamples, uint nchannels, double sample_rate)
 	{
-		if (!channels || nsamples <= 0 || nchannels <= 0)
+		if (!channels)
+			argument_error(__FILE__, __LINE__);
+		if (nsamples <= 0)
+			argument_error(__FILE__, __LINE__);
+		if (nchannels <= 0)
 			argument_error(__FILE__, __LINE__);
 
 		if (sample_rate <= 0) sample_rate = Beeps::sample_rate();
@@ -64,19 +70,32 @@ namespace Beeps
 	}
 
 	void
-	Signals_resize (Signals* signals, uint capacity)
+	Signals_clear (Signals* signals)
 	{
-		if (!signals || !*signals || capacity <= 0)
+		if (!signals)
+			argument_error(__FILE__, __LINE__);
+
+		signals->self->nsamples = 0;
+	}
+
+	void
+	Signals_clear (Signals* signals, uint capacity)
+	{
+		if (!signals)
+			argument_error(__FILE__, __LINE__);
+		if (!*signals)
+			argument_error(__FILE__, __LINE__);
+		if (capacity <= 0)
 			argument_error(__FILE__, __LINE__);
 
-		signals->self->frames->resize(capacity, signals->nchannels());
 		Signals_clear(signals);
+		signals->self->frames->resize(capacity, signals->nchannels());
 	}
 
 	void
 	Signals_resize (Signals* signals, uint nsamples, Float value)
 	{
-		Signals_resize(signals, nsamples);
+		Signals_clear(signals, nsamples);
 
 		Frames* frames = Signals_get_frames(signals);
 		assert(frames);
@@ -89,15 +108,6 @@ namespace Beeps
 		Signals_set_nsamples(signals, nsamples);
 	}
 
-	void
-	Signals_clear (Signals* signals)
-	{
-		if (!signals)
-			argument_error(__FILE__, __LINE__);
-
-		signals->self->nsamples = 0;
-	}
-
 	static uint
 	copy_frames (Signals* to, const Signals& from, uint from_offset)
 	{
@@ -191,7 +201,11 @@ namespace Beeps
 	uint
 	Signals_copy (Signals* to, const Signals& from, uint from_offset)
 	{
-		if (!to || !*to || !from)
+		if (!to)
+			argument_error(__FILE__, __LINE__);
+		if (!*to)
+			argument_error(__FILE__, __LINE__);
+		if (!from)
 			argument_error(__FILE__, __LINE__);
 
 		Signals_clear(to);
@@ -203,23 +217,24 @@ namespace Beeps
 	}
 
 	void
-	Signals_apply (Signals* signals, const Signals& multiplier)
+	Signals_multiply (Signals* signals, const Signals& multiplier)
 	{
-		if (!signals || multiplier.nchannels() != 1)
+		if (!signals)
+			argument_error(__FILE__, __LINE__);
+		if (multiplier.nchannels() != 1)
 			argument_error(__FILE__, __LINE__);
-
 		if (signals->capacity() != multiplier.capacity())
 			argument_error(__FILE__, __LINE__);
 
 		Frames* sigf = Signals_get_frames(signals);
 		Frames* mulf = Signals_get_frames(const_cast<Signals*>(&multiplier));
+		uint nframes = sigf->nframes();
+		uint stride  = sigf->nchannels();
 
 		for (uint ch = 0; ch < sigf->nchannels(); ++ch)
 		{
-			Float* sigp  = &(*sigf)(0, ch);
-			Float* mulp  = &(*mulf)(0, 0);
-			uint nframes = sigf->nframes();
-			uint stride  = sigf->nchannels();
+			Float* sigp = &(*sigf)(0, ch);
+			Float* mulp = &(*mulf)(0, 0);
 			for (uint i = 0; i < nframes; ++i, sigp += stride, ++mulp)
 				*sigp *= *mulp;
 		}
@@ -231,13 +246,14 @@ namespace Beeps
 	{
 		uint nsamples = nsamples_ < 0 ? samples.nsamples() : (uint) nsamples_;
 
-		if (
-			!signals || !*signals ||
-			signals->nchannels() != samples.nchannels() ||
-			signals->capacity() < nsamples)
-		{
+		if (!signals)
+			argument_error(__FILE__, __LINE__);
+		if (!*signals)
+			argument_error(__FILE__, __LINE__);
+		if (signals->nchannels() != samples.nchannels())
+			argument_error(__FILE__, __LINE__);
+		if (signals->capacity() < nsamples)
 			argument_error(__FILE__, __LINE__);
-		}
 
 		Frames* f = Signals_get_frames(signals);
 		assert(f);

data/src/signals.h

@@ -31,15 +31,15 @@ namespace Beeps
 		const float* const* channels,
 		uint nsamples, uint nchannels, double sample_rate = 0);
 
-	void Signals_resize (Signals* signals, uint capacity);
+	void Signals_clear (Signals* signals);
 
-	void Signals_resize (Signals* signals, uint nsamples, Float value);
+	void Signals_clear (Signals* signals, uint capacity);
 
-	void Signals_clear (Signals* signals);
+	void Signals_resize (Signals* signals, uint nsamples, Float value);
 
 	uint Signals_copy (Signals* to, const Signals& from, uint from_offset);
 
-	void Signals_apply (Signals* signals, const Signals& multiplier);
+	void Signals_multiply (Signals* signals, const Signals& multiplier);
 
 	template <typename T>
 	void Signals_write_samples (

data/src/sound.cpp

@@ -9,6 +9,7 @@
 #include "beeps/beeps.h"
 #include "beeps/exception.h"
 #include "beeps/generator.h"
+#include "beeps/debug.h"
 #include "openal.h"
 #include "processor.h"
 #include "signals.h"
@@ -29,19 +30,19 @@ namespace Beeps
 	{
 
 		SoundBuffer (bool create = false)
+		:	self(new Data(create))
 		{
-			if (create) self->create();
 		}
 
 		SoundBuffer (const Signals& signals)
+		:	self(new Data(true))
 		{
-			self->create();
 			write(signals);
 		}
 
 		SoundBuffer (ALint id)
+		:	self(new Data(id))
 		{
-			self->id = id;
 		}
 
 		void clear ()
@@ -59,7 +60,8 @@ namespace Beeps
 			double sample_rate = signals.sample_rate();
 			uint nchannels     = signals.nchannels();
 			uint nsamples      = signals.nsamples();
-			assert(sample_rate > 0 && nchannels > 0 && nsamples > 0);
+			assert(sample_rate > 0 && nchannels > 0);
+			if (nsamples <= 0) return 0;
 
 			const Frames* frames = Signals_get_frames(&signals);
 			assert(frames);
@@ -93,7 +95,7 @@ namespace Beeps
 			return !operator bool();
 		}
 
-		struct Data
+		struct Data : public Xot::NonCopyable
 		{
 
 			void* context = NULL;
@@ -102,14 +104,9 @@ namespace Beeps
 
 			bool owner    = false;
 
-			~Data ()
+			Data (bool create)
 			{
-				clear();
-			}
-
-			void create ()
-			{
-				clear();
+				if (!create) return;
 
 				ALuint id_ = 0;
 				alGenBuffers(1, &id_);
@@ -120,6 +117,16 @@ namespace Beeps
 				owner   = true;
 			}
 
+			Data (ALint id)
+			:	context(OpenAL_get_context()), id(id)
+			{
+			}
+
+			~Data ()
+			{
+				clear();
+			}
+
 			void clear ()
 			{
 				if (owner && is_valid())
@@ -378,7 +385,7 @@ namespace Beeps
 
 		Processor::Ref processor;
 
-		std::unique_ptr<ProcessorContext> processor_context;
+		std::unique_ptr<StreamContext> stream_context;
 
 		void clear ()
 		{
@@ -403,8 +410,8 @@ namespace Beeps
 			assert(processor && *processor && nchannels > 0 && sample_rate > 0);
 
 			this->processor = processor;
-			processor_context.reset(
-				new ProcessorContext(sample_rate / 10, nchannels, sample_rate));
+			stream_context.reset(
+				new StreamContext(sample_rate / 10, nchannels, sample_rate));
 
 			for (int i = 0; i < 2; ++i)
 			{
@@ -418,13 +425,11 @@ namespace Beeps
 
 		bool process_stream (SoundBuffer* buffer)
 		{
-			assert(buffer && processor && processor_context);
-
-			Signals signals = processor_context->process_signals(processor);
-			if (!signals) return false;
+			assert(buffer && processor && stream_context);
 
-			if (processor_context->is_finished())
-				processor_context.reset();
+			Signals signals = stream_context->process_next(processor);
+			if (stream_context->is_finished())
+				stream_context.reset();
 
 			return buffer->write(signals) > 0;
 		}
@@ -447,7 +452,7 @@ namespace Beeps
 
 		bool is_streaming () const
 		{
-			return processor && processor_context && *processor_context;
+			return processor && stream_context;
 		}
 
 	};// SoundPlayer::Data
@@ -687,12 +692,8 @@ namespace Beeps
 				processor && *processor &&
 				seconds > 0 && nchannels > 0 && sample_rate > 0);
 
-			ProcessorContext context(seconds * sample_rate, nchannels, sample_rate);
-			Signals signals = context.process_signals(processor);
-			if (!signals)
-				beeps_error(__FILE__, __LINE__, "failed to process signals");
-
-			this->signals = signals;
+			StreamContext context(seconds * sample_rate, nchannels, sample_rate);
+			this->signals = context.process_next(processor);
 		}
 
 		void attach_to (SoundPlayer* player) override
@@ -798,7 +799,9 @@ namespace Beeps
 	{
 		Processor::Ref ref = processor;
 
-		if (!processor || !*processor)
+		if (!processor)
+			argument_error(__FILE__, __LINE__);
+		if (!*processor)
 			argument_error(__FILE__, __LINE__);
 
 		if (sample_rate <= 0) sample_rate = Beeps::sample_rate();

data/src/win32/beeps.cpp

@@ -0,0 +1,36 @@
+#include "../beeps.h"
+
+
+#include <mfapi.h>
+#include <xot/windows.h>
+#include "exception.h"
+
+
+namespace Beeps
+{
+
+
+	void
+	Beeps_init ()
+	{
+		check_media_foundation_error(
+			CoInitializeEx(NULL, COINIT_MULTITHREADED),
+			__FILE__, __LINE__);
+
+		check_media_foundation_error(
+			MFStartup(MF_VERSION, MFSTARTUP_NOSOCKET),
+			__FILE__, __LINE__);
+	}
+
+	void
+	Beeps_fin ()
+	{
+		check_media_foundation_error(
+			MFShutdown(),
+			__FILE__, __LINE__);
+
+		CoUninitialize();
+	}
+
+
+}// Beeps

data/src/win32/exception.cpp

@@ -0,0 +1,40 @@
+#include "exception.h"
+
+
+#include <xot/string.h>
+
+
+namespace Beeps
+{
+
+
+	MediaFoundationError::MediaFoundationError (const char* str)
+	:	Super(str)
+	{
+	}
+
+
+	namespace ErrorFunctions
+	{
+
+		void
+		media_foundation_error (
+			const char* file, int line, HRESULT hresult, const char* format, ...)
+		{
+			XOT_STRINGF(format, s);
+			throw MediaFoundationError(
+				Xot::error_text(file, line, s + Xot::stringf(" (0x%p)", hresult)));
+		}
+
+	}// ErrorFunctions
+
+
+	void
+	check_media_foundation_error (HRESULT hresult, const char* file, int line)
+	{
+		if (FAILED(hresult))
+			media_foundation_error(file, line, hresult);
+	}
+
+
+}// Beeps

data/src/win32/exception.h

@@ -0,0 +1,40 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __BEEPS_SRC_WIN32_EXCEPTION_H__
+#define __BEEPS_SRC_WIN32_EXCEPTION_H__
+
+
+#include <xot/windows.h>
+#include "beeps/exception.h"
+
+
+namespace Beeps
+{
+
+
+	class MediaFoundationError : public BeepsError
+	{
+		typedef BeepsError Super;
+		public: MediaFoundationError (const char* str = NULL);
+	};
+
+
+	namespace ErrorFunctions
+	{
+
+		[[noreturn]]
+		void media_foundation_error (
+			const char* file, int line,
+			HRESULT hresult, const char* format = NULL, ...);
+
+	}// ErrorFunctions
+
+
+	void check_media_foundation_error (
+		HRESULT hresult, const char* file, int line);
+
+
+}// Beeps
+
+
+#endif//EOH

data/src/win32/signals.cpp

@@ -0,0 +1,186 @@
+#include "../signals.h"
+
+
+#include <mfapi.h>
+#include <mfidl.h>
+#include <mfreadwrite.h>
+#include <xot/noncopyable.h>
+#include <xot/string.h>
+#include <xot/windows.h>
+#include "exception.h"
+
+
+namespace Beeps
+{
+
+
+	template <typename T, void (*Delete) (T*)>
+	struct Ptr : public Xot::NonCopyable
+	{
+
+		T* ptr;
+
+		Ptr () : ptr(NULL) {}
+
+		~Ptr () {Delete(ptr);}
+
+		T* operator -> () {return ptr;}
+
+		operator bool () const {return ptr;}
+
+		bool operator ! () const {return !operator bool();}
+
+	};// Ptr
+
+	template <typename T>
+	static void
+	release (T* object)
+	{
+		if (object) object->Release();
+	}
+
+	template <typename T>
+	static void
+	mem_free (T* object)
+	{
+		if (object) CoTaskMemFree(object);
+	}
+
+	template <typename T>
+	using ReleasePtr = Ptr<T, release<T>>;
+
+	template <typename T>
+	using MemFreePtr = Ptr<T, mem_free<T>>;
+
+
+	static bool is_file_exist (const char* path)
+	{
+		DWORD attribs = GetFileAttributes(path);
+		return
+			attribs != INVALID_FILE_ATTRIBUTES &&
+			!(attribs & FILE_ATTRIBUTE_DIRECTORY);
+	}
+
+	static std::wstring
+	to_wcs (const char* mbs)
+	{
+		size_t len = strlen(mbs);
+		std::wstring wcs(len, L'#');
+		mbstowcs(&wcs[0], mbs, len);
+		return wcs;
+	}
+
+	static void
+	load_bytes (WAVEFORMATEX* format, std::vector<BYTE>* bytes, const char* path)
+	{
+		std::wstring wpath = to_wcs(path);
+
+		ReleasePtr<IMFMediaType> pcm_media_type;
+		check_media_foundation_error(
+			MFCreateMediaType(&pcm_media_type.ptr),
+			__FILE__, __LINE__);
+		pcm_media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio);
+		pcm_media_type->SetGUID(MF_MT_SUBTYPE, MFAudioFormat_PCM);
+
+		ReleasePtr<IMFSourceReader> source_reader;
+		check_media_foundation_error(
+			MFCreateSourceReaderFromURL(wpath.c_str(), NULL, &source_reader.ptr),
+			__FILE__, __LINE__);
+
+		check_media_foundation_error(
+			source_reader->SetCurrentMediaType(
+				MF_SOURCE_READER_FIRST_AUDIO_STREAM, NULL, pcm_media_type.ptr),
+			__FILE__, __LINE__);
+
+		ReleasePtr<IMFMediaType> media_type;
+		check_media_foundation_error(
+			source_reader->GetCurrentMediaType(
+				MF_SOURCE_READER_FIRST_AUDIO_STREAM, &media_type.ptr),
+			__FILE__, __LINE__);
+
+		MemFreePtr<WAVEFORMATEX> format_;
+		check_media_foundation_error(
+			MFCreateWaveFormatExFromMFMediaType(media_type.ptr, &format_.ptr, NULL),
+			__FILE__, __LINE__);
+
+		*format = *format_.ptr;
+		if (format->wFormatTag != WAVE_FORMAT_PCM)
+			beeps_error(__FILE__, __LINE__, "'%s' is not a PCM file.", path);
+
+		while (true)
+		{
+			ReleasePtr<IMFSample> sample;
+			DWORD flags = 0;
+			check_media_foundation_error(
+				source_reader->ReadSample(
+					MF_SOURCE_READER_FIRST_AUDIO_STREAM, 0, NULL, &flags, NULL, &sample.ptr),
+				__FILE__, __LINE__);
+			if (flags & MF_SOURCE_READERF_ENDOFSTREAM)
+				break;
+
+			ReleasePtr<IMFMediaBuffer> buffer;
+			check_media_foundation_error(
+				sample->ConvertToContiguousBuffer(&buffer.ptr),
+				__FILE__, __LINE__);
+
+			BYTE* data = NULL;
+			DWORD size = 0;
+			check_media_foundation_error(
+				buffer->Lock(&data, NULL, &size),
+				__FILE__, __LINE__);
+
+			bytes->resize(bytes->size() + size);
+			memcpy(&(*bytes)[0] + bytes->size() - size, data, size);
+
+			check_media_foundation_error(
+				buffer->Unlock(),
+				__FILE__, __LINE__);
+		}
+	}
+
+	Signals
+	Signals_load (const char* path)
+	{
+		if (!is_file_exist(path))
+			beeps_error(__FILE__, __LINE__, "'%s' not found.", path);
+
+		WAVEFORMATEX format = {0};
+		std::vector<BYTE> bytes;
+		load_bytes(&format, &bytes, path);
+		if (bytes.empty())
+			beeps_error(__FILE__, __LINE__, "failed to read bytes: '%s'", path);
+
+		uint Bps        = format.wBitsPerSample / 8;
+		uint nchannels  = format.nChannels;
+		uint nsamples   = bytes.size() / Bps / nchannels;
+		Signals signals = Signals_create(nsamples, nchannels, format.nSamplesPerSec);
+		Frames* frames  = Signals_get_frames(&signals);
+
+		for (uint channel = 0; channel < nchannels; ++channel)
+		{
+			switch (Bps)
+			{
+				case 1:
+				{
+					const uchar* p = ((uchar*) &bytes[0]) + channel;
+					for (uint sample = 0; sample < nsamples; ++sample, p += nchannels)
+						(*frames)(sample, channel) = (*p - 128) / 128.f;
+					break;
+				}
+
+				case 2:
+				{
+					const ushort* p = ((ushort*) &bytes[0]) + channel;
+					for (uint sample = 0; sample < nsamples; ++sample, p += nchannels)
+						(*frames)(sample, channel) = *p / 32768.f;
+					break;
+				}
+			}
+		}
+
+		Signals_set_nsamples(&signals, nsamples);
+		return signals;
+	}
+
+
+}// Beeps