PlayerThread, ...: move to src/player/

7 files changed, 2231 insertions, 0 deletions

diff --git a/src/player/Control.cxx b/src/player/Control.cxx
new file mode 100644
index 000000000..d7352ad57
--- /dev/null
+++ b/src/player/Control.cxx
@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 2003-2015 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 "Control.hxx"
+#include "Idle.hxx"
+#include "DetachedSong.hxx"
+
+#include <algorithm>
+
+#include <assert.h>
+
+PlayerControl::PlayerControl(PlayerListener &_listener,
+			     MultipleOutputs &_outputs,
+			     unsigned _buffer_chunks,
+			     unsigned _buffered_before_play)
+	:listener(_listener), outputs(_outputs),
+	 buffer_chunks(_buffer_chunks),
+	 buffered_before_play(_buffered_before_play),
+	 command(PlayerCommand::NONE),
+	 state(PlayerState::STOP),
+	 error_type(PlayerError::NONE),
+	 tagged_song(nullptr),
+	 next_song(nullptr),
+	 total_play_time(0),
+	 border_pause(false)
+{
+}
+
+PlayerControl::~PlayerControl()
+{
+	delete next_song;
+	delete tagged_song;
+}
+
+void
+PlayerControl::Play(DetachedSong *song)
+{
+	assert(song != nullptr);
+
+	Lock();
+
+	if (state != PlayerState::STOP)
+		SynchronousCommand(PlayerCommand::STOP);
+
+	assert(next_song == nullptr);
+
+	EnqueueSongLocked(song);
+
+	assert(next_song == nullptr);
+
+	Unlock();
+}
+
+void
+PlayerControl::Cancel()
+{
+	LockSynchronousCommand(PlayerCommand::CANCEL);
+	assert(next_song == nullptr);
+}
+
+void
+PlayerControl::Stop()
+{
+	LockSynchronousCommand(PlayerCommand::CLOSE_AUDIO);
+	assert(next_song == nullptr);
+
+	idle_add(IDLE_PLAYER);
+}
+
+void
+PlayerControl::UpdateAudio()
+{
+	LockSynchronousCommand(PlayerCommand::UPDATE_AUDIO);
+}
+
+void
+PlayerControl::Kill()
+{
+	assert(thread.IsDefined());
+
+	LockSynchronousCommand(PlayerCommand::EXIT);
+	thread.Join();
+
+	idle_add(IDLE_PLAYER);
+}
+
+void
+PlayerControl::PauseLocked()
+{
+	if (state != PlayerState::STOP) {
+		SynchronousCommand(PlayerCommand::PAUSE);
+		idle_add(IDLE_PLAYER);
+	}
+}
+
+void
+PlayerControl::Pause()
+{
+	Lock();
+	PauseLocked();
+	Unlock();
+}
+
+void
+PlayerControl::SetPause(bool pause_flag)
+{
+	Lock();
+
+	switch (state) {
+	case PlayerState::STOP:
+		break;
+
+	case PlayerState::PLAY:
+		if (pause_flag)
+			PauseLocked();
+		break;
+
+	case PlayerState::PAUSE:
+		if (!pause_flag)
+			PauseLocked();
+		break;
+	}
+
+	Unlock();
+}
+
+void
+PlayerControl::SetBorderPause(bool _border_pause)
+{
+	Lock();
+	border_pause = _border_pause;
+	Unlock();
+}
+
+player_status
+PlayerControl::GetStatus()
+{
+	player_status status;
+
+	Lock();
+	SynchronousCommand(PlayerCommand::REFRESH);
+
+	status.state = state;
+
+	if (state != PlayerState::STOP) {
+		status.bit_rate = bit_rate;
+		status.audio_format = audio_format;
+		status.total_time = total_time;
+		status.elapsed_time = elapsed_time;
+	}
+
+	Unlock();
+
+	return status;
+}
+
+void
+PlayerControl::SetError(PlayerError type, Error &&_error)
+{
+	assert(type != PlayerError::NONE);
+	assert(_error.IsDefined());
+
+	error_type = type;
+	error = std::move(_error);
+}
+
+void
+PlayerControl::ClearError()
+{
+	Lock();
+
+	if (error_type != PlayerError::NONE) {
+	    error_type = PlayerError::NONE;
+	    error.Clear();
+	}
+
+	Unlock();
+}
+
+void
+PlayerControl::LockSetTaggedSong(const DetachedSong &song)
+{
+	Lock();
+	delete tagged_song;
+	tagged_song = new DetachedSong(song);
+	Unlock();
+}
+
+void
+PlayerControl::ClearTaggedSong()
+{
+	delete tagged_song;
+	tagged_song = nullptr;
+}
+
+void
+PlayerControl::EnqueueSong(DetachedSong *song)
+{
+	assert(song != nullptr);
+
+	Lock();
+	EnqueueSongLocked(song);
+	Unlock();
+}
+
+bool
+PlayerControl::Seek(DetachedSong *song, SongTime t)
+{
+	assert(song != nullptr);
+
+	Lock();
+
+	delete next_song;
+	next_song = song;
+	seek_time = t;
+	SynchronousCommand(PlayerCommand::SEEK);
+	Unlock();
+
+	assert(next_song == nullptr);
+
+	idle_add(IDLE_PLAYER);
+
+	return true;
+}
+
+void
+PlayerControl::SetCrossFade(float _cross_fade_seconds)
+{
+	if (_cross_fade_seconds < 0)
+		_cross_fade_seconds = 0;
+	cross_fade.duration = _cross_fade_seconds;
+
+	idle_add(IDLE_OPTIONS);
+}
+
+void
+PlayerControl::SetMixRampDb(float _mixramp_db)
+{
+	cross_fade.mixramp_db = _mixramp_db;
+
+	idle_add(IDLE_OPTIONS);
+}
+
+void
+PlayerControl::SetMixRampDelay(float _mixramp_delay_seconds)
+{
+	cross_fade.mixramp_delay = _mixramp_delay_seconds;
+
+	idle_add(IDLE_OPTIONS);
+}
diff --git a/src/player/Control.hxx b/src/player/Control.hxx
new file mode 100644
index 000000000..a2807a9a1
--- /dev/null
+++ b/src/player/Control.hxx
@@ -0,0 +1,463 @@
+/*
+ * Copyright (C) 2003-2015 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_PLAYER_CONTROL_HXX
+#define MPD_PLAYER_CONTROL_HXX
+
+#include "AudioFormat.hxx"
+#include "thread/Mutex.hxx"
+#include "thread/Cond.hxx"
+#include "thread/Thread.hxx"
+#include "util/Error.hxx"
+#include "CrossFade.hxx"
+#include "Chrono.hxx"
+
+#include <stdint.h>
+
+class PlayerListener;
+class MultipleOutputs;
+class DetachedSong;
+
+enum class PlayerState : uint8_t {
+	STOP,
+	PAUSE,
+	PLAY
+};
+
+enum class PlayerCommand : uint8_t {
+	NONE,
+	EXIT,
+	STOP,
+	PAUSE,
+	SEEK,
+	CLOSE_AUDIO,
+
+	/**
+	 * At least one AudioOutput.enabled flag has been modified;
+	 * commit those changes to the output threads.
+	 */
+	UPDATE_AUDIO,
+
+	/** PlayerControl.next_song has been updated */
+	QUEUE,
+
+	/**
+	 * cancel pre-decoding PlayerControl.next_song; if the player
+	 * has already started playing this song, it will completely
+	 * stop
+	 */
+	CANCEL,
+
+	/**
+	 * Refresh status information in the #PlayerControl struct,
+	 * e.g. elapsed_time.
+	 */
+	REFRESH,
+};
+
+enum class PlayerError : uint8_t {
+	NONE,
+
+	/**
+	 * The decoder has failed to decode the song.
+	 */
+	DECODER,
+
+	/**
+	 * The audio output has failed.
+	 */
+	OUTPUT,
+};
+
+struct player_status {
+	PlayerState state;
+	uint16_t bit_rate;
+	AudioFormat audio_format;
+	SignedSongTime total_time;
+	SongTime elapsed_time;
+};
+
+struct PlayerControl {
+	PlayerListener &listener;
+
+	MultipleOutputs &outputs;
+
+	const unsigned buffer_chunks;
+
+	const unsigned buffered_before_play;
+
+	/**
+	 * The handle of the player thread.
+	 */
+	Thread thread;
+
+	/**
+	 * This lock protects #command, #state, #error, #tagged_song.
+	 */
+	mutable Mutex mutex;
+
+	/**
+	 * Trigger this object after you have modified #command.
+	 */
+	Cond cond;
+
+	/**
+	 * This object gets signalled when the player thread has
+	 * finished the #command.  It wakes up the client that waits
+	 * (i.e. the main thread).
+	 */
+	Cond client_cond;
+
+	PlayerCommand command;
+	PlayerState state;
+
+	PlayerError error_type;
+
+	/**
+	 * The error that occurred in the player thread.  This
+	 * attribute is only valid if #error is not
+	 * #PlayerError::NONE.  The object must be freed when this
+	 * object transitions back to #PlayerError::NONE.
+	 */
+	Error error;
+
+	/**
+	 * A copy of the current #DetachedSong after its tags have
+	 * been updated by the decoder (for example, a radio stream
+	 * that has sent a new tag after switching to the next song).
+	 * This shall be used by PlayerListener::OnPlayerTagModified()
+	 * to update the current #DetachedSong in the queue.
+	 *
+	 * Protected by #mutex.  Set by the PlayerThread and consumed
+	 * by the main thread.
+	 */
+	DetachedSong *tagged_song;
+
+	uint16_t bit_rate;
+	AudioFormat audio_format;
+	SignedSongTime total_time;
+	SongTime elapsed_time;
+
+	/**
+	 * The next queued song.
+	 *
+	 * This is a duplicate, and must be freed when this attribute
+	 * is cleared.
+	 */
+	DetachedSong *next_song;
+
+	SongTime seek_time;
+
+	CrossFadeSettings cross_fade;
+
+	double total_play_time;
+
+	/**
+	 * If this flag is set, then the player will be auto-paused at
+	 * the end of the song, before the next song starts to play.
+	 *
+	 * This is a copy of the queue's "single" flag most of the
+	 * time.
+	 */
+	bool border_pause;
+
+	PlayerControl(PlayerListener &_listener,
+		      MultipleOutputs &_outputs,
+		      unsigned buffer_chunks,
+		      unsigned buffered_before_play);
+	~PlayerControl();
+
+	/**
+	 * Locks the object.
+	 */
+	void Lock() const {
+		mutex.lock();
+	}
+
+	/**
+	 * Unlocks the object.
+	 */
+	void Unlock() const {
+		mutex.unlock();
+	}
+
+	/**
+	 * Signals the object.  The object should be locked prior to
+	 * calling this function.
+	 */
+	void Signal() {
+		cond.signal();
+	}
+
+	/**
+	 * Signals the object.  The object is temporarily locked by
+	 * this function.
+	 */
+	void LockSignal() {
+		Lock();
+		Signal();
+		Unlock();
+	}
+
+	/**
+	 * Waits for a signal on the object.  This function is only
+	 * valid in the player thread.  The object must be locked
+	 * prior to calling this function.
+	 */
+	void Wait() {
+		assert(thread.IsInside());
+
+		cond.wait(mutex);
+	}
+
+	/**
+	 * Wake up the client waiting for command completion.
+	 *
+	 * Caller must lock the object.
+	 */
+	void ClientSignal() {
+		assert(thread.IsInside());
+
+		client_cond.signal();
+	}
+
+	/**
+	 * The client calls this method to wait for command
+	 * completion.
+	 *
+	 * Caller must lock the object.
+	 */
+	void ClientWait() {
+		assert(!thread.IsInside());
+
+		client_cond.wait(mutex);
+	}
+
+	/**
+	 * A command has been finished.  This method clears the
+	 * command and signals the client.
+	 *
+	 * To be called from the player thread.  Caller must lock the
+	 * object.
+	 */
+	void CommandFinished() {
+		assert(command != PlayerCommand::NONE);
+
+		command = PlayerCommand::NONE;
+		ClientSignal();
+	}
+
+private:
+	/**
+	 * Wait for the command to be finished by the player thread.
+	 *
+	 * To be called from the main thread.  Caller must lock the
+	 * object.
+	 */
+	void WaitCommandLocked() {
+		while (command != PlayerCommand::NONE)
+			ClientWait();
+	}
+
+	/**
+	 * Send a command to the player thread and synchronously wait
+	 * for it to finish.
+	 *
+	 * To be called from the main thread.  Caller must lock the
+	 * object.
+	 */
+	void SynchronousCommand(PlayerCommand cmd) {
+		assert(command == PlayerCommand::NONE);
+
+		command = cmd;
+		Signal();
+		WaitCommandLocked();
+	}
+
+	/**
+	 * Send a command to the player thread and synchronously wait
+	 * for it to finish.
+	 *
+	 * To be called from the main thread.  This method locks the
+	 * object.
+	 */
+	void LockSynchronousCommand(PlayerCommand cmd) {
+		Lock();
+		SynchronousCommand(cmd);
+		Unlock();
+	}
+
+public:
+	/**
+	 * @param song the song to be queued; the given instance will
+	 * be owned and freed by the player
+	 */
+	void Play(DetachedSong *song);
+
+	/**
+	 * see PlayerCommand::CANCEL
+	 */
+	void Cancel();
+
+	void SetPause(bool pause_flag);
+
+private:
+	void PauseLocked();
+
+public:
+	void Pause();
+
+	/**
+	 * Set the player's #border_pause flag.
+	 */
+	void SetBorderPause(bool border_pause);
+
+	void Kill();
+
+	gcc_pure
+	player_status GetStatus();
+
+	PlayerState GetState() const {
+		return state;
+	}
+
+	/**
+	 * Set the error.  Discards any previous error condition.
+	 *
+	 * Caller must lock the object.
+	 *
+	 * @param type the error type; must not be #PlayerError::NONE
+	 * @param error detailed error information; must be defined.
+	 */
+	void SetError(PlayerError type, Error &&error);
+
+	/**
+	 * Checks whether an error has occurred, and if so, returns a
+	 * copy of the #Error object.
+	 *
+	 * Caller must lock the object.
+	 */
+	gcc_pure
+	Error GetError() const {
+		Error result;
+		if (error_type != PlayerError::NONE)
+			result.Set(error);
+		return result;
+	}
+
+	/**
+	 * Like GetError(), but locks and unlocks the object.
+	 */
+	gcc_pure
+	Error LockGetError() const {
+		Lock();
+		Error result = GetError();
+		Unlock();
+		return result;
+	}
+
+	void ClearError();
+
+	PlayerError GetErrorType() const {
+		return error_type;
+	}
+
+	/**
+	 * Set the #tagged_song attribute to a newly allocated copy of
+	 * the given #DetachedSong.  Locks and unlocks the object.
+	 */
+	void LockSetTaggedSong(const DetachedSong &song);
+
+	void ClearTaggedSong();
+
+	/**
+	 * Read and clear the #tagged_song attribute.
+	 *
+	 * Caller must lock the object.
+	 */
+	DetachedSong *ReadTaggedSong() {
+		DetachedSong *result = tagged_song;
+		tagged_song = nullptr;
+		return result;
+	}
+
+	/**
+	 * Like ReadTaggedSong(), but locks and unlocks the object.
+	 */
+	DetachedSong *LockReadTaggedSong() {
+		Lock();
+		DetachedSong *result = ReadTaggedSong();
+		Unlock();
+		return result;
+	}
+
+	void Stop();
+
+	void UpdateAudio();
+
+private:
+	void EnqueueSongLocked(DetachedSong *song) {
+		assert(song != nullptr);
+		assert(next_song == nullptr);
+
+		next_song = song;
+		SynchronousCommand(PlayerCommand::QUEUE);
+	}
+
+public:
+	/**
+	 * @param song the song to be queued; the given instance will be owned
+	 * and freed by the player
+	 */
+	void EnqueueSong(DetachedSong *song);
+
+	/**
+	 * Makes the player thread seek the specified song to a position.
+	 *
+	 * @param song the song to be queued; the given instance will be owned
+	 * and freed by the player
+	 * @return true on success, false on failure (e.g. if MPD isn't
+	 * playing currently)
+	 */
+	bool Seek(DetachedSong *song, SongTime t);
+
+	void SetCrossFade(float cross_fade_seconds);
+
+	float GetCrossFade() const {
+		return cross_fade.duration;
+	}
+
+	void SetMixRampDb(float mixramp_db);
+
+	float GetMixRampDb() const {
+		return cross_fade.mixramp_db;
+	}
+
+	void SetMixRampDelay(float mixramp_delay_seconds);
+
+	float GetMixRampDelay() const {
+		return cross_fade.mixramp_delay;
+	}
+
+	double GetTotalPlayTime() const {
+		return total_play_time;
+	}
+};
+
+#endif
diff --git a/src/player/CrossFade.cxx b/src/player/CrossFade.cxx
new file mode 100644
index 000000000..6d7b41440
--- /dev/null
+++ b/src/player/CrossFade.cxx
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2003-2015 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 "CrossFade.hxx"
+#include "Chrono.hxx"
+#include "MusicChunk.hxx"
+#include "AudioFormat.hxx"
+#include "util/NumberParser.hxx"
+#include "util/Domain.hxx"
+#include "Log.hxx"
+
+#include <assert.h>
+
+static constexpr Domain cross_fade_domain("cross_fade");
+
+gcc_pure
+static float
+mixramp_interpolate(const char *ramp_list, float required_db)
+{
+	float last_db = 0, last_secs = 0;
+	bool have_last = false;
+
+	/* ramp_list is a string of pairs of dBs and seconds that describe the
+	 * volume profile. Delimiters are semi-colons between pairs and spaces
+	 * between the dB and seconds of a pair.
+	 * The dB values must be monotonically increasing for this to work. */
+
+	while (1) {
+		/* Parse the dB value. */
+		char *endptr;
+		const float db = ParseFloat(ramp_list, &endptr);
+		if (endptr == ramp_list || *endptr != ' ')
+			break;
+
+		ramp_list = endptr + 1;
+
+		/* Parse the time. */
+		float secs = ParseFloat(ramp_list, &endptr);
+		if (endptr == ramp_list || (*endptr != ';' && *endptr != 0))
+			break;
+
+		ramp_list = endptr;
+		if (*ramp_list == ';')
+			++ramp_list;
+
+		/* Check for exact match. */
+		if (db == required_db) {
+			return secs;
+		}
+
+		/* Save if too quiet. */
+		if (db < required_db) {
+			last_db = db;
+			last_secs = secs;
+			have_last = true;
+			continue;
+		}
+
+		/* If required db < any stored value, use the least. */
+		if (!have_last)
+			return secs;
+
+		/* Finally, interpolate linearly. */
+		secs = last_secs + (required_db - last_db) * (secs - last_secs) / (db - last_db);
+		return secs;
+	}
+
+	return -1;
+}
+
+unsigned
+CrossFadeSettings::Calculate(SignedSongTime total_time,
+			     float replay_gain_db, float replay_gain_prev_db,
+			     const char *mixramp_start, const char *mixramp_prev_end,
+			     const AudioFormat af,
+			     const AudioFormat old_format,
+			     unsigned max_chunks) const
+{
+	unsigned int chunks = 0;
+	float chunks_f;
+
+	if (total_time.IsNegative() ||
+	    duration < 0 || duration >= total_time.ToDoubleS() ||
+	    /* we can't crossfade when the audio formats are different */
+	    af != old_format)
+		return 0;
+
+	assert(duration >= 0);
+	assert(af.IsValid());
+
+	chunks_f = (float)af.GetTimeToSize() / (float)CHUNK_SIZE;
+
+	if (mixramp_delay <= 0 || !mixramp_start || !mixramp_prev_end) {
+		chunks = (chunks_f * duration + 0.5);
+	} else {
+		/* Calculate mixramp overlap. */
+		const float mixramp_overlap_current =
+			mixramp_interpolate(mixramp_start,
+					    mixramp_db - replay_gain_db);
+		const float mixramp_overlap_prev =
+			mixramp_interpolate(mixramp_prev_end,
+					    mixramp_db - replay_gain_prev_db);
+		const float mixramp_overlap =
+			mixramp_overlap_current + mixramp_overlap_prev;
+
+		if (mixramp_overlap_current >= 0 &&
+		    mixramp_overlap_prev >= 0 &&
+		    mixramp_delay <= mixramp_overlap) {
+			chunks = (chunks_f * (mixramp_overlap - mixramp_delay));
+			FormatDebug(cross_fade_domain,
+				    "will overlap %d chunks, %fs", chunks,
+				    mixramp_overlap - mixramp_delay);
+		}
+	}
+
+	if (chunks > max_chunks) {
+		chunks = max_chunks;
+		LogWarning(cross_fade_domain,
+			   "audio_buffer_size too small for computed MixRamp overlap");
+	}
+
+	return chunks;
+}
diff --git a/src/player/CrossFade.hxx b/src/player/CrossFade.hxx
new file mode 100644
index 000000000..672abb718
--- /dev/null
+++ b/src/player/CrossFade.hxx
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2003-2015 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_CROSSFADE_HXX
+#define MPD_CROSSFADE_HXX
+
+#include "Compiler.h"
+
+struct AudioFormat;
+class SignedSongTime;
+
+struct CrossFadeSettings {
+	/**
+	 * The configured cross fade duration [s].
+	 */
+	float duration;
+
+	float mixramp_db;
+
+	/**
+	 * The configured MixRapm delay [s].  A non-positive value
+	 * disables MixRamp.
+	 */
+	float mixramp_delay;
+
+	CrossFadeSettings()
+		:duration(0),
+		 mixramp_db(0),
+		 mixramp_delay(-1)
+	{}
+
+
+	/**
+	 * Calculate how many music pipe chunks should be used for crossfading.
+	 *
+	 * @param total_time total_time the duration of the new song
+	 * @param replay_gain_db the ReplayGain adjustment used for this song
+	 * @param replay_gain_prev_db the ReplayGain adjustment used on the last song
+	 * @param mixramp_start the next songs mixramp_start tag
+	 * @param mixramp_prev_end the last songs mixramp_end setting
+	 * @param af the audio format of the new song
+	 * @param old_format the audio format of the current song
+	 * @param max_chunks the maximum number of chunks
+	 * @return the number of chunks for crossfading, or 0 if cross fading
+	 * should be disabled for this song change
+	 */
+	gcc_pure
+	unsigned Calculate(SignedSongTime total_time,
+			   float replay_gain_db, float replay_gain_prev_db,
+			   const char *mixramp_start,
+			   const char *mixramp_prev_end,
+			   AudioFormat af, AudioFormat old_format,
+			   unsigned max_chunks) const;
+};
+
+#endif
diff --git a/src/player/Listener.hxx b/src/player/Listener.hxx
new file mode 100644
index 000000000..e10f2547b
--- /dev/null
+++ b/src/player/Listener.hxx
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2003-2015 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_PLAYER_LISTENER_HXX
+#define MPD_PLAYER_LISTENER_HXX
+
+class PlayerListener {
+public:
+	/**
+	 * Must call playlist_sync().
+	 */
+	virtual void OnPlayerSync() = 0;
+
+	/**
+	 * The current song's tag has changed.
+	 */
+	virtual void OnPlayerTagModified() = 0;
+};
+
+#endif
diff --git a/src/player/Thread.cxx b/src/player/Thread.cxx
new file mode 100644
index 000000000..60e253f4c
--- /dev/null
+++ b/src/player/Thread.cxx
@@ -0,0 +1,1208 @@
+/*
+ * Copyright (C) 2003-2015 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 "Thread.hxx"
+#include "Listener.hxx"
+#include "decoder/DecoderThread.hxx"
+#include "decoder/DecoderControl.hxx"
+#include "MusicPipe.hxx"
+#include "MusicBuffer.hxx"
+#include "MusicChunk.hxx"
+#include "DetachedSong.hxx"
+#include "system/FatalError.hxx"
+#include "CrossFade.hxx"
+#include "Control.hxx"
+#include "output/MultipleOutputs.hxx"
+#include "tag/Tag.hxx"
+#include "Idle.hxx"
+#include "util/Domain.hxx"
+#include "thread/Name.hxx"
+#include "Log.hxx"
+
+#include <string.h>
+
+static constexpr Domain player_domain("player");
+
+enum class CrossFadeState : int8_t {
+	DISABLED = -1,
+	UNKNOWN = 0,
+	ENABLED = 1
+};
+
+class Player {
+	PlayerControl &pc;
+
+	DecoderControl &dc;
+
+	MusicBuffer &buffer;
+
+	MusicPipe *pipe;
+
+	/**
+	 * are we waiting for buffered_before_play?
+	 */
+	bool buffering;
+
+	/**
+	 * true if the decoder is starting and did not provide data
+	 * yet
+	 */
+	bool decoder_starting;
+
+	/**
+	 * Did we wake up the DecoderThread recently?  This avoids
+	 * duplicate wakeup calls.
+	 */
+	bool decoder_woken;
+
+	/**
+	 * is the player paused?
+	 */
+	bool paused;
+
+	/**
+	 * is there a new song in pc.next_song?
+	 */
+	bool queued;
+
+	/**
+	 * Was any audio output opened successfully?  It might have
+	 * failed meanwhile, but was not explicitly closed by the
+	 * player thread.  When this flag is unset, some output
+	 * methods must not be called.
+	 */
+	bool output_open;
+
+	/**
+	 * the song currently being played
+	 */
+	DetachedSong *song;
+
+	/**
+	 * is cross fading enabled?
+	 */
+	CrossFadeState xfade_state;
+
+	/**
+	 * has cross-fading begun?
+	 */
+	bool cross_fading;
+
+	/**
+	 * The number of chunks used for crossfading.
+	 */
+	unsigned cross_fade_chunks;
+
+	/**
+	 * The tag of the "next" song during cross-fade.  It is
+	 * postponed, and sent to the output thread when the new song
+	 * really begins.
+	 */
+	Tag *cross_fade_tag;
+
+	/**
+	 * The current audio format for the audio outputs.
+	 */
+	AudioFormat play_audio_format;
+
+	/**
+	 * The time stamp of the chunk most recently sent to the
+	 * output thread.  This attribute is only used if
+	 * MultipleOutputs::GetElapsedTime() didn't return a usable
+	 * value; the output thread can estimate the elapsed time more
+	 * precisely.
+	 */
+	SongTime elapsed_time;
+
+public:
+	Player(PlayerControl &_pc, DecoderControl &_dc,
+	       MusicBuffer &_buffer)
+		:pc(_pc), dc(_dc), buffer(_buffer),
+		 buffering(true),
+		 decoder_starting(false),
+		 decoder_woken(false),
+		 paused(false),
+		 queued(true),
+		 output_open(false),
+		 song(nullptr),
+		 xfade_state(CrossFadeState::UNKNOWN),
+		 cross_fading(false),
+		 cross_fade_chunks(0),
+		 cross_fade_tag(nullptr),
+		 elapsed_time(SongTime::zero()) {}
+
+private:
+	void ClearAndDeletePipe() {
+		pipe->Clear(buffer);
+		delete pipe;
+	}
+
+	void ClearAndReplacePipe(MusicPipe *_pipe) {
+		ClearAndDeletePipe();
+		pipe = _pipe;
+	}
+
+	void ReplacePipe(MusicPipe *_pipe) {
+		delete pipe;
+		pipe = _pipe;
+	}
+
+	/**
+	 * Start the decoder.
+	 *
+	 * Player lock is not held.
+	 */
+	void StartDecoder(MusicPipe &pipe);
+
+	/**
+	 * The decoder has acknowledged the "START" command (see
+	 * player::WaitForDecoder()).  This function checks if the decoder
+	 * initialization has completed yet.
+	 *
+	 * The player lock is not held.
+	 */
+	bool CheckDecoderStartup();
+
+	/**
+	 * Stop the decoder and clears (and frees) its music pipe.
+	 *
+	 * Player lock is not held.
+	 */
+	void StopDecoder();
+
+	/**
+	 * Is the decoder still busy on the same song as the player?
+	 *
+	 * Note: this function does not check if the decoder is already
+	 * finished.
+	 */
+	gcc_pure
+	bool IsDecoderAtCurrentSong() const {
+		assert(pipe != nullptr);
+
+		return dc.pipe == pipe;
+	}
+
+	/**
+	 * Returns true if the decoder is decoding the next song (or has begun
+	 * decoding it, or has finished doing it), and the player hasn't
+	 * switched to that song yet.
+	 */
+	gcc_pure
+	bool IsDecoderAtNextSong() const {
+		return dc.pipe != nullptr && !IsDecoderAtCurrentSong();
+	}
+
+	/**
+	 * This is the handler for the #PlayerCommand::SEEK command.
+	 *
+	 * The player lock is not held.
+	 */
+	bool SeekDecoder();
+
+	/**
+	 * After the decoder has been started asynchronously, wait for
+	 * the "START" command to finish.  The decoder may not be
+	 * initialized yet, i.e. there is no audio_format information
+	 * yet.
+	 *
+	 * The player lock is not held.
+	 */
+	bool WaitForDecoder();
+
+	/**
+	 * Wrapper for MultipleOutputs::Open().  Upon failure, it
+	 * pauses the player.
+	 *
+	 * @return true on success
+	 */
+	bool OpenOutput();
+
+	/**
+	 * Obtains the next chunk from the music pipe, optionally applies
+	 * cross-fading, and sends it to all audio outputs.
+	 *
+	 * @return true on success, false on error (playback will be stopped)
+	 */
+	bool PlayNextChunk();
+
+	/**
+	 * Sends a chunk of silence to the audio outputs.  This is
+	 * called when there is not enough decoded data in the pipe
+	 * yet, to prevent underruns in the hardware buffers.
+	 *
+	 * The player lock is not held.
+	 */
+	bool SendSilence();
+
+	/**
+	 * Player lock must be held before calling.
+	 */
+	void ProcessCommand();
+
+	/**
+	 * This is called at the border between two songs: the audio output
+	 * has consumed all chunks of the current song, and we should start
+	 * sending chunks from the next one.
+	 *
+	 * The player lock is not held.
+	 *
+	 * @return true on success, false on error (playback will be stopped)
+	 */
+	bool SongBorder();
+
+public:
+	/*
+	 * The main loop of the player thread, during playback.  This
+	 * is basically a state machine, which multiplexes data
+	 * between the decoder thread and the output threads.
+	 */
+	void Run();
+};
+
+static void
+player_command_finished(PlayerControl &pc)
+{
+	pc.Lock();
+	pc.CommandFinished();
+	pc.Unlock();
+}
+
+void
+Player::StartDecoder(MusicPipe &_pipe)
+{
+	assert(queued || pc.command == PlayerCommand::SEEK);
+	assert(pc.next_song != nullptr);
+
+	SongTime start_time = pc.next_song->GetStartTime();
+	if (pc.command == PlayerCommand::SEEK)
+		start_time += pc.seek_time;
+
+	dc.Start(new DetachedSong(*pc.next_song),
+		 start_time, pc.next_song->GetEndTime(),
+		 buffer, _pipe);
+}
+
+void
+Player::StopDecoder()
+{
+	dc.Stop();
+
+	if (dc.pipe != nullptr) {
+		/* clear and free the decoder pipe */
+
+		dc.pipe->Clear(buffer);
+
+		if (dc.pipe != pipe)
+			delete dc.pipe;
+
+		dc.pipe = nullptr;
+	}
+}
+
+bool
+Player::WaitForDecoder()
+{
+	assert(queued || pc.command == PlayerCommand::SEEK);
+	assert(pc.next_song != nullptr);
+
+	queued = false;
+
+	pc.Lock();
+	Error error = dc.GetError();
+	if (error.IsDefined()) {
+		pc.SetError(PlayerError::DECODER, std::move(error));
+
+		delete pc.next_song;
+		pc.next_song = nullptr;
+
+		pc.Unlock();
+
+		return false;
+	}
+
+	pc.ClearTaggedSong();
+
+	delete song;
+	song = pc.next_song;
+	elapsed_time = SongTime::zero();
+
+	/* set the "starting" flag, which will be cleared by
+	   player_check_decoder_startup() */
+	decoder_starting = true;
+
+	/* update PlayerControl's song information */
+	pc.total_time = pc.next_song->GetDuration();
+	pc.bit_rate = 0;
+	pc.audio_format.Clear();
+
+	/* clear the queued song */
+	pc.next_song = nullptr;
+
+	pc.Unlock();
+
+	/* call syncPlaylistWithQueue() in the main thread */
+	pc.listener.OnPlayerSync();
+
+	return true;
+}
+
+/**
+ * Returns the real duration of the song, comprising the duration
+ * indicated by the decoder plugin.
+ */
+static SignedSongTime
+real_song_duration(const DetachedSong &song, SignedSongTime decoder_duration)
+{
+	if (decoder_duration.IsNegative())
+		/* the decoder plugin didn't provide information; fall
+		   back to Song::GetDuration() */
+		return song.GetDuration();
+
+	const SongTime start_time = song.GetStartTime();
+	const SongTime end_time = song.GetEndTime();
+
+	if (end_time.IsPositive() && end_time < SongTime(decoder_duration))
+		return SignedSongTime(end_time - start_time);
+
+	return SignedSongTime(SongTime(decoder_duration) - start_time);
+}
+
+bool
+Player::OpenOutput()
+{
+	assert(play_audio_format.IsDefined());
+	assert(pc.state == PlayerState::PLAY ||
+	       pc.state == PlayerState::PAUSE);
+
+	Error error;
+	if (pc.outputs.Open(play_audio_format, buffer, error)) {
+		output_open = true;
+		paused = false;
+
+		pc.Lock();
+		pc.state = PlayerState::PLAY;
+		pc.Unlock();
+
+		idle_add(IDLE_PLAYER);
+
+		return true;
+	} else {
+		LogError(error);
+
+		output_open = false;
+
+		/* pause: the user may resume playback as soon as an
+		   audio output becomes available */
+		paused = true;
+
+		pc.Lock();
+		pc.SetError(PlayerError::OUTPUT, std::move(error));
+		pc.state = PlayerState::PAUSE;
+		pc.Unlock();
+
+		idle_add(IDLE_PLAYER);
+
+		return false;
+	}
+}
+
+bool
+Player::CheckDecoderStartup()
+{
+	assert(decoder_starting);
+
+	pc.Lock();
+
+	Error error = dc.GetError();
+	if (error.IsDefined()) {
+		/* the decoder failed */
+		pc.SetError(PlayerError::DECODER, std::move(error));
+		pc.Unlock();
+
+		return false;
+	} else if (!dc.IsStarting()) {
+		/* the decoder is ready and ok */
+
+		pc.Unlock();
+
+		if (output_open &&
+		    !pc.outputs.Wait(pc, 1))
+			/* the output devices havn't finished playing
+			   all chunks yet - wait for that */
+			return true;
+
+		pc.Lock();
+		pc.total_time = real_song_duration(*dc.song, dc.total_time);
+		pc.audio_format = dc.in_audio_format;
+		pc.Unlock();
+
+		idle_add(IDLE_PLAYER);
+
+		play_audio_format = dc.out_audio_format;
+		decoder_starting = false;
+
+		if (!paused && !OpenOutput()) {
+			FormatError(player_domain,
+				    "problems opening audio device "
+				    "while playing \"%s\"",
+				    dc.song->GetURI());
+			return true;
+		}
+
+		return true;
+	} else {
+		/* the decoder is not yet ready; wait
+		   some more */
+		dc.WaitForDecoder();
+		pc.Unlock();
+
+		return true;
+	}
+}
+
+bool
+Player::SendSilence()
+{
+	assert(output_open);
+	assert(play_audio_format.IsDefined());
+
+	MusicChunk *chunk = buffer.Allocate();
+	if (chunk == nullptr) {
+		LogError(player_domain, "Failed to allocate silence buffer");
+		return false;
+	}
+
+#ifndef NDEBUG
+	chunk->audio_format = play_audio_format;
+#endif
+
+	const size_t frame_size = play_audio_format.GetFrameSize();
+	/* this formula ensures that we don't send
+	   partial frames */
+	unsigned num_frames = sizeof(chunk->data) / frame_size;
+
+	chunk->time = SignedSongTime::Negative(); /* undefined time stamp */
+	chunk->length = num_frames * frame_size;
+	memset(chunk->data, 0, chunk->length);
+
+	Error error;
+	if (!pc.outputs.Play(chunk, error)) {
+		LogError(error);
+		buffer.Return(chunk);
+		return false;
+	}
+
+	return true;
+}
+
+inline bool
+Player::SeekDecoder()
+{
+	assert(pc.next_song != nullptr);
+
+	const SongTime start_time = pc.next_song->GetStartTime();
+
+	if (!dc.LockIsCurrentSong(*pc.next_song)) {
+		/* the decoder is already decoding the "next" song -
+		   stop it and start the previous song again */
+
+		StopDecoder();
+
+		/* clear music chunks which might still reside in the
+		   pipe */
+		pipe->Clear(buffer);
+
+		/* re-start the decoder */
+		StartDecoder(*pipe);
+		if (!WaitForDecoder()) {
+			/* decoder failure */
+			player_command_finished(pc);
+			return false;
+		}
+	} else {
+		if (!IsDecoderAtCurrentSong()) {
+			/* the decoder is already decoding the "next" song,
+			   but it is the same song file; exchange the pipe */
+			ClearAndReplacePipe(dc.pipe);
+		}
+
+		delete pc.next_song;
+		pc.next_song = nullptr;
+		queued = false;
+	}
+
+	/* wait for the decoder to complete initialization */
+
+	while (decoder_starting) {
+		if (!CheckDecoderStartup()) {
+			/* decoder failure */
+			player_command_finished(pc);
+			return false;
+		}
+	}
+
+	/* send the SEEK command */
+
+	SongTime where = pc.seek_time;
+	if (!pc.total_time.IsNegative()) {
+		const SongTime total_time(pc.total_time);
+		if (where > total_time)
+			where = total_time;
+	}
+
+	if (!dc.Seek(where + start_time)) {
+		/* decoder failure */
+		player_command_finished(pc);
+		return false;
+	}
+
+	elapsed_time = where;
+
+	player_command_finished(pc);
+
+	xfade_state = CrossFadeState::UNKNOWN;
+
+	/* re-fill the buffer after seeking */
+	buffering = true;
+
+	pc.outputs.Cancel();
+
+	return true;
+}
+
+inline void
+Player::ProcessCommand()
+{
+	switch (pc.command) {
+	case PlayerCommand::NONE:
+	case PlayerCommand::STOP:
+	case PlayerCommand::EXIT:
+	case PlayerCommand::CLOSE_AUDIO:
+		break;
+
+	case PlayerCommand::UPDATE_AUDIO:
+		pc.Unlock();
+		pc.outputs.EnableDisable();
+		pc.Lock();
+		pc.CommandFinished();
+		break;
+
+	case PlayerCommand::QUEUE:
+		assert(pc.next_song != nullptr);
+		assert(!queued);
+		assert(!IsDecoderAtNextSong());
+
+		queued = true;
+		pc.CommandFinished();
+
+		pc.Unlock();
+		if (dc.LockIsIdle())
+			StartDecoder(*new MusicPipe());
+		pc.Lock();
+
+		break;
+
+	case PlayerCommand::PAUSE:
+		pc.Unlock();
+
+		paused = !paused;
+		if (paused) {
+			pc.outputs.Pause();
+			pc.Lock();
+
+			pc.state = PlayerState::PAUSE;
+		} else if (!play_audio_format.IsDefined()) {
+			/* the decoder hasn't provided an audio format
+			   yet - don't open the audio device yet */
+			pc.Lock();
+
+			pc.state = PlayerState::PLAY;
+		} else {
+			OpenOutput();
+
+			pc.Lock();
+		}
+
+		pc.CommandFinished();
+		break;
+
+	case PlayerCommand::SEEK:
+		pc.Unlock();
+		SeekDecoder();
+		pc.Lock();
+		break;
+
+	case PlayerCommand::CANCEL:
+		if (pc.next_song == nullptr) {
+			/* the cancel request arrived too late, we're
+			   already playing the queued song...  stop
+			   everything now */
+			pc.command = PlayerCommand::STOP;
+			return;
+		}
+
+		if (IsDecoderAtNextSong()) {
+			/* the decoder is already decoding the song -
+			   stop it and reset the position */
+			pc.Unlock();
+			StopDecoder();
+			pc.Lock();
+		}
+
+		delete pc.next_song;
+		pc.next_song = nullptr;
+		queued = false;
+		pc.CommandFinished();
+		break;
+
+	case PlayerCommand::REFRESH:
+		if (output_open && !paused) {
+			pc.Unlock();
+			pc.outputs.Check();
+			pc.Lock();
+		}
+
+		pc.elapsed_time = !pc.outputs.GetElapsedTime().IsNegative()
+			? SongTime(pc.outputs.GetElapsedTime())
+			: elapsed_time;
+
+		pc.CommandFinished();
+		break;
+	}
+}
+
+static void
+update_song_tag(PlayerControl &pc, DetachedSong &song, const Tag &new_tag)
+{
+	if (song.IsFile())
+		/* don't update tags of local files, only remote
+		   streams may change tags dynamically */
+		return;
+
+	song.SetTag(new_tag);
+
+	pc.LockSetTaggedSong(song);
+
+	/* the main thread will update the playlist version when he
+	   receives this event */
+	pc.listener.OnPlayerTagModified();
+
+	/* notify all clients that the tag of the current song has
+	   changed */
+	idle_add(IDLE_PLAYER);
+}
+
+/**
+ * Plays a #MusicChunk object (after applying software volume).  If
+ * it contains a (stream) tag, copy it to the current song, so MPD's
+ * playlist reflects the new stream tag.
+ *
+ * Player lock is not held.
+ */
+static bool
+play_chunk(PlayerControl &pc,
+	   DetachedSong &song, MusicChunk *chunk,
+	   MusicBuffer &buffer,
+	   const AudioFormat format,
+	   Error &error)
+{
+	assert(chunk->CheckFormat(format));
+
+	if (chunk->tag != nullptr)
+		update_song_tag(pc, song, *chunk->tag);
+
+	if (chunk->IsEmpty()) {
+		buffer.Return(chunk);
+		return true;
+	}
+
+	pc.Lock();
+	pc.bit_rate = chunk->bit_rate;
+	pc.Unlock();
+
+	/* send the chunk to the audio outputs */
+
+	if (!pc.outputs.Play(chunk, error))
+		return false;
+
+	pc.total_play_time += (double)chunk->length /
+		format.GetTimeToSize();
+	return true;
+}
+
+inline bool
+Player::PlayNextChunk()
+{
+	if (!pc.outputs.Wait(pc, 64))
+		/* the output pipe is still large enough, don't send
+		   another chunk */
+		return true;
+
+	unsigned cross_fade_position;
+	MusicChunk *chunk = nullptr;
+	if (xfade_state == CrossFadeState::ENABLED && IsDecoderAtNextSong() &&
+	    (cross_fade_position = pipe->GetSize()) <= cross_fade_chunks) {
+		/* perform cross fade */
+		MusicChunk *other_chunk = dc.pipe->Shift();
+
+		if (!cross_fading) {
+			/* beginning of the cross fade - adjust
+			   crossFadeChunks which might be bigger than
+			   the remaining number of chunks in the old
+			   song */
+			cross_fade_chunks = cross_fade_position;
+			cross_fading = true;
+		}
+
+		if (other_chunk != nullptr) {
+			chunk = pipe->Shift();
+			assert(chunk != nullptr);
+			assert(chunk->other == nullptr);
+
+			/* don't send the tags of the new song (which
+			   is being faded in) yet; postpone it until
+			   the current song is faded out */
+			cross_fade_tag =
+				Tag::MergeReplace(cross_fade_tag,
+						  other_chunk->tag);
+			other_chunk->tag = nullptr;
+
+			if (pc.cross_fade.mixramp_delay <= 0) {
+				chunk->mix_ratio = ((float)cross_fade_position)
+					     / cross_fade_chunks;
+			} else {
+				chunk->mix_ratio = -1;
+			}
+
+			if (other_chunk->IsEmpty()) {
+				/* the "other" chunk was a MusicChunk
+				   which had only a tag, but no music
+				   data - we cannot cross-fade that;
+				   but since this happens only at the
+				   beginning of the new song, we can
+				   easily recover by throwing it away
+				   now */
+				buffer.Return(other_chunk);
+				other_chunk = nullptr;
+			}
+
+			chunk->other = other_chunk;
+		} else {
+			/* there are not enough decoded chunks yet */
+
+			pc.Lock();
+
+			if (dc.IsIdle()) {
+				/* the decoder isn't running, abort
+				   cross fading */
+				pc.Unlock();
+
+				xfade_state = CrossFadeState::DISABLED;
+			} else {
+				/* wait for the decoder */
+				dc.Signal();
+				dc.WaitForDecoder();
+				pc.Unlock();
+
+				return true;
+			}
+		}
+	}
+
+	if (chunk == nullptr)
+		chunk = pipe->Shift();
+
+	assert(chunk != nullptr);
+
+	/* insert the postponed tag if cross-fading is finished */
+
+	if (xfade_state != CrossFadeState::ENABLED && cross_fade_tag != nullptr) {
+		chunk->tag = Tag::MergeReplace(chunk->tag, cross_fade_tag);
+		cross_fade_tag = nullptr;
+	}
+
+	/* play the current chunk */
+
+	Error error;
+	if (!play_chunk(pc, *song, chunk, buffer, play_audio_format, error)) {
+		LogError(error);
+
+		buffer.Return(chunk);
+
+		pc.Lock();
+
+		pc.SetError(PlayerError::OUTPUT, std::move(error));
+
+		/* pause: the user may resume playback as soon as an
+		   audio output becomes available */
+		pc.state = PlayerState::PAUSE;
+		paused = true;
+
+		pc.Unlock();
+
+		idle_add(IDLE_PLAYER);
+
+		return false;
+	}
+
+	/* this formula should prevent that the decoder gets woken up
+	   with each chunk; it is more efficient to make it decode a
+	   larger block at a time */
+	pc.Lock();
+	if (!dc.IsIdle() &&
+	    dc.pipe->GetSize() <= (pc.buffered_before_play +
+				   buffer.GetSize() * 3) / 4) {
+		if (!decoder_woken) {
+			decoder_woken = true;
+			dc.Signal();
+		}
+	} else
+		decoder_woken = false;
+	pc.Unlock();
+
+	return true;
+}
+
+inline bool
+Player::SongBorder()
+{
+	xfade_state = CrossFadeState::UNKNOWN;
+
+	FormatDefault(player_domain, "played \"%s\"", song->GetURI());
+
+	ReplacePipe(dc.pipe);
+
+	pc.outputs.SongBorder();
+
+	if (!WaitForDecoder())
+		return false;
+
+	pc.Lock();
+
+	const bool border_pause = pc.border_pause;
+	if (border_pause) {
+		paused = true;
+		pc.state = PlayerState::PAUSE;
+	}
+
+	pc.Unlock();
+
+	if (border_pause)
+		idle_add(IDLE_PLAYER);
+
+	return true;
+}
+
+inline void
+Player::Run()
+{
+	pipe = new MusicPipe();
+
+	StartDecoder(*pipe);
+	if (!WaitForDecoder()) {
+		assert(song == nullptr);
+
+		StopDecoder();
+		player_command_finished(pc);
+		delete pipe;
+		return;
+	}
+
+	pc.Lock();
+	pc.state = PlayerState::PLAY;
+
+	if (pc.command == PlayerCommand::SEEK)
+		elapsed_time = pc.seek_time;
+
+	pc.CommandFinished();
+
+	while (true) {
+		ProcessCommand();
+		if (pc.command == PlayerCommand::STOP ||
+		    pc.command == PlayerCommand::EXIT ||
+		    pc.command == PlayerCommand::CLOSE_AUDIO) {
+			pc.Unlock();
+			pc.outputs.Cancel();
+			break;
+		}
+
+		pc.Unlock();
+
+		if (buffering) {
+			/* buffering at the start of the song - wait
+			   until the buffer is large enough, to
+			   prevent stuttering on slow machines */
+
+			if (pipe->GetSize() < pc.buffered_before_play &&
+			    !dc.LockIsIdle()) {
+				/* not enough decoded buffer space yet */
+
+				if (!paused && output_open &&
+				    pc.outputs.Check() < 4 &&
+				    !SendSilence())
+					break;
+
+				pc.Lock();
+				/* XXX race condition: check decoder again */
+				dc.WaitForDecoder();
+				continue;
+			} else {
+				/* buffering is complete */
+				buffering = false;
+			}
+		}
+
+		if (decoder_starting) {
+			/* wait until the decoder is initialized completely */
+
+			if (!CheckDecoderStartup())
+				break;
+
+			pc.Lock();
+			continue;
+		}
+
+#ifndef NDEBUG
+		/*
+		music_pipe_check_format(&play_audio_format,
+					next_song_chunk,
+					&dc.out_audio_format);
+		*/
+#endif
+
+		if (dc.LockIsIdle() && queued && dc.pipe == pipe) {
+			/* the decoder has finished the current song;
+			   make it decode the next song */
+
+			assert(dc.pipe == nullptr || dc.pipe == pipe);
+
+			StartDecoder(*new MusicPipe());
+		}
+
+		if (/* no cross-fading if MPD is going to pause at the
+		       end of the current song */
+		    !pc.border_pause &&
+		    IsDecoderAtNextSong() &&
+		    xfade_state == CrossFadeState::UNKNOWN &&
+		    !dc.LockIsStarting()) {
+			/* enable cross fading in this song?  if yes,
+			   calculate how many chunks will be required
+			   for it */
+			cross_fade_chunks =
+				pc.cross_fade.Calculate(dc.total_time,
+							dc.replay_gain_db,
+							dc.replay_gain_prev_db,
+							dc.GetMixRampStart(),
+							dc.GetMixRampPreviousEnd(),
+							dc.out_audio_format,
+							play_audio_format,
+							buffer.GetSize() -
+							pc.buffered_before_play);
+			if (cross_fade_chunks > 0) {
+				xfade_state = CrossFadeState::ENABLED;
+				cross_fading = false;
+			} else
+				/* cross fading is disabled or the
+				   next song is too short */
+				xfade_state = CrossFadeState::DISABLED;
+		}
+
+		if (paused) {
+			pc.Lock();
+
+			if (pc.command == PlayerCommand::NONE)
+				pc.Wait();
+			continue;
+		} else if (!pipe->IsEmpty()) {
+			/* at least one music chunk is ready - send it
+			   to the audio output */
+
+			PlayNextChunk();
+		} else if (pc.outputs.Check() > 0) {
+			/* not enough data from decoder, but the
+			   output thread is still busy, so it's
+			   okay */
+
+			pc.Lock();
+
+			/* wake up the decoder (just in case it's
+			   waiting for space in the MusicBuffer) and
+			   wait for it */
+			dc.Signal();
+			dc.WaitForDecoder();
+			continue;
+		} else if (IsDecoderAtNextSong()) {
+			/* at the beginning of a new song */
+
+			if (!SongBorder())
+				break;
+		} else if (dc.LockIsIdle()) {
+			/* check the size of the pipe again, because
+			   the decoder thread may have added something
+			   since we last checked */
+			if (pipe->IsEmpty()) {
+				/* wait for the hardware to finish
+				   playback */
+				pc.outputs.Drain();
+				break;
+			}
+		} else if (output_open) {
+			/* the decoder is too busy and hasn't provided
+			   new PCM data in time: send silence (if the
+			   output pipe is empty) */
+			if (!SendSilence())
+				break;
+		}
+
+		pc.Lock();
+	}
+
+	StopDecoder();
+
+	ClearAndDeletePipe();
+
+	delete cross_fade_tag;
+
+	if (song != nullptr) {
+		FormatDefault(player_domain, "played \"%s\"", song->GetURI());
+		delete song;
+	}
+
+	pc.Lock();
+
+	pc.ClearTaggedSong();
+
+	if (queued) {
+		assert(pc.next_song != nullptr);
+		delete pc.next_song;
+		pc.next_song = nullptr;
+	}
+
+	pc.state = PlayerState::STOP;
+
+	pc.Unlock();
+}
+
+static void
+do_play(PlayerControl &pc, DecoderControl &dc,
+	MusicBuffer &buffer)
+{
+	Player player(pc, dc, buffer);
+	player.Run();
+}
+
+static void
+player_task(void *arg)
+{
+	PlayerControl &pc = *(PlayerControl *)arg;
+
+	SetThreadName("player");
+
+	DecoderControl dc(pc.mutex, pc.cond);
+	decoder_thread_start(dc);
+
+	MusicBuffer buffer(pc.buffer_chunks);
+
+	pc.Lock();
+
+	while (1) {
+		switch (pc.command) {
+		case PlayerCommand::SEEK:
+		case PlayerCommand::QUEUE:
+			assert(pc.next_song != nullptr);
+
+			pc.Unlock();
+			do_play(pc, dc, buffer);
+			pc.listener.OnPlayerSync();
+			pc.Lock();
+			break;
+
+		case PlayerCommand::STOP:
+			pc.Unlock();
+			pc.outputs.Cancel();
+			pc.Lock();
+
+			/* fall through */
+
+		case PlayerCommand::PAUSE:
+			delete pc.next_song;
+			pc.next_song = nullptr;
+
+			pc.CommandFinished();
+			break;
+
+		case PlayerCommand::CLOSE_AUDIO:
+			pc.Unlock();
+
+			pc.outputs.Release();
+
+			pc.Lock();
+			pc.CommandFinished();
+
+			assert(buffer.IsEmptyUnsafe());
+
+			break;
+
+		case PlayerCommand::UPDATE_AUDIO:
+			pc.Unlock();
+			pc.outputs.EnableDisable();
+			pc.Lock();
+			pc.CommandFinished();
+			break;
+
+		case PlayerCommand::EXIT:
+			pc.Unlock();
+
+			dc.Quit();
+
+			pc.outputs.Close();
+
+			player_command_finished(pc);
+			return;
+
+		case PlayerCommand::CANCEL:
+			delete pc.next_song;
+			pc.next_song = nullptr;
+
+			pc.CommandFinished();
+			break;
+
+		case PlayerCommand::REFRESH:
+			/* no-op when not playing */
+			pc.CommandFinished();
+			break;
+
+		case PlayerCommand::NONE:
+			pc.Wait();
+			break;
+		}
+	}
+}
+
+void
+StartPlayerThread(PlayerControl &pc)
+{
+	assert(!pc.thread.IsDefined());
+
+	Error error;
+	if (!pc.thread.Start(player_task, &pc, error))
+		FatalError(error);
+}
diff --git a/src/player/Thread.hxx b/src/player/Thread.hxx
new file mode 100644
index 000000000..fc6ea4364
--- /dev/null
+++ b/src/player/Thread.hxx
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2003-2015 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.
+ */
+
+/* \file
+ *
+ * The player thread controls the playback.  It acts as a bridge
+ * between the decoder thread and the output thread(s): it receives
+ * #MusicChunk objects from the decoder, optionally mixes them
+ * (cross-fading), applies software volume, and sends them to the
+ * audio outputs via audio_output_all_play().
+ *
+ * It is controlled by the main thread (the playlist code), see
+ * Control.hxx.  The playlist enqueues new songs into the player
+ * thread and sends it commands.
+ *
+ * The player thread itself does not do any I/O.  It synchronizes with
+ * other threads via #GMutex and #GCond objects, and passes
+ * #MusicChunk instances around in #MusicPipe objects.
+ */
+
+#ifndef MPD_PLAYER_THREAD_HXX
+#define MPD_PLAYER_THREAD_HXX
+
+struct PlayerControl;
+
+void
+StartPlayerThread(PlayerControl &pc);
+
+#endif