mixer: migrate to C++ exceptions

src/mixer/plugins/AlsaMixerPlugin.cxx

@@ -26,8 +26,8 @@
 #include "util/ASCII.hxx"
 #include "util/ReusableArray.hxx"
 #include "util/Clamp.hxx"
-#include "util/Error.hxx"
 #include "util/Domain.hxx"
+#include "util/RuntimeError.hxx"
 #include "Log.hxx"
 
 #include <algorithm>
@@ -82,13 +82,13 @@ public:
 	virtual ~AlsaMixer();
 
 	void Configure(const ConfigBlock &block);
-	bool Setup(Error &error);
+	void Setup();
 
 	/* virtual methods from class Mixer */
-	virtual bool Open(Error &error) override;
-	virtual void Close() override;
-	virtual int GetVolume(Error &error) override;
-	virtual bool SetVolume(unsigned volume, Error &error) override;
+	void Open() override;
+	void Close() override;
+	int GetVolume() override;
+	void SetVolume(unsigned volume) override;
 };
 
 static constexpr Domain alsa_mixer_domain("alsa_mixer");
@@ -148,8 +148,11 @@ alsa_mixer_elem_callback(snd_mixer_elem_t *elem, unsigned mask)
 		snd_mixer_elem_get_callback_private(elem);
 
 	if (mask & SND_CTL_EVENT_MASK_VALUE) {
-		int volume = mixer.GetVolume(IgnoreError());
-		mixer.listener.OnMixerVolumeChanged(mixer, volume);
+		try {
+			int volume = mixer.GetVolume();
+			mixer.listener.OnMixerVolumeChanged(mixer, volume);
+		} catch (const std::runtime_error &) {
+		}
 	}
 
 	return 0;
@@ -174,8 +177,7 @@ AlsaMixer::Configure(const ConfigBlock &block)
 static Mixer *
 alsa_mixer_init(EventLoop &event_loop, gcc_unused AudioOutput &ao,
 		MixerListener &listener,
-		const ConfigBlock &block,
-		gcc_unused Error &error)
+		const ConfigBlock &block)
 {
 	AlsaMixer *am = new AlsaMixer(event_loop, listener);
 	am->Configure(block);
@@ -205,39 +207,26 @@ alsa_mixer_lookup_elem(snd_mixer_t *handle, const char *name, unsigned idx)
 	return nullptr;
 }
 
-inline bool
-AlsaMixer::Setup(Error &error)
+inline void
+AlsaMixer::Setup()
 {
 	int err;
 
-	if ((err = snd_mixer_attach(handle, device)) < 0) {
-		error.Format(alsa_mixer_domain, err,
-			     "failed to attach to %s: %s",
-			     device, snd_strerror(err));
-		return false;
-	}
+	if ((err = snd_mixer_attach(handle, device)) < 0)
+		throw FormatRuntimeError("failed to attach to %s: %s",
+					 device, snd_strerror(err));
 
-	if ((err = snd_mixer_selem_register(handle, nullptr,
-		    nullptr)) < 0) {
-		error.Format(alsa_mixer_domain, err,
-			     "snd_mixer_selem_register() failed: %s",
-			     snd_strerror(err));
-		return false;
-	}
+	if ((err = snd_mixer_selem_register(handle, nullptr, nullptr)) < 0)
+		throw FormatRuntimeError("snd_mixer_selem_register() failed: %s",
+					 snd_strerror(err));
 
-	if ((err = snd_mixer_load(handle)) < 0) {
-		error.Format(alsa_mixer_domain, err,
-			     "snd_mixer_load() failed: %s\n",
-			     snd_strerror(err));
-		return false;
-	}
+	if ((err = snd_mixer_load(handle)) < 0)
+		throw FormatRuntimeError("snd_mixer_load() failed: %s\n",
+					 snd_strerror(err));
 
 	elem = alsa_mixer_lookup_elem(handle, control, index);
-	if (elem == nullptr) {
-		error.Format(alsa_mixer_domain, 0,
-			    "no such mixer control: %s", control);
-		return false;
-	}
+	if (elem == nullptr)
+		throw FormatRuntimeError("no such mixer control: %s", control);
 
 	snd_mixer_selem_get_playback_volume_range(elem, &volume_min,
 						  &volume_max);
@@ -246,33 +235,29 @@ AlsaMixer::Setup(Error &error)
 	snd_mixer_elem_set_callback(elem, alsa_mixer_elem_callback);
 
 	monitor = new AlsaMixerMonitor(event_loop, handle);
-
-	return true;
 }
 
