16 files changed, 719 insertions, 20 deletions

diff --git a/src/input/archive_input_plugin.c b/src/input/archive_input_plugin.c
index 97e4836ff..8d78f4c89 100644
--- a/src/input/archive_input_plugin.c
+++ b/src/input/archive_input_plugin.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2010 The Music Player Daemon Project
+ * Copyright (C) 2003-2011 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/input/archive_input_plugin.h b/src/input/archive_input_plugin.h
index 20568cfbe..51095f37f 100644
--- a/src/input/archive_input_plugin.h
+++ b/src/input/archive_input_plugin.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2010 The Music Player Daemon Project
+ * Copyright (C) 2003-2011 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/input/cdio_paranoia_input_plugin.c b/src/input/cdio_paranoia_input_plugin.c
new file mode 100644
index 000000000..400c66ef3
--- /dev/null
+++ b/src/input/cdio_paranoia_input_plugin.c
@@ -0,0 +1,388 @@
+/*
+ * Copyright (C) 2003-2011 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.
+ */
+
+/**
+  * CD-Audio handling (requires libcdio_paranoia)
+  */
+
+#include "config.h"
+#include "input/cdio_paranoia_input_plugin.h"
+#include "input_plugin.h"
+#include "refcount.h"
+#include "pcm_buffer.h"
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdlib.h>
+#include <glib.h>
+#include <assert.h>
+
+#include <cdio/paranoia.h>
+#include <cdio/cd_types.h>
+
+struct input_cdio_paranoia {
+	struct input_stream base;
+
+	cdrom_drive_t *drv;
+	CdIo_t *cdio;
+	cdrom_paranoia_t *para;
+
+	int endian;
+
+	lsn_t lsn_from, lsn_to;
+	int lsn_relofs;
+
+	int trackno;
+
+	char buffer[CDIO_CD_FRAMESIZE_RAW];
+	int buffer_lsn;
+
+	struct pcm_buffer conv_buffer;
+};
+
+static inline GQuark
+cdio_quark(void)
+{
+	return g_quark_from_static_string("cdio");
+}
+
+static void
+input_cdio_close(struct input_stream *is)
+{
+	struct input_cdio_paranoia *i = (struct input_cdio_paranoia *)is;
+
+	pcm_buffer_deinit(&i->conv_buffer);
+
+	if (i->para)
+		cdio_paranoia_free(i->para);
+	if (i->drv)
+		cdio_cddap_close_no_free_cdio( i->drv);
+	if (i->cdio)
+		cdio_destroy( i->cdio );
+
+	input_stream_deinit(&i->base);
+	g_free(i);
+}
+
+struct cdio_uri {
+	char device[64];
+	int track;
+};
+
+static bool
+parse_cdio_uri(struct cdio_uri *dest, const char *src, GError **error_r)
+{
+	if (!g_str_has_prefix(src, "cdda://"))
+		return false;
+
+	src += 7;
+
+	if (*src == 0) {
+		/* play the whole CD in the default drive */
+		dest->device[0] = 0;
+		dest->track = -1;
+		return true;
+	}
+
+	const char *slash = strrchr(src, '/');
+	if (slash == NULL) {
+		/* play the whole CD in the specified drive */
+		g_strlcpy(dest->device, src, sizeof(dest->device));
+		dest->track = -1;
+		return true;
+	}
+
+	size_t device_length = slash - src;
+	if (device_length >= sizeof(dest->device))
+		device_length = sizeof(dest->device) - 1;
+
+	memcpy(dest->device, src, device_length);
+	dest->device[device_length] = 0;
+
+	const char *track = slash + 1;
+
+	char *endptr;
+	dest->track = strtoul(track, &endptr, 10);
+	if (*endptr != 0) {
+		g_set_error(error_r, cdio_quark(), 0,
+			    "Malformed track number");
+		return false;
+	}
+
+	if (endptr == track)
+		/* play the whole CD */
+		dest->track = -1;
+
+	return true;
+}
+
+static char *
+cdio_detect_device(void)
+{
+	char **devices = cdio_get_devices_with_cap(NULL, CDIO_FS_AUDIO, false);
+	if (devices == NULL)
+		return NULL;
+
+	char *device = g_strdup(devices[0]);
+	cdio_free_device_list(devices);
+
+	return device;
+}
+
+static struct input_stream *
+input_cdio_open(const char *uri, GError **error_r)
+{
+	struct input_cdio_paranoia *i;
+
+	struct cdio_uri parsed_uri;
+	if (!parse_cdio_uri(&parsed_uri, uri, error_r))
+		return NULL;
+
+	i = g_new(struct input_cdio_paranoia, 1);
+	input_stream_init(&i->base, &input_plugin_cdio_paranoia, uri);
+
+	/* initialize everything (should be already) */
+	i->drv = NULL;
+	i->cdio = NULL;
+	i->para = NULL;
+	i->trackno = parsed_uri.track;
+	pcm_buffer_init(&i->conv_buffer);
+
+	/* get list of CD's supporting CD-DA */
+	char *device = parsed_uri.device[0] != 0
+		? g_strdup(parsed_uri.device)
+		: cdio_detect_device();
+	if (device == NULL) {
+		g_set_error(error_r, cdio_quark(), 0,
+			    "Unable find or access a CD-ROM drive with an audio CD in it.");
+		input_cdio_close(&i->base);
+		return NULL;
+	}
+
+	/* Found such a CD-ROM with a CD-DA loaded. Use the first drive in the list. */
+	i->cdio = cdio_open(device, DRIVER_UNKNOWN);
+	g_free(device);
+
+	i->drv = cdio_cddap_identify_cdio(i->cdio, 1, NULL);
+
+	if ( !i->drv ) {
+		g_set_error(error_r, cdio_quark(), 0,
+			    "Unable to identify audio CD disc.");
+		input_cdio_close(&i->base);
+		return NULL;
+	}
+
+	cdda_verbose_set(i->drv, CDDA_MESSAGE_FORGETIT, CDDA_MESSAGE_FORGETIT);
+
+	if ( 0 != cdio_cddap_open(i->drv) ) {
+		g_set_error(error_r, cdio_quark(), 0, "Unable to open disc.");
+		input_cdio_close(&i->base);
+		return NULL;
+	}
+
+	i->endian = data_bigendianp(i->drv);
+	switch (i->endian) {
+	case -1:
+		g_debug("cdda: drive returns unknown audio data, assuming Little Endian");
+		i->endian = 0;
+		break;
+	case 0:
+		g_debug("cdda: drive returns audio data Little Endian.");
+		break;
+	case 1:
+		g_debug("cdda: drive returns audio data Big Endian.");
+		break;
+	default:
+		g_set_error(error_r, cdio_quark(), 0,
+			    "Drive returns unknown data type %d", i->endian);
+		input_cdio_close(&i->base);
+		return NULL;
+	}
+
+	i->lsn_relofs = 0;
+
+	if (i->trackno >= 0) {
+		i->lsn_from = cdio_get_track_lsn(i->cdio, i->trackno);
+		i->lsn_to = cdio_get_track_last_lsn(i->cdio, i->trackno);
+	} else {
+		i->lsn_from = 0;
+		i->lsn_to = cdio_get_disc_last_lsn(i->cdio);
+	}
+
+	i->para = cdio_paranoia_init(i->drv);
+
+	/* Set reading mode for full paranoia, but allow skipping sectors. */
+	paranoia_modeset(i->para, PARANOIA_MODE_FULL^PARANOIA_MODE_NEVERSKIP);
+
+	/* seek to beginning of the track */
+	cdio_paranoia_seek(i->para, i->lsn_from, SEEK_SET);
+
+	i->base.ready = true;
+	i->base.seekable = true;
+	i->base.size = (i->lsn_to - i->lsn_from + 1) * CDIO_CD_FRAMESIZE_RAW;
+
+	/* hack to make MPD select the "pcm" decoder plugin */
+	i->base.mime = g_strdup("audio/x-mpd-cdda-pcm");
+
+	return &i->base;
+}
+
+static bool
+input_cdio_seek(struct input_stream *is,
+		goffset offset, int whence, GError **error_r)
+{
+	struct input_cdio_paranoia *cis = (struct input_cdio_paranoia *)is;
+
+	/* calculate absolute offset */
+	switch (whence) {
+	case SEEK_SET:
+		break;
+	case SEEK_CUR:
+		offset += cis->base.offset;
+		break;
+	case SEEK_END:
+		offset += cis->base.size;
+		break;
+	}
+
+	if (offset < 0 || offset > cis->base.size) {
+		g_set_error(error_r, cdio_quark(), 0,
+			    "Invalid offset to seek %ld (%ld)",
+			    (long int)offset, (long int)cis->base.size);
+		return false;
+	}
+
+	/* simple case */
+	if (offset == cis->base.offset)
+		return true;
+
+	/* calculate current LSN */
+	cis->lsn_relofs = offset / CDIO_CD_FRAMESIZE_RAW;
+	cis->base.offset = offset;
+
+	cdio_paranoia_seek(cis->para, cis->lsn_from + cis->lsn_relofs, SEEK_SET);
+
+	return true;
+}
+
+static inline size_t
+pcm16_to_wave(uint16_t *dst16, const uint16_t *src16, size_t length)
+{
+	size_t cnt = length >> 1;
+	while (cnt > 0) {
+		*dst16++ = GUINT16_TO_LE(*src16++);
+		cnt--;
+	}
+	return length;
+}
+
+static size_t
+input_cdio_read(struct input_stream *is, void *ptr, size_t length,
+		GError **error_r)
+{
+	struct input_cdio_paranoia *cis = (struct input_cdio_paranoia *)is;
+	size_t nbytes = 0;
+	int diff;
+	size_t len, maxwrite;
+	int16_t *rbuf;
+	char *s_err, *s_mess;
+	char *wptr = (char *) ptr;
+
+	while (length > 0) {
+
+
+		/* end of track ? */
+		if (cis->lsn_from + cis->lsn_relofs > cis->lsn_to)
+			break;
+
+		//current sector was changed ?
+		if (cis->lsn_relofs != cis->buffer_lsn) {
+			rbuf = cdio_paranoia_read(cis->para, NULL);
+
+			s_err = cdda_errors(cis->drv);
+			if (s_err) {
+				g_warning("paranoia_read: %s", s_err );
+				free(s_err);
+			}
+			s_mess = cdda_messages(cis->drv);
+			if (s_mess) {
+				free(s_mess);
+			}
+			if (!rbuf) {
+				g_set_error(error_r, cdio_quark(), 0,
+					"paranoia read error. Stopping.");
+				return 0;
+			}
+			//do the swapping if nessesary
+			if (cis->endian != 0) {
+				uint16_t *conv_buffer = pcm_buffer_get(&cis->conv_buffer, CDIO_CD_FRAMESIZE_RAW );
+				/* do endian conversion ! */
+				pcm16_to_wave( conv_buffer, (uint16_t*) rbuf, CDIO_CD_FRAMESIZE_RAW);
+				rbuf = (int16_t *)conv_buffer;
+			}
+			//store current buffer
+			memcpy(cis->buffer, rbuf, CDIO_CD_FRAMESIZE_RAW);
+			cis->buffer_lsn = cis->lsn_relofs;
+		} else {
+			//use cached sector
+			rbuf = (int16_t*) cis->buffer;
+		}
+
+		//correct offset
+		diff = cis->base.offset - cis->lsn_relofs * CDIO_CD_FRAMESIZE_RAW;
+
+		assert(diff >= 0 && diff < CDIO_CD_FRAMESIZE_RAW);
+
+		maxwrite = CDIO_CD_FRAMESIZE_RAW - diff;  //# of bytes pending in current buffer
+		len = (length < maxwrite? length : maxwrite);
+
+		//skip diff bytes from this lsn
+		memcpy(wptr, ((char*)rbuf) + diff, len);
+		//update pointer
+		wptr += len;
+		nbytes += len;
+
+		//update offset
+		cis->base.offset += len;
+		cis->lsn_relofs = cis->base.offset / CDIO_CD_FRAMESIZE_RAW;
+		//update length
+		length -= len;
+	}
+
+	return nbytes;
+}
+
+static bool
+input_cdio_eof(struct input_stream *is)
+{
+	struct input_cdio_paranoia *cis = (struct input_cdio_paranoia *)is;
+
+	return (cis->lsn_from + cis->lsn_relofs > cis->lsn_to);
+}
+
+const struct input_plugin input_plugin_cdio_paranoia = {
+	.name = "cdio_paranoia",
+	.open = input_cdio_open,
+	.close = input_cdio_close,
+	.seek = input_cdio_seek,
+	.read = input_cdio_read,
+	.eof = input_cdio_eof
+};
diff --git a/src/input/cdio_paranoia_input_plugin.h b/src/input/cdio_paranoia_input_plugin.h
new file mode 100644
index 000000000..71c5cbe8d
--- /dev/null
+++ b/src/input/cdio_paranoia_input_plugin.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2003-2011 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_CDIO_PARANOIA_INPUT_PLUGIN_H
+#define MPD_CDIO_PARANOIA_INPUT_PLUGIN_H
+
+/**
+ * An input plugin based on libcdio_paranoia library.
+ */
+extern const struct input_plugin input_plugin_cdio_paranoia;
+
+#endif
diff --git a/src/input/curl_input_plugin.c b/src/input/curl_input_plugin.c
index ae645bddf..09010c220 100644
--- a/src/input/curl_input_plugin.c
+++ b/src/input/curl_input_plugin.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2010 The Music Player Daemon Project
+ * Copyright (C) 2003-2011 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -647,6 +647,7 @@ input_curl_easy_init(struct input_curl *c, GError **error_r)
 	curl_easy_setopt(c->easy, CURLOPT_WRITEDATA, c);
 	curl_easy_setopt(c->easy, CURLOPT_HTTP200ALIASES, http_200_aliases);
 	curl_easy_setopt(c->easy, CURLOPT_FOLLOWLOCATION, 1);
