mpd version 0.15.16

With mono sound, jack_sample_size is smaller than frame_size (4 vs 2
bytes), and "space/jack_sample_size==0".  That means mpd_jack_play()
will return 0, although no error has occurred.

Makefile.am

@@ -142,6 +142,7 @@ mpd_headers = \
 	src/tag.h \
 	src/tag_internal.h \
 	src/tag_pool.h \
+	src/tag_table.h \
 	src/tag_ape.h \
 	src/tag_id3.h \
 	src/tag_print.h \

NEWS

@@ -1,3 +1,70 @@
+ver 0.15.16 (2011/03/13)
+* output:
+  - ao: initialize the ao_sample_format struct
+  - jack: fix crash with mono playback
+* encoders:
+  - lame: explicitly configure the output sample rate
+* update: log all file permission problems
+
+
+ver 0.15.15 (2010/11/08)
+* input:
+  - rewind: fix assertion failure
+* output:
+  - shout: artist comes first in stream title
+
+
+ver 0.15.14 (2010/11/06)
+* player_thread: fix assertion failure due to wrong music pipe on seek
+* output_thread: fix assertion failure due to race condition in OPEN
+* input:
+  - rewind: fix double free bug
+* decoders:
+  - mp4ff, ffmpeg: add extension ".m4b" (audio book)
+
+
+ver 0.15.13 (2010/10/10)
+* output_thread: fix race condition after CANCEL command
+* output:
+  - httpd: fix random data in stream title
+  - httpd: MIME type audio/ogg for Ogg Vorbis
+* input:
+  - rewind: update MIME not only once
+  - rewind: enable for MMS
+
+
+ver 0.15.12 (2010/07/20)
+* input:
+  - curl: remove assertion after curl_multi_fdset()
+* tags:
+  - rva2: set "gain", not "peak"
+* decoders:
+  - wildmidi: support version 0.2.3
+
+
+ver 0.15.11 (2010/06/14)
+* tags:
+  - ape: support album artist
+* decoders:
+  - mp4ff: support tags "album artist", "albumartist", "band"
+  - mikmod: fix memory leak
+  - vorbis: handle uri==NULL
+  - ffmpeg: fix memory leak
+  - ffmpeg: free AVFormatContext on error
+  - ffmpeg: read more metadata
+  - ffmpeg: fix libavformat 0.6 by using av_open_input_stream()
+* playlist: emit IDLE_OPTIONS when resetting single mode
+* listen: make get_remote_uid() work on BSD
+
+
+ver 0.15.10 (2010/05/30)
+* input:
+  - mms: fix memory leak in error handler
+  - mms: initialize the "eof" attribute
+* decoders:
+  - mad: properly calculate ID3 size without libid3tag
+
+
 ver 0.15.9 (2010/03/21)
 * decoders:
   - mad: fix crash when seeking at end of song

configure.ac

@@ -1,5 +1,5 @@
 AC_PREREQ(2.60)
-AC_INIT(mpd, 0.15.9, musicpd-dev-team@lists.sourceforge.net)
+AC_INIT(mpd, 0.15.16, musicpd-dev-team@lists.sourceforge.net)
 AC_CONFIG_SRCDIR([src/main.c])
 AM_INIT_AUTOMAKE([foreign 1.9 dist-bzip2])
 AM_CONFIG_HEADER(config.h)
@@ -177,6 +177,7 @@ AC_ARG_ENABLE(un,
 if test x$enable_un = xyes; then
 	AC_DEFINE(HAVE_UN, 1, [Define if unix domain socket support is enabled])
 	STRUCT_UCRED
+	AC_CHECK_FUNCS(getpeereid)
 fi
 
 
@@ -913,17 +914,9 @@ fi
 
 AM_CONDITIONAL(HAVE_AUDIOFILE, test x$enable_audiofile = xyes)
 
-MPD_AUTO_PKG(ffmpeg, FFMPEG, [libavformat libavcodec libavutil],
+MPD_AUTO_PKG(ffmpeg, FFMPEG, [libavformat >= 52 libavcodec >= 51 libavutil >= 49],
 	[ffmpeg decoder library], [libavformat+libavcodec+libavutil not found])
 
-if test x$enable_ffmpeg = xyes; then
-	old_LIBS=$LIBS
-	LIBS="$LIBS $FFMPEG_LIBS"
-	AC_CHECK_LIB(avcodec, avcodec_decode_audio2,,
-		enable_ffmpeg=no)
-	LIBS=$old_LIBS
-fi
-
 if test x$enable_ffmpeg = xyes; then
 	# prior to ffmpeg svn12865, you had to specify include files
 	# without path prefix
@@ -957,6 +950,10 @@ if test x$enable_wildmidi = xyes; then
 	AC_CHECK_LIB(WildMidi, WildMidi_Init,,
 		AC_MSG_ERROR([libwildmidi not found]))
 
+	AC_CHECK_LIB(WildMidi, WildMidi_SampledSeek,
+		[AC_DEFINE(HAVE_WILDMIDI_SAMPLED_SEEK, 1,
+			[Defined if WildMidi_SampledSeek() is available (libwildmidi <= 0.2.2)])])
+
 	CFLAGS=$oldcflags
 	LIBS=$oldlibs
 	CPPFLAGS=$oldcppflags

m4/faad.m4

@@ -58,7 +58,7 @@ if test x$enable_aac = xyes; then
 	fi
 	if test x$enable_aac = xyes; then
   		AC_MSG_CHECKING(that FAAD2 uses buffer and bufferlen)
-		AC_COMPILE_IFELSE([
+		AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 #include <faad.h>
 
 int main() {
@@ -82,9 +82,9 @@ int main() {
 
 	return 0;
 }
-],[AC_MSG_RESULT(yes);AC_DEFINE(HAVE_FAAD_BUFLEN_FUNCS,1,[Define if FAAD2 uses buflen in function calls])],[AC_MSG_RESULT(no);
+])],[AC_MSG_RESULT(yes);AC_DEFINE(HAVE_FAAD_BUFLEN_FUNCS,1,[Define if FAAD2 uses buflen in function calls])],[AC_MSG_RESULT(no);
 		AC_MSG_CHECKING(that FAAD2 can even be used)
-		AC_COMPILE_IFELSE([
+		AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 #include <faad.h>
 
 int main() {
@@ -113,7 +113,7 @@ int main() {
 
 	return 0;
 }
-],AC_MSG_RESULT(yes),[AC_MSG_RESULT(no);enable_aac=no])
+])],AC_MSG_RESULT(yes),[AC_MSG_RESULT(no);enable_aac=no])
 		])
 	fi
 	if test x$enable_aac = xyes; then
@@ -136,7 +136,7 @@ if test x$enable_aac = xyes; then
 	CPPFLAGS=$CFLAGS
 
 	AC_MSG_CHECKING(for broken libfaad headers)
-	AC_COMPILE_IFELSE([
+	AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 #include <faad.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -148,7 +148,7 @@ int main() {
 	faacDecInit2(NULL, NULL, 0, &sample_rate, &channels);
 	return 0;
 }
-	],
+	])],
 		[AC_MSG_RESULT(correct)],
 		[AC_MSG_RESULT(broken);
 		AC_DEFINE(HAVE_FAAD_LONG, 1, [Define if faad.h uses the broken "unsigned long" pointers])])

m4/mpd_check_cflag.m4

@@ -4,9 +4,9 @@ AC_DEFUN([MPD_CHECK_FLAG],[
     [mpd_check_cflag_$var],[
     save_CFLAGS="$CFLAGS"
     CFLAGS="$CFLAGS $1"
-    AC_COMPILE_IFELSE([
+    AC_COMPILE_IFELSE([AC_LANG_SOURCE([
      int main(void) { return 0; }
-     ], [ eval "mpd_check_cflag_$var=yes"
+     ])], [ eval "mpd_check_cflag_$var=yes"
      ], [ eval "mpd_check_cflag_$var=no" ])
     CFLAGS="$save_CFLAGS"
   ])

src/decoder/ffmpeg_plugin.c

@@ -53,48 +53,27 @@ struct ffmpeg_context {
 	struct tag *tag;
 };
 
-struct ffmpeg_stream {
-	/** hack - see url_to_struct() */
-	char url[64];
-
+struct mpd_ffmpeg_stream {
 	struct decoder *decoder;
 	struct input_stream *input;
+
+	ByteIOContext *io;
+	unsigned char buffer[8192];
 };
 
-/**
- * Convert a faked mpd:// URL to a ffmpeg_stream structure.  This is a
- * hack because ffmpeg does not provide a nice API for passing a
- * user-defined pointer to mpdurl_open().
- */
-static struct ffmpeg_stream *url_to_struct(const char *url)
+static int
+mpd_ffmpeg_stream_read(void *opaque, uint8_t *buf, int size)
 {
-	union {
-		const char *in;
-		struct ffmpeg_stream *out;
-	} u = { .in = url };
-	return u.out;
-}
-
-static int mpd_ffmpeg_open(URLContext *h, const char *filename,
-			   G_GNUC_UNUSED int flags)
-{
-	struct ffmpeg_stream *stream = url_to_struct(filename);
-	h->priv_data = stream;
-	h->is_streamed = stream->input->seekable ? 0 : 1;
-	return 0;
-}
-
-static int mpd_ffmpeg_read(URLContext *h, unsigned char *buf, int size)
-{
-	struct ffmpeg_stream *stream = (struct ffmpeg_stream *) h->priv_data;
+	struct mpd_ffmpeg_stream *stream = opaque;
 
 	return decoder_read(stream->decoder, stream->input,
 			    (void *)buf, size);
 }
 
-static int64_t mpd_ffmpeg_seek(URLContext *h, int64_t pos, int whence)
+static int64_t
+mpd_ffmpeg_stream_seek(void *opaque, int64_t pos, int whence)
 {
-	struct ffmpeg_stream *stream = (struct ffmpeg_stream *) h->priv_data;
+	struct mpd_ffmpeg_stream *stream = opaque;
 	bool ret;
 
 	if (whence == AVSEEK_SIZE)
@@ -107,25 +86,36 @@ static int64_t mpd_ffmpeg_seek(URLContext *h, int64_t pos, int whence)
 	return stream->input->offset;
 }
 
-static int mpd_ffmpeg_close(URLContext *h)
+static struct mpd_ffmpeg_stream *
+mpd_ffmpeg_stream_open(struct decoder *decoder, struct input_stream *input)
 {
-	h->priv_data = NULL;
-	return 0;
+	struct mpd_ffmpeg_stream *stream = g_new(struct mpd_ffmpeg_stream, 1);
+	stream->decoder = decoder;
+	stream->input = input;
+	stream->io = av_alloc_put_byte(stream->buffer, sizeof(stream->buffer),
+				       false, stream,
+				       mpd_ffmpeg_stream_read, NULL,
+				       input->seekable
+				       ? mpd_ffmpeg_stream_seek : NULL);
+	if (stream->io == NULL) {
+		g_free(stream);
+		return NULL;
+	}
+
+	return stream;
 }
 
-static URLProtocol mpd_ffmpeg_fileops = {
-	.name = "mpd",
-	.url_open = mpd_ffmpeg_open,
-	.url_read = mpd_ffmpeg_read,
-	.url_seek = mpd_ffmpeg_seek,
-	.url_close = mpd_ffmpeg_close,
-};
+static void
+mpd_ffmpeg_stream_close(struct mpd_ffmpeg_stream *stream)
+{
+	av_free(stream->io);
+	g_free(stream);
+}
 
 static bool
 ffmpeg_init(G_GNUC_UNUSED const struct config_param *param)
 {
 	av_register_all();
-	register_protocol(&mpd_ffmpeg_fileops);
 	return true;
 }
 
@@ -140,64 +130,86 @@ ffmpeg_find_audio_stream(const AVFormatContext *format_context)
 	return -1;
 }
 
-/**
- * Append the suffix of the original URI to the virtual stream URI.
- * Without this, libavformat cannot detect some of the codecs
- * (e.g. "shorten").
- */
-static void
-append_uri_suffix(struct ffmpeg_stream *stream, const char *uri)
+static AVInputFormat *
+ffmpeg_probe(struct decoder *decoder, struct input_stream *is,
+	     const char *uri)
 {
-	assert(stream != NULL);
-	assert(uri != NULL);
+	enum {
+		BUFFER_SIZE = 16384,
+		PADDING = 16,
+	};
 
-	char *base = g_path_get_basename(uri);
+	unsigned char *buffer = g_malloc(BUFFER_SIZE);
+	size_t nbytes = decoder_read(decoder, is, buffer, BUFFER_SIZE);
+	if (nbytes <= PADDING || !input_stream_seek(is, 0, SEEK_SET)) {
+		g_free(buffer);
+		return NULL;
+	}
 
-	const char *suffix = strrchr(base, '.');
-	if (suffix != NULL && suffix[1] != 0)
-		g_strlcat(stream->url, suffix, sizeof(stream->url));
+	/* some ffmpeg parsers (e.g. ac3_parser.c) read a few bytes
+	   beyond the declared buffer limit, which makes valgrind
+	   angry; this workaround removes some padding from the buffer
+	   size */
+	nbytes -= PADDING;
 
-	g_free(base);
+	AVProbeData avpd = {
+		.buf = buffer,
+		.buf_size = nbytes,
+		.filename = uri,
+	};
+
+	AVInputFormat *format = av_probe_input_format(&avpd, true);
+	g_free(buffer);
+
+	return format;
 }
 
 static bool
-ffmpeg_helper(const char *uri, struct input_stream *input,
+ffmpeg_helper(const char *uri,
+	      struct decoder *decoder, struct input_stream *input,
 	      bool (*callback)(struct ffmpeg_context *ctx),
 	      struct ffmpeg_context *ctx)
 {
+	AVInputFormat *input_format = ffmpeg_probe(decoder, input, uri);
+	if (input_format == NULL)
+		return false;
+
+	g_debug("detected input format '%s' (%s)",
+		input_format->name, input_format->long_name);
+
+	struct mpd_ffmpeg_stream *stream =
+		mpd_ffmpeg_stream_open(decoder, input);
+	if (stream == NULL) {
+		g_warning("Failed to open stream");
+		return false;
+	}
+
 	AVFormatContext *format_context;
 	AVCodecContext *codec_context;
 	AVCodec *codec;
 	int audio_stream;
-	struct ffmpeg_stream stream = {
-		.url = "mpd://X", /* only the mpd:// prefix matters */
-	};
 	bool ret;
 
-	if (uri != NULL)
-		append_uri_suffix(&stream, uri);
-
-	stream.input = input;
-	if (ctx && ctx->decoder) {
-		stream.decoder = ctx->decoder; //are we in decoding loop ?
-	} else {
-		stream.decoder = NULL;
-	}
-
 	//ffmpeg works with ours "fileops" helper
-	if (av_open_input_file(&format_context, stream.url, NULL, 0, NULL) != 0) {
+	if (av_open_input_stream(&format_context, stream->io, uri,
+				 input_format, NULL) != 0) {
 		g_warning("Open failed\n");
+		mpd_ffmpeg_stream_close(stream);
 		return false;
 	}
 
 	if (av_find_stream_info(format_context)<0) {
 		g_warning("Couldn't find stream info\n");
+		av_close_input_stream(format_context);
+		mpd_ffmpeg_stream_close(stream);
 		return false;
 	}
 
 	audio_stream = ffmpeg_find_audio_stream(format_context);
 	if (audio_stream == -1) {
 		g_warning("No audio stream inside\n");
+		av_close_input_stream(format_context);
+		mpd_ffmpeg_stream_close(stream);
 		return false;
 	}
 
@@ -209,11 +221,15 @@ ffmpeg_helper(const char *uri, struct input_stream *input,
 
 	if (!codec) {
 		g_warning("Unsupported audio codec\n");
+		av_close_input_stream(format_context);
+		mpd_ffmpeg_stream_close(stream);
 		return false;
 	}
 
 	if (avcodec_open(codec_context, codec)<0) {
 		g_warning("Could not open codec\n");
+		av_close_input_stream(format_context);
+		mpd_ffmpeg_stream_close(stream);
 		return false;
 	}
 
@@ -227,7 +243,8 @@ ffmpeg_helper(const char *uri, struct input_stream *input,
 		ret = true;
 
 	avcodec_close(codec_context);
-	av_close_input_file(format_context);
+	av_close_input_stream(format_context);
+	mpd_ffmpeg_stream_close(stream);
 
 	return ret;
 }
@@ -372,8 +389,10 @@ ffmpeg_decode(struct decoder *decoder, struct input_stream *input)
 	ctx.input = input;
 	ctx.decoder = decoder;
 
-	ffmpeg_helper(decoder_get_uri(decoder), input,
+	char *uri = decoder_get_uri(decoder);
+	ffmpeg_helper(uri, decoder, input,
 		      ffmpeg_decode_internal, &ctx);
+	g_free(uri);
 }
 
 #if LIBAVFORMAT_VERSION_INT >= ((52<<16)+(31<<8)+0)
@@ -401,12 +420,21 @@ static bool ffmpeg_tag_internal(struct ffmpeg_context *ctx)
 	av_metadata_conv(f, NULL, f->iformat->metadata_conv);
 
 	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_TITLE, "title");
+#if LIBAVFORMAT_VERSION_INT >= ((52<<16)+(50<<8))
+	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_ARTIST, "artist");
+	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_DATE, "date");
+#else
 	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_ARTIST, "author");
+	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_DATE, "year");
+#endif
 	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_ALBUM, "album");
 	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_COMMENT, "comment");
 	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_GENRE, "genre");
 	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_TRACK, "track");
-	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_DATE, "year");
+	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_ALBUM_ARTIST, "album_artist");
+	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_COMPOSER, "composer");
+	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_PERFORMER, "performer");
+	ffmpeg_copy_metadata(tag, f->metadata, TAG_ITEM_DISC, "disc");
 #else
 	if (f->author[0])
 		tag_add_item(tag, TAG_ITEM_ARTIST, f->author);
@@ -450,7 +478,7 @@ static struct tag *ffmpeg_tag(const char *file)
 	ctx.decoder = NULL;
 	ctx.tag = tag_new();
 
-	ret = ffmpeg_helper(file, &input, ffmpeg_tag_internal, &ctx);
+	ret = ffmpeg_helper(file, NULL, &input, ffmpeg_tag_internal, &ctx);
 	if (!ret) {
 		tag_free(ctx.tag);
 		ctx.tag = NULL;
@@ -473,7 +501,9 @@ static const char *const ffmpeg_suffixes[] = {
 	"atrac", "au", "aud", "avi", "avm2", "avs", "bap", "bfi", "c93", "cak",
 	"cin", "cmv", "cpk", "daud", "dct", "divx", "dts", "dv", "dvd", "dxa",
 	"eac3", "film", "flac", "flc", "fli", "fll", "flx", "flv", "g726",
-	"gsm", "gxf", "iss", "m1v", "m2v", "m2t", "m2ts", "m4a", "m4v", "mad",
+	"gsm", "gxf", "iss", "m1v", "m2v", "m2t", "m2ts",
+	"m4a", "m4b", "m4v",
+	"mad",
 	"mj2", "mjpeg", "mjpg", "mka", "mkv", "mlp", "mm", "mmf", "mov", "mp+",
 	"mp1", "mp2", "mp3", "mp4", "mpc", "mpeg", "mpg", "mpga", "mpp", "mpu",
 	"mve", "mvi", "mxf", "nc", "nsv", "nut", "nuv", "oga", "ogm", "ogv",

src/decoder/mad_plugin.c

@@ -209,14 +209,14 @@ mp3_fill_buffer(struct mp3_data *data)
 
 #ifdef HAVE_ID3TAG
 /* Parse mp3 RVA2 frame. Shamelessly stolen from madplay. */
-static int parse_rva2(struct id3_tag * tag, struct replay_gain_info * replay_gain_info)
+static bool
+parse_rva2(struct id3_tag *tag, struct replay_gain_info *replay_gain_info)
 {
 	struct id3_frame const * frame;
 
 	id3_latin1_t const *id;
 	id3_byte_t const *data;
 	id3_length_t length;
-	int found;
 
 	enum {
 		CHANNEL_OTHER         = 0x00,
@@ -230,18 +230,18 @@ static int parse_rva2(struct id3_tag * tag, struct replay_gain_info * replay_gai
 		CHANNEL_SUBWOOFER     = 0x08
 	};
 
-	found = 0;
-
 	/* relative volume adjustment information */
 
 	frame = id3_tag_findframe(tag, "RVA2", 0);
-	if (!frame) return 0;
+	if (frame == NULL)
+		return false;
 
 	id   = id3_field_getlatin1(id3_frame_field(frame, 0));
 	data = id3_field_getbinarydata(id3_frame_field(frame, 1),
 					&length);
 
-	if (!id || !data) return 0;
+	if (id == NULL || data == NULL)
+		return false;
 
 	/*
 	 * "The 'identification' string is used to identify the
@@ -277,22 +277,21 @@ static int parse_rva2(struct id3_tag * tag, struct replay_gain_info * replay_gai
 
 			voladj_float  = (double) voladj_fixed / 512;
 
-			replay_gain_info->tuples[REPLAY_GAIN_TRACK].peak = voladj_float;
-			replay_gain_info->tuples[REPLAY_GAIN_ALBUM].peak = voladj_float;
+			replay_gain_info->tuples[REPLAY_GAIN_TRACK].gain = voladj_float;
+			replay_gain_info->tuples[REPLAY_GAIN_ALBUM].gain = voladj_float;
 
 			g_debug("parseRVA2: Relative Volume "
 				"%+.1f dB adjustment (%s)\n",
 				voladj_float, id);
 
-			found = 1;
-			break;
+			return true;
 		}
 
 		data   += 4 + peak_bytes;
 		length -= 4 + peak_bytes;
 	}
 
-	return found;
+	return false;
 }
 #endif
 
@@ -425,7 +424,27 @@ static void mp3_parse_id3(struct mp3_data *data, size_t tagsize,
 	/* This code is enabled when libid3tag is disabled.  Instead
 	   of parsing the ID3 frame, it just skips it. */
 
-	mad_stream_skip(&data->stream, tagsize);
+	size_t count = data->stream.bufend - data->stream.this_frame;
+
+	if (tagsize <= count) {
+		mad_stream_skip(&data->stream, tagsize);
+	} else {
+		mad_stream_skip(&data->stream, count);
+
+		while (count < tagsize) {
+			size_t len = tagsize - count;
+			char ignored[1024];
+			if (len > sizeof(ignored))
+				len = sizeof(ignored);
+
+			len = decoder_read(data->decoder, data->input_stream,
+					   ignored, len);
+			if (len == 0)
+				break;
+			else
+				count += len;
+		}
+	}
 #endif
 }
 
@@ -433,16 +452,16 @@ static void mp3_parse_id3(struct mp3_data *data, size_t tagsize,
 /**
  * This function emulates libid3tag when it is disabled.  Instead of
  * doing a real analyzation of the frame, it just checks whether the
- * frame begins with the string "ID3".  If so, it returns the full
- * length.
+ * frame begins with the string "ID3".  If so, it returns the length
+ * of the ID3 frame.
  */
 static signed long
 id3_tag_query(const void *p0, size_t length)
 {
 	const char *p = p0;
 
-	return length > 3 && memcmp(p, "ID3", 3) == 0
-		? length
+	return length >= 10 && memcmp(p, "ID3", 3) == 0
+		? (p[8] << 7) + p[9] + 10
 		: 0;
 }
 #endif /* !HAVE_ID3TAG */

src/decoder/mikmod_plugin.c

@@ -219,10 +219,12 @@ static struct tag *modTagDup(const char *file)
 	ret->time = 0;
 
 	path2 = g_strdup(file);
-	title = g_strdup(Player_LoadTitle(path2));
+	title = Player_LoadTitle(path2);
 	g_free(path2);
-	if (title)
+	if (title) {
 		tag_add_item(ret, TAG_ITEM_TITLE, title);
+		free(title);
+	}
 
 	return ret;
 }

src/decoder/mp4ff_plugin.c

@@ -19,6 +19,7 @@
 
 #include "../decoder_api.h"
 #include "config.h"
+#include "tag_table.h"
 
 #include <glib.h>
 
@@ -339,6 +340,22 @@ mp4_decode(struct decoder *mpd_decoder, struct input_stream *input_stream)
 	mp4ff_close(mp4fh);
 }
 
+static const char *const mp4ff_tag_names[TAG_NUM_OF_ITEM_TYPES] = {
+	[TAG_ITEM_ALBUM_ARTIST] = "album artist",
+	[TAG_ITEM_COMPOSER] = "writer",
+	[TAG_ITEM_PERFORMER] = "band",
+};
+
+static enum tag_type
+mp4ff_tag_name_parse(const char *name)
+{
+	enum tag_type type = tag_table_lookup(mp4ff_tag_names, name);
+	if (type == TAG_NUM_OF_ITEM_TYPES)
+		type = tag_name_parse_i(name);
+
+	return type;
+}
+
 static struct tag *
 mp4_tag_dup(const char *file)
 {
@@ -394,24 +411,9 @@ mp4_tag_dup(const char *file)
 
 		mp4ff_meta_get_by_index(mp4fh, i, &item, &value);
 
-		if (0 == g_ascii_strcasecmp("artist", item)) {
-			tag_add_item(ret, TAG_ITEM_ARTIST, value);
-		} else if (0 == g_ascii_strcasecmp("title", item)) {
-			tag_add_item(ret, TAG_ITEM_TITLE, value);
-		} else if (0 == g_ascii_strcasecmp("album", item)) {
-			tag_add_item(ret, TAG_ITEM_ALBUM, value);
-		} else if (0 == g_ascii_strcasecmp("track", item)) {
-			tag_add_item(ret, TAG_ITEM_TRACK, value);
-		} else if (0 == g_ascii_strcasecmp("disc", item)) {
-			/* Is that the correct id? */
-			tag_add_item(ret, TAG_ITEM_DISC, value);
-		} else if (0 == g_ascii_strcasecmp("genre", item)) {
-			tag_add_item(ret, TAG_ITEM_GENRE, value);
-		} else if (0 == g_ascii_strcasecmp("date", item)) {
-			tag_add_item(ret, TAG_ITEM_DATE, value);
-		} else if (0 == g_ascii_strcasecmp("writer", item)) {
-			tag_add_item(ret, TAG_ITEM_COMPOSER, value);
-		}
+		enum tag_type type = mp4ff_tag_name_parse(item);
+		if (type != TAG_NUM_OF_ITEM_TYPES)
+			tag_add_item(ret, type, value);
 
 		free(item);
 		free(value);
@@ -423,7 +425,13 @@ mp4_tag_dup(const char *file)
 	return ret;
 }
 
-static const char *const mp4_suffixes[] = { "m4a", "mp4", NULL };
+static const char *const mp4_suffixes[] = {
+	"m4a",
+	"m4b",
+	"mp4",
+	NULL
+};
+
 static const char *const mp4_mime_types[] = { "audio/mp4", "audio/m4a", NULL };
 
 const struct decoder_plugin mp4ff_decoder_plugin = {

src/decoder/vorbis_plugin.c

@@ -97,6 +97,13 @@ static long ogg_tell_cb(void *vdata)
 	return (long)data->input_stream->offset;
 }
 
+static const ov_callbacks vorbis_is_callbacks = {
+	.read_func = ogg_read_cb,
+	.seek_func = ogg_seek_cb,
+	.close_func = ogg_close_cb,
+	.tell_func = ogg_tell_cb,
+};
+
 static const char *
 vorbis_comment_value(const char *comment, const char *needle)
 {
@@ -226,6 +233,9 @@ oggvorbis_seekable(struct decoder *decoder)
 	bool seekable;
 
 	uri = decoder_get_uri(decoder);
+	if (uri == NULL)
+		return false;
+
 	/* disable seeking on remote streams, because libvorbis seeks
 	   around like crazy, and due to being very expensive, this
 	   delays song playback my 10 or 20 seconds */
@@ -241,7 +251,6 @@ vorbis_stream_decode(struct decoder *decoder,
 		     struct input_stream *input_stream)
 {
 	OggVorbis_File vf;
-	ov_callbacks callbacks;
 	OggCallbackData data;
 	struct audio_format audio_format;
 	int current_section;
@@ -266,13 +275,9 @@ vorbis_stream_decode(struct decoder *decoder,
 	data.input_stream = input_stream;
 	data.seekable = input_stream->seekable && oggvorbis_seekable(decoder);
 
-	callbacks.read_func = ogg_read_cb;
-	callbacks.seek_func = ogg_seek_cb;
-	callbacks.close_func = ogg_close_cb;
-	callbacks.tell_func = ogg_tell_cb;
-	if ((ret = ov_open_callbacks(&data, &vf, NULL, 0, callbacks)) < 0) {
+	if ((ret = ov_open_callbacks(&data, &vf, NULL, 0,
+				     vorbis_is_callbacks)) < 0) {
 		const char *error;
-
 		if (decoder_get_command(decoder) != DECODE_COMMAND_NONE)
 			return;
 

src/decoder/wildmidi_plugin.c

@@ -99,7 +99,11 @@ wildmidi_file_decode(struct decoder *decoder, const char *path_fs)
 			unsigned long seek_where = WILDMIDI_SAMPLE_RATE *
 				decoder_seek_where(decoder);
 
+#ifdef HAVE_WILDMIDI_SAMPLED_SEEK
 			WildMidi_SampledSeek(wm, &seek_where);
+#else
+			WildMidi_FastSeek(wm, &seek_where);
+#endif
 			decoder_command_finished(decoder);
 			cmd = DECODE_COMMAND_NONE;
 		}

src/decoder_control.c

@@ -18,6 +18,7 @@
  */
 
 #include "decoder_control.h"
+#include "pipe.h"
 
 #include <assert.h>
 
@@ -58,22 +59,28 @@ static void dc_command_async(enum decoder_command cmd)
 }
 
 void
-dc_start(struct notify *notify, struct song *song)
+dc_start(struct notify *notify, struct song *song, struct music_pipe *pipe)
 {
-	assert(dc.pipe != NULL);
+	assert(dc.pipe == NULL);
 	assert(song != NULL);
+	assert(pipe != NULL);
+	assert(music_pipe_empty(pipe));
 
 	dc.next_song = song;
+	dc.pipe = pipe;
 	dc_command(notify, DECODE_COMMAND_START);
 }
 
 void
-dc_start_async(struct song *song)
+dc_start_async(struct song *song, struct music_pipe *pipe)
 {
-	assert(dc.pipe != NULL);
+	assert(dc.pipe == NULL);
 	assert(song != NULL);
+	assert(pipe != NULL);
+	assert(music_pipe_empty(pipe));
 
 	dc.next_song = song;
+	dc.pipe = pipe;
 	dc_command_async(DECODE_COMMAND_START);
 }
 

src/decoder_control.h

@@ -118,10 +118,10 @@ void
 dc_command_wait(struct notify *notify);
 
 void
-dc_start(struct notify *notify, struct song *song);
+dc_start(struct notify *notify, struct song *song, struct music_pipe *pipe);
 
 void
-dc_start_async(struct song *song);
+dc_start_async(struct song *song, struct music_pipe *pipe);
 
 void
 dc_stop(struct notify *notify);

src/directory.h

@@ -28,8 +28,8 @@
 
 #define DIRECTORY_DIR		"directory: "
 
-#define DEVICE_INARCHIVE	(unsigned)(-1)
-#define DEVICE_CONTAINER	(unsigned)(-2)
+#define DEVICE_INARCHIVE (dev_t)(-1)
+#define DEVICE_CONTAINER (dev_t)(-2)
 
 struct directory {
 	struct dirvec children;

src/directory_print.c

@@ -22,7 +22,7 @@
 #include "client.h"
 #include "song_print.h"
 
-static int
+static void
 dirvec_print(struct client *client, const struct dirvec *dv)
 {
 	size_t i;
@@ -30,15 +30,11 @@ dirvec_print(struct client *client, const struct dirvec *dv)
 	for (i = 0; i < dv->nr; ++i)
 		client_printf(client, DIRECTORY_DIR "%s\n",
 			      directory_get_path(dv->base[i]));
-
-	return 0;
 }
 
-int
+void
 directory_print(struct client *client, const struct directory *directory)
 {
 	dirvec_print(client, &directory->children);
 	songvec_print(client, &directory->songs);
-
-	return 0;
 }

src/directory_print.h

@@ -23,7 +23,7 @@
 struct client;
 struct directory;
 
-int
+void
 directory_print(struct client *client, const struct directory *directory);
 
 #endif

src/encoder/lame_encoder.c

@@ -169,6 +169,13 @@ lame_encoder_setup(struct lame_encoder *encoder, GError **error)
 		return false;
 	}
 
+	if (0 != lame_set_out_samplerate(encoder->gfp,
+					 encoder->audio_format.sample_rate)) {
+		g_set_error(error, lame_encoder_quark(), 0,
+			    "error setting lame out sample rate");
+		return false;
+	}
+
 	if (0 > lame_init_params(encoder->gfp)) {
 		g_set_error(error, lame_encoder_quark(), 0,
 			    "error initializing lame params");

src/icy_server.c

@@ -95,6 +95,7 @@ icy_server_metadata_page(const struct tag *tag, ...)
 	gchar stream_title[(1 + 255 - 28) * 16]; // Length + Metadata -
 						 // "StreamTitle='';StreamUrl='';"
 						 // = 4081 - 28
+	stream_title[0] =  '\0';
 
 	last_item = -1;
 

src/input/curl_input_plugin.c

@@ -241,7 +241,6 @@ input_curl_select(struct input_curl *c)
 	fd_set rfds, wfds, efds;
 	int max_fd, ret;
 	CURLMcode mcode;
-	/* XXX hard coded timeout value.. */
 	struct timeval timeout = {
 		.tv_sec = 1,
 		.tv_usec = 0,
@@ -260,7 +259,23 @@ input_curl_select(struct input_curl *c)
 		return -1;
 	}
 
-	assert(max_fd >= 0);
+#if LIBCURL_VERSION_NUM >= 0x070f04
+	long timeout2;
+	mcode = curl_multi_timeout(c->multi, &timeout2);
+	if (mcode != CURLM_OK) {
+		g_warning("curl_multi_timeout() failed: %s\n",
+			  curl_multi_strerror(mcode));
+		return -1;
+	}
+
+	if (timeout2 >= 0) {
+		if (timeout2 > 10000)
+			timeout2 = 10000;
+
+		timeout.tv_sec = timeout2 / 1000;
+		timeout.tv_usec = (timeout2 % 1000) * 1000;
+	}
+#endif
 
 	ret = select(max_fd + 1, &rfds, &wfds, &efds, &timeout);
 	if (ret < 0)

src/input/mms_input_plugin.c

@@ -49,10 +49,13 @@ input_mms_open(struct input_stream *is, const char *url)
 	m = g_new(struct input_mms, 1);
 	m->mms = mmsx_connect(NULL, NULL, url, 128 * 1024);
 	if (m->mms == NULL) {
+		g_free(m);
 		g_warning("mmsx_connect() failed");
 		return false;
 	}
 
+	m->eof = false;
+
 	/* XX is this correct?  at least this selects the ffmpeg
 	   decoder, which seems to work fine*/
 	is->mime = g_strdup("audio/x-ms-wma");

src/input/rewind_input_plugin.c

@@ -20,6 +20,9 @@
 #include "config.h"
 #include "input/rewind_input_plugin.h"
 #include "input/curl_input_plugin.h"
+#ifdef ENABLE_MMS
+#include "input/mms_input_plugin.h"
+#endif
 #include "input_plugin.h"
 #include "tag.h"
 
@@ -80,16 +83,19 @@ copy_attributes(struct input_stream *dest)
 	const struct input_rewind *r = dest->data;
 	const struct input_stream *src = &r->input;
 
+	assert(dest != src);
+	assert(src->mime == NULL || dest->mime != src->mime);
+
 	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() */
+	if (src->mime != NULL) {
+		g_free(dest->mime);
 		dest->mime = g_strdup(src->mime);
+	}
 }
 
 static void
@@ -219,7 +225,11 @@ input_rewind_open(struct input_stream *is)
 	assert(is != NULL);
 	assert(is->offset == 0);
 
-	if (is->plugin != &input_plugin_curl)
+	if (is->plugin != &input_plugin_curl
+#ifdef ENABLE_MMS
+	    && is->plugin != &input_plugin_mms
+#endif
+	   )
 		/* due to limitations in the input_plugin API, we only
 		   (explicitly) support the CURL input plugin */
 		return;
@@ -229,10 +239,12 @@ input_rewind_open(struct input_stream *is)
 
 	/* move the CURL input stream to c->input */
 	c->input = *is;
-	input_curl_reinit(&c->input);
+	if (is->plugin == &input_plugin_curl)
+		input_curl_reinit(&c->input);
 
 	/* convert the existing input_stream pointer to a "rewind"
 	   input stream */
 	is->plugin = &rewind_input_plugin;
 	is->data = c;
+	is->mime = g_strdup(c->input.mime);
 }

src/listen.c

@@ -407,7 +407,13 @@ static int get_remote_uid(int fd)
 
 	return cred.uid;
 #else
-	(void)fd;
+#ifdef HAVE_GETPEEREID
+	uid_t euid;
+	gid_t egid;
+
+	if (getpeereid(fd, &euid, &egid) == 0)
+		return euid;
+#endif
 	return -1;
 #endif
 }

src/locate.c

@@ -42,9 +42,9 @@ locate_parse_type(const char *str)
 	if (0 == g_ascii_strcasecmp(str, LOCATE_TAG_ANY_KEY))
 		return LOCATE_TAG_ANY_TYPE;
 
-	for (i = 0; i < TAG_NUM_OF_ITEM_TYPES; i++)
-		if (0 == g_ascii_strcasecmp(str, tag_item_names[i]))
-			return i;
+	i = tag_name_parse_i(str);
+	if (i != TAG_NUM_OF_ITEM_TYPES)
+		return i;
 
 	return -1;
 }

src/notify.c

@@ -48,3 +48,10 @@ void notify_signal(struct notify *notify)
 	g_cond_signal(notify->cond);
 	g_mutex_unlock(notify->mutex);
 }
+
+void notify_clear(struct notify *notify)
+{
+	g_mutex_lock(notify->mutex);
+	notify->pending = false;
+	g_mutex_unlock(notify->mutex);
+}

src/notify.h

@@ -45,4 +45,9 @@ void notify_wait(struct notify *notify);
  */
 void notify_signal(struct notify *notify);
 
+/**
+ * Clears a pending notification.
+ */
+void notify_clear(struct notify *notify);
+
 #endif

src/output/ao_plugin.c

@@ -25,6 +25,9 @@
 #undef G_LOG_DOMAIN
 #define G_LOG_DOMAIN "ao"
 
+/* An ao_sample_format, with all fields set to zero: */
+static const ao_sample_format OUR_AO_FORMAT_INITIALIZER;
+
 static unsigned ao_output_ref;
 
 struct ao_data {
@@ -166,7 +169,7 @@ static bool
 ao_output_open(void *data, struct audio_format *audio_format,
 	       GError **error)
 {
-	ao_sample_format format;
+	ao_sample_format format = OUR_AO_FORMAT_INITIALIZER;
 	struct ao_data *ad = (struct ao_data *)data;
 
 	/* support for 24 bit samples in libao is currently dubious,

src/output/httpd_client.c

@@ -27,6 +27,9 @@
 #include <assert.h>
 #include <string.h>
 
+#undef G_LOG_DOMAIN
+#define G_LOG_DOMAIN "httpd_output"
+
 struct httpd_client {
 	/**
 	 * The httpd output object this client is connected to.

src/output/httpd_output_plugin.c

@@ -70,7 +70,7 @@ httpd_output_init(G_GNUC_UNUSED const struct audio_format *audio_format,
 	}
 
 	if (strcmp(encoder_name, "vorbis") == 0)
-		httpd->content_type = "application/x-ogg";
+		httpd->content_type = "audio/ogg";
 	else if (strcmp(encoder_name, "lame") == 0)
 		httpd->content_type = "audio/mpeg";
 	else

src/output/jack_plugin.c

@@ -36,7 +36,7 @@
 #undef G_LOG_DOMAIN
 #define G_LOG_DOMAIN "jack"
 
-static const size_t sample_size = sizeof(jack_default_audio_sample_t);
+static const size_t jack_sample_size = sizeof(jack_default_audio_sample_t);
 
 static const char *const port_names[2] = {
 	"left", "right",
@@ -118,14 +118,15 @@ mpd_jack_process(jack_nframes_t nframes, void *arg)
 
 	for (unsigned i = 0; i < G_N_ELEMENTS(jd->ringbuffer); ++i) {
 		available = jack_ringbuffer_read_space(jd->ringbuffer[i]);
-		assert(available % sample_size == 0);
-		available /= sample_size;
+		assert(available % jack_sample_size == 0);
+		available /= jack_sample_size;
 		if (available > nframes)
 			available = nframes;
 
 		out = jack_port_get_buffer(jd->ports[i], nframes);
 		jack_ringbuffer_read(jd->ringbuffer[i],
-				     (char *)out, available * sample_size);
+				     (char *)out,
+				     available * jack_sample_size);
 
 		while (available < nframes)
 			/* ringbuffer underrun, fill with silence */
@@ -422,7 +423,7 @@ mpd_jack_play(void *data, const void *chunk, size_t size, GError **error)
 			/* send data symmetrically */
 			space = space1;
 
-		if (space >= frame_size)
+		if (space >= jack_sample_size)
 			break;
 
 		/* XXX do something more intelligent to
@@ -430,7 +431,7 @@ mpd_jack_play(void *data, const void *chunk, size_t size, GError **error)
 		g_usleep(1000);
 	}
 
-	space /= sample_size;
+	space /= jack_sample_size;
 	if (space < size)
 		size = space;
 

src/output/shout_plugin.c

@@ -483,7 +483,7 @@ shout_tag_to_metadata(const struct tag *tag, char *dest, size_t size)
 		}
 	}
 
-	snprintf(dest, size, "%s - %s", title, artist);
+	snprintf(dest, size, "%s - %s", artist, title);
 }
 
 static void my_shout_set_tag(void *data,

src/output_all.c

@@ -266,7 +266,7 @@ audio_output_all_open(const struct audio_format *audio_format,
 	else
 		/* if the pipe hasn't been cleared, the the audio
 		   format must not have changed */
-		assert(music_pipe_size(g_mp) == 0 ||
+		assert(music_pipe_empty(g_mp) ||
 		       audio_format_equals(audio_format,
 					   &input_audio_format));
 
@@ -378,7 +378,7 @@ audio_output_all_check(void)
 	assert(g_mp != NULL);
 
 	while ((chunk = music_pipe_peek(g_mp)) != NULL) {
-		assert(music_pipe_size(g_mp) > 0);
+		assert(!music_pipe_empty(g_mp));
 
 		if (!chunk_is_consumed(chunk))
 			/* at least one output is not finished playing

src/output_control.c

@@ -50,6 +50,20 @@ static void ao_command(struct audio_output *ao, enum audio_output_command cmd)
 	ao_command_wait(ao);
 }
 
+/**
+ * Like ao_command(), but assumes the object is locked by the caller.
+ */
+static void
+ao_command_locked(struct audio_output *ao, enum audio_output_command cmd)
+{
+	assert(ao->command == AO_COMMAND_NONE);
+	ao->command = cmd;
+
+	g_mutex_unlock(ao->mutex);
+	ao_command_wait(ao);
+	g_mutex_lock(ao->mutex);
+}
+
 static void ao_command_async(struct audio_output *ao,
 			     enum audio_output_command cmd)
 {
@@ -58,6 +72,12 @@ static void ao_command_async(struct audio_output *ao,
 	notify_signal(&ao->notify);
 }
 
+static void
+audio_output_close_locked(struct audio_output *ao);
+
+/**
+ * Object must be locked (and unlocked) by the caller.
+ */
 static bool
 audio_output_open(struct audio_output *ao,
 		  const struct audio_format *audio_format,
@@ -84,7 +104,7 @@ audio_output_open(struct audio_output *ao,
 
 			/* we're not using audio_output_cancel() here,
 			   because that function is asynchronous */
-			ao_command(ao, AO_COMMAND_CANCEL);
+			ao_command_locked(ao, AO_COMMAND_CANCEL);
 		}
 
 		return true;
@@ -95,7 +115,7 @@ audio_output_open(struct audio_output *ao,
 
 	if (!ao->config_audio_format) {
 		if (ao->open)
-			audio_output_close(ao);
+			audio_output_close_locked(ao);
 
 		/* no audio format is configured: copy in->out, let
 		   the output's open() method determine the effective
@@ -110,7 +130,7 @@ audio_output_open(struct audio_output *ao,
 
 	open = ao->open;
 	if (!open) {
-		ao_command(ao, AO_COMMAND_OPEN);
+		ao_command_locked(ao, AO_COMMAND_OPEN);
 		open = ao->open;
 	}
 
@@ -127,12 +147,19 @@ audio_output_update(struct audio_output *ao,
 {
 	assert(mp != NULL);
 
+	g_mutex_lock(ao->mutex);
+
 	if (ao->enabled) {
 		if (ao->fail_timer == NULL ||
-		    g_timer_elapsed(ao->fail_timer, NULL) > REOPEN_AFTER)
-			return audio_output_open(ao, audio_format, mp);
+		    g_timer_elapsed(ao->fail_timer, NULL) > REOPEN_AFTER) {
+			bool ret = audio_output_open(ao, audio_format, mp);
+			g_mutex_unlock(ao->mutex);
+			return ret;
+		}
 	} else if (audio_output_is_open(ao))
-		audio_output_close(ao);
+		audio_output_close_locked(ao);
+
+	g_mutex_unlock(ao->mutex);
 
 	return false;
 }
@@ -162,21 +189,33 @@ void audio_output_cancel(struct audio_output *ao)
 	ao_command_async(ao, AO_COMMAND_CANCEL);
 }
 
-void audio_output_close(struct audio_output *ao)
+static void
+audio_output_close_locked(struct audio_output *ao)
 {
+	assert(ao != NULL);
 	assert(!ao->open || ao->fail_timer == NULL);
 
 	if (ao->mixer != NULL)
 		mixer_auto_close(ao->mixer);
 
 	if (ao->open)
-		ao_command(ao, AO_COMMAND_CLOSE);
+		ao_command_locked(ao, AO_COMMAND_CLOSE);
 	else if (ao->fail_timer != NULL) {
 		g_timer_destroy(ao->fail_timer);
 		ao->fail_timer = NULL;
 	}
 }
 
+void audio_output_close(struct audio_output *ao)
+{
+	assert(ao != NULL);
+	assert(!ao->open || ao->fail_timer == NULL);
+
+	g_mutex_lock(ao->mutex);
+	audio_output_close_locked(ao);
+	g_mutex_unlock(ao->mutex);
+}
+
 void audio_output_finish(struct audio_output *ao)
 {
 	audio_output_close(ao);

src/output_internal.h

@@ -131,7 +131,8 @@ struct audio_output {
 	const struct music_pipe *pipe;
 
 	/**
-	 * This mutex protects #open, #chunk and #chunk_finished.
+	 * This mutex protects #open, #fail_timer, #chunk and
+	 * #chunk_finished.
 	 */
 	GMutex *mutex;
 

src/output_thread.c

@@ -105,7 +105,12 @@ ao_play_chunk(struct audio_output *ao, const struct music_chunk *chunk)
 
 			/* don't automatically reopen this device for
 			   10 seconds */
+			g_mutex_lock(ao->mutex);
+
+			assert(ao->fail_timer == NULL);
 			ao->fail_timer = g_timer_new();
+
+			g_mutex_unlock(ao->mutex);
 			return false;
 		}
 
@@ -192,10 +197,18 @@ static gpointer audio_output_task(gpointer arg)
 
 		case AO_COMMAND_OPEN:
 			assert(!ao->open);
-			assert(ao->fail_timer == NULL);
 			assert(ao->pipe != NULL);
 			assert(ao->chunk == NULL);
 
+			if (ao->fail_timer != NULL) {
+				/* this can only happen when this
+				   output thread fails while
+				   audio_output_open() is run in the
+				   player thread */
+				g_timer_destroy(ao->fail_timer);
+				ao->fail_timer = NULL;
+			}
+
 			error = NULL;
 			ret = ao_plugin_open(ao->plugin, ao->data,
 					     &ao->out_audio_format,
@@ -268,6 +281,16 @@ static gpointer audio_output_task(gpointer arg)
 			ao->chunk = NULL;
 			if (ao->open)
 				ao_plugin_cancel(ao->plugin, ao->data);
+
+			/* we must clear the notification now, because
+			   the notify_wait() call below must wait
+			   until audio_output_all_cancel() has cleared
+			   the pipe; if another notification happens
+			   to be still pending, we get a race
+			   condition with a crash or an assertion
+			   failure */
+			notify_clear(&ao->notify);
+
 			ao_command_finished(ao);
 
 			/* the player thread will now clear our music

src/pcm_buffer.h

@@ -28,7 +28,7 @@
  * would put too much stress on the allocator.
  */
 struct pcm_buffer {
-	char *buffer;
+	void *buffer;
 
 	size_t size;
 };

src/pipe.h

@@ -20,9 +20,9 @@
 #ifndef MPD_PIPE_H
 #define MPD_PIPE_H
 
-#ifndef NDEBUG
 #include <stdbool.h>
 
+#ifndef NDEBUG
 struct audio_format;
 #endif
 
@@ -99,4 +99,10 @@ music_pipe_push(struct music_pipe *mp, struct music_chunk *chunk);
 unsigned
 music_pipe_size(const struct music_pipe *mp);
 
+static inline bool
+music_pipe_empty(const struct music_pipe *mp)
+{
+	return music_pipe_size(mp) == 0;
+}
+
 #endif

src/player_thread.c

@@ -118,6 +118,33 @@ static void player_command_finished(void)
 	notify_signal(&main_notify);
 }
 
+/**
+ * Is the decoder still busy on the same song as the player?
+ *
+ * Note: this function does not check if the decoder is already
+ * finished.
+ */
+static bool
+player_dc_at_current_song(const struct player *player)
+{
+	assert(player != NULL);
+	assert(player->pipe != NULL);
+
+	return dc.pipe == player->pipe;
+}
+
+/**
+ * Has the decoder already begun decoding the next song?
+ *
+ * Note: this function does not check if the decoder is already
+ * finished.
+ */
+static bool
+player_dc_at_next_song(const struct player *player)
+{
+	return dc.pipe != NULL && !player_dc_at_current_song(player);
+}
+
 /**
  * Stop the decoder and clears (and frees) its music pipe.
  */
@@ -297,10 +324,9 @@ static bool player_seek_decoder(struct player *player)
 		/* clear music chunks which might still reside in the
 		   pipe */
 		music_pipe_clear(player->pipe, player_buffer);
-		dc.pipe = player->pipe;
 
 		/* re-start the decoder */
-		dc_start_async(pc.next_song);
+		dc_start_async(pc.next_song, player->pipe);
 		ret = player_wait_for_decoder(player);
 		if (!ret) {
 			/* decoder failure */
@@ -308,6 +334,14 @@ static bool player_seek_decoder(struct player *player)
 			return false;
 		}
 	} else {
+		if (!player_dc_at_current_song(player)) {
+			/* the decoder is already decoding the "next" song,
+			   but it is the same song file; exchange the pipe */
+			music_pipe_clear(player->pipe, player_buffer);
+			music_pipe_free(player->pipe);
+			player->pipe = dc.pipe;
+		}
+
 		pc.next_song = NULL;
 		player->queued = false;
 	}
@@ -364,7 +398,7 @@ static void player_process_command(struct player *player)
 	case PLAYER_COMMAND_QUEUE:
 		assert(pc.next_song != NULL);
 		assert(!player->queued);
-		assert(dc.pipe == NULL || dc.pipe == player->pipe);
+		assert(!player_dc_at_next_song(player));
 
 		player->queued = true;
 		player_command_finished();
@@ -409,7 +443,7 @@ static void player_process_command(struct player *player)
 			return;
 		}
 
-		if (dc.pipe != NULL && dc.pipe != player->pipe)
+		if (player_dc_at_next_song(player))
 			/* the decoder is already decoding the song -
 			   stop it and reset the position */
 			player_dc_stop(player);
@@ -505,7 +539,7 @@ play_next_chunk(struct player *player)
 		return true;
 
 	if (player->xfade == XFADE_ENABLED &&
-	    dc.pipe != NULL && dc.pipe != player->pipe &&
+	    player_dc_at_next_song(player) &&
 	    (cross_fade_position = music_pipe_size(player->pipe))
 	    <= player->cross_fade_chunks) {
 		/* perform cross fade */
@@ -638,8 +672,7 @@ static void do_play(void)
 	player.pipe = music_pipe_new();
 
 	dc.buffer = player_buffer;
-	dc.pipe = player.pipe;
-	dc_start(&pc.notify, pc.next_song);
+	dc_start(&pc.notify, pc.next_song, player.pipe);
 	if (!player_wait_for_decoder(&player)) {
 		player_dc_stop(&player);
 		player_command_finished();
@@ -706,14 +739,15 @@ static void do_play(void)
 			/* the decoder has finished the current song;
 			   make it decode the next song */
 			assert(pc.next_song != NULL);
-			assert(dc.pipe == NULL || dc.pipe == player.pipe);
+			assert(!player_dc_at_next_song(&player));
+
+			dc.pipe = NULL;
 
 			player.queued = false;
-			dc.pipe = music_pipe_new();
-			dc_start_async(pc.next_song);
+			dc_start_async(pc.next_song, music_pipe_new());
 		}
 
-		if (dc.pipe != NULL && dc.pipe != player.pipe &&
+		if (player_dc_at_next_song(&player) &&
 		    player.xfade == XFADE_UNKNOWN &&
 		    !decoder_is_starting()) {
 			/* enable cross fading in this song?  if yes,
@@ -736,7 +770,7 @@ static void do_play(void)
 
 		if (player.paused)
 			notify_wait(&pc.notify);
-		else if (music_pipe_size(player.pipe) > 0) {
+		else if (!music_pipe_empty(player.pipe)) {
 			/* at least one music chunk is ready - send it
 			   to the audio output */
 
@@ -748,7 +782,7 @@ static void do_play(void)
 
 			/* XXX synchronize in a better way */
 			g_usleep(10000);
-		} else if (dc.pipe != NULL && dc.pipe != player.pipe) {
+		} else if (player_dc_at_next_song(&player)) {
 			/* at the beginning of a new song */
 
 			if (!player_song_border(&player))
@@ -757,7 +791,7 @@ static void do_play(void)
 			/* check the size of the pipe again, because
 			   the decoder thread may have added something
 			   since we last checked */
-			if (music_pipe_size(player.pipe) == 0)
+			if (music_pipe_empty(player.pipe))
 				break;
 		} else {
 			/* the decoder is too busy and hasn't provided

src/playlist_control.c

@@ -24,6 +24,7 @@
 
 #include "playlist_internal.h"
 #include "player_control.h"
+#include "idle.h"
 
 #include <glib.h>
 
@@ -156,6 +157,8 @@ nextSongInPlaylist(struct playlist *playlist)
 	if (next_order < 0) {
 		/* cancel single */
 		playlist->queue.single = false;
+		idle_add(IDLE_OPTIONS);
+
 		/* no song after this one: stop playback */
 		stopPlaylist(playlist);
 

src/tag.c

@@ -64,6 +64,36 @@ const char *tag_item_names[TAG_NUM_OF_ITEM_TYPES] = {
 
 bool ignore_tag_items[TAG_NUM_OF_ITEM_TYPES];
 
+enum tag_type
+tag_name_parse(const char *name)
+{
+	assert(name != NULL);
+
+	for (unsigned i = 0; i < TAG_NUM_OF_ITEM_TYPES; ++i) {
+		assert(tag_item_names[i] != NULL);
+
+		if (strcmp(name, tag_item_names[i]) == 0)
+			return (enum tag_type)i;
+	}
+
+	return TAG_NUM_OF_ITEM_TYPES;
+}
+
+enum tag_type
+tag_name_parse_i(const char *name)
+{
+	assert(name != NULL);
+
+	for (unsigned i = 0; i < TAG_NUM_OF_ITEM_TYPES; ++i) {
+		assert(tag_item_names[i] != NULL);
+
+		if (g_ascii_strcasecmp(name, tag_item_names[i]) == 0)
+			return (enum tag_type)i;
+	}
+
+	return TAG_NUM_OF_ITEM_TYPES;
+}
+
 static size_t items_size(const struct tag *tag)
 {
 	return tag->num_items * sizeof(struct tag_item *);
@@ -76,7 +106,7 @@ void tag_lib_init(void)
 	char *temp;
 	char *s;
 	char *c;
-	int i;
+	enum tag_type type;
 
 	/* parse the "metadata_to_use" config parameter below */
 
@@ -98,16 +128,18 @@ void tag_lib_init(void)
 			if (*s == '\0')
 				quit = 1;
 			*s = '\0';
-			for (i = 0; i < TAG_NUM_OF_ITEM_TYPES; i++) {
-				if (g_ascii_strcasecmp(c, tag_item_names[i]) == 0) {
-					ignore_tag_items[i] = false;
-					break;
-				}
-			}
-			if (strlen(c) && i == TAG_NUM_OF_ITEM_TYPES) {
+
+			c = g_strstrip(c);
+			if (*c == 0)
+				continue;
+
+			type = tag_name_parse_i(c);
+			if (type == TAG_NUM_OF_ITEM_TYPES)
 				g_error("error parsing metadata item \"%s\"",
 					c);
-			}
+
+			ignore_tag_items[type] = false;
+
 			s++;
 			c = s;
 		}

src/tag.h

@@ -93,6 +93,22 @@ struct tag {
 	unsigned num_items;
 };
 
+/**
+ * Parse the string, and convert it into a #tag_type.  Returns
+ * #TAG_NUM_OF_ITEM_TYPES if the string could not be recognized.
+ */
+enum tag_type
+tag_name_parse(const char *name);
+
+/**
+ * Parse the string, and convert it into a #tag_type.  Returns
+ * #TAG_NUM_OF_ITEM_TYPES if the string could not be recognized.
+ *
+ * Case does not matter.
+ */
+enum tag_type
+tag_name_parse_i(const char *name);
+
 /**
  * Creates an empty #tag.
  */

src/tag_ape.c

@@ -19,12 +19,47 @@
 
 #include "tag_ape.h"
 #include "tag.h"
+#include "tag_table.h"
 
 #include <glib.h>
 
 #include <assert.h>
 #include <stdio.h>
 
+static const char *const ape_tag_names[TAG_NUM_OF_ITEM_TYPES] = {
+	[TAG_ITEM_ALBUM_ARTIST] = "album artist",
+	[TAG_ITEM_DATE] = "year"
+};
+
+static enum tag_type
+tag_ape_name_parse(const char *name)
+{
+	enum tag_type type = tag_table_lookup(ape_tag_names, name);
+	if (type == TAG_NUM_OF_ITEM_TYPES)
+		type = tag_name_parse_i(name);
+
+	return type;
+}
+
+static struct tag *
+tag_ape_import_item(struct tag *tag, unsigned long flags,
+		    const char *key, const char *value, size_t value_length)
+{
+	/* we only care about utf-8 text tags */
+	if ((flags & (0x3 << 1)) != 0)
+		return tag;
+
+	enum tag_type type = tag_ape_name_parse(key);
+	if (type == TAG_NUM_OF_ITEM_TYPES)
+		return tag;
+
+	if (tag == NULL)
+		tag = tag_new();
+	tag_add_item_n(tag, type, value, value_length);
+
+	return tag;
+}
+
 struct tag *
 tag_ape_load(const char *file)
 {
@@ -36,7 +71,6 @@ tag_ape_load(const char *file)
 	size_t tagLen;
 	size_t size;
 	unsigned long flags;
-	int i;
 	char *key;
 
 	struct {
@@ -48,26 +82,6 @@ tag_ape_load(const char *file)
 		unsigned char reserved[8];
 	} footer;
 
-	const char *apeItems[7] = {
-		"title",
-		"artist",
-		"album",
-		"comment",
-		"genre",
-		"track",
-		"year"
-	};
-
-	int tagItems[7] = {
-		TAG_ITEM_TITLE,
-		TAG_ITEM_ARTIST,
-		TAG_ITEM_ALBUM,
-		TAG_ITEM_COMMENT,
-		TAG_ITEM_GENRE,
-		TAG_ITEM_TRACK,
-		TAG_ITEM_DATE,
-	};
-
 	fp = fopen(file, "r");
 	if (!fp)
 		return NULL;
@@ -127,17 +141,8 @@ tag_ape_load(const char *file)
 		if (tagLen < size)
 			goto fail;
 
-		/* we only care about utf-8 text tags */
-		if (!(flags & (0x3 << 1))) {
-			for (i = 0; i < 7; i++) {
-				if (g_ascii_strcasecmp(key, apeItems[i]) == 0) {
-					if (!ret)
-						ret = tag_new();
-					tag_add_item_n(ret, tagItems[i],
-						       p, size);
-				}
-			}
-		}
+		ret = tag_ape_import_item(ret, flags, key, p, size);
+
 		p += size;
 		tagLen -= size;
 	}

src/tag_table.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2003-2010 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_TAG_TABLE_H
+#define MPD_TAG_TABLE_H
+
+#include "tag.h"
+
+#include <glib.h>
+
+/**
+ * Looks up a string in a tag translation table (case insensitive).
+ * Returns TAG_NUM_OF_ITEM_TYPES if the specified name was not found
+ * in the table.
+ */
+static inline enum tag_type
+tag_table_lookup(const char *const* table, const char *name)
+{
+	for (unsigned i = 0; i < TAG_NUM_OF_ITEM_TYPES; i++)
+		if (table[i] != NULL &&
+		    g_ascii_strcasecmp(name, table[i]) == 0)
+			return (enum tag_type)i;
+
+	return TAG_NUM_OF_ITEM_TYPES;
+}
+
+#endif

src/update.c

@@ -254,6 +254,9 @@ stat_directory(const struct directory *directory, struct stat *st)
 	if (path_fs == NULL)
 		return -1;
 	ret = stat(path_fs, st);
+	if (ret < 0)
+		g_warning("Failed to stat %s: %s", path_fs, g_strerror(errno));
+
 	g_free(path_fs);
 	return ret;
 }
@@ -270,6 +273,9 @@ stat_directory_child(const struct directory *parent, const char *name,
 		return -1;
 
 	ret = stat(path_fs, st);
+	if (ret < 0)
+		g_warning("Failed to stat %s: %s", path_fs, g_strerror(errno));
+
 	g_free(path_fs);
 	return ret;
 }

src/zeroconf-bonjour.c

@@ -62,7 +62,7 @@ void init_zeroconf_osx(const char *serviceName)
 	DNSServiceErrorType error = DNSServiceRegister(&dnsReference,
 						       0, 0, serviceName,
 						       SERVICE_TYPE, NULL, NULL,
-						       htons(listen_port), 0,
+						       g_htons(listen_port), 0,
 						       NULL,
 						       dnsRegisterCallback,
 						       NULL);