-inline bool
-AlsaMixer::Open(Error &error)
+void
+AlsaMixer::Open()
 {
 	int err;
 
 	volume_set = -1;
 
 	err = snd_mixer_open(&handle, 0);
-	if (err < 0) {
-		error.Format(alsa_mixer_domain, err,
-			     "snd_mixer_open() failed: %s", snd_strerror(err));
-		return false;
-	}
+	if (err < 0)
+		throw FormatRuntimeError("snd_mixer_open() failed: %s",
+					 snd_strerror(err));
 
-	if (!Setup(error)) {
+	try {
+		Setup();
+	} catch (...) {
 		snd_mixer_close(handle);
-		return false;
+		throw;
 	}
-
-	return true;
 }
 
-inline void
+void
 AlsaMixer::Close()
 {
 	assert(handle != nullptr);
@@ -283,8 +268,8 @@ AlsaMixer::Close()
 	snd_mixer_close(handle);
 }
 
-inline int
-AlsaMixer::GetVolume(Error &error)
+int
+AlsaMixer::GetVolume()
 {
 	int err;
 	int ret;
@@ -293,22 +278,16 @@ AlsaMixer::GetVolume(Error &error)
 	assert(handle != nullptr);
 
 	err = snd_mixer_handle_events(handle);
-	if (err < 0) {
-		error.Format(alsa_mixer_domain, err,
-			     "snd_mixer_handle_events() failed: %s",
-			     snd_strerror(err));
-		return false;
-	}
+	if (err < 0)
+		throw FormatRuntimeError("snd_mixer_handle_events() failed: %s",
+					 snd_strerror(err));
 
 	err = snd_mixer_selem_get_playback_volume(elem,
 						  SND_MIXER_SCHN_FRONT_LEFT,
 						  &level);
-	if (err < 0) {
-		error.Format(alsa_mixer_domain, err,
-			     "failed to read ALSA volume: %s",
-			     snd_strerror(err));
-		return false;
-	}
+	if (err < 0)
+		throw FormatRuntimeError("failed to read ALSA volume: %s",
+					 snd_strerror(err));
 
 	ret = ((volume_set / 100.0) * (volume_max - volume_min)
 	       + volume_min) + 0.5;
@@ -322,8 +301,8 @@ AlsaMixer::GetVolume(Error &error)
 	return ret;
 }
 
-inline bool
-AlsaMixer::SetVolume(unsigned volume, Error &error)
+void
+AlsaMixer::SetVolume(unsigned volume)
 {
 	float vol;
 	long level;
@@ -340,14 +319,9 @@ AlsaMixer::SetVolume(unsigned volume, Error &error)
 	level = Clamp(level, volume_min, volume_max);
 
 	err = snd_mixer_selem_set_playback_volume_all(elem, level);
-	if (err < 0) {
-		error.Format(alsa_mixer_domain, err,
-			     "failed to set ALSA volume: %s",
-			     snd_strerror(err));
-		return false;
-	}
-
-	return true;
+	if (err < 0)
+		throw FormatRuntimeError("failed to set ALSA volume: %s",
+					 snd_strerror(err));
 }
 
 const MixerPlugin alsa_mixer_plugin = {

src/mixer/plugins/NullMixerPlugin.cxx

@@ -34,20 +34,18 @@ public:
 	}
 
 	/* virtual methods from class Mixer */
-	bool Open(gcc_unused Error &error) override {
-		return true;
+	void Open() override {
 	}
 
 	void Close() override {
 	}
 
-	int GetVolume(gcc_unused Error &error) override {
+	int GetVolume() override {
 		return volume;
 	}
 
-	bool SetVolume(unsigned _volume, gcc_unused Error &error) override {
+	void SetVolume(unsigned _volume) override {
 		volume = _volume;
-		return true;
 	}
 };
 
@@ -55,8 +53,7 @@ static Mixer *
 null_mixer_init(gcc_unused EventLoop &event_loop,
 		gcc_unused AudioOutput &ao,
 		MixerListener &listener,
-		gcc_unused const ConfigBlock &block,
-		gcc_unused Error &error)
+		gcc_unused const ConfigBlock &block)
 {
 	return new NullMixer(listener);
 }

src/mixer/plugins/OssMixerPlugin.cxx

@@ -21,9 +21,10 @@
 #include "mixer/MixerInternal.hxx"
 #include "config/Block.hxx"
 #include "system/fd_util.h"
+#include "system/Error.hxx"
 #include "util/ASCII.hxx"
-#include "util/Error.hxx"
 #include "util/Domain.hxx"
+#include "util/RuntimeError.hxx"
 #include "Log.hxx"
 
 #include <assert.h>
@@ -49,16 +50,18 @@ class OssMixer final : public Mixer {
 	int volume_control;
 
 public:
-	OssMixer(MixerListener &_listener)
-		:Mixer(oss_mixer_plugin, _listener) {}
+	OssMixer(MixerListener &_listener, const ConfigBlock &block)
+		:Mixer(oss_mixer_plugin, _listener) {
+		Configure(block);
+	}
 
-	bool Configure(const ConfigBlock &block, Error &error);
+	void Configure(const ConfigBlock &block);
 
 	/* virtual methods from class Mixer */
-	virtual bool Open(Error &error) override;
-	virtual void Close() override;
-	virtual int GetVolume(Error &error) override;
-	virtual bool SetVolume(unsigned volume, Error &error) override;
+	void Open() override;
+	void Close() override;
+	int GetVolume() override;
+	void SetVolume(unsigned volume) override;
 };
 
 static constexpr Domain oss_mixer_domain("oss_mixer");
@@ -78,39 +81,27 @@ oss_find_mixer(const char *name)
 	return -1;
 }
 
-inline bool
-OssMixer::Configure(const ConfigBlock &block, Error &error)
+inline void
+OssMixer::Configure(const ConfigBlock &block)
 {
 	device = block.GetBlockValue("mixer_device", VOLUME_MIXER_OSS_DEFAULT);
 	control = block.GetBlockValue("mixer_control");
 
 	if (control != NULL) {
 		volume_control = oss_find_mixer(control);
-		if (volume_control < 0) {
-			error.Format(oss_mixer_domain, 0,
-				     "no such mixer control: %s", control);
-			return false;
-		}
+		if (volume_control < 0)
+			throw FormatRuntimeError("no such mixer control: %s",
+						 control);
 	} else
 		volume_control = SOUND_MIXER_PCM;
-
-	return true;
 }
 
 static Mixer *
 oss_mixer_init(gcc_unused EventLoop &event_loop, gcc_unused AudioOutput &ao,
 	       MixerListener &listener,
-	       const ConfigBlock &block,
-	       Error &error)
+	       const ConfigBlock &block)
 {
-	OssMixer *om = new OssMixer(listener);
-
-	if (!om->Configure(block, error)) {
-		delete om;
-		return nullptr;
-	}
-
-	return om;
+	return new OssMixer(listener, block);
 }
 
 void