+	curl_easy_setopt(c->easy, CURLOPT_NETRC, 1);
 	curl_easy_setopt(c->easy, CURLOPT_MAXREDIRS, 5);
 	curl_easy_setopt(c->easy, CURLOPT_FAILONERROR, true);
 	curl_easy_setopt(c->easy, CURLOPT_ERRORBUFFER, c->error);
diff --git a/src/input/curl_input_plugin.h b/src/input/curl_input_plugin.h
index be7db4e26..7cfe5155c 100644
--- a/src/input/curl_input_plugin.h
+++ b/src/input/curl_input_plugin.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2010 The Music Player Daemon Project
+ * Copyright (C) 2003-2011 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/input/despotify_input_plugin.c b/src/input/despotify_input_plugin.c
new file mode 100644
index 000000000..b63663c50
--- /dev/null
+++ b/src/input/despotify_input_plugin.c
@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2011 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 "input/despotify_input_plugin.h"
+#include "input_plugin.h"
+#include "tag.h"
+#include "despotify_utils.h"
+
+#include <glib.h>
+
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <despotify.h>
+
+#include <stdio.h>
+
+struct input_despotify {
+	struct input_stream base;
+
+	struct despotify_session *session;
+	struct ds_track *track;
+	struct tag *tag;
+	struct ds_pcm_data pcm;
+	size_t len_available;
+	bool eof;
+};
+
+
+static void
+refill_buffer(struct input_despotify *ctx)
+{
+	/* Wait until there is data */
+	while (1) {
+		int rc = despotify_get_pcm(ctx->session, &ctx->pcm);
+
+		if (rc == 0 && ctx->pcm.len) {
+			ctx->len_available = ctx->pcm.len;
+			break;
+		}
+		if (ctx->eof == true)
+			break;
+
+		if (rc < 0) {
+			g_debug("despotify_get_pcm error\n");
+			ctx->eof = true;
+			break;
+		}
+
+		/* Wait a while until next iteration */
+		usleep(50 * 1000);
+	}
+}
+
+static void callback(G_GNUC_UNUSED struct despotify_session* ds,
+		int sig, G_GNUC_UNUSED void* data, void* callback_data)
+{
+	struct input_despotify *ctx = (struct input_despotify *)callback_data;
+
+	switch (sig) {
+	case DESPOTIFY_NEW_TRACK:
+		break;
+
+	case DESPOTIFY_TIME_TELL:
+		break;
+
+	case DESPOTIFY_TRACK_PLAY_ERROR:
+		g_debug("Track play error\n");
+		ctx->eof = true;
+		ctx->len_available = 0;
+		break;
+
+	case DESPOTIFY_END_OF_PLAYLIST:
+		ctx->eof = true;
+		g_debug("End of playlist: %d\n", ctx->eof);
+		break;
+	}
+}
+
+
+static struct input_stream *
+input_despotify_open(const char *url, G_GNUC_UNUSED GError **error_r)
+{
+	struct input_despotify *ctx;
+	struct despotify_session *session;
+	struct ds_link *ds_link;
+	struct ds_track *track;
+
+	if (!g_str_has_prefix(url, "spt://"))
+		return NULL;
+
+	session = mpd_despotify_get_session();
+	if (!session)
+		return NULL;
+
+	ds_link = despotify_link_from_uri(url + 6);
+	if (!ds_link) {
+		g_debug("Can't find %s\n", url);
+		return NULL;
+	}
+	if (ds_link->type != LINK_TYPE_TRACK) {
+		despotify_free_link(ds_link);
+		return NULL;
+	}
+
+	ctx = g_new(struct input_despotify, 1);
+	memset(ctx, 0, sizeof(*ctx));
+
+	track = despotify_link_get_track(session, ds_link);
+	despotify_free_link(ds_link);
+	if (!track) {
+		g_free(ctx);
+		return NULL;
+	}
+
+	input_stream_init(&ctx->base, &input_plugin_despotify, url);
+	ctx->session = session;
+	ctx->track = track;
+	ctx->tag = mpd_despotify_tag_from_track(track);
+	ctx->eof = false;
+	/* Despotify outputs pcm data */
+	ctx->base.mime = g_strdup("audio/x-mpd-cdda-pcm");
+	ctx->base.ready = true;
+
+	if (!mpd_despotify_register_callback(callback, ctx)) {
+		despotify_free_link(ds_link);
+
+		return NULL;
+	}
+
+	if (despotify_play(ctx->session, ctx->track, false) == false) {
+		despotify_free_track(ctx->track);
+		g_free(ctx);
+		return NULL;
+	}
+
+	return &ctx->base;
+}
+
+static size_t
+input_despotify_read(struct input_stream *is, void *ptr, size_t size,
+	       G_GNUC_UNUSED GError **error_r)
+{
+	struct input_despotify *ctx = (struct input_despotify *)is;
+	size_t to_cpy = size;
+
+	if (ctx->len_available == 0)
+		refill_buffer(ctx);
+
+	if (ctx->len_available < size)
+		to_cpy = ctx->len_available;
+	memcpy(ptr, ctx->pcm.buf, to_cpy);
+	ctx->len_available -= to_cpy;
+
+	is->offset += to_cpy;
+
+	return to_cpy;
+}
+
+static void
+input_despotify_close(struct input_stream *is)
+{
+	struct input_despotify *ctx = (struct input_despotify *)is;
+
+	if (ctx->tag != NULL)
+		tag_free(ctx->tag);
+
+	mpd_despotify_unregister_callback(callback);
+	despotify_free_track(ctx->track);
+	input_stream_deinit(&ctx->base);
+	g_free(ctx);
+}
+
+static bool
+input_despotify_eof(struct input_stream *is)
+{
+	struct input_despotify *ctx = (struct input_despotify *)is;
+
+	return ctx->eof;
+}
+
+static bool
+input_despotify_seek(G_GNUC_UNUSED struct input_stream *is,
+	       G_GNUC_UNUSED goffset offset, G_GNUC_UNUSED int whence,
+	       G_GNUC_UNUSED GError **error_r)
+{
+	return false;
+}
+
+static struct tag *
+input_despotify_tag(struct input_stream *is)
+{
+	struct input_despotify *ctx = (struct input_despotify *)is;
+	struct tag *tag = ctx->tag;
+
+	ctx->tag = NULL;
+
+	return tag;
+}
+
+const struct input_plugin input_plugin_despotify = {
+	.name = "spt",
+	.open = input_despotify_open,
+	.close = input_despotify_close,
+	.read = input_despotify_read,
+	.eof = input_despotify_eof,
+	.seek = input_despotify_seek,
+	.tag = input_despotify_tag,
+};
diff --git a/src/input/despotify_input_plugin.h b/src/input/despotify_input_plugin.h
new file mode 100644
index 000000000..4c070d882
--- /dev/null
+++ b/src/input/despotify_input_plugin.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2011 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 INPUT_DESPOTIFY_H
+#define INPUT_DESPOTIFY_H
+
+extern const struct input_plugin input_plugin_despotify;
+
+#endif
diff --git a/src/input/ffmpeg_input_plugin.c b/src/input/ffmpeg_input_plugin.c
index 0a6be29bc..24d80a379 100644
--- a/src/input/ffmpeg_input_plugin.c
+++ b/src/input/ffmpeg_input_plugin.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2010 The Music Player Daemon Project
+ * Copyright (C) 2003-2011 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -21,13 +21,8 @@
 #include "input/ffmpeg_input_plugin.h"
 #include "input_plugin.h"
 
