release v0.19.19

This function exists since FFmpeg 3.1.  Fix a build failure with
FFmpeg 3.0.

INSTALL

@@ -12,7 +12,7 @@ install MPD.  If more information is desired, read the user manual:
 Dependencies
 ------------
 
-gcc 4.6 or later - http://gcc.gnu.org/
+gcc 4.7 or later - http://gcc.gnu.org/
 clang 3.2 or later - http://clang.llvm.org/
 Any other C++11 compliant compiler should also work.
 

Makefile.am

@@ -359,6 +359,7 @@ libutil_a_SOURCES = \
 	src/util/Clamp.hxx \
 	src/util/Alloc.cxx src/util/Alloc.hxx \
 	src/util/VarSize.hxx \
+	src/util/ScopeExit.hxx \
 	src/util/Error.cxx src/util/Error.hxx \
 	src/util/Domain.hxx \
 	src/util/ReusableArray.hxx \
@@ -462,6 +463,7 @@ ICU_LDADD = libicu.a $(ICU_LIBS)
 libpcm_a_SOURCES = \
 	src/pcm/Domain.cxx src/pcm/Domain.hxx \
 	src/pcm/Traits.hxx \
+	src/pcm/Interleave.cxx src/pcm/Interleave.hxx \
 	src/pcm/PcmBuffer.cxx src/pcm/PcmBuffer.hxx \
 	src/pcm/PcmExport.cxx src/pcm/PcmExport.hxx \
 	src/pcm/PcmConvert.cxx src/pcm/PcmConvert.hxx \
@@ -528,7 +530,7 @@ libfs_a_SOURCES = \
 	src/fs/Traits.cxx src/fs/Traits.hxx \
 	src/fs/Config.cxx src/fs/Config.hxx \
 	src/fs/Charset.cxx src/fs/Charset.hxx \
-	src/fs/Path.cxx src/fs/Path.hxx \
+	src/fs/Path.cxx src/fs/Path2.cxx src/fs/Path.hxx \
 	src/fs/AllocatedPath.cxx src/fs/AllocatedPath.hxx \
 	src/fs/FileSystem.cxx src/fs/FileSystem.hxx \
 	src/fs/StandardDirectory.cxx src/fs/StandardDirectory.hxx \
@@ -799,6 +801,11 @@ endif
 if HAVE_FFMPEG
 noinst_LIBRARIES += libffmpeg.a
 libffmpeg_a_SOURCES = \
+	src/lib/ffmpeg/Init.cxx src/lib/ffmpeg/Init.hxx \
+	src/lib/ffmpeg/Time.hxx \
+	src/lib/ffmpeg/Buffer.hxx \
+	src/lib/ffmpeg/LogError.cxx src/lib/ffmpeg/LogError.hxx \
+	src/lib/ffmpeg/LogCallback.cxx src/lib/ffmpeg/LogCallback.hxx \
 	src/lib/ffmpeg/Error.cxx src/lib/ffmpeg/Error.hxx \
 	src/lib/ffmpeg/Domain.cxx src/lib/ffmpeg/Domain.hxx
 libffmpeg_a_CPPFLAGS = $(AM_CPPFLAGS) \
@@ -980,6 +987,8 @@ endif
 
 if HAVE_FFMPEG
 libdecoder_a_SOURCES += \
+	src/decoder/plugins/FfmpegIo.cxx \
+	src/decoder/plugins/FfmpegIo.hxx \
 	src/decoder/plugins/FfmpegMetaData.cxx \
 	src/decoder/plugins/FfmpegMetaData.hxx \
 	src/decoder/plugins/FfmpegDecoderPlugin.cxx \
@@ -1867,6 +1876,7 @@ test_run_convert_SOURCES = test/run_convert.cxx \
 	src/AudioParser.cxx
 test_run_convert_LDADD = \
 	$(PCM_LIBS) \
+	libconf.a \
 	libutil.a \
 	$(GLIB_LIBS)
 

NEWS

@@ -1,3 +1,27 @@
+ver 0.19.19 (2016/08/23)
+* decoder
+  - ffmpeg: bug fix for FFmpeg 3.1 support
+  - wildmidi: support libWildMidi 0.4
+* output
+  - pulse: support 32 bit, 24 bit and floating point playback
+* support non-x86 NetBSD
+* fix clang 3.9 warnings
+
+ver 0.19.18 (2016/08/05)
+* decoder
+  - ffmpeg: fix crash with older FFmpeg versions (< 3.0)
+  - ffmpeg: log detailed error message
+  - ffmpeg: support FFmpeg 3.1
+  - sidplay: detect libsidplay2 with pkg-config
+  - sidplay: log detailed error message
+  - sidplay: read the "date" tag
+  - sidplay: allow building with libsidplayfp instead of libsidplay2
+* output
+  - shout: recognize setting "encoder" instead of "encoding"
+* fix memory leak after stream failure
+* fix build failure with Boost 1.61
+* require gcc 4.7 or newer
+
 ver 0.19.17 (2016/07/09)
 * decoder
   - flac: fix assertion failure while seeking

configure.ac

@@ -1,10 +1,10 @@
 AC_PREREQ(2.60)
 
-AC_INIT(mpd, 0.19.17, musicpd-dev-team@lists.sourceforge.net)
+AC_INIT(mpd, 0.19.19, musicpd-dev-team@lists.sourceforge.net)
 
 VERSION_MAJOR=0
 VERSION_MINOR=19
-VERSION_REVISION=17
+VERSION_REVISION=19
 VERSION_EXTRA=0
 
 AC_CONFIG_SRCDIR([src/Main.cxx])
@@ -542,8 +542,6 @@ AC_ARG_ENABLE(sidplay,
 	AS_HELP_STRING([--enable-sidplay],
 		[enable C64 SID support via libsidplay2]),,
 	enable_sidplay=auto)
