beeps 0.2 → 0.3

data/src/osx/beeps.mm

@@ -0,0 +1,19 @@
+#include "../beeps.h"
+
+
+namespace Beeps
+{
+
+
+	void
+	Beeps_init ()
+	{
+	}
+
+	void
+	Beeps_fin ()
+	{
+	}
+
+
+}// Beeps

data/src/signals.cpp

@@ -24,21 +24,6 @@ namespace Beeps
 	};// Signals::Data
 
 
-	Frames*
-	Signals_get_frames (Signals* signals)
-	{
-		if (!signals)
-			argument_error(__FILE__, __LINE__);
-
-		return signals->self->frames.get();
-	}
-
-	const Frames*
-	Signals_get_frames (const Signals* signals)
-	{
-		return Signals_get_frames(const_cast<Signals*>(signals));
-	}
-
 	Signals
 	Signals_create (uint capacity, uint nchannels, double sample_rate)
 	{
@@ -67,8 +52,10 @@ namespace Beeps
 		frames->setDataRate(sample_rate);
 
 		for (uint channel = 0; channel < nchannels; ++channel)
+		{
 			for (uint sample = 0; sample < nsamples; ++sample)
 				(*frames)(sample, channel) = channels[channel][sample];
+		}
 
 		Signals s;
 		s.self->frames.reset(frames);
@@ -296,6 +283,21 @@ namespace Beeps
 		return (float) (signals.nsamples() / signals.sample_rate());
 	}
 
+	Frames*
+	Signals_get_frames (Signals* signals)
+	{
+		if (!signals)
+			argument_error(__FILE__, __LINE__);
+
+		return signals->self->frames.get();
+	}
+
+	const Frames*
+	Signals_get_frames (const Signals* signals)
+	{
+		return Signals_get_frames(const_cast<Signals*>(signals));
+	}
+
 	static void
 	make_audio_buffer (
 		AudioFile<float>::AudioBuffer* buffer, const Signals& signals)

data/src/signals.h

@@ -24,10 +24,6 @@ namespace Beeps
 	template <typename T> class SignalSamples;
 
 
-	      Frames* Signals_get_frames (      Signals* signals);
-
-	const Frames* Signals_get_frames (const Signals* signals);
-
 	Signals Signals_create (
 		uint capacity, uint nchannels = 1, double sample_rate = 0);
 
@@ -53,6 +49,10 @@ namespace Beeps
 
 	float Signals_get_seconds (const Signals& signals);
 
+	      Frames* Signals_get_frames (      Signals* signals);
+
+	const Frames* Signals_get_frames (const Signals* signals);
+
 	void    Signals_save (const Signals& signals, const char* path);
 
 	Signals Signals_load (const char* path);
@@ -63,8 +63,8 @@ namespace Beeps
 
 		public:
 
-			Frames (unsigned int nFrames = 0, unsigned int nChannels = 0)
-			:	stk::StkFrames(nFrames, nChannels)
+			Frames (unsigned int nframes = 0, unsigned int nchannels = 0)
+			:	stk::StkFrames(nframes, nchannels)
 			{
 			}
 

data/src/sound.cpp

@@ -67,8 +67,10 @@ namespace Beeps
 			std::vector<short> buffer;
 			buffer.reserve(nsamples * nchannels);
 			for (uint sample = 0; sample < nsamples; ++sample)