-#ifdef OLD_FFMPEG_INCLUDES
-#include <avio.h>
-#include <avformat.h>
-#else
 #include <libavformat/avio.h>
 #include <libavformat/avformat.h>
-#endif
 
 #undef G_LOG_DOMAIN
 #define G_LOG_DOMAIN "input_ffmpeg"
@@ -35,7 +30,11 @@
 struct input_ffmpeg {
 	struct input_stream base;
 
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53,0,0)
+	AVIOContext *h;
+#else
 	URLContext *h;
+#endif
 
 	bool eof;
 };
@@ -46,20 +45,29 @@ ffmpeg_quark(void)
 	return g_quark_from_static_string("ffmpeg");
 }
 
+static inline bool
+input_ffmpeg_supported(void)
+{
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53,0,0)
+	void *opaque = NULL;
+	return avio_enum_protocols(&opaque, 0) != NULL;
+#else
+	return av_protocol_next(NULL) != NULL;
+#endif
+}
+
 static bool
 input_ffmpeg_init(G_GNUC_UNUSED const struct config_param *param,
 		  G_GNUC_UNUSED GError **error_r)
 {
 	av_register_all();
 
-#if LIBAVFORMAT_VERSION_MAJOR >= 52
 	/* disable this plugin if there's no registered protocol */
-	if (av_protocol_next(NULL) == NULL) {
+	if (!input_ffmpeg_supported()) {
 		g_set_error(error_r, ffmpeg_quark(), 0,
 			    "No protocol");
 		return false;
 	}
-#endif
 
 	return true;
 }
@@ -80,7 +88,13 @@ input_ffmpeg_open(const char *uri, GError **error_r)
 	i = g_new(struct input_ffmpeg, 1);
 	input_stream_init(&i->base, &input_plugin_ffmpeg, uri);
 
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53,1,0)
+	int ret = avio_open(&i->h, uri, AVIO_FLAG_READ);
+#elif LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53,0,0)
+	int ret = avio_open(&i->h, uri, AVIO_RDONLY);
+#else
 	int ret = url_open(&i->h, uri, URL_RDONLY);
