57 files changed, 3834 insertions, 241 deletions

diff --git a/src/output/OutputAPI.hxx b/src/output/OutputAPI.hxx
new file mode 100644
index 000000000..cfbc43196
--- /dev/null
+++ b/src/output/OutputAPI.hxx
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPD_OUTPUT_API_HXX
+#define MPD_OUTPUT_API_HXX
+
+// IWYU pragma: begin_exports
+
+#include "OutputPlugin.hxx"
+#include "OutputInternal.hxx"
+#include "AudioFormat.hxx"
+#include "tag/Tag.hxx"
+#include "config/ConfigData.hxx"
+
+// IWYU pragma: end_exports
+
+#endif
diff --git a/src/output/OutputAll.cxx b/src/output/OutputAll.cxx
new file mode 100644
index 000000000..ded9fa1e1
--- /dev/null
+++ b/src/output/OutputAll.cxx
@@ -0,0 +1,589 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+#include "OutputAll.hxx"
+#include "PlayerControl.hxx"
+#include "OutputInternal.hxx"
+#include "OutputControl.hxx"
+#include "OutputError.hxx"
+#include "MusicBuffer.hxx"
+#include "MusicPipe.hxx"
+#include "MusicChunk.hxx"
+#include "system/FatalError.hxx"
+#include "util/Error.hxx"
+#include "config/ConfigData.hxx"
+#include "config/ConfigGlobal.hxx"
+#include "config/ConfigOption.hxx"
+#include "notify.hxx"
+
+#include <assert.h>
+#include <string.h>
+
+static AudioFormat input_audio_format;
+
+static struct audio_output **audio_outputs;
+static unsigned int num_audio_outputs;
+
+/**
+ * The #MusicBuffer object where consumed chunks are returned.
+ */
+static MusicBuffer *g_music_buffer;
+
+/**
+ * The #MusicPipe object which feeds all audio outputs.  It is filled
+ * by audio_output_all_play().
+ */
+static MusicPipe *g_mp;
+
+/**
+ * The "elapsed_time" stamp of the most recently finished chunk.
+ */
+static float audio_output_all_elapsed_time = -1.0;
+
+unsigned int audio_output_count(void)
+{
+	return num_audio_outputs;
+}
+
+struct audio_output *
+audio_output_get(unsigned i)
+{
+	assert(i < num_audio_outputs);
+
+	assert(audio_outputs[i] != nullptr);
+
+	return audio_outputs[i];
+}
+
+struct audio_output *
+audio_output_find(const char *name)
+{
+	for (unsigned i = 0; i < num_audio_outputs; ++i) {
+		struct audio_output *ao = audio_output_get(i);
+
+		if (strcmp(ao->name, name) == 0)
+			return ao;
+	}
+
+	/* name not found */
+	return nullptr;
+}
+
+gcc_const
+static unsigned
+audio_output_config_count(void)
+{
+	unsigned int nr = 0;
+	const struct config_param *param = nullptr;
+
+	while ((param = config_get_next_param(CONF_AUDIO_OUTPUT, param)))
+		nr++;
+	if (!nr)
+		nr = 1; /* we'll always have at least one device  */
+	return nr;
+}
+
+void
+audio_output_all_init(PlayerControl &pc)
+{
+	const struct config_param *param = nullptr;
+	unsigned int i;
+	Error error;
+
+	num_audio_outputs = audio_output_config_count();
+	audio_outputs = new audio_output *[num_audio_outputs];
+
+	const config_param empty;
+
+	for (i = 0; i < num_audio_outputs; i++)
+	{
+		unsigned int j;
+
+		param = config_get_next_param(CONF_AUDIO_OUTPUT, param);
+		if (param == nullptr) {
+			/* only allow param to be nullptr if there
+			   just one audio output */
+			assert(i == 0);
+			assert(num_audio_outputs == 1);
+
+			param = &empty;
+		}
+
+		audio_output *output = audio_output_new(*param, pc, error);
+		if (output == nullptr) {
+			if (param != nullptr)
+				FormatFatalError("line %i: %s",
+						 param->line,
+						 error.GetMessage());
+			else
+				FatalError(error);
+		}
+
+		audio_outputs[i] = output;
+
+		/* require output names to be unique: */
+		for (j = 0; j < i; j++) {
+			if (!strcmp(output->name, audio_outputs[j]->name)) {
+				FormatFatalError("output devices with identical "
+						 "names: %s", output->name);
+			}
+		}
+	}
+}
+
+void
+audio_output_all_finish(void)
+{
+	unsigned int i;
+
+	for (i = 0; i < num_audio_outputs; i++) {
+		audio_output_disable(audio_outputs[i]);
+		audio_output_finish(audio_outputs[i]);
+	}
+
+	delete[] audio_outputs;
+	audio_outputs = nullptr;
+	num_audio_outputs = 0;
+}
+
+void
+audio_output_all_enable_disable(void)
+{
+	for (unsigned i = 0; i < num_audio_outputs; i++) {
+		struct audio_output *ao = audio_outputs[i];
+		bool enabled;
+
+		ao->mutex.lock();
+		enabled = ao->really_enabled;
+		ao->mutex.unlock();
+
+		if (ao->enabled != enabled) {
+			if (ao->enabled)
+				audio_output_enable(ao);
+			else
+				audio_output_disable(ao);
+		}
+	}
+}
+
+/**
+ * Determine if all (active) outputs have finished the current
+ * command.
+ */
+static bool
+audio_output_all_finished(void)
+{
+	for (unsigned i = 0; i < num_audio_outputs; ++i) {
+		struct audio_output *ao = audio_outputs[i];
+
+		const ScopeLock protect(ao->mutex);
+		if (audio_output_is_open(ao) &&
+		    !audio_output_command_is_finished(ao))
+			return false;
+	}
+
+	return true;
+}
+
+static void audio_output_wait_all(void)
+{
+	while (!audio_output_all_finished())
+		audio_output_client_notify.Wait();
+}
+
+/**
+ * Signals all audio outputs which are open.
+ */
+static void
+audio_output_allow_play_all(void)
+{
+	for (unsigned i = 0; i < num_audio_outputs; ++i)
+		audio_output_allow_play(audio_outputs[i]);
+}
+
+static void
+audio_output_reset_reopen(struct audio_output *ao)
+{
+	const ScopeLock protect(ao->mutex);
+
+	ao->fail_timer.Reset();
+}
+
+/**
+ * Resets the "reopen" flag on all audio devices.  MPD should
+ * immediately retry to open the device instead of waiting for the
+ * timeout when the user wants to start playback.
+ */
+static void
+audio_output_all_reset_reopen(void)
+{
+	for (unsigned i = 0; i < num_audio_outputs; ++i) {
+		struct audio_output *ao = audio_outputs[i];
+
+		audio_output_reset_reopen(ao);
+	}
+}
+
+/**
+ * Opens all output devices which are enabled, but closed.
+ *
+ * @return true if there is at least open output device which is open
+ */
+static bool
+audio_output_all_update(void)
+{
+	unsigned int i;
+	bool ret = false;
+
+	if (!input_audio_format.IsDefined())
+		return false;
+
+	for (i = 0; i < num_audio_outputs; ++i)
+		ret = audio_output_update(audio_outputs[i],
+					  input_audio_format, *g_mp) || ret;
+
+	return ret;
+}
+
+void
+audio_output_all_set_replay_gain_mode(ReplayGainMode mode)
+{
+	for (unsigned i = 0; i < num_audio_outputs; ++i)
+		audio_output_set_replay_gain_mode(audio_outputs[i], mode);
+}
+
+bool
+audio_output_all_play(struct music_chunk *chunk, Error &error)
+{
+	bool ret;
+	unsigned int i;
+
+	assert(g_music_buffer != nullptr);
+	assert(g_mp != nullptr);
+	assert(chunk != nullptr);
+	assert(chunk->CheckFormat(input_audio_format));
+
+	ret = audio_output_all_update();
+	if (!ret) {
+		/* TODO: obtain real error */
+		error.Set(output_domain, "Failed to open audio output");
+		return false;
+	}
+
+	g_mp->Push(chunk);
+
+	for (i = 0; i < num_audio_outputs; ++i)
+		audio_output_play(audio_outputs[i]);
+
+	return true;
+}
+
+bool
+audio_output_all_open(const AudioFormat audio_format,
+		      MusicBuffer &buffer,
+		      Error &error)
+{
+	bool ret = false, enabled = false;
+	unsigned int i;
+
+	assert(g_music_buffer == nullptr || g_music_buffer == &buffer);
+	assert((g_mp == nullptr) == (g_music_buffer == nullptr));
+
+	g_music_buffer = &buffer;
+
+	/* the audio format must be the same as existing chunks in the
+	   pipe */
+	assert(g_mp == nullptr || g_mp->CheckFormat(audio_format));
+
+	if (g_mp == nullptr)
+		g_mp = new MusicPipe();
+	else
+		/* if the pipe hasn't been cleared, the the audio
+		   format must not have changed */
+		assert(g_mp->IsEmpty() || audio_format == input_audio_format);
+
+	input_audio_format = audio_format;
+
+	audio_output_all_reset_reopen();
+	audio_output_all_enable_disable();
+	audio_output_all_update();
+
+	for (i = 0; i < num_audio_outputs; ++i) {
+		if (audio_outputs[i]->enabled)
+			enabled = true;
+
+		if (audio_outputs[i]->open)
+			ret = true;
+	}
+
+	if (!enabled)
+		error.Set(output_domain, "All audio outputs are disabled");
+	else if (!ret)
+		/* TODO: obtain real error */
+		error.Set(output_domain, "Failed to open audio output");
+
+	if (!ret)
+		/* close all devices if there was an error */
+		audio_output_all_close();
+
+	return ret;
+}
+
+/**
+ * Has the specified audio output already consumed this chunk?
+ */
+static bool
+chunk_is_consumed_in(const struct audio_output *ao,
+		     const struct music_chunk *chunk)
+{
+	if (!ao->open)
+		return true;
+
+	if (ao->chunk == nullptr)
+		return false;
+
+	assert(chunk == ao->chunk || g_mp->Contains(ao->chunk));
+
+	if (chunk != ao->chunk) {
+		assert(chunk->next != nullptr);
+		return true;
+	}
+
+	return ao->chunk_finished && chunk->next == nullptr;
+}
+
+/**
+ * Has this chunk been consumed by all audio outputs?
+ */
+static bool
+chunk_is_consumed(const struct music_chunk *chunk)
+{
+	for (unsigned i = 0; i < num_audio_outputs; ++i) {
+		struct audio_output *ao = audio_outputs[i];
+
+		const ScopeLock protect(ao->mutex);
+		if (!chunk_is_consumed_in(ao, chunk))
+			return false;
+	}
+
+	return true;
+}
+
+/**
+ * There's only one chunk left in the pipe (#g_mp), and all audio
+ * outputs have consumed it already.  Clear the reference.
+ */
+static void
+clear_tail_chunk(gcc_unused const struct music_chunk *chunk, bool *locked)
+{
+	assert(chunk->next == nullptr);
+	assert(g_mp->Contains(chunk));
+
+	for (unsigned i = 0; i < num_audio_outputs; ++i) {
+		struct audio_output *ao = audio_outputs[i];
+
+		/* this mutex will be unlocked by the caller when it's
+		   ready */
+		ao->mutex.lock();
+		locked[i] = ao->open;
+
+		if (!locked[i]) {
+			ao->mutex.unlock();
+			continue;
+		}
+
+		assert(ao->chunk == chunk);
+		assert(ao->chunk_finished);
+		ao->chunk = nullptr;
+	}
+}
+
+unsigned
+audio_output_all_check(void)
+{
+	const struct music_chunk *chunk;
+	bool is_tail;
+	struct music_chunk *shifted;
+	bool locked[num_audio_outputs];
+
+	assert(g_music_buffer != nullptr);
+	assert(g_mp != nullptr);
+
+	while ((chunk = g_mp->Peek()) != nullptr) {
+		assert(!g_mp->IsEmpty());
+
+		if (!chunk_is_consumed(chunk))
+			/* at least one output is not finished playing
+			   this chunk */
+			return g_mp->GetSize();
+
+		if (chunk->length > 0 && chunk->times >= 0.0)
+			/* only update elapsed_time if the chunk
+			   provides a defined value */
+			audio_output_all_elapsed_time = chunk->times;
+
+		is_tail = chunk->next == nullptr;
+		if (is_tail)
+			/* this is the tail of the pipe - clear the
+			   chunk reference in all outputs */
+			clear_tail_chunk(chunk, locked);
+
+		/* remove the chunk from the pipe */
+		shifted = g_mp->Shift();
+		assert(shifted == chunk);
+
+		if (is_tail)
+			/* unlock all audio outputs which were locked
+			   by clear_tail_chunk() */
+			for (unsigned i = 0; i < num_audio_outputs; ++i)
+				if (locked[i])
+					audio_outputs[i]->mutex.unlock();
+
+		/* return the chunk to the buffer */
+		g_music_buffer->Return(shifted);
+	}
+
+	return 0;
+}
+
+bool
+audio_output_all_wait(PlayerControl &pc, unsigned threshold)
+{
+	pc.Lock();
+
+	if (audio_output_all_check() < threshold) {
+		pc.Unlock();
+		return true;
+	}
+
+	pc.Wait();
+	pc.Unlock();
+
+	return audio_output_all_check() < threshold;
+}
+
+void
+audio_output_all_pause(void)
+{
+	unsigned int i;
+
+	audio_output_all_update();
+
+	for (i = 0; i < num_audio_outputs; ++i)
+		audio_output_pause(audio_outputs[i]);
+
+	audio_output_wait_all();
+}
+
+void
+audio_output_all_drain(void)
+{
+	for (unsigned i = 0; i < num_audio_outputs; ++i)
+		audio_output_drain_async(audio_outputs[i]);
+
+	audio_output_wait_all();
+}
+
+void
+audio_output_all_cancel(void)
+{
+	unsigned int i;
+
+	/* send the cancel() command to all audio outputs */
+
+	for (i = 0; i < num_audio_outputs; ++i)
+		audio_output_cancel(audio_outputs[i]);
+
+	audio_output_wait_all();
+
+	/* clear the music pipe and return all chunks to the buffer */
+
+	if (g_mp != nullptr)
+		g_mp->Clear(*g_music_buffer);
+
+	/* the audio outputs are now waiting for a signal, to
+	   synchronize the cleared music pipe */
+
+	audio_output_allow_play_all();
+
+	/* invalidate elapsed_time */
+
+	audio_output_all_elapsed_time = -1.0;
+}
+
+void
+audio_output_all_close(void)
+{
+	unsigned int i;
+
+	for (i = 0; i < num_audio_outputs; ++i)
+		audio_output_close(audio_outputs[i]);
+
+	if (g_mp != nullptr) {
+		assert(g_music_buffer != nullptr);
+
+		g_mp->Clear(*g_music_buffer);
+		delete g_mp;
+		g_mp = nullptr;
+	}
+
+	g_music_buffer = nullptr;
+
+	input_audio_format.Clear();
+
+	audio_output_all_elapsed_time = -1.0;
+}
+
+void
+audio_output_all_release(void)
+{
+	unsigned int i;
+
+	for (i = 0; i < num_audio_outputs; ++i)
+		audio_output_release(audio_outputs[i]);
+
+	if (g_mp != nullptr) {
+		assert(g_music_buffer != nullptr);
+
+		g_mp->Clear(*g_music_buffer);
+		delete g_mp;
+		g_mp = nullptr;
+	}
+
+	g_music_buffer = nullptr;
+
+	input_audio_format.Clear();
+
+	audio_output_all_elapsed_time = -1.0;
+}
+
+void
+audio_output_all_song_border(void)
+{
+	/* clear the elapsed_time pointer at the beginning of a new
+	   song */
+	audio_output_all_elapsed_time = 0.0;
+}
+
+float
+audio_output_all_get_elapsed_time(void)
+{
+	return audio_output_all_elapsed_time;
+}
diff --git a/src/output/OutputAll.hxx b/src/output/OutputAll.hxx
new file mode 100644
index 000000000..b6166eb48
--- /dev/null
+++ b/src/output/OutputAll.hxx
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/*
+ * Functions for dealing with all configured (enabled) audion outputs
+ * at once.
+ *
+ */
+
+#ifndef OUTPUT_ALL_H
+#define OUTPUT_ALL_H
+
+#include "ReplayGainInfo.hxx"
+#include "Compiler.h"
+
+struct AudioFormat;
+class MusicBuffer;
+struct music_chunk;
+struct PlayerControl;
+class Error;
+
+/**
+ * Global initialization: load audio outputs from the configuration
+ * file and initialize them.
+ */
+void
+audio_output_all_init(PlayerControl &pc);
+
+/**
+ * Global finalization: free memory occupied by audio outputs.  All
+ */
+void
+audio_output_all_finish(void);
+
+/**
+ * Returns the total number of audio output devices, including those
+ * who are disabled right now.
+ */
+gcc_const
+unsigned int audio_output_count(void);
+
+/**
+ * Returns the "i"th audio output device.
+ */
+gcc_const
+struct audio_output *
+audio_output_get(unsigned i);
+
+/**
+ * Returns the audio output device with the specified name.  Returns
+ * NULL if the name does not exist.
+ */
+gcc_pure
+struct audio_output *
+audio_output_find(const char *name);
+
+/**
+ * Checks the "enabled" flag of all audio outputs, and if one has
+ * changed, commit the change.
+ */
+void
+audio_output_all_enable_disable(void);
+
+/**
+ * Opens all audio outputs which are not disabled.
+ *
+ * @param audio_format the preferred audio format
+ * @param buffer the #music_buffer where consumed #music_chunk objects
+ * should be returned
+ * @return true on success, false on failure
+ */
+bool
+audio_output_all_open(AudioFormat audio_format,
+		      MusicBuffer &buffer,
+		      Error &error);
+
+/**
+ * Closes all audio outputs.
+ */
+void
+audio_output_all_close(void);
+
+/**
+ * Closes all audio outputs.  Outputs with the "always_on" flag are
+ * put into pause mode.
+ */
+void
+audio_output_all_release(void);
+
+void
+audio_output_all_set_replay_gain_mode(ReplayGainMode mode);
+
+/**
+ * Enqueue a #music_chunk object for playing, i.e. pushes it to a
+ * #MusicPipe.
+ *
+ * @param chunk the #music_chunk object to be played
+ * @return true on success, false if no audio output was able to play
+ * (all closed then)
+ */
+bool
+audio_output_all_play(music_chunk *chunk, Error &error);
+
+/**
+ * Checks if the output devices have drained their music pipe, and
+ * returns the consumed music chunks to the #music_buffer.
+ *
+ * @return the number of chunks to play left in the #MusicPipe
+ */
+unsigned
+audio_output_all_check(void);
+
+/**
+ * Checks if the size of the #MusicPipe is below the #threshold.  If
+ * not, it attempts to synchronize with all output threads, and waits
+ * until another #music_chunk is finished.
+ *
+ * @param threshold the maximum number of chunks in the pipe
+ * @return true if there are less than #threshold chunks in the pipe
+ */
+bool
+audio_output_all_wait(PlayerControl &pc, unsigned threshold);
+
+/**
+ * Puts all audio outputs into pause mode.  Most implementations will
+ * simply close it then.
+ */
+void
+audio_output_all_pause(void);
+
+/**
+ * Drain all audio outputs.
+ */
+void
+audio_output_all_drain(void);
+
+/**
+ * Try to cancel data which may still be in the device's buffers.
+ */
+void
+audio_output_all_cancel(void);
+
+/**
+ * Indicate that a new song will begin now.
+ */
+void
+audio_output_all_song_border(void);
+
+/**
+ * Returns the "elapsed_time" stamp of the most recently finished
+ * chunk.  A negative value is returned when no chunk has been
+ * finished yet.
+ */
+gcc_pure
+float
+audio_output_all_get_elapsed_time(void);
+
+#endif
diff --git a/src/output/OutputCommand.cxx b/src/output/OutputCommand.cxx
new file mode 100644
index 000000000..d82b7c696
--- /dev/null
+++ b/src/output/OutputCommand.cxx
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/*
+ * Glue functions for controlling the audio outputs over the MPD
+ * protocol.  These functions perform extra validation on all
+ * parameters, because they might be from an untrusted source.
+ *
+ */
+
+#include "config.h"
+#include "OutputCommand.hxx"
+#include "OutputAll.hxx"
+#include "OutputInternal.hxx"
+#include "PlayerControl.hxx"
+#include "mixer/MixerControl.hxx"
+#include "Idle.hxx"
+
+extern unsigned audio_output_state_version;
+
+bool
+audio_output_enable_index(unsigned idx)
+{
+	struct audio_output *ao;
+
+	if (idx >= audio_output_count())
+		return false;
+
+	ao = audio_output_get(idx);
+	if (ao->enabled)
+		return true;
+
+	ao->enabled = true;
+	idle_add(IDLE_OUTPUT);
+
+	ao->player_control->UpdateAudio();
+
+	++audio_output_state_version;
+
+	return true;
+}
+
+bool
+audio_output_disable_index(unsigned idx)
+{
+	struct audio_output *ao;
+
+	if (idx >= audio_output_count())
+		return false;
+
+	ao = audio_output_get(idx);
+	if (!ao->enabled)
+		return true;
+
+	ao->enabled = false;
+	idle_add(IDLE_OUTPUT);
+
+	Mixer *mixer = ao->mixer;
+	if (mixer != nullptr) {
+		mixer_close(mixer);
+		idle_add(IDLE_MIXER);
+	}
+
+	ao->player_control->UpdateAudio();
+
+	++audio_output_state_version;
+
+	return true;
+}
+
+bool
+audio_output_toggle_index(unsigned idx)
+{
+	struct audio_output *ao;
+
+	if (idx >= audio_output_count())
+		return false;
+
+	ao = audio_output_get(idx);
+	const bool enabled = ao->enabled = !ao->enabled;
+	idle_add(IDLE_OUTPUT);
+
+	if (!enabled) {
+		Mixer *mixer = ao->mixer;
+		if (mixer != nullptr) {
+			mixer_close(mixer);
+			idle_add(IDLE_MIXER);
+		}
+	}
+
+	ao->player_control->UpdateAudio();
+
+	++audio_output_state_version;
+
+	return true;
+}
diff --git a/src/output/OutputCommand.hxx b/src/output/OutputCommand.hxx
new file mode 100644
index 000000000..4c44dff53
--- /dev/null
+++ b/src/output/OutputCommand.hxx
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/*
+ * Glue functions for controlling the audio outputs over the MPD
+ * protocol.  These functions perform extra validation on all
+ * parameters, because they might be from an untrusted source.
+ *
+ */
+
+#ifndef MPD_OUTPUT_COMMAND_HXX
+#define MPD_OUTPUT_COMMAND_HXX
+
+/**
+ * Enables an audio output.  Returns false if the specified output
+ * does not exist.
+ */
+bool
+audio_output_enable_index(unsigned idx);
+
+/**
+ * Disables an audio output.  Returns false if the specified output
+ * does not exist.
+ */
+bool
+audio_output_disable_index(unsigned idx);
+
+/**
+ * Toggles an audio output.  Returns false if the specified output
+ * does not exist.
+ */
+bool
+audio_output_toggle_index(unsigned idx);
+
+#endif
diff --git a/src/output/OutputControl.cxx b/src/output/OutputControl.cxx
new file mode 100644
index 000000000..1532dbd83
--- /dev/null
+++ b/src/output/OutputControl.cxx
@@ -0,0 +1,325 @@
+
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+#include "OutputControl.hxx"
+#include "OutputThread.hxx"
+#include "OutputInternal.hxx"
+#include "OutputPlugin.hxx"
+#include "OutputError.hxx"
+#include "mixer/MixerControl.hxx"
+#include "notify.hxx"
+#include "filter/plugins/ReplayGainFilterPlugin.hxx"
+#include "util/Error.hxx"
+#include "Log.hxx"
+
+#include <assert.h>
+
+/** after a failure, wait this number of seconds before
+    automatically reopening the device */
+static constexpr unsigned REOPEN_AFTER = 10;
+
+struct notify audio_output_client_notify;
+
+/**
+ * Waits for command completion.
+ *
+ * @param ao the #audio_output instance; must be locked
+ */
+static void ao_command_wait(struct audio_output *ao)
+{
+	while (ao->command != AO_COMMAND_NONE) {
+		ao->mutex.unlock();
+		audio_output_client_notify.Wait();
+		ao->mutex.lock();
+	}
+}
+
+/**
+ * Sends a command to the #audio_output object, but does not wait for
+ * completion.
+ *
+ * @param ao the #audio_output instance; must be locked
+ */
+static void ao_command_async(struct audio_output *ao,
+			     enum audio_output_command cmd)
+{
+	assert(ao->command == AO_COMMAND_NONE);
+	ao->command = cmd;
+	ao->cond.signal();
+}
+
+/**
+ * Sends a command to the #audio_output object and waits for
+ * completion.
+ *
+ * @param ao the #audio_output instance; must be locked
+ */
+static void
+ao_command(struct audio_output *ao, enum audio_output_command cmd)
+{
+	ao_command_async(ao, cmd);
+	ao_command_wait(ao);
+}
+
+/**
+ * Lock the #audio_output object and execute the command
+ * synchronously.
+ */
+static void
+ao_lock_command(struct audio_output *ao, enum audio_output_command cmd)
+{
+	const ScopeLock protect(ao->mutex);
+	ao_command(ao, cmd);
+}
+
+void
+audio_output_set_replay_gain_mode(struct audio_output *ao,
+				  ReplayGainMode mode)
+{
+	if (ao->replay_gain_filter != nullptr)
+		replay_gain_filter_set_mode(ao->replay_gain_filter, mode);
+	if (ao->other_replay_gain_filter != nullptr)
+		replay_gain_filter_set_mode(ao->other_replay_gain_filter, mode);
+}
+
+void
+audio_output_enable(struct audio_output *ao)
+{
+	if (!ao->thread.IsDefined()) {
+		if (ao->plugin->enable == nullptr) {
+			/* don't bother to start the thread now if the
+			   device doesn't even have a enable() method;
+			   just assign the variable and we're done */
+			ao->really_enabled = true;
+			return;
+		}
+
+		audio_output_thread_start(ao);
+	}
+
+	ao_lock_command(ao, AO_COMMAND_ENABLE);
+}
+
+void
+audio_output_disable(struct audio_output *ao)
+{
+	if (!ao->thread.IsDefined()) {
+		if (ao->plugin->disable == nullptr)
+			ao->really_enabled = false;
+		else
+			/* if there's no thread yet, the device cannot
+			   be enabled */
+			assert(!ao->really_enabled);
+
+		return;
+	}
+
+	ao_lock_command(ao, AO_COMMAND_DISABLE);
+}
+
+/**
+ * Object must be locked (and unlocked) by the caller.
+ */
+static bool
+audio_output_open(struct audio_output *ao,
+		  const AudioFormat audio_format,
+		  const MusicPipe &mp)
+{
+	bool open;
+
+	assert(ao != nullptr);
+	assert(ao->allow_play);
+	assert(audio_format.IsValid());
+
+	ao->fail_timer.Reset();
+
+	if (ao->open && audio_format == ao->in_audio_format) {
+		assert(ao->pipe == &mp ||
+		       (ao->always_on && ao->pause));
+
+		if (ao->pause) {
+			ao->chunk = nullptr;
+			ao->pipe = &mp;
+
+			/* unpause with the CANCEL command; this is a
+			   hack, but suits well for forcing the thread
+			   to leave the ao_pause() thread, and we need
+			   to flush the device buffer anyway */
+
+			/* we're not using audio_output_cancel() here,
+			   because that function is asynchronous */
+			ao_command(ao, AO_COMMAND_CANCEL);
+		}
+
+		return true;
+	}
+
+	ao->in_audio_format = audio_format;
+	ao->chunk = nullptr;
+
+	ao->pipe = &mp;
+
+	if (!ao->thread.IsDefined())
+		audio_output_thread_start(ao);
+
+	ao_command(ao, ao->open ? AO_COMMAND_REOPEN : AO_COMMAND_OPEN);
+	open = ao->open;
+
+	if (open && ao->mixer != nullptr) {
+		Error error;
+		if (!mixer_open(ao->mixer, error))
+			FormatWarning(output_domain,
+				      "Failed to open mixer for '%s'",
+				      ao->name);
+	}
+
+	return open;
+}
+
+/**
+ * Same as audio_output_close(), but expects the lock to be held by
+ * the caller.
+ */
+static void
+audio_output_close_locked(struct audio_output *ao)
+{
+	assert(ao != nullptr);
+	assert(ao->allow_play);
+
+	if (ao->mixer != nullptr)
+		mixer_auto_close(ao->mixer);
+
+	assert(!ao->open || !ao->fail_timer.IsDefined());
+
+	if (ao->open)
+		ao_command(ao, AO_COMMAND_CLOSE);
+	else
+		ao->fail_timer.Reset();
+}
+
+bool
+audio_output_update(struct audio_output *ao,
+		    const AudioFormat audio_format,
+		    const MusicPipe &mp)
+{
+	const ScopeLock protect(ao->mutex);
+
+	if (ao->enabled && ao->really_enabled) {
+		if (ao->fail_timer.Check(REOPEN_AFTER * 1000)) {
+			return audio_output_open(ao, audio_format, mp);
+		}
+	} else if (audio_output_is_open(ao))
+		audio_output_close_locked(ao);
+
+	return false;
+}
+
+void
+audio_output_play(struct audio_output *ao)
+{
+	const ScopeLock protect(ao->mutex);
+
+	assert(ao->allow_play);
+
+	if (audio_output_is_open(ao) && !ao->in_playback_loop &&
+	    !ao->woken_for_play) {
+		ao->woken_for_play = true;
+		ao->cond.signal();
+	}
+}
+
+void audio_output_pause(struct audio_output *ao)
+{
+	if (ao->mixer != nullptr && ao->plugin->pause == nullptr)
+		/* the device has no pause mode: close the mixer,
+		   unless its "global" flag is set (checked by
+		   mixer_auto_close()) */
+		mixer_auto_close(ao->mixer);
+
+	const ScopeLock protect(ao->mutex);
+
+	assert(ao->allow_play);
+	if (audio_output_is_open(ao))
+		ao_command_async(ao, AO_COMMAND_PAUSE);
+}
+
+void
+audio_output_drain_async(struct audio_output *ao)
+{
+	const ScopeLock protect(ao->mutex);
+
+	assert(ao->allow_play);
+	if (audio_output_is_open(ao))
+		ao_command_async(ao, AO_COMMAND_DRAIN);
+}
+
+void audio_output_cancel(struct audio_output *ao)
+{
+	const ScopeLock protect(ao->mutex);
+
+	if (audio_output_is_open(ao)) {
+		ao->allow_play = false;
+		ao_command_async(ao, AO_COMMAND_CANCEL);
+	}
+}
+
+void
+audio_output_allow_play(struct audio_output *ao)
+{
+	const ScopeLock protect(ao->mutex);
+
+	ao->allow_play = true;
+	if (audio_output_is_open(ao))
+		ao->cond.signal();
+}
+
+void
+audio_output_release(struct audio_output *ao)
+{
+	if (ao->always_on)
+		audio_output_pause(ao);
+	else
+		audio_output_close(ao);
+}
+
+void audio_output_close(struct audio_output *ao)
+{
+	assert(ao != nullptr);
+	assert(!ao->open || !ao->fail_timer.IsDefined());
+
+	const ScopeLock protect(ao->mutex);
+	audio_output_close_locked(ao);
+}
+
+void audio_output_finish(struct audio_output *ao)
+{
+	audio_output_close(ao);
+
+	assert(!ao->fail_timer.IsDefined());
+
+	if (ao->thread.IsDefined()) {
+		assert(ao->allow_play);
+		ao_lock_command(ao, AO_COMMAND_KILL);
+		ao->thread.Join();
+	}
+
+	audio_output_free(ao);
+}
diff --git a/src/output/OutputControl.hxx b/src/output/OutputControl.hxx
new file mode 100644
index 000000000..7195412ef
--- /dev/null
+++ b/src/output/OutputControl.hxx
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPD_OUTPUT_CONTROL_HXX
+#define MPD_OUTPUT_CONTROL_HXX
+
+#include "ReplayGainInfo.hxx"
+
+#include <stddef.h>
+
+struct audio_output;
+struct AudioFormat;
+struct config_param;
+class MusicPipe;
+
+void
+audio_output_set_replay_gain_mode(audio_output *ao,
+				  ReplayGainMode mode);
+
+/**
+ * Enables the device.
+ */
+void
+audio_output_enable(audio_output *ao);
+
+/**
+ * Disables the device.
+ */
+void
+audio_output_disable(audio_output *ao);
+
+/**
+ * Opens or closes the device, depending on the "enabled" flag.
+ *
+ * @return true if the device is open
+ */
+bool
+audio_output_update(audio_output *ao,
+		    AudioFormat audio_format,
+		    const MusicPipe &mp);
+
+void
+audio_output_play(audio_output *ao);
+
+void
+audio_output_pause(audio_output *ao);
+
+void
+audio_output_drain_async(audio_output *ao);
+
+/**
+ * Clear the "allow_play" flag and send the "CANCEL" command
+ * asynchronously.  To finish the operation, the caller has to call
+ * audio_output_allow_play().
+ */
+void
+audio_output_cancel(audio_output *ao);
+
+/**
+ * Set the "allow_play" and signal the thread.
+ */
+void
+audio_output_allow_play(audio_output *ao);
+
+void
+audio_output_close(audio_output *ao);
+
+/**
+ * Closes the audio output, but if the "always_on" flag is set, put it
+ * into pause mode instead.
+ */
+void
+audio_output_release(audio_output *ao);
+
+void
+audio_output_finish(audio_output *ao);
+
+#endif
diff --git a/src/output/OutputError.cxx b/src/output/OutputError.cxx
new file mode 100644
index 000000000..9d4128912
--- /dev/null
+++ b/src/output/OutputError.cxx
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "OutputError.hxx"
+#include "util/Domain.hxx"
+
+const Domain output_domain("output");
diff --git a/src/output/OutputError.hxx b/src/output/OutputError.hxx
new file mode 100644
index 000000000..e3a20142f
--- /dev/null
+++ b/src/output/OutputError.hxx
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPD_OUTPUT_ERROR_HXX
+#define MPD_OUTPUT_ERROR_HXX
+
+extern const class Domain output_domain;
+
+#endif
diff --git a/src/output/OutputFinish.cxx b/src/output/OutputFinish.cxx
new file mode 100644
index 000000000..16b16f5ce
--- /dev/null
+++ b/src/output/OutputFinish.cxx
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+#include "OutputInternal.hxx"
+#include "OutputPlugin.hxx"
+#include "mixer/MixerControl.hxx"
+#include "filter/FilterInternal.hxx"
+
+#include <assert.h>
+
+void
+ao_base_finish(struct audio_output *ao)
+{
+	assert(!ao->open);
+	assert(!ao->fail_timer.IsDefined());
+	assert(!ao->thread.IsDefined());
+
+	if (ao->mixer != nullptr)
+		mixer_free(ao->mixer);
+
+	delete ao->replay_gain_filter;
+	delete ao->other_replay_gain_filter;
+	delete ao->filter;
+}
+
+void
+audio_output_free(struct audio_output *ao)
+{
+	assert(!ao->open);
+	assert(!ao->fail_timer.IsDefined());
+	assert(!ao->thread.IsDefined());
+
+	ao_plugin_finish(ao);
+}
diff --git a/src/output/OutputInit.cxx b/src/output/OutputInit.cxx
new file mode 100644
index 000000000..16180a415
--- /dev/null
+++ b/src/output/OutputInit.cxx
@@ -0,0 +1,329 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+#include "OutputInternal.hxx"
+#include "OutputList.hxx"
+#include "OutputError.hxx"
+#include "OutputAPI.hxx"
+#include "filter/FilterConfig.hxx"
+#include "AudioParser.hxx"
+#include "mixer/MixerList.hxx"
+#include "mixer/MixerType.hxx"
+#include "mixer/MixerControl.hxx"
+#include "mixer/plugins/SoftwareMixerPlugin.hxx"
+#include "filter/FilterPlugin.hxx"
+#include "filter/FilterRegistry.hxx"
+#include "filter/plugins/AutoConvertFilterPlugin.hxx"
+#include "filter/plugins/ReplayGainFilterPlugin.hxx"
+#include "filter/plugins/ChainFilterPlugin.hxx"
+#include "config/ConfigError.hxx"
+#include "config/ConfigGlobal.hxx"
+#include "util/Error.hxx"
+#include "Log.hxx"
+
+#include <assert.h>
+#include <string.h>
+
+#define AUDIO_OUTPUT_TYPE	"type"
+#define AUDIO_OUTPUT_NAME	"name"
+#define AUDIO_OUTPUT_FORMAT	"format"
+#define AUDIO_FILTERS		"filters"
+
+static const struct audio_output_plugin *
+audio_output_detect(Error &error)
+{
+	LogDefault(output_domain, "Attempt to detect audio output device");
+
+	audio_output_plugins_for_each(plugin) {
+		if (plugin->test_default_device == nullptr)
+			continue;
+
+		FormatDefault(output_domain,
+			      "Attempting to detect a %s audio device",
+			      plugin->name);
+		if (ao_plugin_test_default_device(plugin))
+			return plugin;
+	}
+
+	error.Set(output_domain, "Unable to detect an audio device");
+	return nullptr;
+}
+
+/**
+ * Determines the mixer type which should be used for the specified
+ * configuration block.
+ *
+ * This handles the deprecated options mixer_type (global) and
+ * mixer_enabled, if the mixer_type setting is not configured.
+ */
+gcc_pure
+static enum mixer_type
+audio_output_mixer_type(const config_param &param)
+{
+	/* read the local "mixer_type" setting */
+	const char *p = param.GetBlockValue("mixer_type");
+	if (p != nullptr)
+		return mixer_type_parse(p);
+
+	/* try the local "mixer_enabled" setting next (deprecated) */
+	if (!param.GetBlockValue("mixer_enabled", true))
+		return MIXER_TYPE_NONE;
+
+	/* fall back to the global "mixer_type" setting (also
+	   deprecated) */
+	return mixer_type_parse(config_get_string(CONF_MIXER_TYPE,
+						  "hardware"));
+}
+
+static Mixer *
+audio_output_load_mixer(struct audio_output *ao,
+			const config_param &param,
+			const struct mixer_plugin *plugin,
+			Filter &filter_chain,
+			Error &error)
+{
+	Mixer *mixer;
+
+	switch (audio_output_mixer_type(param)) {
+	case MIXER_TYPE_NONE:
+	case MIXER_TYPE_UNKNOWN:
+		return nullptr;
+
+	case MIXER_TYPE_HARDWARE:
+		if (plugin == nullptr)
+			return nullptr;
+
+		return mixer_new(plugin, ao, param, error);
+
+	case MIXER_TYPE_SOFTWARE:
+		mixer = mixer_new(&software_mixer_plugin, nullptr,
+				  config_param(),
+				  IgnoreError());
+		assert(mixer != nullptr);
+
+		filter_chain_append(filter_chain, "software_mixer",
+				    software_mixer_get_filter(mixer));
+		return mixer;
+	}
+
+	assert(false);
+	gcc_unreachable();
+}
+
+bool
+ao_base_init(struct audio_output *ao,
+	     const struct audio_output_plugin *plugin,
+	     const config_param &param, Error &error)
+{
+	assert(ao != nullptr);
+	assert(plugin != nullptr);
+	assert(plugin->finish != nullptr);
+	assert(plugin->open != nullptr);
+	assert(plugin->close != nullptr);
+	assert(plugin->play != nullptr);
+
+	if (!param.IsNull()) {
+		ao->name = param.GetBlockValue(AUDIO_OUTPUT_NAME);
+		if (ao->name == nullptr) {
+			error.Set(config_domain,
+				  "Missing \"name\" configuration");
+			return false;
+		}
+
+		const char *p = param.GetBlockValue(AUDIO_OUTPUT_FORMAT);
+		if (p != nullptr) {
+			bool success =
+				audio_format_parse(ao->config_audio_format,
+						   p, true, error);
+			if (!success)
+				return false;
+		} else
+			ao->config_audio_format.Clear();
+	} else {
+		ao->name = "default detected output";
+
+		ao->config_audio_format.Clear();
+	}
+
+	ao->plugin = plugin;
+	ao->tags = param.GetBlockValue("tags", true);
+	ao->always_on = param.GetBlockValue("always_on", false);
+	ao->enabled = param.GetBlockValue("enabled", true);
+	ao->really_enabled = false;
+	ao->open = false;
+	ao->pause = false;
+	ao->allow_play = true;
+	ao->in_playback_loop = false;
+	ao->woken_for_play = false;
+
+	/* set up the filter chain */
+
+	ao->filter = filter_chain_new();
+	assert(ao->filter != nullptr);
+
+	/* create the normalization filter (if configured) */
+
+	if (config_get_bool(CONF_VOLUME_NORMALIZATION, false)) {
+		Filter *normalize_filter =
+			filter_new(&normalize_filter_plugin, config_param(),
+				   IgnoreError());
+		assert(normalize_filter != nullptr);
+
+		filter_chain_append(*ao->filter, "normalize",
+				    autoconvert_filter_new(normalize_filter));
+	}
+
+	Error filter_error;
+	filter_chain_parse(*ao->filter,
+			   param.GetBlockValue(AUDIO_FILTERS, ""),
+			   filter_error);
+
+	// It's not really fatal - Part of the filter chain has been set up already
+	// and even an empty one will work (if only with unexpected behaviour)
+	if (filter_error.IsDefined())
+		FormatError(filter_error,
+			    "Failed to initialize filter chain for '%s'",
+			    ao->name);
+
+	ao->command = AO_COMMAND_NONE;
+
+	ao->mixer = nullptr;
+	ao->replay_gain_filter = nullptr;
+	ao->other_replay_gain_filter = nullptr;
+
+	/* done */
+
+	return true;
+}
+
+static bool
+audio_output_setup(struct audio_output *ao, const config_param &param,
+		   Error &error)
+{
+
+	/* create the replay_gain filter */
+
+	const char *replay_gain_handler =
+		param.GetBlockValue("replay_gain_handler", "software");
+
+	if (strcmp(replay_gain_handler, "none") != 0) {
+		ao->replay_gain_filter = filter_new(&replay_gain_filter_plugin,
+						    param, IgnoreError());
+		assert(ao->replay_gain_filter != nullptr);
+
+		ao->replay_gain_serial = 0;
+
+		ao->other_replay_gain_filter = filter_new(&replay_gain_filter_plugin,
+							  param,
+							  IgnoreError());
+		assert(ao->other_replay_gain_filter != nullptr);
+
+		ao->other_replay_gain_serial = 0;
+	} else {
+		ao->replay_gain_filter = nullptr;
+		ao->other_replay_gain_filter = nullptr;
+	}
+
+	/* set up the mixer */
+
+	Error mixer_error;
+	ao->mixer = audio_output_load_mixer(ao, param,
+					    ao->plugin->mixer_plugin,
+					    *ao->filter, mixer_error);
+	if (ao->mixer == nullptr && mixer_error.IsDefined())
+		FormatError(mixer_error,
+			    "Failed to initialize hardware mixer for '%s'",
+			    ao->name);
+
+	/* use the hardware mixer for replay gain? */
+
+	if (strcmp(replay_gain_handler, "mixer") == 0) {
+		if (ao->mixer != nullptr)
+			replay_gain_filter_set_mixer(ao->replay_gain_filter,
+						     ao->mixer, 100);
+		else
+			FormatError(output_domain,
+				    "No such mixer for output '%s'", ao->name);
+	} else if (strcmp(replay_gain_handler, "software") != 0 &&
+		   ao->replay_gain_filter != nullptr) {
+		error.Set(config_domain,
+			  "Invalid \"replay_gain_handler\" value");
+		return false;
+	}
+
+	/* the "convert" filter must be the last one in the chain */
+
+	ao->convert_filter = filter_new(&convert_filter_plugin, config_param(),
+					IgnoreError());
+	assert(ao->convert_filter != nullptr);
+
+	filter_chain_append(*ao->filter, "convert", ao->convert_filter);
+
+	return true;
+}
+
+struct audio_output *
+audio_output_new(const config_param &param,
+		 PlayerControl &pc,
+		 Error &error)
+{
+	const struct audio_output_plugin *plugin;
+
+	if (!param.IsNull()) {
+		const char *p;
+
+		p = param.GetBlockValue(AUDIO_OUTPUT_TYPE);
+		if (p == nullptr) {
+			error.Set(config_domain,
+				  "Missing \"type\" configuration");
+			return nullptr;
+		}
+
+		plugin = audio_output_plugin_get(p);
+		if (plugin == nullptr) {
+			error.Format(config_domain,
+				     "No such audio output plugin: %s", p);
+			return nullptr;
+		}
+	} else {
+		LogWarning(output_domain,
+			   "No 'audio_output' defined in config file");
+
+		plugin = audio_output_detect(error);
+		if (plugin == nullptr)
+			return nullptr;
+
+		FormatDefault(output_domain,
+			      "Successfully detected a %s audio device",
+			      plugin->name);
+	}
+
+	struct audio_output *ao = ao_plugin_init(plugin, param, error);
+	if (ao == nullptr)
+		return nullptr;
+
+	if (!audio_output_setup(ao, param, error)) {
+		ao_plugin_finish(ao);
+		return nullptr;
+	}
+
+	ao->player_control = &pc;
+	return ao;
+}
diff --git a/src/output/OutputInternal.hxx b/src/output/OutputInternal.hxx
new file mode 100644
index 000000000..18404dc01
--- /dev/null
+++ b/src/output/OutputInternal.hxx
@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPD_OUTPUT_INTERNAL_HXX
+#define MPD_OUTPUT_INTERNAL_HXX
+
+#include "AudioFormat.hxx"
+#include "pcm/PcmBuffer.hxx"
+#include "pcm/PcmDither.hxx"
+#include "thread/Mutex.hxx"
+#include "thread/Cond.hxx"
+#include "thread/Thread.hxx"
+#include "system/PeriodClock.hxx"
+
+class Error;
+class Filter;
+class MusicPipe;
+struct config_param;
+struct PlayerControl;
+
+enum audio_output_command {
+	AO_COMMAND_NONE = 0,
+	AO_COMMAND_ENABLE,
+	AO_COMMAND_DISABLE,
+	AO_COMMAND_OPEN,
+
+	/**
+	 * This command is invoked when the input audio format
+	 * changes.
+	 */
+	AO_COMMAND_REOPEN,
+
+	AO_COMMAND_CLOSE,
+	AO_COMMAND_PAUSE,
+
+	/**
+	 * Drains the internal (hardware) buffers of the device.  This
+	 * operation may take a while to complete.
+	 */
+	AO_COMMAND_DRAIN,
+
+	AO_COMMAND_CANCEL,
+	AO_COMMAND_KILL
+};
+
+struct audio_output {
+	/**
+	 * The device's configured display name.
+	 */
+	const char *name;
+
+	/**
+	 * The plugin which implements this output device.
+	 */
+	const struct audio_output_plugin *plugin;
+
+	/**
+	 * The #mixer object associated with this audio output device.
+	 * May be nullptr if none is available, or if software volume is
+	 * configured.
+	 */
+	class Mixer *mixer;
+
+	/**
+	 * Will this output receive tags from the decoder?  The
+	 * default is true, but it may be configured to false to
+	 * suppress sending tags to the output.
+	 */
+	bool tags;
+
+	/**
+	 * Shall this output always play something (i.e. silence),
+	 * even when playback is stopped?
+	 */
+	bool always_on;
+
+	/**
+	 * Has the user enabled this device?
+	 */
+	bool enabled;
+
+	/**
+	 * Is this device actually enabled, i.e. the "enable" method
+	 * has succeeded?
+	 */
+	bool really_enabled;
+
+	/**
+	 * Is the device (already) open and functional?
+	 *
+	 * This attribute may only be modified by the output thread.
+	 * It is protected with #mutex: write accesses inside the
+	 * output thread and read accesses outside of it may only be
+	 * performed while the lock is held.
+	 */
+	bool open;
+
+	/**
+	 * Is the device paused?  i.e. the output thread is in the
+	 * ao_pause() loop.
+	 */
+	bool pause;
+
+	/**
+	 * When this flag is set, the output thread will not do any
+	 * playback.  It will wait until the flag is cleared.
+	 *
+	 * This is used to synchronize the "clear" operation on the
+	 * shared music pipe during the CANCEL command.
+	 */
+	bool allow_play;
+
+	/**
+	 * True while the OutputThread is inside ao_play().  This
+	 * means the PlayerThread does not need to wake up the
+	 * OutputThread when new chunks are added to the MusicPipe,
+	 * because the OutputThread is already watching that.
+	 */
+	bool in_playback_loop;
+
+	/**
+	 * Has the OutputThread been woken up to play more chunks?
+	 * This is set by audio_output_play() and reset by ao_play()
+	 * to reduce the number of duplicate wakeups.
+	 */
+	bool woken_for_play;
+
+	/**
+	 * If not nullptr, the device has failed, and this timer is used
+	 * to estimate how long it should stay disabled (unless
+	 * explicitly reopened with "play").
+	 */
+	PeriodClock fail_timer;
+
+	/**
+	 * The configured audio format.
+	 */
+	AudioFormat config_audio_format;
+
+	/**
+	 * The audio_format in which audio data is received from the
+	 * player thread (which in turn receives it from the decoder).
+	 */
+	AudioFormat in_audio_format;
+
+	/**
+	 * The audio_format which is really sent to the device.  This
+	 * is basically config_audio_format (if configured) or
+	 * in_audio_format, but may have been modified by
+	 * plugin->open().
+	 */
+	AudioFormat out_audio_format;
+
+	/**
+	 * The buffer used to allocate the cross-fading result.
+	 */
+	PcmBuffer cross_fade_buffer;
+
+	/**
+	 * The dithering state for cross-fading two streams.
+	 */
+	PcmDither cross_fade_dither;
+
+	/**
+	 * The filter object of this audio output.  This is an
+	 * instance of chain_filter_plugin.
+	 */
+	Filter *filter;
+
+	/**
+	 * The replay_gain_filter_plugin instance of this audio
+	 * output.
+	 */
+	Filter *replay_gain_filter;
+
+	/**
+	 * The serial number of the last replay gain info.  0 means no
+	 * replay gain info was available.
+	 */
+	unsigned replay_gain_serial;
+
+	/**
+	 * The replay_gain_filter_plugin instance of this audio
+	 * output, to be applied to the second chunk during
+	 * cross-fading.
+	 */
+	Filter *other_replay_gain_filter;
+
+	/**
+	 * The serial number of the last replay gain info by the
+	 * "other" chunk during cross-fading.
+	 */
+	unsigned other_replay_gain_serial;
+
+	/**
+	 * The convert_filter_plugin instance of this audio output.
+	 * It is the last item in the filter chain, and is responsible
+	 * for converting the input data into the appropriate format
+	 * for this audio output.
+	 */
+	Filter *convert_filter;
+
+	/**
+	 * The thread handle, or nullptr if the output thread isn't
+	 * running.
+	 */
+	Thread thread;
+
+	/**
+	 * The next command to be performed by the output thread.
+	 */
+	enum audio_output_command command;
+
+	/**
+	 * The music pipe which provides music chunks to be played.
+	 */
+	const MusicPipe *pipe;
+
+	/**
+	 * This mutex protects #open, #fail_timer, #chunk and
+	 * #chunk_finished.
+	 */
+	Mutex mutex;
+
+	/**
+	 * This condition object wakes up the output thread after
+	 * #command has been set.
+	 */
+	Cond cond;
+
+	/**
+	 * The PlayerControl object which "owns" this output.  This
+	 * object is needed to signal command completion.
+	 */
+	PlayerControl *player_control;
+
+	/**
+	 * The #music_chunk which is currently being played.  All
+	 * chunks before this one may be returned to the
+	 * #music_buffer, because they are not going to be used by
+	 * this output anymore.
+	 */
+	const struct music_chunk *chunk;
+
+	/**
+	 * Has the output finished playing #chunk?
+	 */
+	bool chunk_finished;
+};
+
+/**
+ * Notify object used by the thread's client, i.e. we will send a
+ * notify signal to this object, expecting the caller to wait on it.
+ */
+extern struct notify audio_output_client_notify;
+
+static inline bool
+audio_output_is_open(const struct audio_output *ao)
+{
+	return ao->open;
+}
+
+static inline bool
+audio_output_command_is_finished(const struct audio_output *ao)
+{
+	return ao->command == AO_COMMAND_NONE;
+}
+
+struct audio_output *
+audio_output_new(const config_param &param,
+		 PlayerControl &pc,
+		 Error &error);
+
+bool
+ao_base_init(struct audio_output *ao,
+	     const struct audio_output_plugin *plugin,
+	     const config_param &param, Error &error);
+
+void
+ao_base_finish(struct audio_output *ao);
+
+void
+audio_output_free(struct audio_output *ao);
+
+#endif
diff --git a/src/output/OutputList.cxx b/src/output/OutputList.cxx
new file mode 100644
index 000000000..b914e6d2e
--- /dev/null
+++ b/src/output/OutputList.cxx
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+#include "OutputList.hxx"
+#include "OutputAPI.hxx"
+#include "plugins/AlsaOutputPlugin.hxx"
+#include "plugins/AoOutputPlugin.hxx"
+#include "plugins/FifoOutputPlugin.hxx"
+#include "plugins/HttpdOutputPlugin.hxx"
+#include "plugins/JackOutputPlugin.hxx"
+#include "plugins/NullOutputPlugin.hxx"
+#include "plugins/OpenALOutputPlugin.hxx"
+#include "plugins/OssOutputPlugin.hxx"
+#include "plugins/OSXOutputPlugin.hxx"
+#include "plugins/PipeOutputPlugin.hxx"
+#include "plugins/PulseOutputPlugin.hxx"
+#include "plugins/RecorderOutputPlugin.hxx"
+#include "plugins/RoarOutputPlugin.hxx"
+#include "plugins/ShoutOutputPlugin.hxx"
+#include "plugins/SolarisOutputPlugin.hxx"
+#include "plugins/WinmmOutputPlugin.hxx"
+
+#include <string.h>
+
+const struct audio_output_plugin *const audio_output_plugins[] = {
+#ifdef HAVE_SHOUT
+	&shout_output_plugin,
+#endif
+	&null_output_plugin,
+#ifdef HAVE_FIFO
+	&fifo_output_plugin,
+#endif
+#ifdef ENABLE_PIPE_OUTPUT
+	&pipe_output_plugin,
+#endif
+#ifdef HAVE_ALSA
+	&alsa_output_plugin,
+#endif
+#ifdef HAVE_ROAR
+	&roar_output_plugin,
+#endif
+#ifdef HAVE_AO
+	&ao_output_plugin,
+#endif
+#ifdef HAVE_OSS
+	&oss_output_plugin,
+#endif
+#ifdef HAVE_OPENAL
+	&openal_output_plugin,
+#endif
+#ifdef HAVE_OSX
+	&osx_output_plugin,
+#endif
+#ifdef ENABLE_SOLARIS_OUTPUT
+	&solaris_output_plugin,
+#endif
+#ifdef HAVE_PULSE
+	&pulse_output_plugin,
+#endif
+#ifdef HAVE_JACK
+	&jack_output_plugin,
+#endif
+#ifdef ENABLE_HTTPD_OUTPUT
+	&httpd_output_plugin,
+#endif
+#ifdef ENABLE_RECORDER_OUTPUT
+	&recorder_output_plugin,
+#endif
+#ifdef ENABLE_WINMM_OUTPUT
+	&winmm_output_plugin,
+#endif
+	nullptr
+};
+
+const struct audio_output_plugin *
+audio_output_plugin_get(const char *name)
+{
+	audio_output_plugins_for_each(plugin)
+		if (strcmp(plugin->name, name) == 0)
+			return plugin;
+
+	return nullptr;
+}
diff --git a/src/output/OutputList.hxx b/src/output/OutputList.hxx
new file mode 100644
index 000000000..dfcf7487c
--- /dev/null
+++ b/src/output/OutputList.hxx
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPD_OUTPUT_LIST_HXX
+#define MPD_OUTPUT_LIST_HXX
+
+extern const struct audio_output_plugin *const audio_output_plugins[];
+
+const struct audio_output_plugin *
+audio_output_plugin_get(const char *name);
+
+#define audio_output_plugins_for_each(plugin) \
+	for (const struct audio_output_plugin *plugin, \
+		*const*output_plugin_iterator = &audio_output_plugins[0]; \
+		(plugin = *output_plugin_iterator) != nullptr; ++output_plugin_iterator)
+
+#endif
diff --git a/src/output/OutputPlugin.cxx b/src/output/OutputPlugin.cxx
new file mode 100644
index 000000000..29fd6455a
--- /dev/null
+++ b/src/output/OutputPlugin.cxx
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+#include "OutputPlugin.hxx"
+#include "OutputInternal.hxx"
+
+struct audio_output *
+ao_plugin_init(const struct audio_output_plugin *plugin,
+	       const config_param &param,
+	       Error &error)
+{
+	assert(plugin != nullptr);
+	assert(plugin->init != nullptr);
+
+	return plugin->init(param, error);
+}
+
+void
+ao_plugin_finish(struct audio_output *ao)
+{
+	ao->plugin->finish(ao);
+}
+
+bool
+ao_plugin_enable(struct audio_output *ao, Error &error_r)
+{
+	return ao->plugin->enable != nullptr
+		? ao->plugin->enable(ao, error_r)
+		: true;
+}
+
+void
+ao_plugin_disable(struct audio_output *ao)
+{
+	if (ao->plugin->disable != nullptr)
+		ao->plugin->disable(ao);
+}
+
+bool
+ao_plugin_open(struct audio_output *ao, AudioFormat &audio_format,
+	       Error &error)
+{
+	return ao->plugin->open(ao, audio_format, error);
+}
+
+void
+ao_plugin_close(struct audio_output *ao)
+{
+	ao->plugin->close(ao);
+}
+
+unsigned
+ao_plugin_delay(struct audio_output *ao)
+{
+	return ao->plugin->delay != nullptr
+		? ao->plugin->delay(ao)
+		: 0;
+}
+
+void
+ao_plugin_send_tag(struct audio_output *ao, const Tag *tag)
+{
+	if (ao->plugin->send_tag != nullptr)
+		ao->plugin->send_tag(ao, tag);
+}
+
+size_t
+ao_plugin_play(struct audio_output *ao, const void *chunk, size_t size,
+	       Error &error)
+{
+	return ao->plugin->play(ao, chunk, size, error);
+}
+
+void
+ao_plugin_drain(struct audio_output *ao)
+{
+	if (ao->plugin->drain != nullptr)
+		ao->plugin->drain(ao);
+}
+
+void
+ao_plugin_cancel(struct audio_output *ao)
+{
+	if (ao->plugin->cancel != nullptr)
+		ao->plugin->cancel(ao);
+}
+
+bool
+ao_plugin_pause(struct audio_output *ao)
+{
+	return ao->plugin->pause != nullptr && ao->plugin->pause(ao);
+}
diff --git a/src/output/OutputPlugin.hxx b/src/output/OutputPlugin.hxx
new file mode 100644
index 000000000..7d77c92b2
--- /dev/null
+++ b/src/output/OutputPlugin.hxx
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPD_OUTPUT_PLUGIN_HXX
+#define MPD_OUTPUT_PLUGIN_HXX
+
+#include "Compiler.h"
+
+#include <stddef.h>
+
+struct config_param;
+struct AudioFormat;
+struct Tag;
+class Error;
+
+/**
+ * A plugin which controls an audio output device.
+ */
+struct audio_output_plugin {
+	/**
+	 * the plugin's name
+	 */
+	const char *name;
+
+	/**
+	 * Test if this plugin can provide a default output, in case
+	 * none has been configured.  This method is optional.
+	 */
+	bool (*test_default_device)(void);
+
+	/**
+	 * Configure and initialize the device, but do not open it
+	 * yet.
+	 *
+	 * @param param the configuration section, or nullptr if there is
+	 * no configuration
+	 * @return nullptr on error, or an opaque pointer to the plugin's
+	 * data
+	 */
+	struct audio_output *(*init)(const config_param &param,
+				     Error &error);
+
+	/**
+	 * Free resources allocated by this device.
+	 */
+	void (*finish)(struct audio_output *data);
+
+	/**
+	 * Enable the device.  This may allocate resources, preparing
+	 * for the device to be opened.  Enabling a device cannot
+	 * fail: if an error occurs during that, it should be reported
+	 * by the open() method.
+	 *
+	 * @return true on success, false on error
+	 */
+	bool (*enable)(struct audio_output *data, Error &error);
+
+	/**
+	 * Disables the device.  It is closed before this method is
+	 * called.
+	 */
+	void (*disable)(struct audio_output *data);
+
+	/**
+	 * Really open the device.
+	 *
+	 * @param audio_format the audio format in which data is going
+	 * to be delivered; may be modified by the plugin
+	 */
+	bool (*open)(struct audio_output *data, AudioFormat &audio_format,
+		     Error &error);
+
+	/**
+	 * Close the device.
+	 */
+	void (*close)(struct audio_output *data);
+
+	/**
+	 * Returns a positive number if the output thread shall delay
+	 * the next call to play() or pause().  This should be
+	 * implemented instead of doing a sleep inside the plugin,
+	 * because this allows MPD to listen to commands meanwhile.
+	 *
+	 * @return the number of milliseconds to wait
+	 */
+	unsigned (*delay)(struct audio_output *data);
+
+	/**
+	 * Display metadata for the next chunk.  Optional method,
+	 * because not all devices can display metadata.
+	 */
+	void (*send_tag)(struct audio_output *data, const Tag *tag);
+
+	/**
+	 * Play a chunk of audio data.
+	 *
+	 * @return the number of bytes played, or 0 on error
+	 */
+	size_t (*play)(struct audio_output *data,
+		       const void *chunk, size_t size,
+		       Error &error);
+
+	/**
+	 * Wait until the device has finished playing.
+	 */
+	void (*drain)(struct audio_output *data);
+
+	/**
+	 * Try to cancel data which may still be in the device's
+	 * buffers.
+	 */
+	void (*cancel)(struct audio_output *data);
+
+	/**
+	 * Pause the device.  If supported, it may perform a special
+	 * action, which keeps the device open, but does not play
+	 * anything.  Output plugins like "shout" might want to play
+	 * silence during pause, so their clients won't be
+	 * disconnected.  Plugins which do not support pausing will
+	 * simply be closed, and have to be reopened when unpaused.
+	 *
+	 * @return false on error (output will be closed then), true
+	 * for continue to pause
+	 */
+	bool (*pause)(struct audio_output *data);
+
+	/**
+	 * The mixer plugin associated with this output plugin.  This
+	 * may be nullptr if no mixer plugin is implemented.  When
+	 * created, this mixer plugin gets the same #config_param as
+	 * this audio output device.
+	 */
+	const struct mixer_plugin *mixer_plugin;
+};
+
+static inline bool
+ao_plugin_test_default_device(const struct audio_output_plugin *plugin)
+{
+	return plugin->test_default_device != nullptr
+		? plugin->test_default_device()
+		: false;
+}
+
+gcc_malloc
+struct audio_output *
+ao_plugin_init(const struct audio_output_plugin *plugin,
+	       const config_param &param,
+	       Error &error);
+
+void
+ao_plugin_finish(struct audio_output *ao);
+
+bool
+ao_plugin_enable(struct audio_output *ao, Error &error);
+
+void
+ao_plugin_disable(struct audio_output *ao);
+
+bool
+ao_plugin_open(struct audio_output *ao, AudioFormat &audio_format,
+	       Error &error);
+
+void
+ao_plugin_close(struct audio_output *ao);
+
+gcc_pure
+unsigned
+ao_plugin_delay(struct audio_output *ao);
+
+void
+ao_plugin_send_tag(struct audio_output *ao, const Tag *tag);
+
+size_t
+ao_plugin_play(struct audio_output *ao, const void *chunk, size_t size,
+	       Error &error);
+
+void
+ao_plugin_drain(struct audio_output *ao);
+
+void
+ao_plugin_cancel(struct audio_output *ao);
+
+bool
+ao_plugin_pause(struct audio_output *ao);
+
+#endif
diff --git a/src/output/OutputPrint.cxx b/src/output/OutputPrint.cxx
new file mode 100644
index 000000000..66826f140
--- /dev/null
+++ b/src/output/OutputPrint.cxx
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/*
+ * Protocol specific code for the audio output library.
+ *
+ */
+
+#include "config.h"
+#include "OutputPrint.hxx"
+#include "OutputAll.hxx"
+#include "OutputInternal.hxx"
+#include "client/Client.hxx"
+
+void
+printAudioDevices(Client &client)
+{
+	const unsigned n = audio_output_count();
+
+	for (unsigned i = 0; i < n; ++i) {
+		const struct audio_output *ao = audio_output_get(i);
+
+		client_printf(client,
+			      "outputid: %i\n"
+			      "outputname: %s\n"
+			      "outputenabled: %i\n",
+			      i, ao->name, ao->enabled);
+	}
+}
diff --git a/src/output/OutputPrint.hxx b/src/output/OutputPrint.hxx
new file mode 100644
index 000000000..2d94226fd
--- /dev/null
+++ b/src/output/OutputPrint.hxx
@@ -0,0 +1,34 @@
+
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/*
+ * Protocol specific code for the audio output library.
+ *
+ */
+
+#ifndef MPD_OUTPUT_PRINT_HXX
+#define MPD_OUTPUT_PRINT_HXX
+
+class Client;
+
+void
+printAudioDevices(Client &client);
+
+#endif
diff --git a/src/output/OutputState.cxx b/src/output/OutputState.cxx
new file mode 100644
index 000000000..1141abeda
--- /dev/null
+++ b/src/output/OutputState.cxx
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/*
+ * Saving and loading the audio output states to/from the state file.
+ *
+ */
+
+#include "config.h"
+#include "OutputState.hxx"
+#include "OutputAll.hxx"
+#include "OutputInternal.hxx"
+#include "OutputError.hxx"
+#include "Log.hxx"
+#include "util/StringUtil.hxx"
+
+#include <assert.h>
+#include <stdlib.h>
+
+#define AUDIO_DEVICE_STATE "audio_device_state:"
+
+unsigned audio_output_state_version;
+
+void
+audio_output_state_save(FILE *fp)
+{
+	unsigned n = audio_output_count();
+
+	assert(n > 0);
+
+	for (unsigned i = 0; i < n; ++i) {
+		const struct audio_output *ao = audio_output_get(i);
+
+		fprintf(fp, AUDIO_DEVICE_STATE "%d:%s\n",
+			ao->enabled, ao->name);
+	}
+}
+
+bool
+audio_output_state_read(const char *line)
+{
+	long value;
+	char *endptr;
+	const char *name;
+	struct audio_output *ao;
+
+	if (!StringStartsWith(line, AUDIO_DEVICE_STATE))
+		return false;
+
+	line += sizeof(AUDIO_DEVICE_STATE) - 1;
+
+	value = strtol(line, &endptr, 10);
+	if (*endptr != ':' || (value != 0 && value != 1))
+		return false;
+
+	if (value != 0)
+		/* state is "enabled": no-op */
+		return true;
+
+	name = endptr + 1;
+	ao = audio_output_find(name);
+	if (ao == NULL) {
+		FormatDebug(output_domain,
+			    "Ignoring device state for '%s'", name);
+		return true;
+	}
+
+	ao->enabled = false;
+	return true;
+}
+
+unsigned
+audio_output_state_get_version(void)
+{
+	return audio_output_state_version;
+}
diff --git a/src/output/OutputState.hxx b/src/output/OutputState.hxx
new file mode 100644
index 000000000..a68180ae4
--- /dev/null
+++ b/src/output/OutputState.hxx
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/*
+ * Saving and loading the audio output states to/from the state file.
+ *
+ */
+
+#ifndef MPD_OUTPUT_STATE_HXX
+#define MPD_OUTPUT_STATE_HXX
+
+#include <stdio.h>
+
+bool
+audio_output_state_read(const char *line);
+
+void
+audio_output_state_save(FILE *fp);
+
+/**
+ * Generates a version number for the current state of the audio
+ * outputs.  This is used by timer_save_state_file() to determine
+ * whether the state has changed and the state file should be saved.
+ */
+unsigned
+audio_output_state_get_version(void);
+
+#endif
diff --git a/src/output/OutputThread.cxx b/src/output/OutputThread.cxx
new file mode 100644
index 000000000..52dfc63ef
--- /dev/null
+++ b/src/output/OutputThread.cxx
@@ -0,0 +1,690 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+#include "OutputThread.hxx"
+#include "OutputInternal.hxx"
+#include "OutputAPI.hxx"
+#include "OutputError.hxx"
+#include "pcm/PcmMix.hxx"
+#include "notify.hxx"
+#include "filter/FilterInternal.hxx"
+#include "filter/plugins/ConvertFilterPlugin.hxx"
+#include "filter/plugins/ReplayGainFilterPlugin.hxx"
+#include "PlayerControl.hxx"
+#include "MusicPipe.hxx"
+#include "MusicChunk.hxx"
+#include "thread/Util.hxx"
+#include "thread/Name.hxx"
+#include "system/FatalError.hxx"
+#include "util/Error.hxx"
+#include "Log.hxx"
+#include "Compiler.h"
+
+#include <assert.h>
+#include <string.h>
+
+static void ao_command_finished(struct audio_output *ao)
+{
+	assert(ao->command != AO_COMMAND_NONE);
+	ao->command = AO_COMMAND_NONE;
+
+	ao->mutex.unlock();
+	audio_output_client_notify.Signal();
+	ao->mutex.lock();
+}
+
+static bool
+ao_enable(struct audio_output *ao)
+{
+	Error error;
+	bool success;
+
+	if (ao->really_enabled)
+		return true;
+
+	ao->mutex.unlock();
+	success = ao_plugin_enable(ao, error);
+	ao->mutex.lock();
+	if (!success) {
+		FormatError(error,
+			    "Failed to enable \"%s\" [%s]",
+			    ao->name, ao->plugin->name);
+		return false;
+	}
+
+	ao->really_enabled = true;
+	return true;
+}
+
+static void
+ao_close(struct audio_output *ao, bool drain);
+
+static void
+ao_disable(struct audio_output *ao)
+{
+	if (ao->open)
+		ao_close(ao, false);
+
+	if (ao->really_enabled) {
+		ao->really_enabled = false;
+
+		ao->mutex.unlock();
+		ao_plugin_disable(ao);
+		ao->mutex.lock();
+	}
+}
+
+static AudioFormat
+ao_filter_open(struct audio_output *ao, AudioFormat &format,
+	       Error &error_r)
+{
+	assert(format.IsValid());
+
+	/* the replay_gain filter cannot fail here */
+	if (ao->replay_gain_filter != nullptr &&
+	    !ao->replay_gain_filter->Open(format, error_r).IsDefined())
+		return AudioFormat::Undefined();
+
+	if (ao->other_replay_gain_filter != nullptr &&
+	    !ao->other_replay_gain_filter->Open(format, error_r).IsDefined()) {
+		if (ao->replay_gain_filter != nullptr)
+			ao->replay_gain_filter->Close();
+		return AudioFormat::Undefined();
+	}
+
+	const AudioFormat af = ao->filter->Open(format, error_r);
+	if (!af.IsDefined()) {
+		if (ao->replay_gain_filter != nullptr)
+			ao->replay_gain_filter->Close();
+		if (ao->other_replay_gain_filter != nullptr)
+			ao->other_replay_gain_filter->Close();
+	}
+
+	return af;
+}
+
+static void
+ao_filter_close(struct audio_output *ao)
+{
+	if (ao->replay_gain_filter != nullptr)
+		ao->replay_gain_filter->Close();
+	if (ao->other_replay_gain_filter != nullptr)
+		ao->other_replay_gain_filter->Close();
+
+	ao->filter->Close();
+}
+
+static void
+ao_open(struct audio_output *ao)
+{
+	bool success;
+	Error error;
+	struct audio_format_string af_string;
+
+	assert(!ao->open);
+	assert(ao->pipe != nullptr);
+	assert(ao->chunk == nullptr);
+	assert(ao->in_audio_format.IsValid());
+
+	ao->fail_timer.Reset();
+
+	/* enable the device (just in case the last enable has failed) */
+
+	if (!ao_enable(ao))
+		/* still no luck */
+		return;
+
+	/* open the filter */
+
+	const AudioFormat filter_audio_format =
+		ao_filter_open(ao, ao->in_audio_format, error);
+	if (!filter_audio_format.IsDefined()) {
+		FormatError(error, "Failed to open filter for \"%s\" [%s]",
+			    ao->name, ao->plugin->name);
+
+		ao->fail_timer.Update();
+		return;
+	}
+
+	assert(filter_audio_format.IsValid());
+
+	ao->out_audio_format = filter_audio_format;
+	ao->out_audio_format.ApplyMask(ao->config_audio_format);
+
+	ao->mutex.unlock();
+	success = ao_plugin_open(ao, ao->out_audio_format, error);
+	ao->mutex.lock();
+
+	assert(!ao->open);
+
+	if (!success) {
+		FormatError(error, "Failed to open \"%s\" [%s]",
+			    ao->name, ao->plugin->name);
+
+		ao_filter_close(ao);
+		ao->fail_timer.Update();
+		return;
+	}
+
+	if (!convert_filter_set(ao->convert_filter, ao->out_audio_format,
+				error)) {
+		FormatError(error, "Failed to convert for \"%s\" [%s]",
+			    ao->name, ao->plugin->name);
+
+		ao_filter_close(ao);
+		ao->fail_timer.Update();
+		return;
+	}
+
+	ao->open = true;
+
+	FormatDebug(output_domain,
+		    "opened plugin=%s name=\"%s\" audio_format=%s",
+		    ao->plugin->name, ao->name,
+		    audio_format_to_string(ao->out_audio_format, &af_string));
+
+	if (ao->in_audio_format != ao->out_audio_format)
+		FormatDebug(output_domain, "converting from %s",
+			    audio_format_to_string(ao->in_audio_format,
+						   &af_string));
+}
+
+static void
+ao_close(struct audio_output *ao, bool drain)
+{
+	assert(ao->open);
+
+	ao->pipe = nullptr;
+
+	ao->chunk = nullptr;
+	ao->open = false;
+
+	ao->mutex.unlock();
+
+	if (drain)
+		ao_plugin_drain(ao);
+	else
+		ao_plugin_cancel(ao);
+
+	ao_plugin_close(ao);
+	ao_filter_close(ao);
+
+	ao->mutex.lock();
+
+	FormatDebug(output_domain, "closed plugin=%s name=\"%s\"",
+		    ao->plugin->name, ao->name);
+}
+
+static void
+ao_reopen_filter(struct audio_output *ao)
+{
+	Error error;
+
+	ao_filter_close(ao);
+	const AudioFormat filter_audio_format =
+		ao_filter_open(ao, ao->in_audio_format, error);
+	if (!filter_audio_format.IsDefined() ||
+	    !convert_filter_set(ao->convert_filter, ao->out_audio_format,
+				error)) {
+		FormatError(error,
+			    "Failed to open filter for \"%s\" [%s]",
+			    ao->name, ao->plugin->name);
+
+		/* this is a little code duplication fro ao_close(),
+		   but we cannot call this function because we must
+		   not call filter_close(ao->filter) again */
+
+		ao->pipe = nullptr;
+
+		ao->chunk = nullptr;
+		ao->open = false;
+		ao->fail_timer.Update();
+
+		ao->mutex.unlock();
+		ao_plugin_close(ao);
+		ao->mutex.lock();
+
+		return;
+	}
+}
+
+static void
+ao_reopen(struct audio_output *ao)
+{
+	if (!ao->config_audio_format.IsFullyDefined()) {
+		if (ao->open) {
+			const MusicPipe *mp = ao->pipe;
+			ao_close(ao, true);
+			ao->pipe = mp;
+		}
+
+		/* no audio format is configured: copy in->out, let
+		   the output's open() method determine the effective
+		   out_audio_format */
+		ao->out_audio_format = ao->in_audio_format;
+		ao->out_audio_format.ApplyMask(ao->config_audio_format);
+	}
+
+	if (ao->open)
+		/* the audio format has changed, and all filters have
+		   to be reconfigured */
+		ao_reopen_filter(ao);
+	else
+		ao_open(ao);
+}
+
+/**
+ * Wait until the output's delay reaches zero.
+ *
+ * @return true if playback should be continued, false if a command
+ * was issued
+ */
+static bool
+ao_wait(struct audio_output *ao)
+{
+	while (true) {
+		unsigned delay = ao_plugin_delay(ao);
+		if (delay == 0)
+			return true;
+
+		(void)ao->cond.timed_wait(ao->mutex, delay);
+
+		if (ao->command != AO_COMMAND_NONE)
+			return false;
+	}
+}
+
+static const void *
+ao_chunk_data(struct audio_output *ao, const struct music_chunk *chunk,
+	      Filter *replay_gain_filter,
+	      unsigned *replay_gain_serial_p,
+	      size_t *length_r)
+{
+	assert(chunk != nullptr);
+	assert(!chunk->IsEmpty());
+	assert(chunk->CheckFormat(ao->in_audio_format));
+
+	const void *data = chunk->data;
+	size_t length = chunk->length;
+
+	(void)ao;
+
+	assert(length % ao->in_audio_format.GetFrameSize() == 0);
+
+	if (length > 0 && replay_gain_filter != nullptr) {
+		if (chunk->replay_gain_serial != *replay_gain_serial_p) {
+			replay_gain_filter_set_info(replay_gain_filter,
+						    chunk->replay_gain_serial != 0
+						    ? &chunk->replay_gain_info
+						    : nullptr);
+			*replay_gain_serial_p = chunk->replay_gain_serial;
+		}
+
+		Error error;
+		data = replay_gain_filter->FilterPCM(data, length,
+						     &length, error);
+		if (data == nullptr) {
+			FormatError(error, "\"%s\" [%s] failed to filter",
+				    ao->name, ao->plugin->name);
+			return nullptr;
+		}
+	}
+
+	*length_r = length;
+	return data;
+}
+
+static const void *
+ao_filter_chunk(struct audio_output *ao, const struct music_chunk *chunk,
+		size_t *length_r)
+{
+	size_t length;
+	const void *data = ao_chunk_data(ao, chunk, ao->replay_gain_filter,
+					 &ao->replay_gain_serial, &length);
+	if (data == nullptr)
+		return nullptr;
+
+	if (length == 0) {
+		/* empty chunk, nothing to do */
+		*length_r = 0;
+		return data;
+	}
+
+	/* cross-fade */
+
+	if (chunk->other != nullptr) {
+		size_t other_length;
+		const void *other_data =
+			ao_chunk_data(ao, chunk->other,
+				      ao->other_replay_gain_filter,
+				      &ao->other_replay_gain_serial,
+				      &other_length);
+		if (other_data == nullptr)
+			return nullptr;
+
+		if (other_length == 0) {
+			*length_r = 0;
+			return data;
+		}
+
+		/* if the "other" chunk is longer, then that trailer
+		   is used as-is, without mixing; it is part of the
+		   "next" song being faded in, and if there's a rest,
+		   it means cross-fading ends here */
+
+		if (length > other_length)
+			length = other_length;
+
+		void *dest = ao->cross_fade_buffer.Get(other_length);
+		memcpy(dest, other_data, other_length);
+		if (!pcm_mix(ao->cross_fade_dither, dest, data, length,
+			     ao->in_audio_format.format,
+			     1.0 - chunk->mix_ratio)) {
+			FormatError(output_domain,
+				    "Cannot cross-fade format %s",
+				    sample_format_to_string(ao->in_audio_format.format));
+			return nullptr;
+		}
+
+		data = dest;
+		length = other_length;
+	}
+
+	/* apply filter chain */
+
+	Error error;
+	data = ao->filter->FilterPCM(data, length, &length, error);
+	if (data == nullptr) {
+		FormatError(error, "\"%s\" [%s] failed to filter",
+			    ao->name, ao->plugin->name);
+		return nullptr;
+	}
+
+	*length_r = length;
+	return data;
+}
+
+static bool
+ao_play_chunk(struct audio_output *ao, const struct music_chunk *chunk)
+{
+	assert(ao != nullptr);
+	assert(ao->filter != nullptr);
+
+	if (ao->tags && gcc_unlikely(chunk->tag != nullptr)) {
+		ao->mutex.unlock();
+		ao_plugin_send_tag(ao, chunk->tag);
+		ao->mutex.lock();
+	}
+
+	size_t size;
+#if GCC_CHECK_VERSION(4,7)
+	/* workaround -Wmaybe-uninitialized false positive */
+	size = 0;
+#endif
+	const char *data = (const char *)ao_filter_chunk(ao, chunk, &size);
+	if (data == nullptr) {
+		ao_close(ao, false);
+
+		/* don't automatically reopen this device for 10
+		   seconds */
+		ao->fail_timer.Update();
+		return false;
+	}
+
+	Error error;
+
+	while (size > 0 && ao->command == AO_COMMAND_NONE) {
+		size_t nbytes;
+
+		if (!ao_wait(ao))
+			break;
+
+		ao->mutex.unlock();
+		nbytes = ao_plugin_play(ao, data, size, error);
+		ao->mutex.lock();
+		if (nbytes == 0) {
+			/* play()==0 means failure */
+			FormatError(error, "\"%s\" [%s] failed to play",
+				    ao->name, ao->plugin->name);
+
+			ao_close(ao, false);
+
+			/* don't automatically reopen this device for
+			   10 seconds */
+			assert(!ao->fail_timer.IsDefined());
+			ao->fail_timer.Update();
+
+			return false;
+		}
+
+		assert(nbytes <= size);
+		assert(nbytes % ao->out_audio_format.GetFrameSize() == 0);
+
+		data += nbytes;
+		size -= nbytes;
+	}
+
+	return true;
+}
+
+static const struct music_chunk *
+ao_next_chunk(struct audio_output *ao)
+{
+	return ao->chunk != nullptr
+		/* continue the previous play() call */
+		? ao->chunk->next
+		/* get the first chunk from the pipe */
+		: ao->pipe->Peek();
+}
+
+/**
+ * Plays all remaining chunks, until the tail of the pipe has been
+ * reached (and no more chunks are queued), or until a command is
+ * received.
+ *
+ * @return true if at least one chunk has been available, false if the
+ * tail of the pipe was already reached
+ */
+static bool
+ao_play(struct audio_output *ao)
+{
+	bool success;
+	const struct music_chunk *chunk;
+
+	assert(ao->pipe != nullptr);
+
+	chunk = ao_next_chunk(ao);
+	if (chunk == nullptr)
+		/* no chunk available */
+		return false;
+
+	ao->chunk_finished = false;
+
+	assert(!ao->in_playback_loop);
+	ao->in_playback_loop = true;
+
+	while (chunk != nullptr && ao->command == AO_COMMAND_NONE) {
+		assert(!ao->chunk_finished);
+
+		ao->chunk = chunk;
+
+		success = ao_play_chunk(ao, chunk);
+		if (!success) {
+			assert(ao->chunk == nullptr);
+			break;
+		}
+
+		assert(ao->chunk == chunk);
+		chunk = chunk->next;
+	}
+
+	assert(ao->in_playback_loop);
+	ao->in_playback_loop = false;
+
+	ao->chunk_finished = true;
+
+	ao->mutex.unlock();
+	ao->player_control->LockSignal();
+	ao->mutex.lock();
+
+	return true;
+}
+
+static void ao_pause(struct audio_output *ao)
+{
+	bool ret;
+
+	ao->mutex.unlock();
+	ao_plugin_cancel(ao);
+	ao->mutex.lock();
+
+	ao->pause = true;
+	ao_command_finished(ao);
+
+	do {
+		if (!ao_wait(ao))
+			break;
+
+		ao->mutex.unlock();
+		ret = ao_plugin_pause(ao);
+		ao->mutex.lock();
+
+		if (!ret) {
+			ao_close(ao, false);
+			break;
+		}
+	} while (ao->command == AO_COMMAND_NONE);
+
+	ao->pause = false;
+}
+
+static void
+audio_output_task(void *arg)
+{
+	struct audio_output *ao = (struct audio_output *)arg;
+
+	FormatThreadName("output:%s", ao->name);
+
+	SetThreadRealtime();
+
+	ao->mutex.lock();
+
+	while (1) {
+		switch (ao->command) {
+		case AO_COMMAND_NONE:
+			break;
+
+		case AO_COMMAND_ENABLE:
+			ao_enable(ao);
+			ao_command_finished(ao);
+			break;
+
+		case AO_COMMAND_DISABLE:
+			ao_disable(ao);
+			ao_command_finished(ao);
+			break;
+
+		case AO_COMMAND_OPEN:
+			ao_open(ao);
+			ao_command_finished(ao);
+			break;
+
+		case AO_COMMAND_REOPEN:
+			ao_reopen(ao);
+			ao_command_finished(ao);
+			break;
+
+		case AO_COMMAND_CLOSE:
+			assert(ao->open);
+			assert(ao->pipe != nullptr);
+
+			ao_close(ao, false);
+			ao_command_finished(ao);
+			break;
+
+		case AO_COMMAND_PAUSE:
+			if (!ao->open) {
+				/* the output has failed after
+				   audio_output_all_pause() has
+				   submitted the PAUSE command; bail
+				   out */
+				ao_command_finished(ao);
+				break;
+			}
+
+			ao_pause(ao);
+			/* don't "break" here: this might cause
+			   ao_play() to be called when command==CLOSE
+			   ends the paused state - "continue" checks
+			   the new command first */
+			continue;
+
+		case AO_COMMAND_DRAIN:
+			if (ao->open) {
+				assert(ao->chunk == nullptr);
+				assert(ao->pipe->Peek() == nullptr);
+
+				ao->mutex.unlock();
+				ao_plugin_drain(ao);
+				ao->mutex.lock();
+			}
+
+			ao_command_finished(ao);
+			continue;
+
+		case AO_COMMAND_CANCEL:
+			ao->chunk = nullptr;
+
+			if (ao->open) {
+				ao->mutex.unlock();
+				ao_plugin_cancel(ao);
+				ao->mutex.lock();
+			}
+
+			ao_command_finished(ao);
+			continue;
+
+		case AO_COMMAND_KILL:
+			ao->chunk = nullptr;
+			ao_command_finished(ao);
+			ao->mutex.unlock();
+			return;
+		}
+
+		if (ao->open && ao->allow_play && ao_play(ao))
+			/* don't wait for an event if there are more
+			   chunks in the pipe */
+			continue;
+
+		if (ao->command == AO_COMMAND_NONE) {
+			ao->woken_for_play = false;
+			ao->cond.wait(ao->mutex);
+		}
+	}
+}
+
+void audio_output_thread_start(struct audio_output *ao)
+{
+	assert(ao->command == AO_COMMAND_NONE);
+
+	Error error;
+	if (!ao->thread.Start(audio_output_task, ao, error))
+		FatalError(error);
+}
diff --git a/src/output/OutputThread.hxx b/src/output/OutputThread.hxx
new file mode 100644
index 000000000..1cdbd65f2
--- /dev/null
+++ b/src/output/OutputThread.hxx
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPD_OUTPUT_THREAD_HXX
+#define MPD_OUTPUT_THREAD_HXX
+
+struct audio_output;
+
+void
+audio_output_thread_start(audio_output *ao);
+
+#endif
diff --git a/src/output/AlsaOutputPlugin.cxx b/src/output/plugins/AlsaOutputPlugin.cxx
index 4877d3a46..f2d6916a5 100644
--- a/src/output/AlsaOutputPlugin.cxx
+++ b/src/output/plugins/AlsaOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,15 +19,14 @@
 
 #include "config.h"
 #include "AlsaOutputPlugin.hxx"
-#include "OutputAPI.hxx"
-#include "MixerList.hxx"
+#include "../OutputAPI.hxx"
+#include "mixer/MixerList.hxx"
 #include "pcm/PcmExport.hxx"
 #include "util/Manual.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
 #include "Log.hxx"
 
-#include <glib.h>
 #include <alsa/asoundlib.h>
 
 #include <string>
@@ -118,7 +117,7 @@ struct AlsaOutput {
 	 * It contains silence samples, enough to fill one period (see
 	 * #period_frames).
 	 */
-	void *silence;
+	uint8_t *silence;
 
 	AlsaOutput():mode(0), writei(snd_pcm_writei) {
 	}
@@ -593,8 +592,8 @@ configure_hw:
 	ad->period_frames = alsa_period_size;
 	ad->period_position = 0;
 
-	ad->silence = g_malloc(snd_pcm_frames_to_bytes(ad->pcm,
-						       alsa_period_size));
+	ad->silence = new uint8_t[snd_pcm_frames_to_bytes(ad->pcm,
+							  alsa_period_size)];
 	snd_pcm_format_set_silence(format, ad->silence,
 				   alsa_period_size * channels);
 
@@ -641,7 +640,7 @@ alsa_setup_dsd(AlsaOutput *ad, const AudioFormat audio_format,
 		error.Format(alsa_output_domain,
 			     "Failed to configure DSD-over-USB on ALSA device \"%s\"",
 			     alsa_device(ad));
-		g_free(ad->silence);
+		delete[] ad->silence;
 		return false;
 	}
 
@@ -811,7 +810,7 @@ alsa_close(struct audio_output *ao)
 	AlsaOutput *ad = (AlsaOutput *)ao;
 
 	snd_pcm_close(ad->pcm);
-	g_free(ad->silence);
+	delete[] ad->silence;
 }
 
 static size_t
diff --git a/src/output/AlsaOutputPlugin.hxx b/src/output/plugins/AlsaOutputPlugin.hxx
index dc7e639a8..63508e041 100644
--- a/src/output/AlsaOutputPlugin.hxx
+++ b/src/output/plugins/AlsaOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/AoOutputPlugin.cxx b/src/output/plugins/AoOutputPlugin.cxx
index e66969e20..efc1e0c6e 100644
--- a/src/output/AoOutputPlugin.cxx
+++ b/src/output/plugins/AoOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,7 +19,7 @@
 
 #include "config.h"
 #include "AoOutputPlugin.hxx"
-#include "OutputAPI.hxx"
+#include "../OutputAPI.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
 #include "Log.hxx"
diff --git a/src/output/AoOutputPlugin.hxx b/src/output/plugins/AoOutputPlugin.hxx
index a44885e56..cbf2fd589 100644
--- a/src/output/AoOutputPlugin.hxx
+++ b/src/output/plugins/AoOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/FifoOutputPlugin.cxx b/src/output/plugins/FifoOutputPlugin.cxx
index aeb9a6a87..6e3a4d332 100644
--- a/src/output/FifoOutputPlugin.cxx
+++ b/src/output/plugins/FifoOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,10 +19,9 @@
 
 #include "config.h"
 #include "FifoOutputPlugin.hxx"
-#include "ConfigError.hxx"
-#include "OutputAPI.hxx"
+#include "config/ConfigError.hxx"
+#include "../OutputAPI.hxx"
 #include "Timer.hxx"
-#include "system/fd_util.h"
 #include "fs/AllocatedPath.hxx"
 #include "fs/FileSystem.hxx"
 #include "util/Error.hxx"
@@ -30,10 +29,8 @@
 #include "Log.hxx"
 #include "open.h"
 
-#include <sys/types.h>
 #include <sys/stat.h>
 #include <errno.h>
-#include <string.h>
 #include <unistd.h>
 
 #define FIFO_BUFFER_SIZE 65536 /* pipe capacity on Linux >= 2.6.11 */
diff --git a/src/output/FifoOutputPlugin.hxx b/src/output/plugins/FifoOutputPlugin.hxx
index dca2886d8..394ec3ae9 100644
--- a/src/output/FifoOutputPlugin.hxx
+++ b/src/output/plugins/FifoOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/HttpdClient.cxx b/src/output/plugins/HttpdClient.cxx
index 8e13fda38..d761bdf57 100644
--- a/src/output/HttpdClient.cxx
+++ b/src/output/plugins/HttpdClient.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -37,24 +37,26 @@ HttpdClient::~HttpdClient()
 		if (current_page != nullptr)
 			current_page->Unref();
 
-		for (auto page : pages)
-			page->Unref();
+		ClearQueue();
 	}
 
 	if (metadata)
 		metadata->Unref();