+			{
 				for (uint channel = 0; channel < nchannels; ++channel)
 					buffer.push_back((*frames)(sample, channel) * SHRT_MAX);
+			}
 
 			alBufferData(
 				self->id,
@@ -94,9 +96,11 @@ namespace Beeps
 		struct Data
 		{
 
-			ALint id   = -1;
+			void* context = NULL;
+
+			ALint id      = -1;
 
-			bool owner = false;
+			bool owner    = false;
 
 			~Data ()
 			{
@@ -111,26 +115,28 @@ namespace Beeps
 				alGenBuffers(1, &id_);
 				OpenAL_check_error(__FILE__, __LINE__);
 
-				id    = id_;
-				owner = true;
+				context = OpenAL_get_context();
+				id      = id_;
+				owner   = true;
 			}
 
 			void clear ()
 			{
-				if (owner && id >= 0)
+				if (owner && is_valid())
 				{
 					ALuint id_ = id;
 					alDeleteBuffers(1, &id_);
 					OpenAL_check_error(__FILE__, __LINE__);
 				}
 
-				id    = -1;
-				owner = false;
+				context = NULL;
+				id      = -1;
+				owner   = false;
 			}
 
 			bool is_valid () const
 			{
-				return id >= 0;
+				return id >= 0 && context == OpenAL_get_context();
 			}
 
 		};// Data
@@ -145,9 +151,7 @@ namespace Beeps
 
 		void create ()
 		{
-			ALuint id_ = 0;
-			alGenSources(1, &id_);
-			if (OpenAL_no_error()) self->id = id_;
+			self->create();
 		}
 
 		void clear ()
@@ -310,7 +314,7 @@ namespace Beeps
 
 		operator bool () const
 		{
-			return self->id >= 0;
+			return self->is_valid();
 		}
 
 		bool operator ! () const
@@ -321,22 +325,41 @@ namespace Beeps
 		struct Data
 		{
 
-			ALint id = -1;
+			void* context = NULL;
+
+			ALint id      = -1;
 
 			~Data ()
 			{
 				clear();
 			}
 
+			void create ()
+			{
+				ALuint id_ = 0;
+				alGenSources(1, &id_);
+				if (!OpenAL_no_error()) return;
+
+				context = OpenAL_get_context();
+				id      = id_;
+			}
+
 			void clear ()
 			{
-				if (id < 0) return;
+				if (is_valid())
+				{
+					ALuint id_ = id;
+					alDeleteSources(1, &id_);
+					OpenAL_check_error(__FILE__, __LINE__);
+				}
 
-				ALuint id_ = id;
-				alDeleteSources(1, &id_);
-				OpenAL_check_error(__FILE__, __LINE__);
+				context = NULL;
+				id      = -1;
+			}
 
-				id = -1;
+			bool is_valid () const
+			{
+				return id >= 0 && context == OpenAL_get_context();
 			}
 
 		};// Data

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

data/test/helper.rb

@@ -8,8 +8,3 @@ require 'beeps'
 require 'test/unit'
 
 include Xot::Test
-
-
-unless defined?($BEEPS_NOAUTOINIT) && $BEEPS_NOAUTOINIT
-  def Beeps.fin!() end
-end

data/test/test_sound_player.rb

@@ -54,6 +54,10 @@ class TestSoundPlayer < Test::Unit::TestCase
   end
 
   def test_play_end_then_stop()
+    # FIXME: not tested because it fails due to GHA's "Null Audio Device".
+    # https://github.com/xord/beeps/actions/runs/9044146493/job/24852497305
+    return if github_actions?
+
     s   = sound
     sec = s.seconds
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beeps
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.3'
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-13 00:00:00.000000000 Z
+date: 2024-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: rucy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
 description: Synthesize and play beep sounds.
 email: xordog@gmail.com
 executables: []
@@ -128,6 +128,7 @@ files:
 - src/adsr.cpp
 - src/analyser.cpp
 - src/beeps.cpp
+- src/beeps.h
 - src/exception.cpp
 - src/file_in.cpp
 - src/gain.cpp
@@ -136,6 +137,7 @@ files:
 - src/openal.cpp
 - src/openal.h
 - src/oscillator.cpp
+- src/osx/beeps.mm
 - src/osx/signals.mm
 - src/pitch_shift.cpp
 - src/processor.cpp
@@ -145,6 +147,10 @@ files:
 - src/sound.cpp
 - src/sound.h
 - src/time_stretch.cpp
+- src/win32/beeps.cpp
+- src/win32/exception.cpp
+- src/win32/exception.h
+- src/win32/signals.cpp
 - test/helper.rb
 - test/test_beeps.rb
 - test/test_beeps_init.rb