@@ -121,38 +112,32 @@ OssMixer::Close()
 	close(device_fd);
 }
 
-bool
-OssMixer::Open(Error &error)
+void
+OssMixer::Open()
 {
 	device_fd = open_cloexec(device, O_RDONLY, 0);
-	if (device_fd < 0) {
-		error.FormatErrno("failed to open %s", device);
-		return false;
-	}
+	if (device_fd < 0)
+		throw FormatErrno("failed to open %s", device);
 
-	if (control) {
-		int devmask = 0;
+	try {
+		if (control) {
+			int devmask = 0;
 
-		if (ioctl(device_fd, SOUND_MIXER_READ_DEVMASK, &devmask) < 0) {
-			error.SetErrno("READ_DEVMASK failed");
-			Close();
-			return false;
-		}
+			if (ioctl(device_fd, SOUND_MIXER_READ_DEVMASK, &devmask) < 0)
+				throw MakeErrno("READ_DEVMASK failed");
 
-		if (((1 << volume_control) & devmask) == 0) {
-			error.Format(oss_mixer_domain, 0,
-				     "mixer control \"%s\" not usable",
-				     control);
-			Close();
-			return false;
+			if (((1 << volume_control) & devmask) == 0)
+				throw FormatErrno("mixer control \"%s\" not usable",
+						  control);
 		}
+	} catch (...) {
+		Close();
+		throw;
 	}
-
-	return true;
 }
 
 int
-OssMixer::GetVolume(Error &error)
+OssMixer::GetVolume()
 {
 	int left, right, level;
 	int ret;
@@ -160,10 +145,8 @@ OssMixer::GetVolume(Error &error)
 	assert(device_fd >= 0);
 
 	ret = ioctl(device_fd, MIXER_READ(volume_control), &level);
-	if (ret < 0) {
-		error.SetErrno("failed to read OSS volume");
-		return false;
-	}
+	if (ret < 0)
+		throw MakeErrno("failed to read OSS volume");
 
 	left = level & 0xff;
 	right = (level & 0xff00) >> 8;
@@ -177,24 +160,18 @@ OssMixer::GetVolume(Error &error)
 	return left;
 }
 
-bool
-OssMixer::SetVolume(unsigned volume, Error &error)
+void
+OssMixer::SetVolume(unsigned volume)
 {
 	int level;
-	int ret;
 
 	assert(device_fd >= 0);
 	assert(volume <= 100);
 
 	level = (volume << 8) + volume;
 
-	ret = ioctl(device_fd, MIXER_WRITE(volume_control), &level);
-	if (ret < 0) {
-		error.SetErrno("failed to set OSS volume");
-		return false;
-	}
-
-	return true;
+	if (ioctl(device_fd, MIXER_WRITE(volume_control), &level) < 0)
+		throw MakeErrno("failed to set OSS volume");
 }
 
 const MixerPlugin oss_mixer_plugin = {

src/mixer/plugins/PulseMixerPlugin.cxx

@@ -25,13 +25,14 @@
 #include "mixer/MixerInternal.hxx"
 #include "mixer/Listener.hxx"
 #include "output/plugins/PulseOutputPlugin.hxx"
-#include "util/Error.hxx"
 
 #include <pulse/context.h>
 #include <pulse/introspect.h>
 #include <pulse/stream.h>
 #include <pulse/subscribe.h>
 
+#include <stdexcept>
+
 #include <assert.h>
 
 class PulseMixer final : public Mixer {
@@ -52,18 +53,17 @@ public:
 	void Offline();
 	void VolumeCallback(const pa_sink_input_info *i, int eol);
 	void Update(pa_context *context, pa_stream *stream);
-	int GetVolumeInternal(Error &error);
+	int GetVolumeInternal();
 
 	/* virtual methods from class Mixer */
-	bool Open(gcc_unused Error &error) override {
-		return true;
+	void Open() override {
 	}
 
 	void Close() override {
 	}
 
-	int GetVolume(Error &error) override;
-	bool SetVolume(unsigned volume, Error &error) override;
+	int GetVolume() override;
+	void SetVolume(unsigned volume) override;
 };
 
 void
@@ -91,7 +91,7 @@ PulseMixer::VolumeCallback(const pa_sink_input_info *i, int eol)
 	online = true;
 	volume = i->volume;
 
-	listener.OnMixerVolumeChanged(*this, GetVolumeInternal(IgnoreError()));
+	listener.OnMixerVolumeChanged(*this, GetVolumeInternal());
 }
 
 /**
@@ -163,8 +163,7 @@ pulse_mixer_on_change(PulseMixer &pm,
 static Mixer *
 pulse_mixer_init(gcc_unused EventLoop &event_loop, AudioOutput &ao,
 		 MixerListener &listener,
-		 gcc_unused const ConfigBlock &block,
-		 gcc_unused Error &error)
+		 gcc_unused const ConfigBlock &block)
 {
 	PulseOutput &po = (PulseOutput &)ao;
 	PulseMixer *pm = new PulseMixer(po, listener);
@@ -180,42 +179,37 @@ PulseMixer::~PulseMixer()
 }
 
 int
-PulseMixer::GetVolume(gcc_unused Error &error)
+PulseMixer::GetVolume()
 {
 	Pulse::LockGuard lock(pulse_output_get_mainloop(output));
 
-	return GetVolumeInternal(error);
+	return GetVolumeInternal();
 }
 
 /**
  * Pulse mainloop lock must be held by caller
  */
 int
-PulseMixer::GetVolumeInternal(gcc_unused Error &error)
+PulseMixer::GetVolumeInternal()
 {
 	return online ?
 		(int)((100 * (pa_cvolume_avg(&volume) + 1)) / PA_VOLUME_NORM)
 		: -1;
 }
 
-bool
-PulseMixer::SetVolume(unsigned new_volume, Error &error)
+void
+PulseMixer::SetVolume(unsigned new_volume)
 {
 	Pulse::LockGuard lock(pulse_output_get_mainloop(output));
 
-	if (!online) {
-		error.Set(pulse_domain, "disconnected");
-		return false;
-	}
+	if (!online)
+		throw std::runtime_error("disconnected");
 
 	struct pa_cvolume cvolume;
 	pa_cvolume_set(&cvolume, volume.channels,
 		       (new_volume * PA_VOLUME_NORM + 50) / 100);
-	bool success = pulse_output_set_volume(output, &cvolume, error);
-	if (success)
-		volume = cvolume;
-
-	return success;
+	pulse_output_set_volume(output, &cvolume);
+	volume = cvolume;
 }
 
 const MixerPlugin pulse_mixer_plugin = {

src/mixer/plugins/RoarMixerPlugin.cxx

@@ -34,36 +34,34 @@ public:
 		 self(_output) {}
 
 	/* virtual methods from class Mixer */
-	virtual bool Open(gcc_unused Error &error) override {
-		return true;
+	void Open() override {
 	}
 
 	virtual void Close() override {
 	}
 
-	virtual int GetVolume(Error &error) override;
-	virtual bool SetVolume(unsigned volume, Error &error) override;
+	int GetVolume() override;
+	void SetVolume(unsigned volume) override;
 };
 
 static Mixer *
 roar_mixer_init(gcc_unused EventLoop &event_loop, AudioOutput &ao,
 		MixerListener &listener,
-		gcc_unused const ConfigBlock &block,
-		gcc_unused Error &error)
+		gcc_unused const ConfigBlock &block)
 {
 	return new RoarMixer((RoarOutput &)ao, listener);
 }
 
 int
-RoarMixer::GetVolume(gcc_unused Error &error)
+RoarMixer::GetVolume()
 {
 	return roar_output_get_volume(self);
 }
 
-bool
-RoarMixer::SetVolume(unsigned volume, gcc_unused Error &error)
+void
+RoarMixer::SetVolume(unsigned volume)
 {
-	return roar_output_set_volume(self, volume);
+	roar_output_set_volume(self, volume);
 }
 
 const MixerPlugin roar_mixer_plugin = {

src/mixer/plugins/SoftwareMixerPlugin.cxx

@@ -26,7 +26,6 @@
 #include "filter/plugins/VolumeFilterPlugin.hxx"
 #include "pcm/Volume.hxx"
 #include "config/Block.hxx"
-#include "util/Error.hxx"
 
 #include <assert.h>
 #include <math.h>
@@ -48,26 +47,24 @@ public:
 	void SetFilter(Filter *_filter);
 
 	/* virtual methods from class Mixer */
-	virtual bool Open(gcc_unused Error &error) override {
-		return true;
+	void Open() override {
 	}
 
 	virtual void Close() override {
 	}
 
-	virtual int GetVolume(gcc_unused Error &error) override {
+	int GetVolume() override {
 		return volume;
 	}
 
-	virtual bool SetVolume(unsigned volume, Error &error) override;
+	void SetVolume(unsigned volume) override;
 };
 
 static Mixer *
 software_mixer_init(gcc_unused EventLoop &event_loop,
 		    gcc_unused AudioOutput &ao,
 		    MixerListener &listener,
-		    gcc_unused const ConfigBlock &block,
-		    gcc_unused Error &error)
+		    gcc_unused const ConfigBlock &block)
 {
 	return new SoftwareMixer(listener);
 }
@@ -87,8 +84,8 @@ PercentVolumeToSoftwareVolume(unsigned volume)
 		return 0;
 }
 
-bool
-SoftwareMixer::SetVolume(unsigned new_volume, gcc_unused Error &error)
+void
+SoftwareMixer::SetVolume(unsigned new_volume)
 {
 	assert(new_volume <= 100);
 
@@ -96,7 +93,6 @@ SoftwareMixer::SetVolume(unsigned new_volume, gcc_unused Error &error)
 
 	if (filter != nullptr)
 		volume_filter_set(filter, PercentVolumeToSoftwareVolume(new_volume));
-	return true;
 }
 
 const MixerPlugin software_mixer_plugin = {

src/mixer/plugins/WinmmMixerPlugin.cxx

@@ -21,11 +21,11 @@
 #include "mixer/MixerInternal.hxx"
 #include "output/OutputAPI.hxx"
 #include "output/plugins/WinmmOutputPlugin.hxx"
-#include "util/Error.hxx"
-#include "util/Domain.hxx"
 
 #include <mmsystem.h>
 
+#include <stdexcept>
+
 #include <assert.h>
 #include <math.h>
 #include <windows.h>
@@ -40,19 +40,16 @@ public:
 	}
 
 	/* virtual methods from class Mixer */
-	virtual bool Open(gcc_unused Error &error) override {
-		return true;
+	void Open() override {
 	}
 
-	virtual void Close() override {
+	void Close() override {
 	}
 
-	virtual int GetVolume(Error &error) override;
-	virtual bool SetVolume(unsigned volume, Error &error) override;
+	int GetVolume() override;
+	void SetVolume(unsigned volume) override;
 };
 
-static constexpr Domain winmm_mixer_domain("winmm_mixer");
-
 static inline int
 winmm_volume_decode(DWORD volume)
 {
@@ -69,40 +66,33 @@ winmm_volume_encode(int volume)
 static Mixer *
 winmm_mixer_init(gcc_unused EventLoop &event_loop, AudioOutput &ao,
 		 MixerListener &listener,
-		 gcc_unused const ConfigBlock &block,
-		 gcc_unused Error &error)
+		 gcc_unused const ConfigBlock &block)
 {
 	return new WinmmMixer((WinmmOutput &)ao, listener);
 }
 
 int
-WinmmMixer::GetVolume(Error &error)
+WinmmMixer::GetVolume()
 {
 	DWORD volume;
 	HWAVEOUT handle = winmm_output_get_handle(output);
 	MMRESULT result = waveOutGetVolume(handle, &volume);
 
-	if (result != MMSYSERR_NOERROR) {
-		error.Set(winmm_mixer_domain, "Failed to get winmm volume");
-		return -1;
-	}
+	if (result != MMSYSERR_NOERROR)
+		throw std::runtime_error("Failed to get winmm volume");
 
 	return winmm_volume_decode(volume);
 }
 
-bool
-WinmmMixer::SetVolume(unsigned volume, Error &error)
+void
+WinmmMixer::SetVolume(unsigned volume)
 {
 	DWORD value = winmm_volume_encode(volume);
 	HWAVEOUT handle = winmm_output_get_handle(output);
 	MMRESULT result = waveOutSetVolume(handle, value);
 
-	if (result != MMSYSERR_NOERROR) {
-		error.Set(winmm_mixer_domain, "Failed to set winmm volume");
-		return false;
-	}
-
-	return true;
+	if (result != MMSYSERR_NOERROR)
+		throw std::runtime_error("Failed to set winmm volume");
 }
 
 const MixerPlugin winmm_mixer_plugin = {