+#endif
 	if (ret != 0) {
 		g_free(i);
 		g_set_error(error_r, ffmpeg_quark(), ret,
@@ -91,8 +105,13 @@ input_ffmpeg_open(const char *uri, GError **error_r)
 	i->eof = false;
 
 	i->base.ready = true;
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53,0,0)
+	i->base.seekable = (i->h->seekable & AVIO_SEEKABLE_NORMAL) != 0;
+	i->base.size = avio_size(i->h);
+#else
 	i->base.seekable = !i->h->is_streamed;
 	i->base.size = url_filesize(i->h);
+#endif
 
 	/* hack to make MPD select the "ffmpeg" decoder plugin - since
 	   avio.h doesn't tell us the MIME type of the resource, we
@@ -109,7 +128,11 @@ input_ffmpeg_read(struct input_stream *is, void *ptr, size_t size,
 {
 	struct input_ffmpeg *i = (struct input_ffmpeg *)is;
 
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53,0,0)
+	int ret = avio_read(i->h, ptr, size);
+#else
 	int ret = url_read(i->h, ptr, size);
+#endif
 	if (ret <= 0) {
 		if (ret < 0)
 			g_set_error(error_r, ffmpeg_quark(), 0,
@@ -128,7 +151,11 @@ input_ffmpeg_close(struct input_stream *is)
 {
 	struct input_ffmpeg *i = (struct input_ffmpeg *)is;
 
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53,0,0)
+	avio_close(i->h);
+#else
 	url_close(i->h);
+#endif
 	input_stream_deinit(&i->base);
 	g_free(i);
 }
@@ -146,7 +173,11 @@ input_ffmpeg_seek(struct input_stream *is, goffset offset, int whence,
 		  G_GNUC_UNUSED GError **error_r)
 {
 	struct input_ffmpeg *i = (struct input_ffmpeg *)is;
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53,0,0)
+	int64_t ret = avio_seek(i->h, offset, whence);
+#else
 	int64_t ret = url_seek(i->h, offset, whence);
+#endif
 
 	if (ret >= 0) {
 		i->eof = false;
diff --git a/src/input/ffmpeg_input_plugin.h b/src/input/ffmpeg_input_plugin.h
index ff87064be..393836ca5 100644
--- a/src/input/ffmpeg_input_plugin.h
+++ b/src/input/ffmpeg_input_plugin.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2010 The Music Player Daemon Project
+ * Copyright (C) 2003-2011 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/input/file_input_plugin.c b/src/input/file_input_plugin.c
index 3646c656e..82ce59e5e 100644
--- a/src/input/file_input_plugin.c
+++ b/src/input/file_input_plugin.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2010 The Music Player Daemon Project
+ * Copyright (C) 2003-2011 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/input/file_input_plugin.h b/src/input/file_input_plugin.h
index 40340e8bd..f24769d57 100644
--- a/src/input/file_input_plugin.h
+++ b/src/input/file_input_plugin.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2010 The Music Player Daemon Project
+ * Copyright (C) 2003-2011 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/input/mms_input_plugin.c b/src/input/mms_input_plugin.c
index 834d111b8..d74196574 100644
--- a/src/input/mms_input_plugin.c
+++ b/src/input/mms_input_plugin.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2010 The Music Player Daemon Project
+ * Copyright (C) 2003-2011 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/input/mms_input_plugin.h b/src/input/mms_input_plugin.h
index 2e10cfbb9..d6aa593f2 100644
--- a/src/input/mms_input_plugin.h
+++ b/src/input/mms_input_plugin.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2010 The Music Player Daemon Project
+ * Copyright (C) 2003-2011 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/input/rewind_input_plugin.c b/src/input/rewind_input_plugin.c
index 6325a978e..33d93d0a4 100644
--- a/src/input/rewind_input_plugin.c
+++ b/src/input/rewind_input_plugin.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2010 The Music Player Daemon Project
+ * Copyright (C) 2003-2011 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/input/rewind_input_plugin.h b/src/input/rewind_input_plugin.h
index 23d25d94d..83abe257a 100644
--- a/src/input/rewind_input_plugin.h
+++ b/src/input/rewind_input_plugin.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2010 The Music Player Daemon Project
+ * Copyright (C) 2003-2011 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify