mixer: migrate to C++ exceptions

src/mixer/MixerAll.cxx

@@ -24,9 +24,10 @@
 #include "MixerList.hxx"
 #include "output/Internal.hxx"
 #include "pcm/Volume.hxx"
-#include "util/Error.hxx"
 #include "Log.hxx"
 
+#include <stdexcept>
+
 #include <assert.h>
 
 static int
@@ -39,14 +40,14 @@ output_mixer_get_volume(const AudioOutput &ao)
 	if (mixer == nullptr)
 		return -1;
 
-	Error error;
-	int volume = mixer_get_volume(mixer, error);
-	if (volume < 0 && error.IsDefined())
-		FormatError(error,
+	try {
+		return mixer_get_volume(mixer);
+	} catch (const std::runtime_error &e) {
+		FormatError(e,
 			    "Failed to read mixer for '%s'",
 			    ao.name);
-
-	return volume;
+		return -1;
+	}
 }
 
 int
@@ -81,14 +82,15 @@ output_mixer_set_volume(AudioOutput &ao, unsigned volume)
 	if (mixer == nullptr)
 		return false;
 
-	Error error;
-	bool success = mixer_set_volume(mixer, volume, error);
-	if (!success && error.IsDefined())
-		FormatError(error,
+	try {
+		mixer_set_volume(mixer, volume);
+		return true;
+	} catch (const std::runtime_error &e) {
+		FormatError(e,
 			    "Failed to set mixer for '%s'",
 			    ao.name);
-
-	return success;
+		return false;
+	}
 }
 
 bool
@@ -114,7 +116,7 @@ output_mixer_get_software_volume(const AudioOutput &ao)
 	if (mixer == nullptr || !mixer->IsPlugin(software_mixer_plugin))
 		return -1;
 
-	return mixer_get_volume(mixer, IgnoreError());
+	return mixer_get_volume(mixer);
 }
 
 int
@@ -148,6 +150,6 @@ MultipleOutputs::SetSoftwareVolume(unsigned volume)
 		if (mixer != nullptr &&
 		    (&mixer->plugin == &software_mixer_plugin ||
 		     &mixer->plugin == &null_mixer_plugin))
-			mixer_set_volume(mixer, volume, IgnoreError());
+			mixer_set_volume(mixer, volume);
 	}
 }

src/mixer/MixerControl.cxx

@@ -20,7 +20,6 @@
 #include "config.h"
 #include "MixerControl.hxx"
 #include "MixerInternal.hxx"
-#include "util/Error.hxx"
 
 #include <assert.h>
 
@@ -28,10 +27,9 @@ Mixer *
 mixer_new(EventLoop &event_loop,
 	  const MixerPlugin &plugin, AudioOutput &ao,
 	  MixerListener &listener,
-	  const ConfigBlock &block,
-	  Error &error)
+	  const ConfigBlock &block)
 {
-	Mixer *mixer = plugin.init(event_loop, ao, listener, block, error);
+	Mixer *mixer = plugin.init(event_loop, ao, listener, block);
 
 	assert(mixer == nullptr || mixer->IsPlugin(plugin));
 
@@ -50,20 +48,24 @@ mixer_free(Mixer *mixer)
 	delete mixer;
 }
 
-bool
-mixer_open(Mixer *mixer, Error &error)
+void
+mixer_open(Mixer *mixer)
 {
-	bool success;
-
 	assert(mixer != nullptr);
 
 	const ScopeLock protect(mixer->mutex);
 
-	success = mixer->open || (mixer->open = mixer->Open(error));
+	if (mixer->open)
+		return;
 
-	mixer->failed = !success;
-
-	return success;
+	try {
+		mixer->Open();
+		mixer->open = true;
+		mixer->failed = false;
+	} catch (...) {
+		mixer->failed = true;
+		throw;
+	}
 }
 
 static void
@@ -109,39 +111,41 @@ mixer_failed(Mixer *mixer)
 }
 
 int
-mixer_get_volume(Mixer *mixer, Error &error)
+mixer_get_volume(Mixer *mixer)
 {
 	int volume;
 
 	assert(mixer != nullptr);
 
-	if (mixer->plugin.global && !mixer->failed &&
-	    !mixer_open(mixer, error))
-		return -1;
+	if (mixer->plugin.global && !mixer->failed)
+		mixer_open(mixer);
 
 	const ScopeLock protect(mixer->mutex);
 
 	if (mixer->open) {
-		volume = mixer->GetVolume(error);
-		if (volume < 0 && error.IsDefined())
+		try {
+			volume = mixer->GetVolume();
+		} catch (...) {
 			mixer_failed(mixer);
+			throw;
+		}
 	} else
 		volume = -1;
 
 	return volume;
 }
 
-bool
-mixer_set_volume(Mixer *mixer, unsigned volume, Error &error)
+void
+mixer_set_volume(Mixer *mixer, unsigned volume)
 {
 	assert(mixer != nullptr);
 	assert(volume <= 100);
 
-	if (mixer->plugin.global && !mixer->failed &&
-	    !mixer_open(mixer, error))
-		return false;
+	if (mixer->plugin.global && !mixer->failed)
+		mixer_open(mixer);
 
 	const ScopeLock protect(mixer->mutex);
 
-	return mixer->open && mixer->SetVolume(volume, error);
+	if (mixer->open)
+		mixer->SetVolume(volume);
 }

src/mixer/MixerControl.hxx

@@ -25,7 +25,6 @@
 #ifndef MPD_MIXER_CONTROL_HXX
 #define MPD_MIXER_CONTROL_HXX
 
-class Error;
 class Mixer;
 class EventLoop;
 struct AudioOutput;
@@ -33,17 +32,22 @@ struct MixerPlugin;
 class MixerListener;
 struct ConfigBlock;
 
+/**
+ * Throws std::runtime_error on error.
+ */
 Mixer *
 mixer_new(EventLoop &event_loop, const MixerPlugin &plugin, AudioOutput &ao,
 	  MixerListener &listener,
-	  const ConfigBlock &block,
-	  Error &error);
+	  const ConfigBlock &block);
 
 void
 mixer_free(Mixer *mixer);
 
-bool
-mixer_open(Mixer *mixer, Error &error);
+/**
+ * Throws std::runtime_error on error.
+ */
+void
+mixer_open(Mixer *mixer);
 
 void
 mixer_close(Mixer *mixer);
@@ -55,10 +59,16 @@ mixer_close(Mixer *mixer);
 void
 mixer_auto_close(Mixer *mixer);
 
+/**
+ * Throws std::runtime_error on error.
+ */
 int
-mixer_get_volume(Mixer *mixer, Error &error);
+mixer_get_volume(Mixer *mixer);
 
-bool
-mixer_set_volume(Mixer *mixer, unsigned volume, Error &error);
+/**
+ * Throws std::runtime_error on error.
+ */
+void
+mixer_set_volume(Mixer *mixer, unsigned volume);
 
 #endif

src/mixer/MixerInternal.hxx

@@ -67,9 +67,9 @@ public:
 	/**
 	 * Open mixer device
 	 *
-	 * @return true on success, false on error
+	 * Throws std::runtime_error on error.
 	 */
-	virtual bool Open(Error &error) = 0;
+	virtual void Open() = 0;
 
 	/**
 	 * Close mixer device
@@ -79,19 +79,22 @@ public:
 	/**
 	 * Reads the current volume.
 	 *
+	 * Throws std::runtime_error on error.
+	 *
 	 * @return the current volume (0..100 including) or -1 if
-	 * unavailable or on error (error set, mixer will be closed)
+	 * unavailable
 	 */
 	gcc_pure
-	virtual int GetVolume(Error &error) = 0;
+	virtual int GetVolume() = 0;
 
 	/**
 	 * Sets the volume.
 	 *
-	 * @param volume the new volume (0..100 including) @return
-	 * true on success, false on error
+	 * Throws std::runtime_error on error.
+	 *
+	 * @param volume the new volume (0..100 including)
 	 */
-	virtual bool SetVolume(unsigned volume, Error &error) = 0;
+	virtual void SetVolume(unsigned volume) = 0;
 };
 
 #endif

src/mixer/MixerPlugin.hxx

@@ -32,22 +32,20 @@ struct AudioOutput;
 class Mixer;
 class MixerListener;
 class EventLoop;
-class Error;
 
 struct MixerPlugin {
 	/**
          * Alocates and configures a mixer device.
 	 *
+	 * Throws std::runtime_error on error.
+	 *
 	 * @param ao the associated AudioOutput
 	 * @param param the configuration section
-	 * @param error_r location to store the error occurring, or
-	 * nullptr to ignore errors
-	 * @return a mixer object, or nullptr on error
+	 * @return a mixer object
 	 */
 	Mixer *(*init)(EventLoop &event_loop, AudioOutput &ao,
 		       MixerListener &listener,
-		       const ConfigBlock &block,
-		       Error &error);
+		       const ConfigBlock &block);
 
 	/**
 	 * If true, then the mixer is automatically opened, even if

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 (((1 << volume_control) & devmask) == 0) {
-			error.Format(oss_mixer_domain, 0,
-				     "mixer control \"%s\" not usable",
-				     control);
-			Close();
-			return false;
+			if (ioctl(device_fd, SOUND_MIXER_READ_DEVMASK, &devmask) < 0)
+				throw MakeErrno("READ_DEVMASK failed");
+
+			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 = {