input/rewind: new input_stream wrapper to allow stream rewinding

This replaces the rewinding buffer code from the CURL input plugin.
It is more generic, and allows rewinding even when the server sends
Icy-Metadata (which would have been too difficult to implement within
the CURL plugin).

This is a rather complex patch for the stable branch (v0.15.x), but it
fixes a serious problem: the "vorbis" decoder plugin was unable to
play streams with Icy-Metadata, because it couldn't rewind the stream
after detecting the codec (Vorbis vs. FLAC).

Makefile.am

@@ -75,6 +75,7 @@ mpd_headers = \
 	src/input_stream.h \
 	src/input/file_input_plugin.h \
 	src/input/curl_input_plugin.h \
+	src/input/rewind_input_plugin.h \
 	src/input/lastfm_input_plugin.h \
 	src/input/mms_input_plugin.h \
 	src/icy_server.h \
@@ -467,7 +468,9 @@ INPUT_SRC = \
 	src/input/file_input_plugin.c
 
 if HAVE_CURL
-INPUT_SRC += src/input/curl_input_plugin.c src/icy_metadata.c
+INPUT_SRC += src/input/curl_input_plugin.c \
+	src/input/rewind_input_plugin.c \
+	src/icy_metadata.c
 endif
 
 if ENABLE_LASTFM

NEWS

@@ -1,4 +1,6 @@
 ver 0.15.8 (2009/??/??)
+* input:
+  - curl: allow rewinding with Icy-Metadata
 * decoders:
   - ffmpeg, flac, vorbis: added more flac/vorbis MIME types
 

src/input/curl_input_plugin.c

@@ -732,6 +732,18 @@ input_curl_easy_init(struct input_stream *is)
 	return true;
 }
 
+void
+input_curl_reinit(struct input_stream *is)
+{
+	struct input_curl *c = is->data;
+
+	assert(is->plugin == &input_plugin_curl);
+	assert(c->easy != NULL);
+
+	curl_easy_setopt(c->easy, CURLOPT_WRITEHEADER, is);
+	curl_easy_setopt(c->easy, CURLOPT_WRITEDATA, is);
+}
+
 static bool
 input_curl_send_request(struct input_curl *c)
 {

src/input/curl_input_plugin.h

@@ -20,6 +20,16 @@
 #ifndef MPD_INPUT_CURL_H
 #define MPD_INPUT_CURL_H
 
+struct input_stream;
+
 extern const struct input_plugin input_plugin_curl;
 
+/**
+ * This is a workaround for an input_stream API deficiency; after
+ * exchanging the input_stream pointer in input_rewind_open(), this
+ * function is called to reinitialize CURL's data pointers.
+ */
+void
+input_curl_reinit(struct input_stream *is);
+
 #endif

src/input/rewind_input_plugin.c

@@ -0,0 +1,238 @@
+/*
+ * Copyright (C) 2003-2009 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/rewind_input_plugin.h"
+#include "input/curl_input_plugin.h"
+#include "input_plugin.h"
+#include "tag.h"
+
+#include <glib.h>
+
+#include <assert.h>
+#include <stdio.h>
+
+#undef G_LOG_DOMAIN
+#define G_LOG_DOMAIN "input_rewind"
+
+struct input_rewind {
+	struct input_stream input;
+
+	/**
+	 * The read position within the buffer.  Undefined as long as
+	 * reading_from_buffer() returns false.
+	 */
+	size_t head;
+
+	/**
+	 * The write/append position within the buffer.
+	 */
+	size_t tail;
+
+	/**
+	 * The size of this buffer is the maximum number of bytes
+	 * which can be rewinded cheaply without passing the "seek"
+	 * call to CURL.
+	 *
+	 * The origin of this buffer is always the beginning of the
+	 * stream (offset 0).
+	 */
+	char buffer[64 * 1024];
+};
+
+/**
+ * Are we currently reading from the buffer, and does the buffer
+ * contain more data for the next read operation?
+ */
+static bool
+reading_from_buffer(const struct input_stream *is)
+{
+	const struct input_rewind *r = is->data;
+
+	return r->tail > 0 && is->offset < r->input.offset;
+}
+
+/**
+ * Copy public attributes from the underlying input stream to the
+ * "rewind" input stream.  This function is called when a method of
+ * the underlying stream has returned, which may have modified these
+ * attributes.
+ */
+static void
+copy_attributes(struct input_stream *dest)
+{
+	const struct input_rewind *r = dest->data;
+	const struct input_stream *src = &r->input;
+
+	dest->ready = src->ready;
+	dest->seekable = src->seekable;
+	dest->error = src->error;
+	dest->size = src->size;
+	dest->offset = src->offset;
+
+	if (dest->mime == NULL && src->mime != NULL)
+		/* this is set only once, and the duplicated pointer
+		   is freed by input_stream_close() */
+		dest->mime = g_strdup(src->mime);
+}
+
+static void
+input_rewind_close(struct input_stream *is)
+{
+	struct input_rewind *r = is->data;
+
+	input_stream_close(&r->input);
+
+	g_free(r);
+}
+
+static struct tag *
+input_rewind_tag(struct input_stream *is)
+{
+	struct input_rewind *r = is->data;
+
+	return input_stream_tag(&r->input);
+}
+
+static int
+input_rewind_buffer(struct input_stream *is)
+{
+	struct input_rewind *r = is->data;
+
+	int ret = input_stream_buffer(&r->input);
+	if (ret < 0 || !reading_from_buffer(is))
+		copy_attributes(is);
+
+	return ret;
+}
+
+static size_t
+input_rewind_read(struct input_stream *is, void *ptr, size_t size)
+{
+	struct input_rewind *r = is->data;
+
+	if (reading_from_buffer(is)) {
+		/* buffered read */
+
+		assert(r->head == (size_t)is->offset);
+		assert(r->tail == (size_t)r->input.offset);
+
+		if (size > r->tail - r->head)
+			size = r->tail - r->head;
+
+		memcpy(ptr, r->buffer + r->head, size);
+		r->head += size;
+		is->offset += size;
+
+		return size;
+	} else {
+		/* pass method call to underlying stream */
+
+		size_t nbytes = input_stream_read(&r->input, ptr, size);
+
+		if (r->input.offset > (off_t)sizeof(r->buffer))
+			/* disable buffering */
+			r->tail = 0;
+		else if (r->tail == (size_t)is->offset) {
+			/* append to buffer */
+
+			memcpy(r->buffer + r->tail, ptr, nbytes);
+			r->tail += nbytes;
+
+			assert(r->tail == (size_t)r->input.offset);
+		}
+
+		copy_attributes(is);
+
+		return nbytes;
+	}
+}
+
+static bool
+input_rewind_eof(G_GNUC_UNUSED struct input_stream *is)
+{
+	struct input_rewind *r = is->data;
+
+	return !reading_from_buffer(is) && input_stream_eof(&r->input);
+}
+
+static bool
+input_rewind_seek(struct input_stream *is, off_t offset, int whence)
+{
+	struct input_rewind *r = is->data;
+
+	assert(is->ready);
+
+	if (whence == SEEK_SET && r->tail > 0 && offset <= (off_t)r->tail) {
+		/* buffered seek */
+
+		assert(!reading_from_buffer(is) ||
+		       r->head == (size_t)is->offset);
+		assert(r->tail == (size_t)r->input.offset);
+
+		r->head = (size_t)offset;
+		is->offset = offset;
+
+		return true;
+	} else {
+		bool success = input_stream_seek(&r->input, offset, whence);
+		copy_attributes(is);
+
+		/* disable the buffer, because r->input has left the
+		   buffered range now */
+		r->tail = 0;
+
+		return success;
+	}
+}
+
+static const struct input_plugin rewind_input_plugin = {
+	.close = input_rewind_close,
+	.tag = input_rewind_tag,
+	.buffer = input_rewind_buffer,
+	.read = input_rewind_read,
+	.eof = input_rewind_eof,
+	.seek = input_rewind_seek,
+};
+
+void
+input_rewind_open(struct input_stream *is)
+{
+	struct input_rewind *c;
+
+	assert(is != NULL);
+	assert(is->offset == 0);
+
+	if (is->plugin != &input_plugin_curl)
+		/* due to limitations in the input_plugin API, we only
+		   (explicitly) support the CURL input plugin */
+		return;
+
+	c = g_new(struct input_rewind, 1);
+	c->tail = 0;
+
+	/* move the CURL input stream to c->input */
+	c->input = *is;
+	input_curl_reinit(&c->input);
+
+	/* convert the existing input_stream pointer to a "rewind"
+	   input stream */
+	is->plugin = &rewind_input_plugin;
+	is->data = c;
+}

src/input/rewind_input_plugin.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2003-2009 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
+ *
+ * A wrapper for an input_stream object which allows cheap buffered
+ * rewinding.  This is useful while detecting the stream codec (let
+ * each decoder plugin peek a portion from the stream).
+ */
+
+#ifndef MPD_INPUT_REWIND_H
+#define MPD_INPUT_REWIND_H
+
+#include "config.h"
+
+struct input_stream;
+
+#ifdef HAVE_CURL
+
+void
+input_rewind_open(struct input_stream *is);
+
+#else
+
+static inline void
+input_rewind_open(struct input_stream *is)
+{
+	(void)is;
+}
+
+#endif
+
+#endif

src/input_stream.c

@@ -22,6 +22,7 @@
 #include "conf.h"
 
 #include "input/file_input_plugin.h"
+#include "input/rewind_input_plugin.h"
 
 #ifdef ENABLE_ARCHIVE
 #include "input/archive_input_plugin.h"
@@ -131,6 +132,8 @@ input_stream_open(struct input_stream *is, const char *url)
 			assert(is->plugin->eof != NULL);
 			assert(!is->seekable || is->plugin->seek != NULL);
 
+			input_rewind_open(is);
+
 			return true;
 		}
 	}