release v0.19.17

This is required if a stream ands without another chained FLAC file.

Makefile.am

@@ -467,6 +467,7 @@ libpcm_a_SOURCES = \
 	src/pcm/PcmConvert.cxx src/pcm/PcmConvert.hxx \
 	src/pcm/PcmDop.cxx src/pcm/PcmDop.hxx \
 	src/pcm/Volume.cxx src/pcm/Volume.hxx \
+	src/pcm/Silence.cxx src/pcm/Silence.hxx \
 	src/pcm/PcmMix.cxx src/pcm/PcmMix.hxx \
 	src/pcm/PcmChannels.cxx src/pcm/PcmChannels.hxx \
 	src/pcm/PcmPack.cxx src/pcm/PcmPack.hxx \
@@ -1219,6 +1220,7 @@ liboutput_plugins_a_SOURCES = \
 
 MIXER_LIBS = \
 	libmixer_plugins.a \
+	$(ALSA_LIBS) \
 	$(PULSE_LIBS)
 
 MIXER_API_SRC = \
@@ -2108,7 +2110,9 @@ developer_DATA = $(wildcard doc/developer/*.html)
 
 DOCBOOK_HTML = $(patsubst %.xml,%/index.html,$(DOCBOOK_FILES))
 
-$(DOCBOOK_HTML): %/index.html: %.xml
+DOCBOOK_INCLUDES = $(wildcard $(srcdir)/doc/include/*.xml)
+
+$(DOCBOOK_HTML): %/index.html: %.xml $(DOCBOOK_INCLUDES)
 	$(XMLTO) -o $(@D) --stringparam chunker.output.encoding=utf-8 html --stringparam use.id.as.filename=1 $<
 
 doc/api/html/index.html: doc/doxygen.conf
@@ -2149,8 +2153,9 @@ EXTRA_DIST = $(doc_DATA) autogen.sh \
 	test/test_archive_bzip2.sh  \
 	test/test_archive_iso9660.sh \
 	test/test_archive_zzip.sh \
-	$(wildcard scripts/*.sh) \
+	$(wildcard $(srcdir)/scripts/*.rb) \
 	$(man_MANS) $(DOCBOOK_FILES) doc/mpdconf.example doc/doxygen.conf \
+	$(wildcard $(srcdir)/doc/include/*.xml) \
 	systemd/mpd.socket \
 	android/AndroidManifest.xml \
 	android/build.py \

NEWS

@@ -1,3 +1,60 @@
+ver 0.19.17 (2016/07/09)
+* decoder
+  - flac: fix assertion failure while seeking
+  - flac: fix stream duration indicator
+  - fix seek problems in several plugins
+* fix spurious seek error "Failed to allocate silence buffer"
+* replay gain: fix "replay_gain_handler mixer" setting
+* DSD: use 0x69 as silence pattern
+* fix use-after-free bug on "close" and "kill"
+
+ver 0.19.16 (2016/06/13)
+* faster seeking
+* fix system include path order
+* add missing DocBook file to tarball
+
+ver 0.19.15 (2016/04/30)
+* decoder
+  - ffmpeg: support FFmpeg 3.0
+  - ffmpeg: use as fallback instead of "mad" if no plugin matches
+  - opus: support bigger OpusTags packets
+* fix more build failures on non-glibc builds due to constexpr Mutex
+* fix build failure due to missing include
+* fix unit test on Alpha
+
+ver 0.19.14 (2016/03/18)
+* decoder
+  - dsdiff: fix off-by-one buffer overflow
+  - opus: limit tag size to 64 kB
+* archive
+  - iso9660: fix buffer overflow
+* fix quadratic runtime bug in the tag pool
+* fix build failures on non-glibc builds due to constexpr Mutex
+
+ver 0.19.13 (2016/02/23)
+* tags
+  - aiff, riff: fix ID3 chunk padding
+* decoder
+  - ffmpeg: support the TAK codec
+* fix disappearing duration of remote songs during playback
+* initialize supplementary groups with glibc 2.19+
+
+ver 0.19.12 (2015/12/15)
+* fix assertion failure on malformed UTF-8 tag
+* fix build failure on non-Linux systems
+* fix LimitRTTIME in systemd unit file
+
+ver 0.19.11 (2015/10/27)
+* tags
+  - ape: fix buffer overflow
+* decoder
+  - ffmpeg: fix crash due to wrong avio_alloc_context() call
+  - gme: don't loop forever, fall back to GME's default play length
+* encoder
+  - flac: fix crash with 32 bit playback
+* mixer
+  - fix mixer lag after enabling/disabling output
+
 ver 0.19.10 (2015/06/21)
 * input
   - curl: fix deadlock on small responses

configure.ac

@@ -1,10 +1,10 @@
 AC_PREREQ(2.60)
 
-AC_INIT(mpd, 0.19.10, musicpd-dev-team@lists.sourceforge.net)
+AC_INIT(mpd, 0.19.17, musicpd-dev-team@lists.sourceforge.net)
 
 VERSION_MAJOR=0
 VERSION_MINOR=19
-VERSION_REVISION=10
+VERSION_REVISION=17
 VERSION_EXTRA=0
 
 AC_CONFIG_SRCDIR([src/Main.cxx])
@@ -206,6 +206,7 @@ if test x$host_is_linux = xyes; then
 fi
 
 AC_CHECK_FUNCS(getpwnam_r getpwuid_r)
+AC_CHECK_FUNCS(initgroups)
 AC_CHECK_FUNCS(strndup)
 
 if test x$host_is_linux = xyes; then
@@ -702,12 +703,6 @@ AC_ARG_ENABLE(glib,
 if test x$enable_glib = xyes; then
 	PKG_CHECK_MODULES([GLIB], [glib-2.0 >= 2.28 gthread-2.0],,
 		[AC_MSG_ERROR([GLib 2.28 is required])])
-
-	if test x$GCC = xyes; then
-		# suppress warnings in the GLib headers
-		GLIB_CFLAGS=`echo $GLIB_CFLAGS |sed -e 's,-I/,-isystem /,g'`
-	fi
-
 	AC_DEFINE(HAVE_GLIB, 1, [Define if GLib is used])
 fi
 AM_CONDITIONAL(HAVE_GLIB, test x$enable_glib = xyes)

doc/developer.xml

@@ -1,6 +1,7 @@
 <?xml version='1.0' encoding="utf-8"?>
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
-               "docbook/dtd/xml/4.2/docbookx.dtd">
+<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+                      "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
+
 <book>
   <title>The Music Player Daemon - Developer's Manual</title>
 

doc/include/tags.xml

@@ -0,0 +1,154 @@
+<?xml version='1.0' encoding="utf-8"?>
+<!DOCTYPE itemizedlist PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+                              "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
+
+<itemizedlist>
+  <listitem>
+    <para>
+      <varname>artist</varname>: the artist name.  Its meaning is not
+      well-defined; see <varname>composer</varname> and
+      <varname>performer</varname> for more specific tags.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>artistsort</varname>: same as
+      <varname>artist</varname>, but for sorting.  This usually omits
+      prefixes such as "The".
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>album</varname>: the album name.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>albumsort</varname>: same as <varname>album</varname>,
+      but for sorting.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>albumartist</varname>: on multi-artist albums, this is
+      the artist name which shall be used for the whole album.  The
+      exact meaning of this tag is not well-defined.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>albumartistsort</varname>: same as
+      <varname>albumartist</varname>, but for sorting.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>title</varname>: the song title.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>track</varname>: the track number within the album.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>name</varname>: a name for this song.  This is not the
+      song title.  The exact meaning of this tag is not well-defined.
+      It is often used by badly configured internet radio stations
+      with broken tags to squeeze both the artist name and the song
+      title in one tag.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>genre</varname>: the music genre.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>date</varname>: the song's release date.  This is
+      usually a 4-digit year.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>composer</varname>: the artist who composed the song.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>performer</varname>: the artist who performed the song.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>comment</varname>: a human-readable comment about this
+      song.  The exact meaning of this tag is not well-defined.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>disc</varname>: the disc number in a multi-disc album.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>musicbrainz_artistid</varname>: the artist id in the
+      <ulink
+      url="http://musicbrainz.org/doc/MusicBrainzTag">MusicBrainz</ulink>
+      database.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>musicbrainz_albumid</varname>: the album id in the
+      <ulink
+      url="http://musicbrainz.org/doc/MusicBrainzTag">MusicBrainz</ulink>
+      database.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>musicbrainz_albumartistid</varname>: the album artist
+      id in the <ulink
+      url="http://musicbrainz.org/doc/MusicBrainzTag">MusicBrainz</ulink>
+      database.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>musicbrainz_trackid</varname>: the track id in the
+      <ulink
+      url="http://musicbrainz.org/doc/MusicBrainzTag">MusicBrainz</ulink>
+      database.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para>
+      <varname>musicbrainz_releasetrackid</varname>: the release track
+      id in the <ulink
+      url="http://musicbrainz.org/doc/MusicBrainzTag">MusicBrainz</ulink>
+      database.
+    </para>
+  </listitem>
+</itemizedlist>

doc/mpd.conf.5

@@ -174,18 +174,6 @@ MP3 playback.
 This specifies whether relative or absolute paths for song filenames are used
 when saving playlists.  The default is "no".
 .TP
-.B metadata_to_use <tags>
-This specifies the tag types that will be scanned for and made available to
-clients.  Note that you must recreate (not update) your database for changes to
-this parameter to take effect.  Possible values are artist, album, title,
-track, name, genre, date, composer, performer, comment, disc,
-musicbrainz_artistid, musicbrainz_albumid, musicbrainz_albumartistid,
-musicbrainz_releasetrackid, musicbrainz_trackid.  Multiple tags may be specified
-as a comma separated list.
-An example value is "artist,album,title,track".  The special value "none" may
-be used alone to disable all metadata.  The default is to use all known tag
-types except for comments and those starting with "musicbrainz".
-.TP
 .B auto_update <yes or no>
 This specifies the whether to support automatic update of music database when
 files are changed in music_directory. The default is to disable autoupdate

doc/mpdconf.example

@@ -115,7 +115,7 @@
 #
 # This setting defines a list of tag types that will be extracted during the
 # audio file discovery process. The complete list of possible values can be
-# found in the mpd.conf man page.
+# found in the user manual.
 #metadata_to_use	"artist,album,title,track,name,genre,date,composer,performer,disc"
 #
 # This setting enables automatic update of MPD's database when files in 

doc/protocol.xml

@@ -1,6 +1,7 @@
 <?xml version='1.0' encoding="utf-8"?>
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
-               "docbook/dtd/xml/4.2/docbookx.dtd">
+<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+                      "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
+
 <book>
   <title>The Music Player Daemon protocol</title>
 
@@ -201,6 +202,25 @@
         omitted, then the maximum possible value is assumed.
       </para>
     </section>
+
+    <section id="tags">
+      <title>Tags</title>
+
+      <para>
+        The following tags are supported by
+        <application>MPD</application>:
+      </para>
+
+      <xi:include href="include/tags.xml"
+                  xmlns:xi="http://www.w3.org/2001/XInclude"/>
+
+      <para>
+        There can be multiple values for some of these tags.  For
+        example, <application>MPD</application> may return multiple
+        lines with a <varname>performer</varname> tag.  A tag value is
+        a UTF-8 string.
+      </para>
+    </section>
   </chapter>
 
   <chapter id="recipes">

doc/user.xml

@@ -1,6 +1,7 @@
 <?xml version='1.0' encoding="utf-8"?>
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
-               "docbook/dtd/xml/4.2/docbookx.dtd">
+<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+                      "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
+
 <book>
   <title>The Music Player Daemon - User's Manual</title>
 
@@ -16,7 +17,7 @@
       <application>MPD</application> (Music Player Daemon) is, as the
       name suggests, a server software allowing you to remotely play
       your music, handle playlists, deliver music (HTTP streams with
-      various sub-protocols) and organizze playlists.
+      various sub-protocols) and organize playlists.
     </para>
 
     <para>
@@ -944,6 +945,33 @@ systemctl start mpd.socket</programlisting>
     <section id="config_other">
       <title>Other Settings</title>
 
+      <informaltable>
+        <tgroup cols="2">
+          <thead>
+            <row>
+              <entry>Setting</entry>
+              <entry>Description</entry>
+            </row>
+          </thead>
+          <tbody>
+            <row>
+              <entry>
+                <varname>metadata_to_use</varname>
+                <parameter>TAG1,TAG2,...</parameter>
+              </entry>
+              <entry>
+                Use only the specified tags, and ignore the others.
+                This setting can reduce the database size and
+                <application>MPD</application>'s memory usage by
+                omitting unused tags.  By default, all tags but
+                <varname>comment</varname> are enabled.  The special
+                value "none" disables all tags.
+              </entry>
+            </row>
+          </tbody>
+        </tgroup>
+      </informaltable>
+
       <section>
         <title>The State File</title>
 
@@ -1190,6 +1218,58 @@ database {
         plugin).
       </para>
     </section>
+
+    <section id="realtime">
+      <title>Real-Time Scheduling</title>
+
+      <para>
+        On Linux, <application>MPD</application> attempts to configure
+        <ulink
+        url="https://en.wikipedia.org/wiki/Real-time_computing">real-time
+        scheduling</ulink> for some threads that benefit from it.
+      </para>
+
+      <para>
+        This is only possible you allow <application>MPD</application>
+        to do it.  This privilege is controlled by
+        <varname>RLIMIT_RTPRIO</varname>
+        <varname>RLIMIT_RTTIME</varname>.  You can configure this
+        privilege with <command>ulimit</command> before launching
+        <application>MPD</application>:
+      </para>
+
+      <programlisting>ulimit -HS -r 50; mpd</programlisting>
+
+      <para>
+        Or you can use the <command>prlimit</command> program from the
+        <application>util-linux</application> package:
+      </para>
+
+      <programlisting>prlimit --rtprio=50 --rttime=unlimited mpd</programlisting>
+
+      <para>
+        The <application>systemd</application> service file shipped
+        with <application>MPD</application> comes with this setting.
+      </para>
+
+      <para>
+        This works only if the Linux kernel was compiled with
+        <varname>CONFIG_RT_GROUP_SCHED</varname> disabled.  Use the
+        following command to check this option for your current
+        kernel:
+      </para>
+
+      <programlisting>zgrep ^CONFIG_RT_GROUP_SCHED /proc/config.gz</programlisting>
+
+      <note>
+        <para>
+          There is a rumor that real-time scheduling improves audio
+          quality.  That is not true.  All it does is reduce the
+          probability of skipping (audio buffer xruns) when the
+          computer is under heavy load.
+        </para>
+      </note>
+    </section>
   </chapter>
 
   <chapter id="use">
@@ -1245,6 +1325,19 @@ database {
       </para>
     </section>
 
+    <section id="tags">
+      <title>Metadata</title>
+
+      <para>
+        When scanning or playing a song,
+        <application>MPD</application> parses its metadata.  The
+        following tags are supported:
+      </para>
+
+      <xi:include href="include/tags.xml"
+                  xmlns:xi="http://www.w3.org/2001/XInclude"/>
+    </section>
+
     <section id="queue">
       <title>The queue</title>
 
@@ -2595,7 +2688,8 @@ buffer_size: 16384</programlisting>
           / <ulink
           url="http://icecast.org/"><application>IceCast</application></ulink>.
           HTTP streaming clients like
-          <application>mplayer</application> can connect to it.
+          <application>mplayer</application>, <application>VLC</application>,
+          and <application>mpv</application> can connect to it.
         </para>
 
         <para>

src/DetachedSong.hxx

@@ -188,6 +188,14 @@ public:
 		tag = std::move(other.tag);
 	}
 
+	/**
+	 * Similar to the MoveTagFrom(), but move only the #TagItem
+	 * array.
+	 */
+	void MoveTagItemsFrom(DetachedSong &&other) {
+		tag.MoveItemsFrom(std::move(other.tag));
+	}
+
 	time_t GetLastModified() const {
 		return mtime;
 	}

src/Main.cxx

@@ -54,7 +54,6 @@
 #include "system/FatalError.hxx"
 #include "util/UriUtil.hxx"
 #include "util/Error.hxx"
-#include "util/Domain.hxx"
 #include "thread/Id.hxx"
 #include "thread/Slack.hxx"
 #include "lib/icu/Init.hxx"
@@ -123,8 +122,6 @@
 static constexpr unsigned DEFAULT_BUFFER_SIZE = 4096;
 static constexpr unsigned DEFAULT_BUFFER_BEFORE_PLAY = 10;
 
-static constexpr Domain main_domain("main");
-
 #ifdef ANDROID
 Context *context;
 #endif
@@ -633,7 +630,7 @@ static int mpd_main_after_fork(struct options options)
 					 config_get_unsigned(CONF_AUTO_UPDATE_DEPTH,
 							     INT_MAX));
 #else
-		FormatWarning(main_domain,
+		FormatWarning(config_domain,
 			      "inotify: auto_update was disabled. enable during compilation phase");
 #endif
 	}

src/PlayerThread.cxx

@@ -25,6 +25,7 @@
 #include "MusicPipe.hxx"
 #include "MusicBuffer.hxx"
 #include "MusicChunk.hxx"
+#include "pcm/Silence.hxx"
 #include "DetachedSong.hxx"
 #include "system/FatalError.hxx"
 #include "CrossFade.hxx"
@@ -486,8 +487,12 @@ Player::SendSilence()
 
 	MusicChunk *chunk = buffer.Allocate();
 	if (chunk == nullptr) {
-		LogError(player_domain, "Failed to allocate silence buffer");
-		return false;
+		/* this is non-fatal, because this means that the
+		   decoder has filled to buffer completely meanwhile;
+		   by ignoring the error, we work around this race
+		   condition */
+		LogDebug(player_domain, "Failed to allocate silence buffer");
+		return true;
 	}
 
 #ifndef NDEBUG
@@ -501,7 +506,7 @@ Player::SendSilence()
 
 	chunk->time = SignedSongTime::Negative(); /* undefined time stamp */
 	chunk->length = num_frames * frame_size;
-	memset(chunk->data, 0, chunk->length);
+	PcmSilence({chunk->data, chunk->length}, play_audio_format.format);
 
 	Error error;
 	if (!pc.outputs.Play(chunk, error)) {
@@ -518,6 +523,8 @@ Player::SeekDecoder()
 {
 	assert(pc.next_song != nullptr);
 
+	pc.outputs.Cancel();
+
 	const SongTime start_time = pc.next_song->GetStartTime();
 
 	if (!dc.LockIsCurrentSong(*pc.next_song)) {
@@ -583,8 +590,6 @@ Player::SeekDecoder()
 	/* re-fill the buffer after seeking */
 	buffering = true;
 
-	pc.outputs.Cancel();
-
 	return true;
 }
 

src/archive/plugins/Iso9660ArchivePlugin.cxx

@@ -66,7 +66,11 @@ public:
 		return iso9660_iso_seek_read(iso, ptr, start, i_size);
 	}
 
-	void Visit(const char *path, ArchiveVisitor &visitor);
+	/**
+	 * @param capacity the path buffer size
+	 */
+	void Visit(char *path, size_t length, size_t capacity,
+		   ArchiveVisitor &visitor);
 
 	virtual void Close() override {
 		Unref();
@@ -84,32 +88,36 @@ static constexpr Domain iso9660_domain("iso9660");
 /* archive open && listing routine */
 
 inline void
-Iso9660ArchiveFile::Visit(const char *psz_path, ArchiveVisitor &visitor)
+Iso9660ArchiveFile::Visit(char *path, size_t length, size_t capacity,
+			  ArchiveVisitor &visitor)
 {
-	CdioList_t *entlist;
-	CdioListNode_t *entnode;
-	iso9660_stat_t *statbuf;
-	char pathname[4096];
-
-	entlist = iso9660_ifs_readdir (iso, psz_path);
+	auto *entlist = iso9660_ifs_readdir(iso, path);
 	if (!entlist) {
 		return;
 	}
 	/* Iterate over the list of nodes that iso9660_ifs_readdir gives  */
+	CdioListNode_t *entnode;
 	_CDIO_LIST_FOREACH (entnode, entlist) {
-		statbuf = (iso9660_stat_t *) _cdio_list_node_data (entnode);
+		auto *statbuf = (iso9660_stat_t *)
+			_cdio_list_node_data(entnode);
+		const char *filename = statbuf->filename;
+		if (strcmp(filename, ".") == 0 || strcmp(filename, "..") == 0)
+			continue;
 
-		strcpy(pathname, psz_path);
-		strcat(pathname, statbuf->filename);
+		size_t filename_length = strlen(filename);
+		if (length + filename_length + 1 >= capacity)
+			/* file name is too long */
+			continue;
+
+		memcpy(path + length, filename, filename_length + 1);
+		size_t new_length = length + filename_length;
 
 		if (iso9660_stat_s::_STAT_DIR == statbuf->type ) {
-			if (strcmp(statbuf->filename, ".") && strcmp(statbuf->filename, "..")) {
-				strcat(pathname, "/");
-				Visit(pathname, visitor);
-			}
+			memcpy(path + new_length, "/", 2);
+			Visit(path, new_length + 1, capacity, visitor);
 		} else {
 			//remove leading /
-			visitor.VisitArchiveEntry(pathname + 1);
+			visitor.VisitArchiveEntry(path + 1);
 		}
 	}
 	_cdio_list_free (entlist, true);
@@ -133,7 +141,8 @@ iso9660_archive_open(Path pathname, Error &error)
 void
 Iso9660ArchiveFile::Visit(ArchiveVisitor &visitor)
 {
-	Visit("/", visitor);
+	char path[4096] = "/";
+	Visit(path, 1, sizeof(path), visitor);
 }
 
 /* single archive handling */

src/client/ClientRead.cxx

@@ -52,8 +52,8 @@ Client::OnSocketInput(void *data, size_t length)
 		break;
 
 	case CommandResult::KILL:
-		Close();
 		partition.instance.event_loop->Break();
+		Close();
 		return InputResult::CLOSED;
 
 	case CommandResult::FINISH:

src/decoder/DecoderAPI.cxx

@@ -301,7 +301,8 @@ decoder_check_cancel_read(const Decoder *decoder)
 	/* ignore the SEEK command during initialization, the plugin
 	   should handle that after it has initialized successfully */
 	if (dc.command == DecoderCommand::SEEK &&
-	    (dc.state == DecoderState::START || decoder->seeking))
+	    (dc.state == DecoderState::START || decoder->seeking ||
+	     decoder->initial_seek_running))
 		return false;
 
 	return true;

src/decoder/DecoderBuffer.hxx

@@ -25,6 +25,7 @@
 #include "util/ConstBuffer.hxx"
 
 #include <stddef.h>
+#include <stdint.h>
 
 struct Decoder;
 class InputStream;

src/decoder/DecoderThread.cxx

@@ -255,7 +255,11 @@ decoder_run_stream_fallback(Decoder &decoder, InputStream &is)
 {
 	const struct DecoderPlugin *plugin;
 
+#ifdef HAVE_FFMPEG
+	plugin = decoder_plugin_from_name("ffmpeg");
+#else
 	plugin = decoder_plugin_from_name("mad");
+#endif
 	return plugin != nullptr && plugin->stream_decode != nullptr &&
 		decoder_stream_decode(*plugin, decoder, is);
 }

src/decoder/plugins/DsdiffDecoderPlugin.cxx

@@ -205,7 +205,7 @@ dsdiff_handle_native_tag(InputStream &is,
 	if (length == 0 || length > 60)
 		return;
 
-	char string[length];
+	char string[length + 1];
 	char *label;
 	label = string;
 

src/decoder/plugins/FfmpegDecoderPlugin.cxx

@@ -92,14 +92,14 @@ struct AvioStream {
 
 	AVIOContext *io;
 
-	unsigned char buffer[8192];
-
 	AvioStream(Decoder *_decoder, InputStream &_input)
 		:decoder(_decoder), input(_input), io(nullptr) {}
 
 	~AvioStream() {
-		if (io != nullptr)
+		if (io != nullptr) {
+			av_free(io->buffer);
 			av_free(io);
+		}
 	}
 
 	bool Open();
@@ -153,11 +153,20 @@ mpd_ffmpeg_stream_seek(void *opaque, int64_t pos, int whence)
 bool
 AvioStream::Open()
 {
-	io = avio_alloc_context(buffer, sizeof(buffer),
+	constexpr size_t BUFFER_SIZE = 8192;
+	auto buffer = (unsigned char *)av_malloc(BUFFER_SIZE);
+	if (buffer == nullptr)
+		return false;
+
+	io = avio_alloc_context(buffer, BUFFER_SIZE,
 				false, this,
 				mpd_ffmpeg_stream_read, nullptr,
 				input.IsSeekable()
 				? mpd_ffmpeg_stream_seek : nullptr);
+	/* If avio_alloc_context() fails, who frees the buffer?  The
+	   libavformat API documentation does not specify this, it
+	   only says that AVIOContext.buffer must be freed in the end,
+	   however no AVIOContext exists in that failure code path. */
 	return io != nullptr;
 }
 
@@ -190,10 +199,10 @@ ffmpeg_init(gcc_unused const config_param &param)
 }
 
 static int
-ffmpeg_find_audio_stream(const AVFormatContext *format_context)
+ffmpeg_find_audio_stream(const AVFormatContext &format_context)
 {
-	for (unsigned i = 0; i < format_context->nb_streams; ++i)
-		if (format_context->streams[i]->codec->codec_type ==
+	for (unsigned i = 0; i < format_context.nb_streams; ++i)
+		if (format_context.streams[i]->codec->codec_type ==
 		    AVMEDIA_TYPE_AUDIO)
 			return i;
 
@@ -267,22 +276,22 @@ copy_interleave_frame2(uint8_t *dest, uint8_t **src,
  * Copy PCM data from a AVFrame to an interleaved buffer.
  */
 static int
-copy_interleave_frame(const AVCodecContext *codec_context,
-		      const AVFrame *frame,
+copy_interleave_frame(const AVCodecContext &codec_context,
+		      const AVFrame &frame,
 		      uint8_t **output_buffer,
 		      uint8_t **global_buffer, int *global_buffer_size)
 {
 	int plane_size;
 	const int data_size =
 		av_samples_get_buffer_size(&plane_size,
-					   codec_context->channels,
-					   frame->nb_samples,
-					   codec_context->sample_fmt, 1);
+					   codec_context.channels,
+					   frame.nb_samples,
+					   codec_context.sample_fmt, 1);
 	if (data_size <= 0)
 		return data_size;
 
-	if (av_sample_fmt_is_planar(codec_context->sample_fmt) &&
-	    codec_context->channels > 1) {
+	if (av_sample_fmt_is_planar(codec_context.sample_fmt) &&
+	    codec_context.channels > 1) {
 		if(*global_buffer_size < data_size) {
 			av_freep(global_buffer);
 
@@ -294,12 +303,12 @@ copy_interleave_frame(const AVCodecContext *codec_context,
 			*global_buffer_size = data_size;
 		}
 		*output_buffer = *global_buffer;
-		copy_interleave_frame2(*output_buffer, frame->extended_data,
-				       frame->nb_samples,
-				       codec_context->channels,
-				       av_get_bytes_per_sample(codec_context->sample_fmt));
+		copy_interleave_frame2(*output_buffer, frame.extended_data,
+				       frame.nb_samples,
+				       codec_context.channels,
+				       av_get_bytes_per_sample(codec_context.sample_fmt));
 	} else {
-		*output_buffer = frame->extended_data[0];
+		*output_buffer = frame.extended_data[0];
 	}
 
 	return data_size;
@@ -340,41 +349,39 @@ PtsToPcmFrame(uint64_t pts, const AVStream &stream,
  */
 static DecoderCommand
 ffmpeg_send_packet(Decoder &decoder, InputStream &is,
-		   const AVPacket *packet,
-		   AVCodecContext *codec_context,
-		   const AVStream *stream,
+		   AVPacket &&packet,
+		   AVCodecContext &codec_context,
+		   const AVStream &stream,
 		   AVFrame *frame,
 		   uint64_t min_frame, size_t pcm_frame_size,
 		   uint8_t **buffer, int *buffer_size)
 {
 	size_t skip_bytes = 0;
 
-	const auto pts = StreamRelativePts(*packet, *stream);
+	const auto pts = StreamRelativePts(packet, stream);
 	if (pts >= 0) {
 		if (min_frame > 0) {
-			auto cur_frame = PtsToPcmFrame(pts, *stream,
-						       *codec_context);
+			auto cur_frame = PtsToPcmFrame(pts, stream,
+						       codec_context);
 			if (cur_frame < min_frame)
 				skip_bytes = pcm_frame_size * (min_frame - cur_frame);
 		} else
 			decoder_timestamp(decoder,
-					  time_from_ffmpeg(pts, stream->time_base));
+					  time_from_ffmpeg(pts, stream.time_base));
 	}
 
-	AVPacket packet2 = *packet;
-
 	uint8_t *output_buffer;
 
 	DecoderCommand cmd = DecoderCommand::NONE;
-	while (packet2.size > 0 && cmd == DecoderCommand::NONE) {
+	while (packet.size > 0 && cmd == DecoderCommand::NONE) {
 		int audio_size = 0;
 		int got_frame = 0;
-		int len = avcodec_decode_audio4(codec_context,
+		int len = avcodec_decode_audio4(&codec_context,
 						frame, &got_frame,
-						&packet2);
+						&packet);
 		if (len >= 0 && got_frame) {
 			audio_size = copy_interleave_frame(codec_context,
-							   frame,
+							   *frame,
 							   &output_buffer,
 							   buffer, buffer_size);
 			if (audio_size < 0)
@@ -388,8 +395,8 @@ ffmpeg_send_packet(Decoder &decoder, InputStream &is,
 			break;
 		}
 
-		packet2.data += len;
-		packet2.size -= len;
+		packet.data += len;
+		packet.size -= len;
 
 		if (audio_size <= 0)
 			continue;
@@ -408,7 +415,7 @@ ffmpeg_send_packet(Decoder &decoder, InputStream &is,
 
 		cmd = decoder_data(decoder, is,
 				   data, audio_size,
-				   codec_context->bit_rate / 1000);
+				   codec_context.bit_rate / 1000);
 	}
 	return cmd;
 }
@@ -526,7 +533,7 @@ ffmpeg_decode(Decoder &decoder, InputStream &input)
 		return;
 	}
 
-	int audio_stream = ffmpeg_find_audio_stream(format_context);
+	int audio_stream = ffmpeg_find_audio_stream(*format_context);
 	if (audio_stream == -1) {
 		LogError(ffmpeg_domain, "No audio stream inside");
 		avformat_close_input(&format_context);
@@ -622,8 +629,9 @@ ffmpeg_decode(Decoder &decoder, InputStream &input)
 
 		if (packet.stream_index == audio_stream) {
 			cmd = ffmpeg_send_packet(decoder, input,
-						 &packet, codec_context,
-						 av_stream,
+						 std::move(packet),
+						 *codec_context,
+						 *av_stream,
 						 frame,
 						 min_frame, audio_format.GetFrameSize(),
 						 &interleaved_buffer, &interleaved_buffer_size);
@@ -631,7 +639,11 @@ ffmpeg_decode(Decoder &decoder, InputStream &input)
 		} else
 			cmd = decoder_get_command(decoder);
 
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(56, 25, 100)
+		av_packet_unref(&packet);
+#else
 		av_free_packet(&packet);
+#endif
 
 		if (cmd == DecoderCommand::SEEK) {
 			int64_t where =
@@ -700,7 +712,7 @@ ffmpeg_scan_stream(InputStream &is,
 	}
 
 	ffmpeg_scan_dictionary(f->metadata, handler, handler_ctx);
-	int idx = ffmpeg_find_audio_stream(f);
+	int idx = ffmpeg_find_audio_stream(*f);
 	if (idx >= 0)
 		ffmpeg_scan_dictionary(f->streams[idx]->metadata,
 				       handler, handler_ctx);
@@ -729,7 +741,7 @@ static const char *const ffmpeg_suffixes[] = {
 	"mve", "mvi", "mxf", "nc", "nsv", "nut", "nuv", "oga", "ogm", "ogv",
 	"ogx", "oma", "ogg", "omg", "opus", "psp", "pva", "qcp", "qt", "r3d", "ra",
 	"ram", "rl2", "rm", "rmvb", "roq", "rpl", "rvc", "shn", "smk", "snd",
-	"sol", "son", "spx", "str", "swf", "tgi", "tgq", "tgv", "thp", "ts",
+	"sol", "son", "spx", "str", "swf", "tak", "tgi", "tgq", "tgv", "thp", "ts",
 	"tsp", "tta", "xa", "xvid", "uv", "uv2", "vb", "vid", "vob", "voc",
 	"vp6", "vmd", "wav", "webm", "wma", "wmv", "wsaud", "wsvga", "wv",
 	"wve",

src/decoder/plugins/FlacCommon.cxx

@@ -33,7 +33,7 @@ flac_data::flac_data(Decoder &_decoder,
 		     InputStream &_input_stream)
 	:FlacInput(_input_stream, &_decoder),
 	 initialized(false), unsupported(false),
-	 total_frames(0), first_frame(0), next_frame(0), position(0),
+	 position(0),
 	 decoder(_decoder), input_stream(_input_stream)
 {
 }
@@ -59,6 +59,38 @@ flac_sample_format(unsigned bits_per_sample)
 	}
 }
 
+bool
+flac_data::Initialize(unsigned sample_rate, unsigned bits_per_sample,
+		      unsigned channels, FLAC__uint64 total_frames)
+{
+	assert(!initialized);
+	assert(!unsupported);
+
+	::Error error;
+	if (!audio_format_init_checked(audio_format,
+				       sample_rate,
+				       flac_sample_format(bits_per_sample),
+				       channels, error)) {
+		LogError(error);
+		unsupported = true;
+		return false;
+	}
+
+	frame_size = audio_format.GetFrameSize();
+
+	const auto duration = total_frames > 0
+		? SignedSongTime::FromScale<uint64_t>(total_frames,
+						      audio_format.sample_rate)
+		: SignedSongTime::Negative();
+
+	decoder_initialized(decoder, audio_format,
+			    input_stream.IsSeekable(),
+			    duration);
+
+	initialized = true;
+	return true;
+}
+
 static void
 flac_got_stream_info(struct flac_data *data,
 		     const FLAC__StreamMetadata_StreamInfo *stream_info)
@@ -66,22 +98,10 @@ flac_got_stream_info(struct flac_data *data,
 	if (data->initialized || data->unsupported)
 		return;
 
-	Error error;
-	if (!audio_format_init_checked(data->audio_format,
-				       stream_info->sample_rate,
-				       flac_sample_format(stream_info->bits_per_sample),
-				       stream_info->channels, error)) {
-		LogError(error);
-		data->unsupported = true;
-		return;
-	}
-
-	data->frame_size = data->audio_format.GetFrameSize();
-
-	if (data->total_frames == 0)
-		data->total_frames = stream_info->total_samples;
-
-	data->initialized = true;
+	data->Initialize(stream_info->sample_rate,
+			 stream_info->bits_per_sample,
+			 stream_info->channels,
+			 stream_info->total_samples);
 }
 
 void flac_metadata_common_cb(const FLAC__StreamMetadata * block,
@@ -125,28 +145,11 @@ flac_got_first_frame(struct flac_data *data, const FLAC__FrameHeader *header)
 	if (data->unsupported)
 		return false;
 
-	Error error;
-	if (!audio_format_init_checked(data->audio_format,
-				       header->sample_rate,
-				       flac_sample_format(header->bits_per_sample),
-				       header->channels, error)) {
-		LogError(error);
-		data->unsupported = true;
-		return false;
-	}
-
-	data->frame_size = data->audio_format.GetFrameSize();
-
-	const auto duration = SongTime::FromScale<uint64_t>(data->total_frames,
-							    data->audio_format.sample_rate);
-
-	decoder_initialized(data->decoder, data->audio_format,
-			    data->input_stream.IsSeekable(),
-			    duration);
-
-	data->initialized = true;
-
-	return true;
+	return data->Initialize(header->sample_rate,
+				header->bits_per_sample,
+				header->channels,
+				/* unknown duration */
+				0);
 }
 
 FLAC__StreamDecoderWriteStatus
@@ -155,7 +158,6 @@ flac_common_write(struct flac_data *data, const FLAC__Frame * frame,
 		  FLAC__uint64 nbytes)
 {
 	void *buffer;
-	unsigned bit_rate;
 
 	if (!data->initialized && !flac_got_first_frame(data, &frame->header))
 		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
@@ -167,16 +169,12 @@ flac_common_write(struct flac_data *data, const FLAC__Frame * frame,
 		     data->audio_format.format, buf,
 		     0, frame->header.blocksize);
 
-	if (nbytes > 0)
-		bit_rate = nbytes * 8 * frame->header.sample_rate /
-			(1000 * frame->header.blocksize);
-	else
-		bit_rate = 0;
+	unsigned bit_rate = nbytes * 8 * frame->header.sample_rate /
+		(1000 * frame->header.blocksize);
 
 	auto cmd = decoder_data(data->decoder, data->input_stream,
 				buffer, buffer_size,
 				bit_rate);
-	data->next_frame += frame->header.blocksize;
 	switch (cmd) {
 	case DecoderCommand::NONE:
 	case DecoderCommand::START:

src/decoder/plugins/FlacCommon.hxx

@@ -55,23 +55,9 @@ struct flac_data : public FlacInput {
 	AudioFormat audio_format;
 
 	/**
-	 * The total number of frames in this song.  The decoder
-	 * plugin may initialize this attribute to override the value
-	 * provided by libFLAC (e.g. for sub songs from a CUE sheet).
+	 * End of last frame's position within the stream.  This is
+	 * used for bit rate calculations.
 	 */
-	FLAC__uint64 total_frames;
-
-	/**
-	 * The number of the first frame in this song.  This is only
-	 * non-zero if playing sub songs from a CUE sheet.
-	 */
-	FLAC__uint64 first_frame;
-
-	/**
-	 * The number of the next frame which is going to be decoded.
-	 */
-	FLAC__uint64 next_frame;
-
 	FLAC__uint64 position;
 
 	Decoder &decoder;
@@ -80,6 +66,12 @@ struct flac_data : public FlacInput {
 	Tag tag;
 
 	flac_data(Decoder &decoder, InputStream &input_stream);
+
+	/**
+	 * Wrapper for decoder_initialized().
+	 */
+	bool Initialize(unsigned sample_rate, unsigned bits_per_sample,
+			unsigned channels, FLAC__uint64 total_frames);
 };
 
 void flac_metadata_common_cb(const FLAC__StreamMetadata * block,

src/decoder/plugins/FlacDecoderPlugin.cxx

@@ -132,26 +132,16 @@ flac_decoder_new(void)
 }
 
 static bool
-flac_decoder_initialize(struct flac_data *data, FLAC__StreamDecoder *sd,
-			FLAC__uint64 duration)
+flac_decoder_initialize(struct flac_data *data, FLAC__StreamDecoder *sd)
 {
-	data->total_frames = duration;
-
 	if (!FLAC__stream_decoder_process_until_end_of_metadata(sd)) {
-		LogWarning(flac_domain, "problem reading metadata");
+		if (FLAC__stream_decoder_get_state(sd) != FLAC__STREAM_DECODER_END_OF_STREAM)
+			LogWarning(flac_domain, "problem reading metadata");
 		return false;
 	}
 
 	if (data->initialized) {
 		/* done */
-
-		const auto duration2 =
-			SongTime::FromScale<uint64_t>(data->total_frames,
-						      data->audio_format.sample_rate);
-
-		decoder_initialized(data->decoder, data->audio_format,
-				    data->input_stream.IsSeekable(),
-				    duration2);
 		return true;
 	}
 
@@ -167,13 +157,10 @@ flac_decoder_initialize(struct flac_data *data, FLAC__StreamDecoder *sd,
 }
 
 static void
-flac_decoder_loop(struct flac_data *data, FLAC__StreamDecoder *flac_dec,
-		  FLAC__uint64 t_start, FLAC__uint64 t_end)
+flac_decoder_loop(struct flac_data *data, FLAC__StreamDecoder *flac_dec)
 {
 	Decoder &decoder = data->decoder;
 
-	data->first_frame = t_start;
-
 	while (true) {
 		DecoderCommand cmd;
 		if (!data->tag.IsEmpty()) {
@@ -184,24 +171,49 @@ flac_decoder_loop(struct flac_data *data, FLAC__StreamDecoder *flac_dec,
 			cmd = decoder_get_command(decoder);
 
 		if (cmd == DecoderCommand::SEEK) {
-			FLAC__uint64 seek_sample = t_start +
+			FLAC__uint64 seek_sample =
 				decoder_seek_where_frame(decoder);
-			if (seek_sample >= t_start &&
-			    (t_end == 0 || seek_sample <= t_end) &&
-			    FLAC__stream_decoder_seek_absolute(flac_dec, seek_sample)) {
-				data->next_frame = seek_sample;
+			if (FLAC__stream_decoder_seek_absolute(flac_dec, seek_sample)) {
 				data->position = 0;
 				decoder_command_finished(decoder);
 			} else
 				decoder_seek_error(decoder);
-		} else if (cmd == DecoderCommand::STOP ||
-			   FLAC__stream_decoder_get_state(flac_dec) == FLAC__STREAM_DECODER_END_OF_STREAM)
+		} else if (cmd == DecoderCommand::STOP)
 			break;
 
-		if (t_end != 0 && data->next_frame >= t_end)
-			/* end of this sub track */
+		switch (FLAC__stream_decoder_get_state(flac_dec)) {
+		case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
+		case FLAC__STREAM_DECODER_READ_METADATA:
+		case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
+		case FLAC__STREAM_DECODER_READ_FRAME:
+			/* continue decoding */
 			break;
 
+		case FLAC__STREAM_DECODER_END_OF_STREAM:
+			/* regular end of stream */
+			return;
+
+		case FLAC__STREAM_DECODER_SEEK_ERROR:
+			/* try to recover from seek error */
+			if (!FLAC__stream_decoder_flush(flac_dec)) {
+				LogError(flac_domain, "FLAC__stream_decoder_flush() failed");
+				return;
+			}
+
+			break;
+
+		case FLAC__STREAM_DECODER_OGG_ERROR:
+		case FLAC__STREAM_DECODER_ABORTED:
+		case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
+			/* an error, fatal enough for us to abort the
+			   decoder */
+			return;
+
+		case FLAC__STREAM_DECODER_UNINITIALIZED:
+			/* we shouldn't see this, ever - bail out */
+			return;
+		}
+
 		if (!FLAC__stream_decoder_process_single(flac_dec) &&
 		    decoder_get_command(decoder) == DecoderCommand::NONE) {
 			/* a failure that was not triggered by a
@@ -250,6 +262,24 @@ stream_init(FLAC__StreamDecoder *flac_dec, struct flac_data *data, bool is_ogg)
 		: stream_init_flac(flac_dec, data);
 }
 
+static bool
+FlacInitAndDecode(struct flac_data &data, FLAC__StreamDecoder *sd, bool is_ogg)
+{
+	auto init_status = stream_init(sd, &data, is_ogg);
+	if (init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
+		LogWarning(flac_domain,
+			   FLAC__StreamDecoderInitStatusString[init_status]);
+		return false;
+	}
+
+	bool result = flac_decoder_initialize(&data, sd);
+	if (result)
+		flac_decoder_loop(&data, sd);
+
+	FLAC__stream_decoder_finish(sd);
+	return result;
+}
+
 static void
 flac_decode_internal(Decoder &decoder,
 		     InputStream &input_stream,
@@ -263,24 +293,8 @@ flac_decode_internal(Decoder &decoder,
 
 	struct flac_data data(decoder, input_stream);
 
-	FLAC__StreamDecoderInitStatus status =
-		stream_init(flac_dec, &data, is_ogg);
-	if (status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
-		FLAC__stream_decoder_delete(flac_dec);
-		LogWarning(flac_domain,
-			   FLAC__StreamDecoderInitStatusString[status]);
-		return;
-	}
+	FlacInitAndDecode(data, flac_dec, is_ogg);
 
-	if (!flac_decoder_initialize(&data, flac_dec, 0)) {
-		FLAC__stream_decoder_finish(flac_dec);
-		FLAC__stream_decoder_delete(flac_dec);
-		return;
-	}
-
-	flac_decoder_loop(&data, flac_dec, 0, 0);
-
-	FLAC__stream_decoder_finish(flac_dec);
 	FLAC__stream_decoder_delete(flac_dec);
 }
 

src/decoder/plugins/FlacIOHandle.cxx

@@ -20,6 +20,7 @@
 #include "config.h"
 #include "FlacIOHandle.hxx"
 #include "util/Error.hxx"
+#include "Log.hxx"
 #include "Compiler.h"
 
 #include <errno.h>
@@ -87,7 +88,13 @@ FlacIOSeek(FLAC__IOHandle handle, FLAC__int64 _offset, int whence)
 		return -1;
 	}
 
-	return is->LockSeek(offset, IgnoreError()) ? 0 : -1;
+	Error error;
+	if (!is->LockSeek(offset, error)) {
+		LogError(error);
+		return -1;
+	}
+
+	return 0;
 }
 
 static FLAC__int64

src/decoder/plugins/GmeDecoderPlugin.cxx

@@ -156,8 +156,11 @@ gme_file_decode(Decoder &decoder, Path path_fs)
 		return;
 	}
 
-	const SignedSongTime song_len = ti->length > 0
-		? SignedSongTime::FromMS(ti->length)
+	const int length = ti->play_length;
+	gme_free_info(ti);
+
+	const SignedSongTime song_len = length > 0
+		? SignedSongTime::FromMS(length)
 		: SignedSongTime::Negative();
 
 	/* initialize the MPD decoder */
@@ -168,7 +171,6 @@ gme_file_decode(Decoder &decoder, Path path_fs)
 				       SampleFormat::S16, GME_CHANNELS,
 				       error)) {
 		LogError(error);
-		gme_free_info(ti);
 		gme_delete(emu);
 		return;
 	}
@@ -179,8 +181,8 @@ gme_file_decode(Decoder &decoder, Path path_fs)
 	if (gme_err != nullptr)
 		LogWarning(gme_domain, gme_err);
 
-	if (ti->length > 0)
-		gme_set_fade(emu, ti->length);
+	if (length > 0)
+		gme_set_fade(emu, length);
 
 	/* play */
 	DecoderCommand cmd;
@@ -196,16 +198,17 @@ gme_file_decode(Decoder &decoder, Path path_fs)
 		if (cmd == DecoderCommand::SEEK) {
 			unsigned where = decoder_seek_time(decoder).ToMS();
 			gme_err = gme_seek(emu, where);
-			if (gme_err != nullptr)
+			if (gme_err != nullptr) {
 				LogWarning(gme_domain, gme_err);
-			decoder_command_finished(decoder);
+				decoder_seek_error(decoder);
+			} else
+				decoder_command_finished(decoder);
 		}
 
 		if (gme_track_ended(emu))
 			break;
 	} while (cmd != DecoderCommand::STOP);
 
-	gme_free_info(ti);
 	gme_delete(emu);
 }
 
@@ -236,9 +239,9 @@ gme_scan_file(Path path_fs,
 
 	assert(ti != nullptr);
 
-	if (ti->length > 0)
+	if (ti->play_length > 0)
 		tag_handler_invoke_duration(handler, handler_ctx,
-					    SongTime::FromMS(ti->length));
+					    SongTime::FromMS(ti->play_length));
 
 	if (ti->song != nullptr) {
 		if (gme_track_count(emu) > 1) {

src/decoder/plugins/MpcdecDecoderPlugin.cxx

@@ -22,10 +22,12 @@
 #include "../DecoderAPI.hxx"
 #include "input/InputStream.hxx"
 #include "CheckAudioFormat.hxx"
+#include "pcm/Traits.hxx"
 #include "tag/TagHandler.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
 #include "util/Macros.hxx"
+#include "util/Clamp.hxx"
 #include "Log.hxx"
 
 #include <mpc/mpcdec.h>
@@ -42,6 +44,9 @@ struct mpc_decoder_data {
 
 static constexpr Domain mpcdec_domain("mpcdec");
 
+static constexpr SampleFormat mpcdec_sample_format = SampleFormat::S24_P32;
+typedef SampleTraits<mpcdec_sample_format> MpcdecSampleTraits;
+
 static mpc_int32_t
 mpc_read_cb(mpc_reader *reader, void *ptr, mpc_int32_t size)
 {
@@ -91,18 +96,15 @@ mpc_getsize_cb(mpc_reader *reader)
 }
 
 /* this _looks_ performance-critical, don't de-inline -- eric */
-static inline int32_t
+static inline MpcdecSampleTraits::value_type
 mpc_to_mpd_sample(MPC_SAMPLE_FORMAT sample)
 {
 	/* only doing 16-bit audio for now */
-	int32_t val;
+	MpcdecSampleTraits::value_type val;
 
-	enum {
-		bits = 24,
-	};
-
-	const int clip_min = -1 << (bits - 1);
-	const int clip_max = (1 << (bits - 1)) - 1;
+	constexpr int bits = MpcdecSampleTraits::BITS;
+	constexpr auto clip_min = MpcdecSampleTraits::MIN;
+	constexpr auto clip_max = MpcdecSampleTraits::MAX;
 
 #ifdef MPC_FIXED_POINT
 	const int shift = bits - MPC_FIXED_POINT_SCALE_SHIFT;
@@ -117,16 +119,12 @@ mpc_to_mpd_sample(MPC_SAMPLE_FORMAT sample)
 	val = sample * float_scale;
 #endif
 
-	if (val < clip_min)
-		val = clip_min;
-	else if (val > clip_max)
-		val = clip_max;
-
-	return val;
+	return Clamp(val, clip_min, clip_max);
 }
 
 static void
-mpc_to_mpd_buffer(int32_t *dest, const MPC_SAMPLE_FORMAT *src,
+mpc_to_mpd_buffer(MpcdecSampleTraits::pointer_type dest,
+		  const MPC_SAMPLE_FORMAT *src,
 		  unsigned num_samples)
 {
 	while (num_samples-- > 0)
@@ -162,7 +160,7 @@ mpcdec_decode(Decoder &mpd_decoder, InputStream &is)
 	Error error;
 	AudioFormat audio_format;
 	if (!audio_format_init_checked(audio_format, info.sample_freq,
-				       SampleFormat::S24_P32,
+				       mpcdec_sample_format,
 				       info.channels, error)) {
 		LogError(error);
 		mpc_demux_exit(demux);
@@ -214,7 +212,7 @@ mpcdec_decode(Decoder &mpd_decoder, InputStream &is)
 		mpc_uint32_t ret = frame.samples;
 		ret *= info.channels;
 
-		int32_t chunk[ARRAY_SIZE(sample_buffer)];
+		MpcdecSampleTraits::value_type chunk[ARRAY_SIZE(sample_buffer)];
 		mpc_to_mpd_buffer(chunk, sample_buffer, ret);
 
 		long bit_rate = vbr_update_bits * audio_format.sample_rate

src/decoder/plugins/OpusDecoderPlugin.cxx

@@ -441,13 +441,15 @@ mpd_opus_scan_stream(InputStream &is,
 	if (!oy.ExpectFirstPage(os))
 		return false;
 
-	/* read at most two more pages */
-	unsigned remaining_pages = 2;
+	/* read at most 64 more pages */
+	unsigned remaining_pages = 64;
+
+	unsigned remaining_packets = 4;
 
 	bool result = false;
 
 	ogg_packet packet;
-	while (true) {
+	while (remaining_packets > 0) {
 		int r = ogg_stream_packetout(&os, &packet);
 		if (r < 0) {
 			result = false;
@@ -466,6 +468,8 @@ mpd_opus_scan_stream(InputStream &is,
 			continue;
 		}
 
+		--remaining_packets;
+
 		if (packet.b_o_s) {
 			if (!IsOpusHead(packet))
 				break;

src/decoder/plugins/OpusReader.hxx

@@ -85,7 +85,7 @@ public:
 
 	char *ReadString() {
 		uint32_t length;
-		if (!ReadWord(length))
+		if (!ReadWord(length) || length >= 65536)
 			return nullptr;
 
 		const char *src = (const char *)Read(length);

src/encoder/plugins/FlacEncoderPlugin.cxx

@@ -157,8 +157,6 @@ flac_encoder_open(Encoder *_encoder, AudioFormat &audio_format, Error &error)
 	struct flac_encoder *encoder = (struct flac_encoder *)_encoder;
 	unsigned bits_per_sample;
 
-	encoder->audio_format = audio_format;
-
 	/* FIXME: flac should support 32bit as well */
 	switch (audio_format.format) {
 	case SampleFormat::S8:
@@ -178,6 +176,8 @@ flac_encoder_open(Encoder *_encoder, AudioFormat &audio_format, Error &error)
 		audio_format.format = SampleFormat::S24_P32;
 	}
 
+	encoder->audio_format = audio_format;
+
 	/* allocate the encoder */
 	encoder->fse = FLAC__stream_encoder_new();
 	if (encoder->fse == nullptr) {

src/encoder/plugins/ShineEncoderPlugin.cxx

@@ -26,7 +26,6 @@
 #include "util/NumberParser.hxx"
 #include "util/DynamicFifoBuffer.hxx"
 #include "util/Error.hxx"
-#include "util/Domain.hxx"
 
 extern "C"
 {
@@ -60,8 +59,6 @@ struct ShineEncoder {
 	bool WriteChunk(bool flush);
 };
 
-static constexpr Domain shine_encoder_domain("shine_encoder");
-
 inline bool
 ShineEncoder::Configure(const config_param &param,
 			 gcc_unused Error &error)

src/encoder/plugins/WaveEncoderPlugin.cxx

@@ -27,6 +27,8 @@
 #include <assert.h>
 #include <string.h>
 
+static constexpr uint16_t WAVE_FORMAT_PCM = 1;
+
 struct WaveEncoder {
 	Encoder encoder;
 	unsigned bits;
@@ -64,15 +66,15 @@ fill_wave_header(struct wave_header *header, int channels, int bits,
 	header->id_fmt = ToLE32(0x20746d66);
 	header->id_data = ToLE32(0x61746164);
 
-        /* wave format */
-	header->format = ToLE16(1); // PCM_FORMAT
+	/* wave format */
+	header->format = ToLE16(WAVE_FORMAT_PCM);
 	header->channels = ToLE16(channels);
 	header->bits = ToLE16(bits);
 	header->freq = ToLE32(freq);
 	header->blocksize = ToLE16(block_size);
 	header->byterate = ToLE32(freq * block_size);
 
-        /* chunk sizes (fake data length) */
+	/* chunk sizes (fake data length) */
 	header->fmt_size = ToLE32(16);
 	header->data_size = ToLE32(data_size);
 	header->riff_size = ToLE32(4 + (8 + 16) + (8 + data_size));

src/event/BufferedSocket.cxx

@@ -118,9 +118,15 @@ BufferedSocket::OnSocketReady(unsigned flags)
 	if (flags & READ) {
 		assert(!input.IsFull());
 
-		if (!ReadToBuffer() || !ResumeInput())
+		if (!ReadToBuffer())
 			return false;
 
+		if (!ResumeInput())
+			/* we must return "true" here or
+			   SocketMonitor::Dispatch() will call
+			   Cancel() on a freed object */
+			return true;
+
 		if (!input.IsFull())
 			ScheduleRead();
 	}

src/filter/plugins/ReplayGainFilterPlugin.cxx

@@ -134,8 +134,6 @@ ReplayGainFilter::Update()
 		volume = pcm_float_to_volume(scale);
 	}
 
-	pv.SetVolume(volume);
-
 	if (mixer != nullptr) {
 		/* update the hardware mixer volume */
 
@@ -146,7 +144,8 @@ ReplayGainFilter::Update()
 		Error error;
 		if (!mixer_set_volume(mixer, _volume, error))
 			LogError(error, "Failed to update hardware mixer");
-	}
+	} else
+		pv.SetVolume(volume);
 }
 
 static Filter *
@@ -174,7 +173,9 @@ ReplayGainFilter::Close()
 ConstBuffer<void>
 ReplayGainFilter::FilterPCM(ConstBuffer<void> src, gcc_unused Error &error)
 {
-	return pv.Apply(src);
+	return mixer != nullptr
+		? src
+		: pv.Apply(src);
 }
 
 const struct filter_plugin replay_gain_filter_plugin = {

src/filter/plugins/RouteFilterPlugin.cxx

@@ -47,9 +47,11 @@
 #include "filter/FilterInternal.hxx"
 #include "filter/FilterRegistry.hxx"
 #include "pcm/PcmBuffer.hxx"
+#include "pcm/Silence.hxx"
 #include "util/StringUtil.hxx"
 #include "util/Error.hxx"
 #include "util/ConstBuffer.hxx"
+#include "util/WritableBuffer.hxx"
 
 #include <algorithm>
 
@@ -266,9 +268,8 @@ RouteFilter::FilterPCM(ConstBuffer<void> src, gcc_unused Error &error)
 			    (unsigned)sources[c] >= input_format.channels) {
 				// No source for this destination output,
 				// give it zeroes as input
-				memset(chan_destination,
-					0x00,
-					bytes_per_frame_per_channel);
+				PcmSilence({chan_destination, bytes_per_frame_per_channel},
+					   input_format.format);
 			} else {
 				// Get the data from channel sources[c]
 				// and copy it to the output

src/filter/plugins/VolumeFilterPlugin.cxx

@@ -26,7 +26,6 @@
 #include "AudioFormat.hxx"
 #include "util/ConstBuffer.hxx"
 #include "util/Error.hxx"
-#include "util/Domain.hxx"
 
 #include <assert.h>
 #include <string.h>
@@ -50,8 +49,6 @@ public:
 				    Error &error) override;
 };
 
-static constexpr Domain volume_domain("pcm_volume");
-
 static Filter *
 volume_filter_init(gcc_unused const config_param &param,
 		   gcc_unused Error &error)

src/mixer/MixerAll.cxx

@@ -25,13 +25,10 @@
 #include "output/Internal.hxx"
 #include "pcm/Volume.hxx"
 #include "util/Error.hxx"
-#include "util/Domain.hxx"
 #include "Log.hxx"
 
 #include <assert.h>
 
-static constexpr Domain mixer_domain("mixer");
-
 static int
 output_mixer_get_volume(const AudioOutput &ao)
 {

src/mixer/plugins/PulseMixerPlugin.cxx

@@ -218,7 +218,7 @@ PulseMixer::SetVolume(unsigned new_volume, Error &error)
 
 	struct pa_cvolume cvolume;
 	pa_cvolume_set(&cvolume, volume.channels,
-		       (pa_volume_t)new_volume * PA_VOLUME_NORM / 100 + 0.5);
+		       (new_volume * PA_VOLUME_NORM + 50) / 100);
 	bool success = pulse_output_set_volume(output, &cvolume, error);
 	if (success)
 		volume = cvolume;

src/notify.hxx

@@ -28,7 +28,7 @@ struct notify {
 	Cond cond;
 	bool pending;
 
-#if !defined(WIN32) && !defined(__NetBSD__) && !defined(__BIONIC__)
+#ifdef __GLIBC__
 	constexpr
 #endif
 	notify():pending(false) {}

src/output/OutputCommand.cxx

@@ -30,6 +30,7 @@
 #include "Internal.hxx"
 #include "PlayerControl.hxx"
 #include "mixer/MixerControl.hxx"
+#include "mixer/Volume.hxx"
 #include "Idle.hxx"
 
 extern unsigned audio_output_state_version;
@@ -47,6 +48,11 @@ audio_output_enable_index(MultipleOutputs &outputs, unsigned idx)
 	ao.enabled = true;
 	idle_add(IDLE_OUTPUT);
 
+	if (ao.mixer != nullptr) {
+		InvalidateHardwareVolume();
+		idle_add(IDLE_MIXER);
+	}
+
 	ao.player_control->UpdateAudio();
 
 	++audio_output_state_version;
@@ -70,6 +76,7 @@ audio_output_disable_index(MultipleOutputs &outputs, unsigned idx)
 	Mixer *mixer = ao.mixer;
 	if (mixer != nullptr) {
 		mixer_close(mixer);
+		InvalidateHardwareVolume();
 		idle_add(IDLE_MIXER);
 	}
 
@@ -94,6 +101,7 @@ audio_output_toggle_index(MultipleOutputs &outputs, unsigned idx)
 		Mixer *mixer = ao.mixer;
 		if (mixer != nullptr) {
 			mixer_close(mixer);
+			InvalidateHardwareVolume();
 			idle_add(IDLE_MIXER);
 		}
 	}

src/output/plugins/PipeOutputPlugin.cxx

@@ -22,7 +22,6 @@
 #include "../OutputAPI.hxx"
 #include "config/ConfigError.hxx"
 #include "util/Error.hxx"
-#include "util/Domain.hxx"
 
 #include <string>
 
@@ -44,8 +43,6 @@ struct PipeOutput {
 	bool Configure(const config_param &param, Error &error);
 };
 
-static constexpr Domain pipe_output_domain("pipe_output");
-
 inline bool
 PipeOutput::Configure(const config_param &param, Error &error)
 {

src/output/plugins/ShoutOutputPlugin.cxx

@@ -247,7 +247,6 @@ ShoutOutput::Configure(const config_param &param, Error &error)
 
 	{
 		char temp[11];
-		memset(temp, 0, sizeof(temp));
 
 		snprintf(temp, sizeof(temp), "%u", audio_format.channels);
 		shout_set_audio_info(shout_conn, SHOUT_AI_CHANNELS, temp);

src/pcm/Silence.cxx

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2003-2016 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 "Silence.hxx"
+#include "AudioFormat.hxx"
+#include "util/WritableBuffer.hxx"
+
+#include <string.h>
+
+void
+PcmSilence(WritableBuffer<void> dest, SampleFormat format)
+{
+	uint8_t pattern = 0;
+	if (format == SampleFormat::DSD)
+		pattern = 0x69;
+
+	memset(dest.data, pattern, dest.size);
+}

src/pcm/Silence.hxx

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2003-2016 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_PCM_SILENCE_HXX
+#define MPD_PCM_SILENCE_HXX
+
+#include "check.h"
+
+#include <stdint.h>
+
+template<typename T> struct WritableBuffer;
+enum class SampleFormat : uint8_t;
+
+/**
+ * Fill the given buffer with the format-specific silence pattern.
+ */
+void
+PcmSilence(WritableBuffer<void> dest, SampleFormat format);
+
+#endif

src/pcm/Volume.cxx

@@ -19,10 +19,12 @@
 
 #include "config.h"
 #include "Volume.hxx"
+#include "Silence.hxx"
 #include "Domain.hxx"
 #include "PcmUtils.hxx"
 #include "Traits.hxx"
 #include "util/ConstBuffer.hxx"
+#include "util/WritableBuffer.hxx"
 #include "util/Error.hxx"
 
 #include "PcmDither.cxx" // including the .cxx file to get inlined templates
@@ -134,9 +136,7 @@ PcmVolume::Apply(ConstBuffer<void> src)
 
 	if (volume == 0) {
 		/* optimized special case: 0% volume = memset(0) */
-		/* TODO: is this valid for all sample formats? What
-		   about floating point? */
-		memset(data, 0, src.size);
+		PcmSilence({data, src.size}, format);
 		return { data, src.size };
 	}
 

src/playlist/plugins/XspfPlaylistPlugin.cxx

@@ -25,14 +25,11 @@
 #include "input/InputStream.hxx"
 #include "tag/TagBuilder.hxx"
 #include "util/Error.hxx"
-#include "util/Domain.hxx"
 #include "lib/expat/ExpatParser.hxx"
 #include "Log.hxx"
 
 #include <string.h>
 
-static constexpr Domain xspf_domain("xspf");
-
 /**
  * This is the state object for the GLib XML parser.
  */

src/protocol/ArgParser.cxx

@@ -92,7 +92,7 @@ check_range(Client &client, unsigned *value_r1, unsigned *value_r2,
 		return false;
 	}
 
-	if (unsigned(value) > std::numeric_limits<unsigned>::max()) {
+	if (value > std::numeric_limits<int>::max()) {
 		command_error(client, ACK_ERROR_ARG,
 			      "Number too large: %s", s);
 		return false;
@@ -117,7 +117,7 @@ check_range(Client &client, unsigned *value_r1, unsigned *value_r2,
 			return false;
 		}
 
-		if (unsigned(value) > std::numeric_limits<unsigned>::max()) {
+		if (value > std::numeric_limits<int>::max()) {
 			command_error(client, ACK_ERROR_ARG,
 				      "Number too large: %s", s);
 			return false;

src/queue/Playlist.cxx

@@ -37,7 +37,7 @@ playlist::TagModified(DetachedSong &&song)
 
 	DetachedSong &current_song = queue.GetOrder(current);
 	if (song.IsSame(current_song))
-		current_song.MoveTagFrom(std::move(song));
+		current_song.MoveTagItemsFrom(std::move(song));
 
 	queue.ModifyAtOrder(current);
 	queue.IncrementVersion();

src/tag/Aiff.cxx

@@ -84,14 +84,14 @@ aiff_seek_id3(FILE *file)
 			   underflow when casting to off_t */
 			return 0;
 
-		if (size % 2 != 0)
-			/* pad byte */
-			++size;
-
 		if (memcmp(chunk.id, "ID3 ", 4) == 0)
 			/* found it! */
 			return size;
 
+		if (size % 2 != 0)
+			/* pad byte */
+			++size;
+
 		if (fseek(file, size, SEEK_CUR) != 0)
 			return 0;
 	}

src/tag/ApeLoader.cxx

@@ -78,12 +78,12 @@ ape_scan_internal(FILE *fp, ApeTagCallback callback)
 
 		/* get the key */
 		const char *key = p;
-		while (remaining > size && *p != '\0') {
-			p++;
-			remaining--;
-		}
-		p++;
-		remaining--;
+		const char *key_end = (const char *)memchr(p, '\0', remaining);
+		if (key_end == nullptr)
+			break;
+
+		p = key_end + 1;
+		remaining -= p - key;
 
 		/* get the value */
 		if (remaining < size)

src/tag/Riff.cxx

@@ -82,15 +82,15 @@ riff_seek_id3(FILE *file)
 			   underflow when casting to off_t */
 			return 0;
 
-		if (size % 2 != 0)
-			/* pad byte */
-			++size;
-
 		if (memcmp(chunk.id, "id3 ", 4) == 0 ||
 		    memcmp(chunk.id, "ID3 ", 4) == 0)
 			/* found it! */
 			return size;
 
+		if (size % 2 != 0)
+			/* pad byte */
+			++size;
+
 		if (fseek(file, size, SEEK_CUR) != 0)
 			return 0;
 	}

src/tag/Tag.hxx

@@ -80,9 +80,17 @@ struct Tag {
 	Tag &operator=(Tag &&other) {
 		duration = other.duration;
 		has_playlist = other.has_playlist;
+		MoveItemsFrom(std::move(other));
+		return *this;
+	}
+
+	/**
+	 * Similar to the move operator, but move only the #TagItem
+	 * array.
+	 */
+	void MoveItemsFrom(Tag &&other) {
 		std::swap(items, other.items);
 		std::swap(num_items, other.num_items);
-		return *this;
 	}
 
 	/**

src/tag/TagPool.cxx

@@ -23,19 +23,23 @@
 #include "util/Cast.hxx"
 #include "util/VarSize.hxx"
 
+#include <limits>
+
 #include <assert.h>
 #include <string.h>
 #include <stdlib.h>
 
 Mutex tag_pool_lock;
 
-static constexpr size_t NUM_SLOTS = 4096;
+static constexpr size_t NUM_SLOTS = 4093;
 
 struct TagPoolSlot {
 	TagPoolSlot *next;
 	unsigned char ref;
 	TagItem item;
 
+	static constexpr unsigned MAX_REF = std::numeric_limits<decltype(ref)>::max();
+
 	TagPoolSlot(TagPoolSlot *_next, TagType type,
 		    const char *value, size_t length)
 		:next(_next), ref(1) {
@@ -116,7 +120,7 @@ tag_pool_get_item(TagType type, const char *value, size_t length)
 		if (slot->item.type == type &&
 		    length == strlen(slot->item.value) &&
 		    memcmp(value, slot->item.value, length) == 0 &&
-		    slot->ref < 0xff) {
+		    slot->ref < TagPoolSlot::MAX_REF) {
 			assert(slot->ref > 0);
 			++slot->ref;
 			return &slot->item;
@@ -135,19 +139,15 @@ tag_pool_dup_item(TagItem *item)
 
 	assert(slot->ref > 0);
 
-	if (slot->ref < 0xff) {
+	if (slot->ref < TagPoolSlot::MAX_REF) {
 		++slot->ref;
 		return item;
 	} else {
-		/* the reference counter overflows above 0xff;
-		   duplicate the item, and start with 1 */
+		/* the reference counter overflows above MAX_REF;
+		   obtain a reference to a different TagPoolSlot which
+		   isn't yet "full" */
 		size_t length = strlen(item->value);
-		auto slot_p = tag_value_slot_p(item->type,
-					       item->value, length);
-		slot = TagPoolSlot::Create(*slot_p, item->type,
-					   item->value, strlen(item->value));
-		*slot_p = slot;
-		return &slot->item;
+		return tag_pool_get_item(item->type, item->value, length);
 	}
 }
 

src/tag/TagString.cxx

@@ -40,9 +40,9 @@ FindInvalidUTF8(const char *p, const char *const end)
 		/* now call the other SequenceLengthUTF8() overload
 		   which also validates the continuations */
 		const size_t t = SequenceLengthUTF8(p);
-		assert(s == t);
 		if (t == 0)
 			return p;
+		assert(s == t);
 
 		p += s;
 	}

src/thread/PosixCond.hxx

@@ -41,9 +41,13 @@ class PosixCond {
 	pthread_cond_t cond;
 
 public:
-#if defined(__NetBSD__) || defined(__BIONIC__)
-	/* NetBSD's PTHREAD_COND_INITIALIZER is not compatible with
-	   "constexpr" */
+#ifdef __GLIBC__
+	/* optimized constexpr constructor for pthread implementations
+	   that support it */
+	constexpr PosixCond():cond(PTHREAD_COND_INITIALIZER) {}
+#else
+	/* slow fallback for pthread implementations that are not
+	   compatible with "constexpr" */
 	PosixCond() {
 		pthread_cond_init(&cond, nullptr);
 	}
@@ -51,10 +55,6 @@ public:
 	~PosixCond() {
 		pthread_cond_destroy(&cond);
 	}
-#else
-	/* optimized constexpr constructor for sane POSIX
-	   implementations */
-	constexpr PosixCond():cond(PTHREAD_COND_INITIALIZER) {}
 #endif
 
 	PosixCond(const PosixCond &other) = delete;

src/thread/PosixMutex.hxx

@@ -41,9 +41,13 @@ class PosixMutex {
 	pthread_mutex_t mutex;
 
 public:
-#if defined(__NetBSD__) || defined(__BIONIC__)
-	/* NetBSD's PTHREAD_MUTEX_INITIALIZER is not compatible with
-	   "constexpr" */
+#ifdef __GLIBC__
+	/* optimized constexpr constructor for pthread implementations
+	   that support it */
+	constexpr PosixMutex():mutex(PTHREAD_MUTEX_INITIALIZER) {}
+#else
+	/* slow fallback for pthread implementations that are not
+	   compatible with "constexpr" */
 	PosixMutex() {
 		pthread_mutex_init(&mutex, nullptr);
 	}
@@ -51,10 +55,6 @@ public:
 	~PosixMutex() {
 		pthread_mutex_destroy(&mutex);
 	}
-#else
-	/* optimized constexpr constructor for sane POSIX
-	   implementations */
-	constexpr PosixMutex():mutex(PTHREAD_MUTEX_INITIALIZER) {}
 #endif
 
 	PosixMutex(const PosixMutex &other) = delete;

src/unix/Daemon.cxx

@@ -22,7 +22,6 @@
 #include "system/FatalError.hxx"
 #include "fs/AllocatedPath.hxx"
 #include "fs/FileSystem.hxx"
-#include "util/Domain.hxx"
 #include "PidFile.hxx"
 #include "Log.hxx"
 
@@ -37,8 +36,6 @@
 #include <grp.h>
 #endif
 
-static constexpr Domain daemon_domain("daemon");
-
 #ifndef WIN32
 
 /** the Unix user name which MPD runs as */
@@ -113,7 +110,7 @@ daemonize_set_user(void)
 				       (int)user_gid);
 	}
 
-#ifdef _BSD_SOURCE
+#ifdef HAVE_INITGROUPS
 	/* init supplementary groups
 	 * (must be done before we change our uid)
 	 */

src/util/HugeAllocator.cxx

@@ -46,7 +46,7 @@ static size_t
 AlignToPageSize(size_t size)
 {
 	static const long page_size = sysconf(_SC_PAGESIZE);
-	if (page_size > 0)
+	if (page_size == 0)
 		return size;
 
 	size_t ps(page_size);

systemd/mpd.service.in

@@ -7,16 +7,7 @@ ExecStart=@prefix@/bin/mpd --no-daemon
 
 # allow MPD to use real-time priority 50
 LimitRTPRIO=50
-LimitRTTIME=-1
-
-# move MPD to a top-level cgroup, as real-time budget assignment fails
-# in cgroup /system/mpd.service, because /system has a zero real-time
-# budget; see
-# http://www.freedesktop.org/wiki/Software/systemd/MyServiceCantGetRealtime/
-ControlGroup=cpu:/mpd
-
-# assign a real-time budget
-ControlGroupAttribute=cpu.rt_runtime_us 500000
+LimitRTTIME=infinity
 
 [Install]
 WantedBy=multi-user.target

test/test_byte_reverse.cxx

@@ -49,9 +49,9 @@ CPPUNIT_TEST_SUITE_REGISTRATION(ByteReverseTest);
 void
 ByteReverseTest::TestByteReverse2()
 {
-	static const char src[] = "123456";
+	static const char src[] gcc_alignas(uint16_t, 2) = "123456";
 	static const char result[] = "214365";
-	static uint8_t dest[ARRAY_SIZE(src)];
+	static uint8_t dest[ARRAY_SIZE(src)] gcc_alignas(uint16_t, 2);
 
 	reverse_bytes(dest, (const uint8_t *)src,
 		      (const uint8_t *)(src + ARRAY_SIZE(src) - 1), 2);
@@ -73,9 +73,9 @@ ByteReverseTest::TestByteReverse3()
 void
 ByteReverseTest::TestByteReverse4()
 {
-	static const char src[] = "12345678";
+	static const char src[] gcc_alignas(uint32_t, 4) = "12345678";
 	static const char result[] = "43218765";
-	static uint8_t dest[ARRAY_SIZE(src)];
+	static uint8_t dest[ARRAY_SIZE(src)] gcc_alignas(uint32_t, 4);
 
 	reverse_bytes(dest, (const uint8_t *)src,
 		      (const uint8_t *)(src + ARRAY_SIZE(src) - 1), 4);