-MPD_DEPENDS([enable_sidplay], [enable_glib],
-	[Cannot use --enable-sidplay with --disable-glib])
 
 AC_ARG_ENABLE(shine-encoder,
 	AS_HELP_STRING([--enable-shine-encoder],
@@ -1335,31 +1333,36 @@ AM_CONDITIONAL(ENABLE_VORBIS_DECODER, test x$enable_vorbis = xyes || test x$enab
 
 dnl --------------------------------- sidplay ---------------------------------
 if test x$enable_sidplay != xno; then
-	# we're not using pkg-config here
+	dnl Check for libsidplayfp first
-	# because libsidplay2's .pc file requires libtool
+	PKG_CHECK_MODULES([SIDPLAY], [libsidplayfp libsidutils],
-	AC_CHECK_LIB([sidplay2],[main],[found_sidplay=yes],[found_sidplay=no],[])
+		[found_sidplayfp=yes],
+		[found_sidplayfp=no])
+	found_sidplay=$found_sidplayfp
+fi
+
+if test x$enable_sidplay != xno && test x$found_sidplayfp = xno; then
+	PKG_CHECK_MODULES([SIDPLAY], [libsidplay2 libsidutils],
+		[found_sidplay=yes],
+		[found_sidplay=no])
 
 	MPD_AUTO_PRE(sidplay, [sidplay decoder plugin],
 		[libsidplay2 not found])
 fi
 
-if test x$enable_sidplay != xno; then
+if test x$enable_sidplay != xno && test x$found_sidplayfp = xno; then
 	AC_CHECK_LIB([resid-builder], [main],
 		[found_sidplay=yes], [found_sidplay=no])
 
-	if test x$found_sidplay = xyes; then
-		AC_CHECK_LIB([sidutils],[main],[:],[found_sidplay=no],[])
-	fi
-
 	MPD_AUTO_RESULT(sidplay, [sidplay decoder plugin],
-		[libresid-builder or libsidutils not found])
+		[libresid-builder not found])
 fi
 
 if test x$enable_sidplay = xyes; then
-	AC_SUBST(SIDPLAY_LIBS,"-lsidplay2 -lresid-builder -lsidutils")
+	SIDPLAY_LIBS="$SIDPLAY_LIBS -lresid-builder"
-	AC_SUBST(SIDPLAY_CFLAGS,)
-
 	AC_DEFINE(ENABLE_SIDPLAY, 1, [Define for libsidplay2 support])
+	if test x$found_sidplayfp = xyes; then
+		AC_DEFINE(HAVE_SIDPLAYFP, 1, [Define if libsidplayfp is used instead of libsidplay2])
+	fi
 fi
 
 AM_CONDITIONAL(ENABLE_SIDPLAY, test x$enable_sidplay = xyes)

doc/developer.xml

@@ -41,7 +41,7 @@
       <listitem>
         <para>
           the code should be C++11 compliant, and must compile with
-          <application>GCC</application> 4.6 and
+          <application>GCC</application> 4.7 and
           <application>clang</application> 3.2
         </para>
       </listitem>

doc/mpdconf.example

@@ -231,7 +231,7 @@ input {
 #
 #audio_output {
 #	type		"shout"
-#	encoding	"ogg"			# optional
+#	encoder		"vorbis"		# optional
 #	name		"My Shout Stream"
 #	host		"localhost"
 #	port		"8000"

src/Chrono.hxx

@@ -26,7 +26,7 @@
 #include <utility>
 #include <cstdint>
 
-#if defined(__GNUC__) && !GCC_CHECK_VERSION(4,7) && !defined(__clang__)
+#if GCC_OLDER_THAN(4,7)
 /* std::chrono::duration operators are "constexpr" since gcc 4.7 */
 #define chrono_constexpr gcc_pure
 #else

src/Compiler.h

@@ -28,24 +28,41 @@
 #define GCC_VERSION 0
 #endif
 
+#ifdef __clang__
+#  define CLANG_VERSION GCC_MAKE_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
+#elif defined(__GNUC__)
+#  define CLANG_VERSION 0
+#endif
+
+/**
+ * Are we building with the specified version of gcc (not clang or any
+ * other compiler) or newer?
+ */
 #define GCC_CHECK_VERSION(major, minor) \
-	(defined(__GNUC__) && GCC_VERSION >= GCC_MAKE_VERSION(major, minor, 0))
+	(CLANG_VERSION == 0 && \
+	 GCC_VERSION >= GCC_MAKE_VERSION(major, minor, 0))
+
+/**
+ * Are we building with clang (any version) or at least the specified
+ * gcc version?
+ */
+#define CLANG_OR_GCC_VERSION(major, minor) \
+	(CLANG_VERSION > 0 || GCC_CHECK_VERSION(major, minor))
 
 /**
  * Are we building with gcc (not clang or any other compiler) and a
  * version older than the specified one?
  */
 #define GCC_OLDER_THAN(major, minor) \
-	(defined(__GNUC__) && !defined(__clang__) && \
+	(GCC_VERSION > 0 && CLANG_VERSION == 0 && \
 	 GCC_VERSION < GCC_MAKE_VERSION(major, minor, 0))
 
 #ifdef __clang__
-#  define CLANG_VERSION GCC_MAKE_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
 #  if __clang_major__ < 3
 #    error Sorry, your clang version is too old.  You need at least version 3.1.
 #  endif
 #elif defined(__GNUC__)
-#  if GCC_OLDER_THAN(4,6)
+#  if GCC_OLDER_THAN(4,7)
 #    error Sorry, your gcc version is too old.  You need at least version 4.6.
 #  endif
 #else
@@ -56,10 +73,9 @@
  * Are we building with the specified version of clang or newer?
  */
 #define CLANG_CHECK_VERSION(major, minor) \
-	(defined(__clang__) && \
+	(CLANG_VERSION >= GCC_MAKE_VERSION(major, minor, 0))
-	 CLANG_VERSION >= GCC_MAKE_VERSION(major, minor, 0))
 
-#if GCC_CHECK_VERSION(4,0)
+#if CLANG_OR_GCC_VERSION(4,0)
 
 /* GCC 4.x */
 
@@ -119,7 +135,7 @@
 
 #endif
 
-#if GCC_CHECK_VERSION(4,3)
+#if CLANG_OR_GCC_VERSION(4,3)
 
 #define gcc_hot __attribute__((hot))
 #define gcc_cold __attribute__((cold))
@@ -131,7 +147,7 @@
 
 #endif /* ! GCC_UNUSED >= 40300 */
 
-#if GCC_CHECK_VERSION(4,6) && !defined(__clang__)
+#if GCC_CHECK_VERSION(4,6)
 #define gcc_flatten __attribute__((flatten))
 #else
 #define gcc_flatten
@@ -140,7 +156,7 @@
 #ifndef __cplusplus
 /* plain C99 has "restrict" */
 #define gcc_restrict restrict
-#elif GCC_CHECK_VERSION(4,0)
+#elif CLANG_OR_GCC_VERSION(4,0)
 /* "__restrict__" is a GCC extension for C++ */
 #define gcc_restrict __restrict__
 #else
@@ -158,7 +174,7 @@
 #define final
 #endif
 
-#if defined(__clang__) || GCC_CHECK_VERSION(4,8)
+#if CLANG_OR_GCC_VERSION(4,8)
 #define gcc_alignas(T, fallback) alignas(T)
 #else
 #define gcc_alignas(T, fallback) gcc_aligned(fallback)

src/archive/plugins/Bzip2ArchivePlugin.cxx

@@ -53,7 +53,7 @@ public:
 
 	Bzip2ArchiveFile(Path path, InputStream *_is)
 		:ArchiveFile(bz2_archive_plugin),
-		 name(PathTraitsFS::GetBase(path.c_str())),
+		 name(path.GetBase().c_str()),
 		 istream(_is) {
 		// remove .bz2 suffix
 		const size_t len = name.length();

src/db/Helpers.cxx

@@ -46,7 +46,7 @@ StatsVisitTag(DatabaseStats &stats, StringSet &artists, StringSet &albums,
 	for (const auto &item : tag) {
 		switch (item.type) {
 		case TAG_ARTIST:
-#if defined(__clang__) || GCC_CHECK_VERSION(4,8)
+#if CLANG_OR_GCC_VERSION(4,8)
 			artists.emplace(item.value);
 #else
 			artists.insert(item.value);
@@ -54,7 +54,7 @@ StatsVisitTag(DatabaseStats &stats, StringSet &artists, StringSet &albums,
 			break;
 
 		case TAG_ALBUM:
-#if defined(__clang__) || GCC_CHECK_VERSION(4,8)
+#if CLANG_OR_GCC_VERSION(4,8)
 			albums.emplace(item.value);
 #else
 			albums.insert(item.value);

src/db/plugins/upnp/UpnpDatabasePlugin.cxx

@@ -749,7 +749,7 @@ UpnpDatabase::VisitUniqueTags(const DatabaseSelection &selection,
 
 			const char *value = dirent.tag.GetValue(tag);
 			if (value != nullptr) {
-#if defined(__clang__) || GCC_CHECK_VERSION(4,8)
+#if CLANG_OR_GCC_VERSION(4,8)
 				values.emplace(value);
 #else
 				values.insert(value);

src/db/update/ExcludeList.cxx

@@ -34,7 +34,9 @@
 #include <string.h>
 #include <errno.h>
 
+#ifdef HAVE_GLIB
 static constexpr Domain exclude_list_domain("exclude_list");
+#endif
 
 bool
 ExcludeList::LoadFile(Path path_fs)

src/decoder/DecoderThread.cxx

@@ -98,6 +98,7 @@ decoder_input_stream_open(DecoderControl &dc, const char *uri)
 
 	if (!is->Check(error)) {
 		dc.Unlock();
+		delete is;
 
 		LogError(error);
 		return nullptr;

src/decoder/plugins/FfmpegIo.cxx

@@ -0,0 +1,100 @@
+/*
+ * 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.
+ */
+
+/* necessary because libavutil/common.h uses UINT64_C */
+#define __STDC_CONSTANT_MACROS
+
+#include "config.h"
+#include "FfmpegIo.hxx"
+#include "../DecoderAPI.hxx"
+#include "input/InputStream.hxx"
+#include "util/Error.hxx"
+
+AvioStream::~AvioStream()
+{
+	if (io != nullptr) {
+		av_free(io->buffer);
+		av_free(io);
+	}
+}
+
+static int
+mpd_ffmpeg_stream_read(void *opaque, uint8_t *buf, int size)
+{
+	AvioStream *stream = (AvioStream *)opaque;
+
+	return decoder_read(stream->decoder, stream->input,
+			    (void *)buf, size);
+}
+
+static int64_t
+mpd_ffmpeg_stream_seek(void *opaque, int64_t pos, int whence)
+{
+	AvioStream *stream = (AvioStream *)opaque;
+
+	switch (whence) {
+	case SEEK_SET:
+		break;
+
+	case SEEK_CUR:
+		pos += stream->input.GetOffset();
+		break;
+
+	case SEEK_END:
+		if (!stream->input.KnownSize())
+			return -1;
+
+		pos += stream->input.GetSize();
+		break;
+
+	case AVSEEK_SIZE:
+		if (!stream->input.KnownSize())
+			return -1;
+
+		return stream->input.GetSize();
+
+	default:
+		return -1;
+	}
+
+	if (!stream->input.LockSeek(pos, IgnoreError()))
+		return -1;
+
+	return stream->input.GetOffset();
+}
+
+bool
+AvioStream::Open()
+{
+	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;
+}

src/decoder/plugins/FfmpegIo.hxx

@@ -0,0 +1,48 @@
+/*
+ * 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_FFMPEG_IO_HXX
+#define MPD_FFMPEG_IO_HXX
+
+#include "check.h"
+
+extern "C" {
+#include "libavformat/avio.h"
+}
+
+#include <stdint.h>
+
+class InputStream;
+struct Decoder;
+
+struct AvioStream {
+	Decoder *const decoder;
+	InputStream &input;
+
+	AVIOContext *io;
+
+	AvioStream(Decoder *_decoder, InputStream &_input)
+		:decoder(_decoder), input(_input), io(nullptr) {}
+
+	~AvioStream();
+
+	bool Open();
+};
+
+#endif

src/decoder/plugins/FfmpegMetaData.cxx

@@ -36,9 +36,9 @@ static const struct tag_table ffmpeg_tags[] = {
 };
 
 static void
-ffmpeg_copy_metadata(TagType type,
+FfmpegScanTag(TagType type,
-		     AVDictionary *m, const char *name,
+	      AVDictionary *m, const char *name,
-		     const struct tag_handler *handler, void *handler_ctx)
+	      const struct tag_handler *handler, void *handler_ctx)
 {
 	AVDictionaryEntry *mt = nullptr;
 
@@ -48,8 +48,8 @@ ffmpeg_copy_metadata(TagType type,
 }
 
 static void
-ffmpeg_scan_pairs(AVDictionary *dict,
+FfmpegScanPairs(AVDictionary *dict,
-		  const struct tag_handler *handler, void *handler_ctx)
+		const struct tag_handler *handler, void *handler_ctx)
 {
 	AVDictionaryEntry *i = nullptr;
 
@@ -59,18 +59,20 @@ ffmpeg_scan_pairs(AVDictionary *dict,
 }
 
 void
-ffmpeg_scan_dictionary(AVDictionary *dict,
+FfmpegScanDictionary(AVDictionary *dict,
-		       const struct tag_handler *handler, void *handler_ctx)
+		     const struct tag_handler *handler, void *handler_ctx)
 {
-	for (unsigned i = 0; i < TAG_NUM_OF_ITEM_TYPES; ++i)
+	if (handler->tag != nullptr) {
-		ffmpeg_copy_metadata(TagType(i), dict, tag_item_names[i],
+		for (unsigned i = 0; i < TAG_NUM_OF_ITEM_TYPES; ++i)
-				     handler, handler_ctx);
+			FfmpegScanTag(TagType(i), dict, tag_item_names[i],
+				      handler, handler_ctx);
 
-	for (const struct tag_table *i = ffmpeg_tags;
+		for (const struct tag_table *i = ffmpeg_tags;
-	     i->name != nullptr; ++i)
+		     i->name != nullptr; ++i)
-		ffmpeg_copy_metadata(i->type, dict, i->name,
+			FfmpegScanTag(i->type, dict, i->name,
-				     handler, handler_ctx);
+				      handler, handler_ctx);
+	}
 
 	if (handler->pair != nullptr)
-		ffmpeg_scan_pairs(dict, handler, handler_ctx);
+		FfmpegScanPairs(dict, handler, handler_ctx);
 }

src/decoder/plugins/FfmpegMetaData.hxx

@@ -32,7 +32,7 @@ extern "C" {
 struct tag_handler;
 
 void
-ffmpeg_scan_dictionary(AVDictionary *dict,
+FfmpegScanDictionary(AVDictionary *dict,
-		       const tag_handler *handler, void *handler_ctx);
+		     const tag_handler *handler, void *handler_ctx);
 
 #endif

src/decoder/plugins/SidplayDecoderPlugin.cxx

@@ -22,67 +22,61 @@
 #include "../DecoderAPI.hxx"
 #include "tag/TagHandler.hxx"
 #include "fs/Path.hxx"
+#include "fs/AllocatedPath.hxx"
+#include "util/Macros.hxx"
 #include "util/FormatString.hxx"
 #include "util/Domain.hxx"
+#include "util/Error.hxx"
 #include "system/ByteOrder.hxx"
+#include "system/FatalError.hxx"
 #include "Log.hxx"
 
-#include <errno.h>
-#include <stdlib.h>
 #include <string.h>
-#include <glib.h>
 
+#ifdef HAVE_SIDPLAYFP
+#include <sidplayfp/sidplayfp.h>
+#include <sidplayfp/SidInfo.h>
+#include <sidplayfp/SidConfig.h>
+#include <sidplayfp/SidTune.h>
+#include <sidplayfp/SidTuneInfo.h>
+#include <sidplayfp/builders/resid.h>
+#include <sidplayfp/builders/residfp.h>
+#include <sidplayfp/SidDatabase.h>
+#else
 #include <sidplay/sidplay2.h>
 #include <sidplay/builders/resid.h>
 #include <sidplay/utils/SidTuneMod.h>
+#include <sidplay/utils/SidDatabase.h>
+#endif
 
 #define SUBTUNE_PREFIX "tune_"
 
 static constexpr Domain sidplay_domain("sidplay");
 
-static GPatternSpec *path_with_subtune;
+static SidDatabase *songlength_database;
-static const char *songlength_file;
-static GKeyFile *songlength_database;
 
 static bool all_files_are_containers;
 static unsigned default_songlength;
 
 static bool filter_setting;
 
-static GKeyFile *
+static SidDatabase *
-sidplay_load_songlength_db(const char *path)
+sidplay_load_songlength_db(const Path path)
 {
-	GError *error = nullptr;
+	SidDatabase *db = new SidDatabase();
-	gchar *data;
+#ifdef HAVE_SIDPLAYFP
-	gsize size;
+	bool error = !db->open(path.c_str());
-
+#else
-	if (!g_file_get_contents(path, &data, &size, &error)) {
+	bool error = db->open(path.c_str()) < 0;
+#endif
+	if (error) {
 		FormatError(sidplay_domain,
 			    "unable to read songlengths file %s: %s",
-			    path, error->message);
+			    path.c_str(), db->error());
-		g_error_free(error);
+		delete db;
 		return nullptr;
 	}
 
-	/* replace any ; comment characters with # */
-	for (gsize i = 0; i < size; i++)
-		if (data[i] == ';')
-			data[i] = '#';
-
-	GKeyFile *db = g_key_file_new();
-	bool success = g_key_file_load_from_data(db, data, size,
-						 G_KEY_FILE_NONE, &error);
-	g_free(data);
-	if (!success) {
-		FormatError(sidplay_domain,
-			    "unable to parse songlengths file %s: %s",
-			    path, error->message);
-		g_error_free(error);
-		g_key_file_free(db);
-		return nullptr;
-	}
-
-	g_key_file_set_list_separator(db, ' ');
 	return db;
 }
 
@@ -90,18 +84,18 @@ static bool
 sidplay_init(const config_param &param)
 {
 	/* read the songlengths database file */
-	songlength_file = param.GetBlockValue("songlength_database");
+	Error error;
-	if (songlength_file != nullptr)
+	const auto database_path = param.GetBlockPath("songlength_database", error);
-		songlength_database = sidplay_load_songlength_db(songlength_file);
+	if (!database_path.IsNull())
+		songlength_database = sidplay_load_songlength_db(database_path);
+	else if (error.IsDefined())
+		FatalError(error);
 
 	default_songlength = param.GetBlockValue("default_songlength", 0u);
 
 	all_files_are_containers =
 		param.GetBlockValue("all_files_are_containers", true);
 
-	path_with_subtune=g_pattern_spec_new(
-			"*/" SUBTUNE_PREFIX "???.sid");
-
 	filter_setting = param.GetBlockValue("filter", true);
 
 	return true;
@@ -110,98 +104,81 @@ sidplay_init(const config_param &param)
 static void
 sidplay_finish()
 {
-	g_pattern_spec_free(path_with_subtune);
+	delete songlength_database;
-
-	if(songlength_database)
-		g_key_file_free(songlength_database);
 }
 
-/**
+struct SidplayContainerPath {
- * returns the file path stripped of any /tune_xxx.sid subtune
+	AllocatedPath path;
- * suffix
+	unsigned track;
- */
+};
-static char *
-get_container_name(Path path_fs)
-{
-	char *path_container = strdup(path_fs.c_str());
 
-	if(!g_pattern_match(path_with_subtune,
+gcc_pure
-		strlen(path_container), path_container, nullptr))
-		return path_container;
-
-	char *ptr=g_strrstr(path_container, "/" SUBTUNE_PREFIX);
-	if(ptr) *ptr='\0';
-
-	return path_container;
-}
-
-/**
- * returns tune number from file.sid/tune_xxx.sid style path or 1 if
- * no subtune is appended
- */
 static unsigned
-get_song_num(const char *path_fs)
+ParseSubtuneName(const char *base)
 {
-	if(g_pattern_match(path_with_subtune,
+	if (memcmp(base, SUBTUNE_PREFIX, sizeof(SUBTUNE_PREFIX) - 1) != 0)
-		strlen(path_fs), path_fs, nullptr)) {
+		return 0;
-		char *sub=g_strrstr(path_fs, "/" SUBTUNE_PREFIX);
-		if(!sub) return 1;
 
-		sub+=strlen("/" SUBTUNE_PREFIX);
+	base += sizeof(SUBTUNE_PREFIX) - 1;
-		int song_num=strtol(sub, nullptr, 10);
 
-		if (errno == EINVAL)
+	char *endptr;
-			return 1;
+	auto track = strtoul(base, &endptr, 10);
-		else
+	if (endptr == base || *endptr != '.')
-			return song_num;
+		return 0;
-	} else
+
-		return 1;
+	return track;
 }
 
-/* get the song length in seconds */
+/**
+ * returns the file path stripped of any /tune_xxx.* subtune suffix
+ * and the track number (or 1 if no "tune_xxx" suffix is present).
+ */
+static SidplayContainerPath
+ParseContainerPath(Path path_fs)
+{
+	const Path base = path_fs.GetBase();
+	unsigned track;
+	if (base.IsNull() ||
+	    (track = ParseSubtuneName(base.c_str())) < 1)
+		return { AllocatedPath(path_fs), 1 };
+
+	return { path_fs.GetDirectoryName(), track };
+}
+
+#ifdef HAVE_SIDPLAYFP
+
 static SignedSongTime
-get_song_length(Path path_fs)
+get_song_length(SidTune &tune)
 {
 	if (songlength_database == nullptr)
 		return SignedSongTime::Negative();
 
-	char *sid_file = get_container_name(path_fs);
+	const auto length = songlength_database->length(tune);
-	SidTuneMod tune(sid_file);
+	if (length < 0)
-	free(sid_file);
-	if(!tune) {
-		LogWarning(sidplay_domain,
-			   "failed to load file for calculating md5 sum");
 		return SignedSongTime::Negative();
-	}
-	char md5sum[SIDTUNE_MD5_LENGTH+1];
-	tune.createMD5(md5sum);
 
-	const unsigned song_num = get_song_num(path_fs.c_str());
+	return SignedSongTime::FromS(length);
-
-	gsize num_items;
-	gchar **values=g_key_file_get_string_list(songlength_database,
-		"Database", md5sum, &num_items, nullptr);
-	if(!values || song_num>num_items) {
-		g_strfreev(values);
-		return SignedSongTime::Negative();
-	}
-
-	int minutes=strtol(values[song_num-1], nullptr, 10);
-	if(errno==EINVAL) minutes=0;
-
-	int seconds;
-	char *ptr=strchr(values[song_num-1], ':');
-	if(ptr) {
-		seconds=strtol(ptr+1, nullptr, 10);
-		if(errno==EINVAL) seconds=0;
-	} else
-		seconds=0;
-
-	g_strfreev(values);
-
-	return SignedSongTime::FromS((minutes * 60) + seconds);
 }
 
+#else
+
+static SignedSongTime
+get_song_length(SidTuneMod &tune)
+{
+	assert(tune);
+
+	if (songlength_database == nullptr)
+		return SignedSongTime::Negative();
+
+	const auto length = songlength_database->length(tune);
+	if (length < 0)
+		return SignedSongTime::Negative();
+
+	return SignedSongTime::FromS(length);
+}
+
+#endif
+
 static void
 sidplay_file_decode(Decoder &decoder, Path path_fs)
 {
@@ -209,26 +186,43 @@ sidplay_file_decode(Decoder &decoder, Path path_fs)
 
 	/* load the tune */
 
-	char *path_container=get_container_name(path_fs);
+	const auto container = ParseContainerPath(path_fs);
-	SidTune tune(path_container, nullptr, true);
+#ifdef HAVE_SIDPLAYFP
-	free(path_container);
+	SidTune tune(container.path.c_str());
-	if (!tune) {
+#else
-		LogWarning(sidplay_domain, "failed to load file");
+	SidTuneMod tune(container.path.c_str());
+#endif
+	if (!tune.getStatus()) {
+#ifdef HAVE_SIDPLAYFP
+		const char *error = tune.statusString();
+#else
+		const char *error = tune.getInfo().statusString;
+#endif
+		FormatWarning(sidplay_domain, "failed to load file: %s",
+			      error);
 		return;
 	}
 
-	const int song_num = get_song_num(path_fs.c_str());
+	const int song_num = container.track;
 	tune.selectSong(song_num);
 
-	auto duration = get_song_length(path_fs);
+	auto duration = get_song_length(tune);
 	if (duration.IsNegative() && default_songlength > 0)
 		duration = SongTime::FromS(default_songlength);
 
 	/* initialize the player */
 
+#ifdef HAVE_SIDPLAYFP
+	sidplayfp player;
+#else
 	sidplay2 player;
-	int iret = player.load(&tune);
+#endif
-	if (iret != 0) {
+#ifdef HAVE_SIDPLAYFP
+	bool error = !player.load(&tune);
+#else
+	bool error = player.load(&tune) < 0;
+#endif
+	if (error) {
 		FormatWarning(sidplay_domain,
 			      "sidplay2.load() failed: %s", player.error());
 		return;
@@ -236,53 +230,104 @@ sidplay_file_decode(Decoder &decoder, Path path_fs)
 
 	/* initialize the builder */
 
-	ReSIDBuilder builder("ReSID");
+#ifdef HAVE_SIDPLAYFP
-	if (!builder) {
+	ReSIDfpBuilder builder("ReSID");
-		LogWarning(sidplay_domain,
+	if (!builder.getStatus()) {
-			   "failed to initialize ReSIDBuilder");
+		FormatWarning(sidplay_domain,
+			      "failed to initialize ReSIDfpBuilder: %s",
+			      builder.error());
 		return;
 	}
 
+	builder.create(player.info().maxsids());
+	if (!builder.getStatus()) {
+		FormatWarning(sidplay_domain,
+			      "ReSIDfpBuilder.create() failed: %s",
+			      builder.error());
+		return;
+	}
+#else
+	ReSIDBuilder builder("ReSID");
 	builder.create(player.info().maxsids);
 	if (!builder) {
-		LogWarning(sidplay_domain, "ReSIDBuilder.create() failed");
+		FormatWarning(sidplay_domain, "ReSIDBuilder.create() failed: %s",
+			      builder.error());
 		return;
 	}
+#endif
 
 	builder.filter(filter_setting);
-	if (!builder) {
+#ifdef HAVE_SIDPLAYFP
-		LogWarning(sidplay_domain, "ReSIDBuilder.filter() failed");
+	if (!builder.getStatus()) {
+		FormatWarning(sidplay_domain,
+			      "ReSIDfpBuilder.filter() failed: %s",
+			      builder.error());
 		return;
 	}
+#else
+	if (!builder) {
+		FormatWarning(sidplay_domain, "ReSIDBuilder.filter() failed: %s",
+			      builder.error());
+		return;
+	}
+#endif
 
 	/* configure the player */
 
-	sid2_config_t config = player.config();
+	auto config = player.config();
 
+#ifndef HAVE_SIDPLAYFP
 	config.clockDefault = SID2_CLOCK_PAL;
 	config.clockForced = true;
 	config.clockSpeed = SID2_CLOCK_CORRECT;
+#endif
 	config.frequency = 48000;
+#ifndef HAVE_SIDPLAYFP
 	config.optimisation = SID2_DEFAULT_OPTIMISATION;
 
 	config.precision = 16;
 	config.sidDefault = SID2_MOS6581;
+#endif
 	config.sidEmulation = &builder;
+#ifdef HAVE_SIDPLAYFP
+	config.samplingMethod = SidConfig::INTERPOLATE;
+	config.fastSampling = false;
+#else
 	config.sidModel = SID2_MODEL_CORRECT;
 	config.sidSamples = true;
 	config.sampleFormat = IsLittleEndian()
 		? SID2_LITTLE_SIGNED
 		: SID2_BIG_SIGNED;
-	if (tune.isStereo()) {
+#endif
+
+#ifdef HAVE_SIDPLAYFP
+	const bool stereo = tune.getInfo()->sidChips() >= 2;
+#else
+	const bool stereo = tune.isStereo();
+#endif
+
+	if (stereo) {
+#ifdef HAVE_SIDPLAYFP
+		config.playback = SidConfig::STEREO;
+#else
 		config.playback = sid2_stereo;
+#endif
 		channels = 2;
 	} else {
+#ifdef HAVE_SIDPLAYFP
+		config.playback = SidConfig::MONO;
+#else
 		config.playback = sid2_mono;
+#endif
 		channels = 1;
 	}
 
-	iret = player.config(config);
+#ifdef HAVE_SIDPLAYFP
-	if (iret != 0) {
+	error = !player.config(config);
+#else
+	error = player.config(config) < 0;
+#endif
+	if (error) {
 		FormatWarning(sidplay_domain,
 			      "sidplay2.config() failed: %s", player.error());
 		return;
@@ -297,17 +342,21 @@ sidplay_file_decode(Decoder &decoder, Path path_fs)
 
 	/* .. and play */
 
+#ifdef HAVE_SIDPLAYFP
+	constexpr unsigned timebase = 1;
+#else
 	const unsigned timebase = player.timebase();
+#endif
 	const unsigned end = duration.IsNegative()
 		? 0u
 		: duration.ToScale<uint64_t>(timebase);
 
 	DecoderCommand cmd;
 	do {
-		char buffer[4096];
+		short buffer[4096];
 		size_t nbytes;
 
-		nbytes = player.play(buffer, sizeof(buffer));
+		nbytes = player.play(buffer, ARRAY_SIZE(buffer));
 		if (nbytes == 0)
 			break;
 
@@ -328,7 +377,7 @@ sidplay_file_decode(Decoder &decoder, Path path_fs)
 
 			/* ignore data until target time is reached */
 			while(data_time<target_time) {
-				nbytes=player.play(buffer, sizeof(buffer));
+				nbytes=player.play(buffer, ARRAY_SIZE(buffer));
 				if(nbytes==0)
 					break;
 				data_time = player.time();
@@ -343,41 +392,72 @@ sidplay_file_decode(Decoder &decoder, Path path_fs)
 	} while (cmd != DecoderCommand::STOP);
 }
 
+gcc_pure
+static const char *
+GetInfoString(const SidTuneInfo &info, unsigned i)
+{
+#ifdef HAVE_SIDPLAYFP
+	return info.numberOfInfoStrings() > i
+		? info.infoString(i)
+		: nullptr;
+#else
+	return info.numberOfInfoStrings > i
+		? info.infoString[i]
+		: nullptr;
+#endif
+}
+
 static bool
 sidplay_scan_file(Path path_fs,
 		  const struct tag_handler *handler, void *handler_ctx)
 {
-	const int song_num = get_song_num(path_fs.c_str());
+	const auto container = ParseContainerPath(path_fs);
-	char *path_container=get_container_name(path_fs);
+	const unsigned song_num = container.track;
 
-	SidTune tune(path_container, nullptr, true);
+#ifdef HAVE_SIDPLAYFP
-	free(path_container);
+	SidTune tune(container.path.c_str());
-	if (!tune)
+#else
+	SidTuneMod tune(container.path.c_str());
+#endif
+	if (!tune.getStatus())
 		return false;
 
+	tune.selectSong(song_num);
+
+#ifdef HAVE_SIDPLAYFP
+	const SidTuneInfo &info = *tune.getInfo();
+	const unsigned n_tracks = info.songs();
+#else
 	const SidTuneInfo &info = tune.getInfo();
+	const unsigned n_tracks = info.songs;
+#endif
 
 	/* title */
-	const char *title;
+	const char *title = GetInfoString(info, 0);
-	if (info.numberOfInfoStrings > 0 && info.infoString[0] != nullptr)
+	if (title == nullptr)
-		title=info.infoString[0];
+		title = "";
-	else
-		title="";
 
-	if(info.songs>1) {
+	if (n_tracks > 1) {
 		char tag_title[1024];
 		snprintf(tag_title, sizeof(tag_title),
-			 "%s (%d/%d)",
+			 "%s (%d/%u)",
-			 title, song_num, info.songs);
+			 title, song_num, n_tracks);
 		tag_handler_invoke_tag(handler, handler_ctx,
 				       TAG_TITLE, tag_title);
 	} else
 		tag_handler_invoke_tag(handler, handler_ctx, TAG_TITLE, title);
 
 	/* artist */
-	if (info.numberOfInfoStrings > 1 && info.infoString[1] != nullptr)
+	const char *artist = GetInfoString(info, 1);
+	if (artist != nullptr)
 		tag_handler_invoke_tag(handler, handler_ctx, TAG_ARTIST,
-				       info.infoString[1]);
+				       artist);
+
+	/* date */
+	const char *date = GetInfoString(info, 2);
+	if (date != nullptr)
+		tag_handler_invoke_tag(handler, handler_ctx, TAG_DATE,
+				       date);
 
 	/* track */
 	char track[16];
@@ -385,7 +465,7 @@ sidplay_scan_file(Path path_fs,
 	tag_handler_invoke_tag(handler, handler_ctx, TAG_TRACK, track);
 
 	/* time */
-	const auto duration = get_song_length(path_fs);
+	const auto duration = get_song_length(tune);
 	if (!duration.IsNegative())
 		tag_handler_invoke_duration(handler, handler_ctx,
 					    SongTime(duration));
@@ -397,19 +477,25 @@ static char *
 sidplay_container_scan(Path path_fs, const unsigned int tnum)
 {
 	SidTune tune(path_fs.c_str(), nullptr, true);
-	if (!tune)
+	if (!tune.getStatus())
 		return nullptr;
 
-	const SidTuneInfo &info=tune.getInfo();
+#ifdef HAVE_SIDPLAYFP
+	const SidTuneInfo &info = *tune.getInfo();
+	const unsigned n_tracks = info.songs();
+#else
+	const SidTuneInfo &info = tune.getInfo();
+	const unsigned n_tracks = info.songs;
+#endif
 
 	/* Don't treat sids containing a single tune
 		as containers */
-	if(!all_files_are_containers && info.songs<2)
+	if(!all_files_are_containers && n_tracks < 2)
 		return nullptr;
 
 	/* Construct container/tune path names, eg.
 		Delta.sid/tune_001.sid */
-	if(tnum<=info.songs) {
+	if (tnum <= n_tracks) {
 		return FormatNew(SUBTUNE_PREFIX "%03u.sid", tnum);
 	} else
 		return nullptr;

src/decoder/plugins/WildmidiDecoderPlugin.cxx

@@ -65,6 +65,24 @@ wildmidi_finish(void)
 	WildMidi_Shutdown();
 }
 
+static DecoderCommand
+wildmidi_output(Decoder &decoder, midi *wm)
+{
+#ifdef LIBWILDMIDI_VER_MAJOR
+	/* WildMidi 0.4 has switched from "char*" to "int8_t*" */
+	int8_t buffer[4096];
+#else
+	/* pre 0.4 */
+	char buffer[4096];
+#endif
+
+	int length = WildMidi_GetOutput(wm, buffer, sizeof(buffer));
+	if (length <= 0)
+		return DecoderCommand::STOP;
+
+	return decoder_data(decoder, nullptr, buffer, length, 0);
+}
+
 static void
 wildmidi_file_decode(Decoder &decoder, Path path_fs)
 {
@@ -94,18 +112,11 @@ wildmidi_file_decode(Decoder &decoder, Path path_fs)
 
 	DecoderCommand cmd;
 	do {
-		char buffer[4096];
-		int len;
-
 		info = WildMidi_GetInfo(wm);
 		if (info == nullptr)
 			break;
 
-		len = WildMidi_GetOutput(wm, buffer, sizeof(buffer));
+		cmd = wildmidi_output(decoder, wm);
-		if (len <= 0)
-			break;
-
-		cmd = decoder_data(decoder, nullptr, buffer, len, 0);
 
 		if (cmd == DecoderCommand::SEEK) {
 			unsigned long seek_where =

src/fs/AllocatedPath.cxx

@@ -111,7 +111,7 @@ AllocatedPath::ChopSeparators()
 	while (l >= 2 && PathTraitsFS::IsSeparator(p[l - 1])) {
 		--l;
 
-#if GCC_CHECK_VERSION(4,7) && !defined(__clang__)
+#if GCC_CHECK_VERSION(4,7)
 		value.pop_back();
 #else
 		value.erase(value.end() - 1, value.end());

src/fs/AllocatedPath.hxx

@@ -252,7 +252,7 @@ public:
 	void ChopSeparators();
 
 	gcc_pure
-	bool IsAbsolute() {
+	bool IsAbsolute() const {
 		return PathTraitsFS::IsAbsolute(c_str());
 	}
 };

src/fs/Path.hxx

@@ -29,6 +29,8 @@
 #include <assert.h>
 #include <string.h>
 
+class AllocatedPath;
+
 /**
  * A path name in the native file system character set.
  *
@@ -128,6 +130,22 @@ public:
 	gcc_pure
 	std::string ToUTF8() const;
 
+	/**
+	 * Determine the "base" file name.
+	 * The return value points inside this object.
+	 */
+	gcc_pure
+	Path GetBase() const {
+		return FromFS(PathTraitsFS::GetBase(value));
+	}
+
+	/**
+	 * Gets directory name of this path.
+	 * Returns a "nulled" instance on error.
+	 */
+	gcc_pure
+	AllocatedPath GetDirectoryName() const;
+
 	/**
 	 * Determine the relative part of the given path to this
 	 * object, not including the directory separator.  Returns an
@@ -140,7 +158,7 @@ public:
 	}
 
 	gcc_pure
-	bool IsAbsolute() {
+	bool IsAbsolute() const {
 		return PathTraitsFS::IsAbsolute(c_str());
 	}
 };

src/fs/Path2.cxx

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2003-2014 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 "Path.hxx"
+#include "AllocatedPath.hxx"
+
+AllocatedPath
+Path::GetDirectoryName() const
+{
+	return AllocatedPath::FromFS(PathTraitsFS::GetParent(c_str()));
+}

src/lib/ffmpeg/Buffer.hxx

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2003-2014 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_FFMPEG_BUFFER_HXX
+#define MPD_FFMPEG_BUFFER_HXX
+
+extern "C" {
+#include <libavutil/mem.h>
+
+#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(52, 18, 0)
+#define HAVE_AV_FAST_MALLOC
+#else
+#include <libavcodec/avcodec.h>
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 25, 0)
+#define HAVE_AV_FAST_MALLOC
+#endif
+#endif
+}
+
+#include <stddef.h>
+
+/* suppress the ffmpeg compatibility macro */
+#ifdef SampleFormat
+#undef SampleFormat
+#endif
+
+class FfmpegBuffer {
+	void *data;
+	unsigned size;
+
+public:
+	FfmpegBuffer():data(nullptr), size(0) {}
+
+	~FfmpegBuffer() {
+		av_free(data);
+	}
+
+	void *Get(size_t min_size) {
+#ifdef HAVE_AV_FAST_MALLOC
+		av_fast_malloc(&data, &size, min_size);
+#else
+		void *new_data = av_fast_realloc(data, &size, min_size);
+		if (new_data == nullptr)
+			return AVERROR(ENOMEM);
+		data = new_data;
+#endif
+		return data;
+	}
+
+	template<typename T>
+	T *GetT(size_t n) {
+		return (T *)Get(n * sizeof(T));
+	}
+};
+
+#endif

src/lib/ffmpeg/Init.cxx

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2003-2014 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.
+ */
+
+/* necessary because libavutil/common.h uses UINT64_C */
+#define __STDC_CONSTANT_MACROS
+
+#include "config.h"
+#include "Init.hxx"
+#include "LogCallback.hxx"
+
+extern "C" {
+#include <libavformat/avformat.h>
+}
+
+void
+FfmpegInit()
+{
+	av_log_set_callback(FfmpegLogCallback);
+
+	av_register_all();
+}
+

src/lib/ffmpeg/Init.hxx

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2003-2014 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_FFMPEG_INIT_HXX
+#define MPD_FFMPEG_INIT_HXX
+
+void
+FfmpegInit();
+
+#endif

src/lib/ffmpeg/LogCallback.cxx

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2003-2014 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.
+ */
+
+/* necessary because libavutil/common.h uses UINT64_C */
+#define __STDC_CONSTANT_MACROS
+
+#include "config.h"
+#include "LogCallback.hxx"
+#include "Domain.hxx"
+#include "LogV.hxx"
+#include "util/Domain.hxx"
+
+extern "C" {
+#include <libavutil/log.h>
+}
+
+#include <stdio.h>
+
+gcc_const
+static LogLevel
+FfmpegImportLogLevel(int level)
+{
+	if (level <= AV_LOG_FATAL)
+		return LogLevel::ERROR;
+
+	if (level <= AV_LOG_WARNING)
+		return LogLevel::WARNING;
+
+	if (level <= AV_LOG_INFO)
+		return LogLevel::INFO;
+
+	return LogLevel::DEBUG;
+}
+
+void
+FfmpegLogCallback(gcc_unused void *ptr, int level, const char *fmt, va_list vl)
+{
+	const AVClass * cls = nullptr;
+
+	if (ptr != nullptr)
+		cls = *(const AVClass *const*)ptr;
+
+	if (cls != nullptr) {
+		char domain[64];
+		snprintf(domain, sizeof(domain), "%s/%s",
+			 ffmpeg_domain.GetName(), cls->item_name(ptr));
+		const Domain d(domain);
+		LogFormatV(d, FfmpegImportLogLevel(level), fmt, vl);
+	}
+}

src/lib/ffmpeg/LogCallback.hxx

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2003-2014 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_FFMPEG_LOG_CALLBACK_HXX
+#define MPD_FFMPEG_LOG_CALLBACK_HXX
+
+#include "check.h"
+
+#include <stdarg.h>
+
+void
+FfmpegLogCallback(void *ptr, int level, const char *fmt, va_list vl);
+
+#endif

src/lib/ffmpeg/LogError.cxx

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2003-2014 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 "LogError.hxx"
+#include "Domain.hxx"
+#include "Log.hxx"
+
+#include <cstdint> /* needed due to libavutil bug */
+
+extern "C" {
+#include <libavutil/error.h>
+}
+
+void
+LogFfmpegError(int errnum)
+{
+	char msg[256];
+	av_strerror(errnum, msg, sizeof(msg));
+	LogError(ffmpeg_domain, msg);
+}
+
+void
+LogFfmpegError(int errnum, const char *prefix)
+{
+	char msg[256];
+	av_strerror(errnum, msg, sizeof(msg));
+	FormatError(ffmpeg_domain, "%s: %s", prefix, msg);
+}

src/lib/ffmpeg/LogError.hxx

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2003-2014 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_FFMPEG_LOG_ERROR_HXX
+#define MPD_FFMPEG_LOG_ERROR_HXX
+
+void
+LogFfmpegError(int errnum);
+
+void
+LogFfmpegError(int errnum, const char *prefix);
+
+#endif

src/lib/ffmpeg/Time.hxx

@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2003-2014 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_FFMPEG_TIME_HXX
+#define MPD_FFMPEG_TIME_HXX
+
+#include "Chrono.hxx"
+#include "Compiler.h"
+
+extern "C" {
+#include <libavutil/avutil.h>
+#include <libavutil/mathematics.h>
+}
+
+#include <assert.h>
+#include <stdint.h>
+
+/* suppress the ffmpeg compatibility macro */
+#ifdef SampleFormat
+#undef SampleFormat
+#endif
+
+gcc_const
+static inline double
+FfmpegTimeToDouble(int64_t t, const AVRational time_base)
+{
+	assert(t != (int64_t)AV_NOPTS_VALUE);
+
+	return (double)av_rescale_q(t, time_base, (AVRational){1, 1024})
+		/ (double)1024;
+}
+
+template<typename Ratio>
+static inline constexpr AVRational
+RatioToAVRational()
+{
+	return { Ratio::num, Ratio::den };
+}
+
+/**
+ * Convert a FFmpeg time stamp to a #SongTime.
+ */
+gcc_const
+static inline SongTime
+FromFfmpegTime(int64_t t, const AVRational time_base)
+{
+	assert(t != (int64_t)AV_NOPTS_VALUE);
+
+	return SongTime::FromMS(av_rescale_q(t, time_base,
+					     (AVRational){1, 1000}));
+}
+
+/**
+ * Convert a FFmpeg time stamp to a #SignedSongTime.
+ */
+gcc_const
+static inline SignedSongTime
+FromFfmpegTimeChecked(int64_t t, const AVRational time_base)
+{
+	return t != (int64_t)AV_NOPTS_VALUE
+		? SignedSongTime(FromFfmpegTime(t, time_base))
+		: SignedSongTime::Negative();
+}
+
+/**
+ * Convert a #SongTime to a FFmpeg time stamp with the given base.
+ */
+gcc_const
+static inline int64_t
+ToFfmpegTime(SongTime t, const AVRational time_base)
+{
+	return av_rescale_q(t.count(),
+			    RatioToAVRational<SongTime::period>(),
+			    time_base);
+}
+
+/**
+ * Replace #AV_NOPTS_VALUE with the given fallback.
+ */
+static constexpr int64_t
+FfmpegTimestampFallback(int64_t t, int64_t fallback)
+{
+	return gcc_likely(t != int64_t(AV_NOPTS_VALUE))
+		? t
+		: fallback;
+}
+
+#endif

src/lib/nfs/Manager.cxx

@@ -59,6 +59,18 @@ NfsManager::Compare::operator()(const ManagedConnection &a,
 	return result < 0;
 }
 
+inline bool
+NfsManager::Compare::operator()(const ManagedConnection &a,
+				const ManagedConnection &b) const
+{
+	int result = strcmp(a.GetServer(), b.GetServer());
+	if (result != 0)
+		return result < 0;
+
+	result = strcmp(a.GetExportName(), b.GetExportName());
+	return result < 0;
+}
+
 NfsManager::~NfsManager()
 {
 	assert(GetEventLoop().IsInside());

src/lib/nfs/Manager.hxx

@@ -64,6 +64,10 @@ class NfsManager final : IdleMonitor {
 		gcc_pure
 		bool operator()(const ManagedConnection &a,
 				const LookupKey b) const;
+
+		gcc_pure
+		bool operator()(const ManagedConnection &a,
+				const ManagedConnection &b) const;
 	};
 
 	/**

src/neighbor/plugins/SmbclientNeighborPlugin.cxx

@@ -216,7 +216,7 @@ SmbclientNeighborExplorer::Run()
 			prev = i;
 		} else {
 			/* can't see it anymore: move to "lost" */
-#if defined(__clang__) || GCC_CHECK_VERSION(4,7)
+#if CLANG_OR_GCC_VERSION(4,7)
 			lost.splice_after(lost.before_begin(), list, prev);
 #else
 			/* the forward_list::splice_after() lvalue

src/output/plugins/PulseOutputPlugin.cxx

@@ -545,7 +545,6 @@ pulse_output_open(AudioOutput *ao, AudioFormat &audio_format,
 		  Error &error)
 {
 	PulseOutput *po = (PulseOutput *)ao;
-	pa_sample_spec ss;
 
 	assert(po->mainloop != nullptr);
 
@@ -575,11 +574,30 @@ pulse_output_open(AudioOutput *ao, AudioFormat &audio_format,
 		return false;
 	}
 
-	/* MPD doesn't support the other pulseaudio sample formats, so
+	/* Use the sample formats that our version of PulseAudio and MPD
-	   we just force MPD to send us everything as 16 bit */
+	   have in common, otherwise force MPD to send 16 bit */
-	audio_format.format = SampleFormat::S16;
+
+	pa_sample_spec ss;
+
+	switch (audio_format.format) {
+	case SampleFormat::FLOAT:
+		ss.format = PA_SAMPLE_FLOAT32NE;
+		break;
+	case SampleFormat::S32:
+		ss.format = PA_SAMPLE_S32NE;
+		break;
+	case SampleFormat::S24_P32:
+		ss.format = PA_SAMPLE_S24_32NE;
+		break;
+	case SampleFormat::S16:
+		ss.format = PA_SAMPLE_S16NE;
+		break;
+	default:
+		audio_format.format = SampleFormat::S16;
+		ss.format = PA_SAMPLE_S16NE;
+		break;
+	}
 
-	ss.format = PA_SAMPLE_S16NE;
 	ss.rate = audio_format.sample_rate;
 	ss.channels = audio_format.channels;
 

src/output/plugins/ShoutOutputPlugin.cxx

@@ -164,7 +164,9 @@ ShoutOutput::Configure(const config_param &param, Error &error)
 		}
 	}
 
-	const char *encoding = param.GetBlockValue("encoding", "ogg");
+	const char *encoding = param.GetBlockValue("encoder", nullptr);
+	if (encoding == nullptr)
+		encoding = param.GetBlockValue("encoding", "vorbis");
 	const auto encoder_plugin = shout_encoder_plugin_get(encoding);
 	if (encoder_plugin == nullptr) {
 		error.Format(config_domain,

src/output/plugins/httpd/HttpdInternal.hxx

@@ -153,7 +153,7 @@ public:
 	HttpdOutput(EventLoop &_loop);
 	~HttpdOutput();
 
-#if defined(__clang__) || GCC_CHECK_VERSION(4,7)
+#if CLANG_OR_GCC_VERSION(4,7)
 	constexpr
 #endif
 	static HttpdOutput *Cast(AudioOutput *ao) {

src/pcm/Interleave.cxx

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2003-2015 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+#include "Interleave.hxx"
+
+#include <stdint.h>
+#include <string.h>
+
+static void
+GenericPcmInterleave(uint8_t *dest, ConstBuffer<const uint8_t *> src,
+		     size_t n_frames, size_t sample_size)
+{
+	for (size_t frame = 0; frame < n_frames; ++frame) {
+		for (size_t channel = 0; channel < src.size; ++channel) {
+			memcpy(dest, src[channel] + frame * sample_size,
+			       sample_size);
+			dest += sample_size;
+		}
+	}
+}
+
+void
+PcmInterleave(void *dest, ConstBuffer<const void *> src,
+	      size_t n_frames, size_t sample_size)
+{
+	GenericPcmInterleave((uint8_t *)dest,
+			     ConstBuffer<const uint8_t *>((const uint8_t *const*)src.data,
+							  src.size),
+			     n_frames, sample_size);
+}

src/pcm/Interleave.hxx

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2003-2015 The Music Player Daemon Project
+ * http://www.musicpd.org
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPD_PCM_INTERLEAVE_HXX
+#define MPD_PCM_INTERLEAVE_HXX
+
+#include "check.h"
+#include "util/ConstBuffer.hxx"
+
+/**
+ * Interleave planar PCM samples from #src to #dest.
+ */
+void
+PcmInterleave(void *dest, ConstBuffer<const void *> src,
+	      size_t n_frames, size_t sample_size);
+
+#endif

src/storage/CompositeStorage.cxx

@@ -137,7 +137,7 @@ CompositeStorage::Directory::Make(const char *uri)
 	Directory *directory = this;
 	while (*uri != 0) {
 		const std::string name = NextSegment(uri);
-#if defined(__clang__) || GCC_CHECK_VERSION(4,8)
+#if CLANG_OR_GCC_VERSION(4,8)
 		auto i = directory->children.emplace(std::move(name),
 						     Directory());
 #else

src/system/ByteOrder.hxx

@@ -40,7 +40,7 @@
 /* well-known big-endian */
 #  define IS_LITTLE_ENDIAN false
 #  define IS_BIG_ENDIAN true
-#elif defined(__APPLE__)
+#elif defined(__APPLE__) || defined(__NetBSD__)
 /* compile-time check for MacOS */
 #  include <machine/endian.h>
 #  if BYTE_ORDER == LITTLE_ENDIAN

src/tag/Set.cxx

@@ -75,7 +75,7 @@ TagSet::InsertUnique(const Tag &src, TagType type, const char *value,
 	else
 		builder.AddItem(type, value);
 	CopyTagMask(builder, src, group_mask);
-#if defined(__clang__) || GCC_CHECK_VERSION(4,8)
+#if CLANG_OR_GCC_VERSION(4,8)
 	emplace(builder.Commit());
 #else
 	insert(builder.Commit());

src/tag/TagPool.cxx

@@ -91,7 +91,7 @@ calc_hash(TagType type, const char *p)
 	return hash ^ type;
 }
 
-#if defined(__clang__) || GCC_CHECK_VERSION(4,7)
+#if CLANG_OR_GCC_VERSION(4,7)
 	constexpr
 #endif
 static inline TagPoolSlot *

src/util/Cast.hxx

@@ -84,7 +84,7 @@ ContainerAttributeOffset(const A C::*p)
  * Cast the given pointer to a struct member to its parent structure.
  */
 template<class C, class A>
-#if defined(__clang__) || GCC_CHECK_VERSION(4,7)
+#if CLANG_OR_GCC_VERSION(4,7)
 constexpr
 #endif
 static inline C &
@@ -97,7 +97,7 @@ ContainerCast(A &a, A C::*member)
  * Cast the given pointer to a struct member to its parent structure.
  */
 template<class C, class A>
-#if defined(__clang__) || GCC_CHECK_VERSION(4,7)
+#if CLANG_OR_GCC_VERSION(4,7)
 constexpr
 #endif
 static inline const C &

src/util/Manual.hxx

@@ -41,7 +41,7 @@
 
 #include <assert.h>
 
-#if defined(__clang__) || GCC_CHECK_VERSION(4,7)
+#if CLANG_OR_GCC_VERSION(4,7)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif
@@ -114,7 +114,7 @@ public:
 	}
 };
 
-#if defined(__clang__) || GCC_VERSION >= 40700
+#if CLANG_OR_GCC_VERSION(4,7)
 #pragma GCC diagnostic pop
 #endif
 

src/util/ScopeExit.hxx

@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2015 Max Kellermann <max@duempel.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
+ * FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SCOPE_EXIT_HXX
+#define SCOPE_EXIT_HXX
+
+#include "Compiler.h"
+
+#include <utility>
+
+/**
+ * Internal class.  Do not use directly.
+ */
+template<typename F>
+class ScopeExitGuard : F {
+	bool enabled = true;
+
+public:
+	explicit ScopeExitGuard(F &&f):F(std::forward<F>(f)) {}
+
+	ScopeExitGuard(ScopeExitGuard &&src)
+		:F(std::move(src)) {
+		src.enabled = false;
+	}
+
+	~ScopeExitGuard() {
+		if (enabled)
+			F::operator()();
+	}
+
+	ScopeExitGuard(const ScopeExitGuard &) = delete;
+	ScopeExitGuard &operator=(const ScopeExitGuard &) = delete;
+};
+
+/**
+ * Internal class.  Do not use directly.
+ */
+struct ScopeExitTag {
+	/* this operator is a trick so we don't need to close
+	   parantheses at the end of the expression AtScopeExit()
+	   call */
+	template<typename F>
+	ScopeExitGuard<F> operator+(F &&f) {
+		return ScopeExitGuard<F>(std::forward<F>(f));
+	}
+};
+
+#define ScopeExitCat(a, b) a ## b
+#define ScopeExitName(line) ScopeExitCat(at_scope_exit_, line)
+
+/**
+ * Call the block after this macro at the end of the current scope.
+ * Parameters are lambda captures.
+ *
+ * This is exception-safe, however the given code block must not throw
+ * exceptions.
+ *
+ * This attempts to be a better boost/scope_exit.hpp, without all of
+ * Boost's compile-time and runtime bloat.
+ */
+#define AtScopeExit(...) auto ScopeExitName(__LINE__) = ScopeExitTag() + [__VA_ARGS__]()
+
+#endif