+
+	if (IsDefined())
+		BufferedSocket::Close();
 }
 
 void
 HttpdClient::Close()
 {
-	httpd->RemoveClient(*this);
+	httpd.RemoveClient(*this);
 }
 
 void
 HttpdClient::LockClose()
 {
-	const ScopeLock protect(httpd->mutex);
+	const ScopeLock protect(httpd.mutex);
 	Close();
 }
 
@@ -67,7 +69,7 @@ HttpdClient::BeginResponse()
 	current_page = nullptr;
 
 	if (!head_method)
-		httpd->SendHeader(*this);
+		httpd.SendHeader(*this);
 }
 
 /**
@@ -155,13 +157,13 @@ HttpdClient::SendResponse()
 			 "realTimeInfo.dlna.org: DLNA.ORG_TLAG=*\r\n"
 			 "contentFeatures.dlna.org: DLNA.ORG_OP=01;DLNA.ORG_CI=0\r\n"
 			 "\r\n",
-			 httpd->content_type);
+			 httpd.content_type);
 
 	} else if (metadata_requested) {
 		char *metadata_header =
-			icy_server_metadata_header(httpd->name, httpd->genre,
-						   httpd->website,
-						   httpd->content_type,
+			icy_server_metadata_header(httpd.name, httpd.genre,
+						   httpd.website,
+						   httpd.content_type,
 						   metaint);
 
 		g_strlcpy(buffer, metadata_header, sizeof(buffer));
@@ -176,7 +178,7 @@ HttpdClient::SendResponse()
 			 "Pragma: no-cache\r\n"
 			 "Cache-Control: no-cache, no-store\r\n"
 			 "\r\n",
-			 httpd->content_type);
+			 httpd.content_type);
 	}
 
 	ssize_t nbytes = SocketMonitor::Write(buffer, strlen(buffer));
@@ -192,11 +194,12 @@ HttpdClient::SendResponse()
 	return true;
 }
 
-HttpdClient::HttpdClient(HttpdOutput *_httpd, int _fd, EventLoop &_loop,
+HttpdClient::HttpdClient(HttpdOutput &_httpd, int _fd, EventLoop &_loop,
 			 bool _metadata_supported)
 	:BufferedSocket(_fd, _loop),
 	 httpd(_httpd),
 	 state(REQUEST),
+	 queue_size(0),
 	 head_method(false),
 	 dlna_streaming_requested(false),
 	 metadata_supported(_metadata_supported),
@@ -207,16 +210,24 @@ HttpdClient::HttpdClient(HttpdOutput *_httpd, int _fd, EventLoop &_loop,
 {
 }
 
-size_t
-HttpdClient::GetQueueSize() const
+void
+HttpdClient::ClearQueue()
 {
-	if (state != RESPONSE)
-		return 0;
+	assert(state == RESPONSE);
 
-	size_t size = 0;
-	for (auto page : pages)
-		size += page->size;
-	return size;
+	while (!pages.empty()) {
+		Page *page = pages.front();
+		pages.pop();
+
+#ifndef NDEBUG
+		assert(queue_size >= page->size);
+		queue_size -= page->size;
+#endif
+
+		page->Unref();
+	}
+
+	assert(queue_size == 0);
 }
 
 void
@@ -225,9 +236,7 @@ HttpdClient::CancelQueue()
 	if (state != RESPONSE)
 		return;
 
-	for (auto page : pages)
-		page->Unref();
-	pages.clear();
+	ClearQueue();
 
 	if (current_page == nullptr)
 		CancelWrite();
@@ -262,7 +271,7 @@ HttpdClient::GetBytesTillMetaData() const
 inline bool
 HttpdClient::TryWrite()
 {
-	const ScopeLock protect(httpd->mutex);
+	const ScopeLock protect(httpd.mutex);
 
 	assert(state == RESPONSE);
 
@@ -270,14 +279,17 @@ HttpdClient::TryWrite()
 		if (pages.empty()) {
 			/* another thread has removed the event source
 			   while this thread was waiting for
-			   httpd->mutex */
+			   httpd.mutex */
 			CancelWrite();
 			return true;
 		}
 
 		current_page = pages.front();
-		pages.pop_front();
+		pages.pop();
 		current_position = 0;
+
+		assert(queue_size >= current_page->size);
+		queue_size -= current_page->size;
 	}
 
 	const ssize_t bytes_to_write = GetBytesTillMetaData();
@@ -378,8 +390,15 @@ HttpdClient::PushPage(Page *page)
 		/* the client is still writing the HTTP request */
 		return;
 
+	if (queue_size > 256 * 1024) {
+		FormatDebug(httpd_output_domain,
+			    "client is too slow, flushing its queue");
+		ClearQueue();
+	}
+
 	page->Ref();
-	pages.push_back(page);
+	pages.push(page);
+	queue_size += page->size;
 
 	ScheduleWrite();
 }
diff --git a/src/output/HttpdClient.hxx b/src/output/plugins/HttpdClient.hxx
index 66a819232..f94f05769 100644
--- a/src/output/HttpdClient.hxx
+++ b/src/output/plugins/HttpdClient.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -23,18 +23,19 @@
 #include "event/BufferedSocket.hxx"
 #include "Compiler.h"
 
+#include <queue>
 #include <list>
 
 #include <stddef.h>
 
-struct HttpdOutput;
+class HttpdOutput;
 class Page;
 
-class HttpdClient final : public BufferedSocket {
+class HttpdClient final : BufferedSocket {
 	/**
 	 * The httpd output object this client is connected to.
 	 */
-	HttpdOutput *const httpd;
+	HttpdOutput &httpd;
 
 	/**
 	 * The current state of the client.
@@ -53,7 +54,12 @@ class HttpdClient final : public BufferedSocket {
 	/**
 	 * A queue of #Page objects to be sent to the client.
 	 */
-	std::list<Page *> pages;
+	std::queue<Page *, std::list<Page *>> pages;
+
+	/**
+	 * The sum of all page sizes in #pages.
+	 */
+	size_t queue_size;
 
 	/**
 	 * The #page which is currently being sent to the client.
@@ -120,7 +126,7 @@ public:
 	 * @param httpd the HTTP output device
 	 * @param fd the socket file descriptor
 	 */
-	HttpdClient(HttpdOutput *httpd, int _fd, EventLoop &_loop,
+	HttpdClient(HttpdOutput &httpd, int _fd, EventLoop &_loop,
 		    bool _metadata_supported);
 
 	/**
@@ -137,12 +143,6 @@ public:
 	void LockClose();
 
 	/**
-	 * Returns the total size of this client's page queue.
-	 */
-	gcc_pure
-	size_t GetQueueSize() const;
-
-	/**
 	 * Clears the page queue.
 	 */
 	void CancelQueue();
@@ -180,6 +180,9 @@ public:
 	 */
 	void PushMetaData(Page *page);
 
+private:
+	void ClearQueue();
+
 protected:
 	virtual bool OnSocketReady(unsigned flags) override;
 	virtual InputResult OnSocketInput(void *data, size_t length) override;
diff --git a/src/output/HttpdInternal.hxx b/src/output/plugins/HttpdInternal.hxx
index b76493a44..506730d11 100644
--- a/src/output/HttpdInternal.hxx
+++ b/src/output/plugins/HttpdInternal.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -25,10 +25,12 @@
 #ifndef MPD_OUTPUT_HTTPD_INTERNAL_H
 #define MPD_OUTPUT_HTTPD_INTERNAL_H
 
-#include "OutputInternal.hxx"
+#include "../OutputInternal.hxx"
 #include "Timer.hxx"
 #include "thread/Mutex.hxx"
 #include "event/ServerSocket.hxx"
+#include "event/DeferredMonitor.hxx"
+#include "util/Cast.hxx"
 
 #ifdef _LIBCPP_VERSION
 /* can't use incomplete template arguments with libc++ */
@@ -36,6 +38,8 @@
 #endif
 
 #include <forward_list>
+#include <queue>
+#include <list>
 
 struct config_param;
 class Error;
@@ -46,7 +50,7 @@ class Page;
 struct Encoder;
 struct Tag;
 
-struct HttpdOutput final : private ServerSocket {
+class HttpdOutput final : ServerSocket, DeferredMonitor {
 	struct audio_output base;
 
 	/**
@@ -68,6 +72,7 @@ struct HttpdOutput final : private ServerSocket {
 	 */
 	size_t unflushed_input;
 
+public:
 	/**
 	 * The MIME type produced by the #encoder.
 	 */
@@ -80,6 +85,13 @@ struct HttpdOutput final : private ServerSocket {
 	mutable Mutex mutex;
 
 	/**
+	 * This condition gets signalled when an item is removed from
+	 * #pages.
+	 */
+	Cond cond;
+
+private:
+	/**
 	 * A #Timer object to synchronize this output with the
 	 * wallclock.
 	 */
@@ -96,6 +108,15 @@ struct HttpdOutput final : private ServerSocket {
 	Page *metadata;
 
 	/**
+	 * The page queue, i.e. pages from the encoder to be
+	 * broadcasted to all clients.  This container is necessary to
+	 * pass pages from the OutputThread to the IOThread.  It is
+	 * protected by #mutex, and removing signals #cond.
+	 */
+	std::queue<Page *, std::list<Page *>> pages;
+
+ public:
+	/**
 	 * The configured name.
 	 */
 	char const *name;
@@ -108,6 +129,7 @@ struct HttpdOutput final : private ServerSocket {
 	 */
 	char const *website;
 
+private:
 	/**
 	 * A linked list containing all clients which are currently
 	 * connected.
@@ -126,11 +148,46 @@ struct HttpdOutput final : private ServerSocket {
 	 */
 	unsigned clients_max, clients_cnt;
 
+public:
 	HttpdOutput(EventLoop &_loop);
 	~HttpdOutput();
 
+#if GCC_CHECK_VERSION(4,6) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winvalid-offsetof"
+#endif
+
+	static constexpr HttpdOutput *Cast(audio_output *ao) {
+		return ContainerCast(ao, HttpdOutput, base);
+	}
+
+#if GCC_CHECK_VERSION(4,6) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
+	using DeferredMonitor::GetEventLoop;
+
+	bool Init(const config_param &param, Error &error);
+
+	void Finish() {
+		ao_base_finish(&base);
+	}
+
 	bool Configure(const config_param &param, Error &error);
 
+	audio_output *InitAndConfigure(const config_param &param,
+				       Error &error) {
+		if (!Init(param, error))
+			return nullptr;
+
+		if (!Configure(param, error)) {
+			Finish();
+			return nullptr;
+		}
+
+		return &base;
+	}
+
 	bool Bind(Error &error);
 	void Unbind();
 
@@ -181,6 +238,9 @@ struct HttpdOutput final : private ServerSocket {
 	 */
 	void SendHeader(HttpdClient &client) const;
 
+	gcc_pure
+	unsigned Delay() const;
+
 	/**
 	 * Reads data from the encoder (as much as available) and
 	 * returns it as a new #page object.
@@ -203,7 +263,13 @@ struct HttpdOutput final : private ServerSocket {
 
 	void SendTag(const Tag *tag);
 
+	size_t Play(const void *chunk, size_t size, Error &error);
+
+	void CancelAllClients();
+
 private:
+	virtual void RunDeferred() override;
+
 	virtual void OnAccept(int fd, const sockaddr &address,
 			      size_t address_length, int uid) override;
 };
diff --git a/src/output/HttpdOutputPlugin.cxx b/src/output/plugins/HttpdOutputPlugin.cxx
index 369c06937..6921cb808 100644
--- a/src/output/HttpdOutputPlugin.cxx
+++ b/src/output/plugins/HttpdOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -21,20 +21,19 @@
 #include "HttpdOutputPlugin.hxx"
 #include "HttpdInternal.hxx"
 #include "HttpdClient.hxx"
-#include "OutputAPI.hxx"
-#include "EncoderPlugin.hxx"
-#include "EncoderList.hxx"
+#include "../OutputAPI.hxx"
+#include "encoder/EncoderPlugin.hxx"
+#include "encoder/EncoderList.hxx"
 #include "system/Resolver.hxx"
 #include "Page.hxx"
 #include "IcyMetaDataServer.hxx"
 #include "system/fd_util.h"
-#include "Main.hxx"
+#include "IOThread.hxx"
+#include "event/Call.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
 #include "Log.hxx"
 
-#include <glib.h>
-
 #include <assert.h>
 
 #include <sys/types.h>
@@ -51,7 +50,7 @@ const Domain httpd_output_domain("httpd_output");
 
 inline
 HttpdOutput::HttpdOutput(EventLoop &_loop)
-	:ServerSocket(_loop),
+	:ServerSocket(_loop), DeferredMonitor(_loop),
 	 encoder(nullptr), unflushed_input(0),
 	 metadata(nullptr)
 {
@@ -72,8 +71,11 @@ HttpdOutput::Bind(Error &error)
 {
 	open = false;
 
-	const ScopeLock protect(mutex);
-	return ServerSocket::Open(error);
+	bool result = false;
+	BlockingCall(GetEventLoop(), [this, &error, &result](){
+			result = ServerSocket::Open(error);
+		});
+	return result;
 }
 
 inline void
@@ -81,8 +83,9 @@ HttpdOutput::Unbind()
 {
 	assert(!open);
 
-	const ScopeLock protect(mutex);
-	ServerSocket::Close();
+	BlockingCall(GetEventLoop(), [this](){
+			ServerSocket::Close();
+		});
 }
 
 inline bool
@@ -130,47 +133,30 @@ HttpdOutput::Configure(const config_param &param, Error &error)
 	return true;
 }
 
+inline bool
+HttpdOutput::Init(const config_param &param, Error &error)
+{
+	return ao_base_init(&base, &httpd_output_plugin, param, error);
+}
+
 static struct audio_output *
 httpd_output_init(const config_param &param, Error &error)
 {
-	HttpdOutput *httpd = new HttpdOutput(*main_loop);
+	HttpdOutput *httpd = new HttpdOutput(io_thread_get());
 
-	if (!ao_base_init(&httpd->base, &httpd_output_plugin, param,
-			  error)) {
+	audio_output *result = httpd->InitAndConfigure(param, error);
+	if (result == nullptr)
 		delete httpd;
-		return nullptr;
-	}
 
-	if (!httpd->Configure(param, error)) {
-		ao_base_finish(&httpd->base);
-		delete httpd;
-		return nullptr;
-	}
-
-	return &httpd->base;
-}
-
-#if GCC_CHECK_VERSION(4,6) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Winvalid-offsetof"
-#endif
-
-static inline constexpr HttpdOutput *
-Cast(audio_output *ao)
-{
-	return (HttpdOutput *)((char *)ao - offsetof(HttpdOutput, base));
+	return result;
 }
 
-#if GCC_CHECK_VERSION(4,6) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-
 static void
 httpd_output_finish(struct audio_output *ao)
 {
-	HttpdOutput *httpd = Cast(ao);
+	HttpdOutput *httpd = HttpdOutput::Cast(ao);
 
-	ao_base_finish(&httpd->base);
+	httpd->Finish();
 	delete httpd;
 }
 
@@ -181,7 +167,7 @@ httpd_output_finish(struct audio_output *ao)
 inline void
 HttpdOutput::AddClient(int fd)
 {
-	clients.emplace_front(this, fd, GetEventLoop(),
+	clients.emplace_front(*this, fd, GetEventLoop(),
 			      encoder->plugin.tag == nullptr);
 	++clients_cnt;
 
@@ -191,6 +177,29 @@ HttpdOutput::AddClient(int fd)
 }
 
 void
+HttpdOutput::RunDeferred()
+{
+	/* this method runs in the IOThread; it broadcasts pages from
+	   our own queue to all clients */
+
+	const ScopeLock protect(mutex);
+
+	while (!pages.empty()) {
+		Page *page = pages.front();
+		pages.pop();
+
+		for (auto &client : clients)
+			client.PushPage(page);
+
+		page->Unref();
+	}
+
+	/* wake up the client that may be waiting for the queue to be
+	   flushed */
+	cond.broadcast();
+}
+
+void
 HttpdOutput::OnAccept(int fd, const sockaddr &address,
 		      size_t address_length, gcc_unused int uid)
 {
@@ -199,9 +208,10 @@ HttpdOutput::OnAccept(int fd, const sockaddr &address,
 
 #ifdef HAVE_LIBWRAP
 	if (address.sa_family != AF_UNIX) {
-		char *hostaddr = sockaddr_to_string(&address, address_length,
-						    IgnoreError());
-		const char *progname = g_get_prgname();
+		const auto hostaddr = sockaddr_to_string(&address,
+							 address_length);
+		// TODO: shall we obtain the program name from argv[0]?
+		const char *progname = "mpd";
 
 		struct request_info req;
 		request_init(&req, RQ_FILE, fd, RQ_DAEMON, progname, 0);
@@ -212,13 +222,10 @@ HttpdOutput::OnAccept(int fd, const sockaddr &address,
 			/* tcp wrappers says no */
 			FormatWarning(httpd_output_domain,
 				      "libwrap refused connection (libwrap=%s) from %s",
-				      progname, hostaddr);
-			g_free(hostaddr);
+				      progname, hostaddr.c_str());
 			close_socket(fd);
 			return;
 		}
-
-		g_free(hostaddr);
 	}
 #else
 	(void)address;
@@ -271,7 +278,7 @@ HttpdOutput::ReadPage()
 static bool
 httpd_output_enable(struct audio_output *ao, Error &error)
 {
-	HttpdOutput *httpd = Cast(ao);
+	HttpdOutput *httpd = HttpdOutput::Cast(ao);
 
 	return httpd->Bind(error);
 }
@@ -279,7 +286,7 @@ httpd_output_enable(struct audio_output *ao, Error &error)
 static void
 httpd_output_disable(struct audio_output *ao)
 {
-	HttpdOutput *httpd = Cast(ao);
+	HttpdOutput *httpd = HttpdOutput::Cast(ao);
 
 	httpd->Unbind();
 }
@@ -325,9 +332,7 @@ static bool
 httpd_output_open(struct audio_output *ao, AudioFormat &audio_format,
 		  Error &error)
 {
-	HttpdOutput *httpd = Cast(ao);
-
-	assert(httpd->clients.empty());
+	HttpdOutput *httpd = HttpdOutput::Cast(ao);
 
 	const ScopeLock protect(httpd->mutex);
 	return httpd->Open(audio_format, error);
@@ -342,7 +347,9 @@ HttpdOutput::Close()
 
 	delete timer;
 
-	clients.clear();
+	BlockingCall(GetEventLoop(), [this](){
+			clients.clear();
+		});
 
 	if (header != nullptr)
 		header->Unref();
@@ -353,7 +360,7 @@ HttpdOutput::Close()
 static void
 httpd_output_close(struct audio_output *ao)
 {
-	HttpdOutput *httpd = Cast(ao);
+	HttpdOutput *httpd = HttpdOutput::Cast(ao);
 
 	const ScopeLock protect(httpd->mutex);
 	httpd->Close();
@@ -382,17 +389,15 @@ HttpdOutput::SendHeader(HttpdClient &client) const
 		client.PushPage(header);
 }
 
-static unsigned
-httpd_output_delay(struct audio_output *ao)
+inline unsigned
+HttpdOutput::Delay() const
 {
-	HttpdOutput *httpd = Cast(ao);
-
-	if (!httpd->LockHasClients() && httpd->base.pause) {
+	if (!LockHasClients() && base.pause) {
 		/* if there's no client and this output is paused,
 		   then httpd_output_pause() will not do anything, it
 		   will not fill the buffer and it will not update the
 		   timer; therefore, we reset the timer here */
-		httpd->timer->Reset();
+		timer->Reset();
 
 		/* some arbitrary delay that is long enough to avoid
 		   consuming too much CPU, and short enough to notice
@@ -400,39 +405,47 @@ httpd_output_delay(struct audio_output *ao)
 		return 1000;
 	}
 
-	return httpd->timer->IsStarted()
-		? httpd->timer->GetDelay()
+	return timer->IsStarted()
+		? timer->GetDelay()
 		: 0;
 }
 
+static unsigned
+httpd_output_delay(struct audio_output *ao)
+{
+	HttpdOutput *httpd = HttpdOutput::Cast(ao);
+
+	return httpd->Delay();
+}
+
 void
 HttpdOutput::BroadcastPage(Page *page)
 {
 	assert(page != nullptr);
 
-	const ScopeLock protect(mutex);
-	for (auto &client : clients)
-		client.PushPage(page);
+	mutex.lock();
+	pages.push(page);
+	page->Ref();
+	mutex.unlock();
+
+	DeferredMonitor::Schedule();
 }
 
 void
 HttpdOutput::BroadcastFromEncoder()
 {
+	/* synchronize with the IOThread */
 	mutex.lock();
-	for (auto &client : clients) {
-		if (client.GetQueueSize() > 256 * 1024) {
-			FormatDebug(httpd_output_domain,
-				    "client is too slow, flushing its queue");
-			client.CancelQueue();
-		}
-	}
-	mutex.unlock();
+	while (!pages.empty())
+		cond.wait(mutex);
 
 	Page *page;
-	while ((page = ReadPage()) != nullptr) {
-		BroadcastPage(page);
-		page->Unref();
-	}
+	while ((page = ReadPage()) != nullptr)
+		pages.push(page);
+
+	mutex.unlock();
+
+	DeferredMonitor::Schedule();
 }
 
 inline bool
@@ -447,28 +460,34 @@ HttpdOutput::EncodeAndPlay(const void *chunk, size_t size, Error &error)
 	return true;
 }
 
-static size_t
-httpd_output_play(struct audio_output *ao, const void *chunk, size_t size,
-		  Error &error)
+inline size_t
+HttpdOutput::Play(const void *chunk, size_t size, Error &error)
 {
-	HttpdOutput *httpd = Cast(ao);
-
-	if (httpd->LockHasClients()) {
-		if (!httpd->EncodeAndPlay(chunk, size, error))
+	if (LockHasClients()) {
+		if (!EncodeAndPlay(chunk, size, error))
 			return 0;
 	}
 
-	if (!httpd->timer->IsStarted())
-		httpd->timer->Start();
-	httpd->timer->Add(size);
+	if (!timer->IsStarted())
+		timer->Start();
+	timer->Add(size);
 
 	return size;
 }
 
+static size_t
+httpd_output_play(struct audio_output *ao, const void *chunk, size_t size,
+		  Error &error)
+{
+	HttpdOutput *httpd = HttpdOutput::Cast(ao);
+
+	return httpd->Play(chunk, size, error);
+}
+
 static bool
 httpd_output_pause(struct audio_output *ao)
 {
-	HttpdOutput *httpd = Cast(ao);
+	HttpdOutput *httpd = HttpdOutput::Cast(ao);
 
 	if (httpd->LockHasClients()) {
 		static const char silence[1020] = { 0 };
@@ -531,19 +550,36 @@ HttpdOutput::SendTag(const Tag *tag)
 static void
 httpd_output_tag(struct audio_output *ao, const Tag *tag)
 {
-	HttpdOutput *httpd = Cast(ao);
+	HttpdOutput *httpd = HttpdOutput::Cast(ao);
 
 	httpd->SendTag(tag);
 }
 
+inline void
+HttpdOutput::CancelAllClients()
+{
+	const ScopeLock protect(mutex);
+
+	while (!pages.empty()) {
+		Page *page = pages.front();
+		pages.pop();
+		page->Unref();
+	}
+
+	for (auto &client : clients)
+		client.CancelQueue();
+
+	cond.broadcast();
+}
+
 static void
 httpd_output_cancel(struct audio_output *ao)
 {
-	HttpdOutput *httpd = Cast(ao);
+	HttpdOutput *httpd = HttpdOutput::Cast(ao);
 
-	const ScopeLock protect(httpd->mutex);
-	for (auto &client : httpd->clients)
-		client.CancelQueue();
+	BlockingCall(io_thread_get(), [httpd](){
+			httpd->CancelAllClients();
+		});
 }
 
 const struct audio_output_plugin httpd_output_plugin = {
diff --git a/src/output/HttpdOutputPlugin.hxx b/src/output/plugins/HttpdOutputPlugin.hxx
index c74d2bd4a..78218e5f0 100644
--- a/src/output/HttpdOutputPlugin.hxx
+++ b/src/output/plugins/HttpdOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/JackOutputPlugin.cxx b/src/output/plugins/JackOutputPlugin.cxx
index 7ed672f95..b981c1292 100644
--- a/src/output/JackOutputPlugin.cxx
+++ b/src/output/plugins/JackOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,8 +19,8 @@
 
 #include "config.h"
 #include "JackOutputPlugin.hxx"
-#include "OutputAPI.hxx"
-#include "ConfigError.hxx"
+#include "../OutputAPI.hxx"
+#include "config/ConfigError.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
 #include "Log.hxx"
@@ -34,10 +34,6 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <errno.h>
 
 enum {
 	MAX_PORTS = 16,
diff --git a/src/output/JackOutputPlugin.hxx b/src/output/plugins/JackOutputPlugin.hxx
index 908105ad2..ee3fe9238 100644
--- a/src/output/JackOutputPlugin.hxx
+++ b/src/output/plugins/JackOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/NullOutputPlugin.cxx b/src/output/plugins/NullOutputPlugin.cxx
index e2eec9dbc..c336d86e6 100644
--- a/src/output/NullOutputPlugin.cxx
+++ b/src/output/plugins/NullOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,11 +19,9 @@
 
 #include "config.h"
 #include "NullOutputPlugin.hxx"
-#include "OutputAPI.hxx"
+#include "../OutputAPI.hxx"
 #include "Timer.hxx"
 
-#include <assert.h>
-
 struct NullOutput {
 	struct audio_output base;
 
diff --git a/src/output/NullOutputPlugin.hxx b/src/output/plugins/NullOutputPlugin.hxx
index a58f1cb13..05b8ef3d8 100644
--- a/src/output/NullOutputPlugin.hxx
+++ b/src/output/plugins/NullOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/OSXOutputPlugin.cxx b/src/output/plugins/OSXOutputPlugin.cxx
index 97ebae056..c247336d7 100644
--- a/src/output/OSXOutputPlugin.cxx
+++ b/src/output/plugins/OSXOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,8 +19,8 @@
 
 #include "config.h"
 #include "OSXOutputPlugin.hxx"
-#include "OutputAPI.hxx"
-#include "util/fifo_buffer.h"
+#include "../OutputAPI.hxx"
+#include "util/DynamicFifoBuffer.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
 #include "thread/Mutex.hxx"
@@ -44,7 +44,7 @@ struct OSXOutput {
 	Mutex mutex;
 	Cond condition;
 
-	struct fifo_buffer *buffer;
+	DynamicFifoBuffer<uint8_t> *buffer;
 };
 
 static constexpr Domain osx_output_domain("osx_output");
@@ -72,7 +72,7 @@ osx_output_configure(OSXOutput *oo, const config_param &param)
 	}
 	else {
 		oo->component_subtype = kAudioUnitSubType_HALOutput;
-		/* XXX am I supposed to g_strdup() this? */
+		/* XXX am I supposed to strdup() this? */
 		oo->device_name = device;
 	}
 }
@@ -207,22 +207,19 @@ osx_render(void *vdata,
 
 	od->mutex.lock();
 
-	size_t nbytes;
-	const void *src = fifo_buffer_read(od->buffer, &nbytes);
+	auto src = od->buffer->Read();
+	if (!src.IsEmpty()) {
+		if (src.size > buffer_size)
+			src.size = buffer_size;
 
-	if (src != NULL) {
-		if (nbytes > buffer_size)
-			nbytes = buffer_size;
-
-		memcpy(buffer->mData, src, nbytes);
-		fifo_buffer_consume(od->buffer, nbytes);
-	} else
-		nbytes = 0;
+		memcpy(buffer->mData, src.data, src.size);
+		od->buffer->Consume(src.size);
+	}
 
 	od->condition.signal();
 	od->mutex.unlock();
 
-	buffer->mDataByteSize = nbytes;
+	buffer->mDataByteSize = src.size;
 
 	unsigned i;
 	for (i = 1; i < buffer_list->mNumberBuffers; ++i) {
@@ -298,7 +295,7 @@ osx_output_cancel(struct audio_output *ao)
 	OSXOutput *od = (OSXOutput *)ao;
 
 	const ScopeLock protect(od->mutex);
-	fifo_buffer_clear(od->buffer);
+	od->buffer->Clear();
 }
 
 static void
@@ -309,7 +306,7 @@ osx_output_close(struct audio_output *ao)
 	AudioOutputUnitStop(od->au);
 	AudioUnitUninitialize(od->au);
 
-	fifo_buffer_free(od->buffer);
+	delete od->buffer;
 }
 
 static bool
@@ -370,8 +367,8 @@ osx_output_open(struct audio_output *ao, AudioFormat &audio_format,
 	}
 
 	/* create a buffer of 1s */
-	od->buffer = fifo_buffer_new(audio_format.sample_rate *
-				     audio_format.GetFrameSize());
+	od->buffer = new DynamicFifoBuffer<uint8_t>(audio_format.sample_rate *
+						    audio_format.GetFrameSize());
 
 	status = AudioOutputUnitStart(od->au);
 	if (status != 0) {
@@ -393,23 +390,21 @@ osx_output_play(struct audio_output *ao, const void *chunk, size_t size,
 
 	const ScopeLock protect(od->mutex);
 
-	void *dest;
-	size_t max_length;
-
+	DynamicFifoBuffer<uint8_t>::Range dest;
 	while (true) {
-		dest = fifo_buffer_write(od->buffer, &max_length);
-		if (dest != NULL)
+		dest = od->buffer->Write();
+		if (!dest.IsEmpty())
 			break;
 
 		/* wait for some free space in the buffer */
 		od->condition.wait(od->mutex);
 	}
 
-	if (size > max_length)
-		size = max_length;
+	if (size > dest.size)
+		size = dest.size;
 
-	memcpy(dest, chunk, size);
-	fifo_buffer_append(od->buffer, size);
+	memcpy(dest.data, chunk, size);
+	od->buffer->Append(size);
 
 	return size;
 }
diff --git a/src/output/OSXOutputPlugin.hxx b/src/output/plugins/OSXOutputPlugin.hxx
index 2a4172880..0de10f83e 100644
--- a/src/output/OSXOutputPlugin.hxx
+++ b/src/output/plugins/OSXOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/OpenALOutputPlugin.cxx b/src/output/plugins/OpenALOutputPlugin.cxx
index 268cf17cc..f590f0ea0 100644
--- a/src/output/OpenALOutputPlugin.cxx
+++ b/src/output/plugins/OpenALOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,7 +19,7 @@
 
 #include "config.h"
 #include "OpenALOutputPlugin.hxx"
-#include "OutputAPI.hxx"
+#include "../OutputAPI.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
 
diff --git a/src/output/OpenALOutputPlugin.hxx b/src/output/plugins/OpenALOutputPlugin.hxx
index e1ebf3d4f..eb43d1aa5 100644
--- a/src/output/OpenALOutputPlugin.hxx
+++ b/src/output/plugins/OpenALOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/OssOutputPlugin.cxx b/src/output/plugins/OssOutputPlugin.cxx
index 68f2a38aa..2157a9476 100644
--- a/src/output/OssOutputPlugin.cxx
+++ b/src/output/plugins/OssOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,8 +19,8 @@
 
 #include "config.h"
 #include "OssOutputPlugin.hxx"
-#include "OutputAPI.hxx"
-#include "MixerList.hxx"
+#include "../OutputAPI.hxx"
+#include "mixer/MixerList.hxx"
 #include "system/fd_util.h"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
diff --git a/src/output/OssOutputPlugin.hxx b/src/output/plugins/OssOutputPlugin.hxx
index 6c5c9530b..4762fa652 100644
--- a/src/output/OssOutputPlugin.hxx
+++ b/src/output/plugins/OssOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/PipeOutputPlugin.cxx b/src/output/plugins/PipeOutputPlugin.cxx
index 34d615284..2eb0c6dd8 100644
--- a/src/output/PipeOutputPlugin.cxx
+++ b/src/output/plugins/PipeOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,8 +19,8 @@
 
 #include "config.h"
 #include "PipeOutputPlugin.hxx"
-#include "OutputAPI.hxx"
-#include "ConfigError.hxx"
+#include "../OutputAPI.hxx"
+#include "config/ConfigError.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
 
diff --git a/src/output/PipeOutputPlugin.hxx b/src/output/plugins/PipeOutputPlugin.hxx
index f0c29706b..42b01b9f7 100644
--- a/src/output/PipeOutputPlugin.hxx
+++ b/src/output/plugins/PipeOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/PulseOutputPlugin.cxx b/src/output/plugins/PulseOutputPlugin.cxx
index ab797387d..6bb66450e 100644
--- a/src/output/PulseOutputPlugin.cxx
+++ b/src/output/plugins/PulseOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,9 +19,9 @@
 
 #include "config.h"
 #include "PulseOutputPlugin.hxx"
-#include "OutputAPI.hxx"
-#include "MixerList.hxx"
-#include "mixer/PulseMixerPlugin.hxx"
+#include "../OutputAPI.hxx"
+#include "mixer/MixerList.hxx"
+#include "mixer/plugins/PulseMixerPlugin.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
 #include "Log.hxx"
diff --git a/src/output/PulseOutputPlugin.hxx b/src/output/plugins/PulseOutputPlugin.hxx
index 0ed8404bc..9df557282 100644
--- a/src/output/PulseOutputPlugin.hxx
+++ b/src/output/plugins/PulseOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -41,6 +41,6 @@ pulse_output_clear_mixer(PulseOutput *po, PulseMixer *pm);
 
 bool
 pulse_output_set_volume(PulseOutput *po,
-			const struct pa_cvolume *volume, Error &error);
+			const pa_cvolume *volume, Error &error);
 
 #endif
diff --git a/src/output/RecorderOutputPlugin.cxx b/src/output/plugins/RecorderOutputPlugin.cxx
index 9a7eba01f..685438009 100644
--- a/src/output/RecorderOutputPlugin.cxx
+++ b/src/output/plugins/RecorderOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,10 +19,10 @@
 
 #include "config.h"
 #include "RecorderOutputPlugin.hxx"
-#include "OutputAPI.hxx"
-#include "EncoderPlugin.hxx"
-#include "EncoderList.hxx"
-#include "ConfigError.hxx"
+#include "../OutputAPI.hxx"
+#include "encoder/EncoderPlugin.hxx"
+#include "encoder/EncoderList.hxx"
+#include "config/ConfigError.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
 #include "system/fd_util.h"
diff --git a/src/output/RecorderOutputPlugin.hxx b/src/output/plugins/RecorderOutputPlugin.hxx
index a27f51e23..4fac911a1 100644
--- a/src/output/RecorderOutputPlugin.hxx
+++ b/src/output/plugins/RecorderOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/RoarOutputPlugin.cxx b/src/output/plugins/RoarOutputPlugin.cxx
index 895a165d1..1192b2625 100644
--- a/src/output/RoarOutputPlugin.cxx
+++ b/src/output/plugins/RoarOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * Copyright (C) 2010-2011 Philipp 'ph3-der-loewe' Schafft
  * Copyright (C) 2010-2011 Hans-Kristian 'maister' Arntzen
  *
@@ -20,8 +20,8 @@
 
 #include "config.h"
 #include "RoarOutputPlugin.hxx"
-#include "OutputAPI.hxx"
-#include "MixerList.hxx"
+#include "../OutputAPI.hxx"
+#include "mixer/MixerList.hxx"
 #include "thread/Mutex.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
diff --git a/src/output/RoarOutputPlugin.hxx b/src/output/plugins/RoarOutputPlugin.hxx
index 04949e421..27c5dc420 100644
--- a/src/output/RoarOutputPlugin.hxx
+++ b/src/output/plugins/RoarOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/ShoutOutputPlugin.cxx b/src/output/plugins/ShoutOutputPlugin.cxx
index 19f2b61cd..f86e5ce4b 100644
--- a/src/output/ShoutOutputPlugin.cxx
+++ b/src/output/plugins/ShoutOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,10 +19,10 @@
 
 #include "config.h"
 #include "ShoutOutputPlugin.hxx"
-#include "OutputAPI.hxx"
-#include "EncoderPlugin.hxx"
-#include "EncoderList.hxx"
-#include "ConfigError.hxx"
+#include "../OutputAPI.hxx"
+#include "encoder/EncoderPlugin.hxx"
+#include "encoder/EncoderList.hxx"
+#include "config/ConfigError.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
 #include "system/FatalError.hxx"
diff --git a/src/output/ShoutOutputPlugin.hxx b/src/output/plugins/ShoutOutputPlugin.hxx
index 496b77975..d437e0b0d 100644
--- a/src/output/ShoutOutputPlugin.hxx
+++ b/src/output/plugins/ShoutOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/SolarisOutputPlugin.cxx b/src/output/plugins/SolarisOutputPlugin.cxx
index 0836dc2e2..38ed2e314 100644
--- a/src/output/SolarisOutputPlugin.cxx
+++ b/src/output/plugins/SolarisOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,7 +19,7 @@
 
 #include "config.h"
 #include "SolarisOutputPlugin.hxx"
-#include "OutputAPI.hxx"
+#include "../OutputAPI.hxx"
 #include "system/fd_util.h"
 #include "util/Error.hxx"
 
diff --git a/src/output/SolarisOutputPlugin.hxx b/src/output/plugins/SolarisOutputPlugin.hxx
index d0fbd32c8..9ce848a40 100644
--- a/src/output/SolarisOutputPlugin.hxx
+++ b/src/output/plugins/SolarisOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/src/output/WinmmOutputPlugin.cxx b/src/output/plugins/WinmmOutputPlugin.cxx
index d2508ee2a..66d49eb9a 100644
--- a/src/output/WinmmOutputPlugin.cxx
+++ b/src/output/plugins/WinmmOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,9 +19,9 @@
 
 #include "config.h"
 #include "WinmmOutputPlugin.hxx"
-#include "OutputAPI.hxx"
+#include "../OutputAPI.hxx"
 #include "pcm/PcmBuffer.hxx"
-#include "MixerList.hxx"
+#include "mixer/MixerList.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
 #include "util/Macros.hxx"
diff --git a/src/output/WinmmOutputPlugin.hxx b/src/output/plugins/WinmmOutputPlugin.hxx
index a6b7733ec..1409a2e8c 100644
--- a/src/output/WinmmOutputPlugin.hxx
+++ b/src/output/plugins/WinmmOutputPlugin.hxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2013 The Music Player Daemon Project
+ * Copyright (C) 2003-2014 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify