release v0.19.7

setvbuf() does not seem to have an effect on Windows.

.gitignore

@@ -77,6 +77,8 @@ tags
 /test/test_vorbis_encoder
 /test/DumpDatabase
 
+/lib/
+
 /*.tar.gz
 /*.tar.bz2
 /*.tar.xz

NEWS

@@ -1,3 +1,26 @@
+ver 0.19.7 (2014/12/17)
+* input
+  - nfs: fix crash while canceling a failing file open operation
+  - nfs: fix memory leak on connection failure
+  - nfs: fix reconnect after mount failure
+  - nfs: implement mount timeout (60 seconds)
+* storage
+  - nfs: implement I/O timeout (60 seconds)
+* playlist
+  - embcue: fix filename suffix detection
+  - don't skip non-existent songs in "listplaylist"
+* decoder
+  - ffmpeg: fix time stamp underflow
+* fix memory allocator bug on Windows
+
+ver 0.19.6 (2014/12/08)
+* decoder
+  - ffmpeg: support FFmpeg 2.5
+* fix build failure with musl
+* android
+  - update libFLAC to 1.3.1
+  - update FFmpeg to 2.5
+
 ver 0.19.5 (2014/11/26)
 * input
   - nfs: fix crash on connection failure
@@ -138,6 +161,17 @@ ver 0.19 (2014/10/10)
 * install systemd unit for socket activation
 * Android port
 
+ver 0.18.21 (2014/12/17)
+* playlist
+  - embcue: fix filename suffix detection
+* decoder
+  - ffmpeg: fix time stamp underflow
+
+ver 0.18.20 (2014/12/08)
+* decoder
+  - ffmpeg: support FFmpeg 2.5
+* fix build failure with musl
+
 ver 0.18.19 (2014/11/26)
 * archive
   - zzip: fix crash after seeking

android/AndroidManifest.xml

@@ -2,8 +2,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
           package="org.musicpd"
           android:installLocation="auto"
-          android:versionCode="9"
-          android:versionName="0.19.5">
+          android:versionCode="10"
+          android:versionName="0.19.6">
 
   <uses-sdk android:minSdkVersion="9" android:targetSdkVersion="17"/>
 

android/build.py

@@ -314,8 +314,8 @@ thirdparty_libs = [
     ),
 
     AutotoolsProject(
-        'https://svn.xiph.org/releases/flac/flac-1.3.0.tar.xz',
-        '13b5c214cee8373464d3d65dee362cdd',
+        'http://downloads.xiph.org/releases/flac/flac-1.3.1.tar.xz',
+        'b9922c9a0378c88d3e901b234f852698',
         'lib/libFLAC.a',
         [
             '--disable-shared', '--enable-static',
@@ -341,8 +341,8 @@ thirdparty_libs = [
     ),
 
     FfmpegProject(
-        'http://www.ffmpeg.org/releases/ffmpeg-2.2.3.tar.bz2',
-        'dbb5b6b69bd010916f17df0ae596e0b1',
+        'http://ffmpeg.org/releases/ffmpeg-2.5.tar.bz2',
+        '4346fe710cc6bdd981f6534d2420d1ab',
         'lib/libavcodec.a',
         [
             '--disable-shared', '--enable-static',
@@ -366,8 +366,8 @@ thirdparty_libs = [
     ),
 
     AutotoolsProject(
-        'http://curl.haxx.se/download/curl-7.37.0.tar.lzma',
-        '54bfd1eb5214f604186d6f5ac61c7781',
+        'http://curl.haxx.se/download/curl-7.39.0.tar.lzma',
+        'e9aa6dec29920eba8ef706ea5823bad7',
         'lib/libcurl.a',
         [
             '--disable-shared', '--enable-static',

configure.ac

@@ -1,10 +1,10 @@
 AC_PREREQ(2.60)
 
-AC_INIT(mpd, 0.19.5, musicpd-dev-team@lists.sourceforge.net)
+AC_INIT(mpd, 0.19.7, musicpd-dev-team@lists.sourceforge.net)
 
 VERSION_MAJOR=0
 VERSION_MINOR=19
-VERSION_REVISION=5
+VERSION_REVISION=7
 VERSION_EXTRA=0
 
 AC_CONFIG_SRCDIR([src/Main.cxx])

src/LogBackend.cxx

@@ -194,6 +194,12 @@ FileLog(const Domain &domain, const char *message)
 		domain.GetName(),
 		chomp_length(message), message);
 
+#ifdef WIN32
+	/* force-flush the log file, because setvbuf() does not seem
+	   to have an effect on WIN32 */
+	fflush(stderr);
+#endif
+
 #ifdef HAVE_GLIB
 	g_free(converted);
 #endif

src/LogInit.cxx

@@ -111,6 +111,9 @@ log_early_init(bool verbose)
 #ifdef ANDROID
 	(void)verbose;
 #else
+	/* force stderr to be line-buffered */
+	setvbuf(stderr, nullptr, _IOLBF, 0);
+
 	if (verbose)
 		SetLogThreshold(LogLevel::DEBUG);
 #endif

src/decoder/plugins/FfmpegDecoderPlugin.cxx

@@ -313,10 +313,13 @@ ffmpeg_send_packet(Decoder &decoder, InputStream &is,
 		   AVFrame *frame,
 		   uint8_t **buffer, int *buffer_size)
 {
-	if (packet->pts >= 0 && packet->pts != (int64_t)AV_NOPTS_VALUE)
-		decoder_timestamp(decoder,
-				  time_from_ffmpeg(packet->pts - start_time_fallback(*stream),
-				  stream->time_base));
+	if (packet->pts >= 0 && packet->pts != (int64_t)AV_NOPTS_VALUE) {
+		auto start = start_time_fallback(*stream);
+		if (packet->pts >= start)
+			decoder_timestamp(decoder,
+					  time_from_ffmpeg(packet->pts - start,
+							   stream->time_base));
+	}
 
 	AVPacket packet2 = *packet;
 
@@ -423,10 +426,15 @@ ffmpeg_probe(Decoder *decoder, InputStream &is)
 	avpd.filename = is.GetURI();
 
 #ifdef AVPROBE_SCORE_MIME
+#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(56, 5, 1)
 	/* this attribute was added in libav/ffmpeg version 11, but
 	   unfortunately it's "uint8_t" instead of "char", and it's
 	   not "const" - wtf? */
 	avpd.mime_type = (uint8_t *)const_cast<char *>(is.GetMimeType());
+#else
+	/* API problem fixed in FFmpeg 2.5 */
+	avpd.mime_type = is.GetMimeType();
+#endif
 #endif
 
 	return av_probe_input_format(&avpd, true);

src/event/Loop.cxx

@@ -179,9 +179,10 @@ EventLoop::Run()
 		mutex.lock();
 		HandleDeferred();
 		busy = false;
+		const bool _again = again;
 		mutex.unlock();
 
-		if (again)
+		if (_again)
 			/* re-evaluate timers because one of the
 			   IdleMonitors may have added a new
 			   timeout */

src/input/Init.cxx

@@ -67,7 +67,7 @@ input_stream_global_init(Error &error)
 		case InputPlugin::InitResult::UNAVAILABLE:
 			if (error.IsDefined()) {
 				FormatError(error,
-					    "Input plugin '%s' is unavailable: ",
+					    "Input plugin '%s' is unavailable",
 					    plugin->name);
 				error.Clear();
 			}

src/lib/nfs/Blocking.cxx

@@ -20,7 +20,9 @@
 #include "config.h"
 #include "Blocking.hxx"
 #include "Connection.hxx"
+#include "Domain.hxx"
 #include "event/Call.hxx"
+#include "util/Error.hxx"
 
 bool
 BlockingNfsOperation::Run(Error &_error)
@@ -31,7 +33,10 @@ BlockingNfsOperation::Run(Error &_error)
 		    [this](){ connection.AddLease(*this); });
 
 	/* wait for completion */
-	LockWaitFinished();
+	if (!LockWaitFinished()) {
+		_error.Set(nfs_domain, 0, "Timeout");
+		return false;
+	}
 
 	/* check for error */
 	if (error.IsDefined()) {

src/lib/nfs/Blocking.hxx

@@ -35,6 +35,8 @@ class NfsConnection;
  * thread, and method Run() waits for completion.
  */
 class BlockingNfsOperation : protected NfsCallback, NfsLease {
+	static constexpr unsigned timeout_ms = 60000;
+
 	Mutex mutex;
 	Cond cond;
 
@@ -52,10 +54,13 @@ public:
 	bool Run(Error &error);
 
 private:
-	void LockWaitFinished() {
+	bool LockWaitFinished() {
 		const ScopeLock protect(mutex);
 		while (!finished)
-			cond.wait(mutex);
+			if (!cond.timed_wait(mutex, timeout_ms))
+				return false;
+
+		return true;
 	}
 
 	/**

src/lib/nfs/Cancellable.hxx

@@ -157,6 +157,12 @@ public:
 
 		return *i;
 	}
+
+	template<typename F>
+	void ForEach(F &&f) {
+		for (CT &i : list)
+			f(i);
+	}
 };
 
 #endif

src/lib/nfs/Connection.cxx

@@ -34,11 +34,15 @@ extern "C" {
 
 #include <poll.h> /* for POLLIN, POLLOUT */
 
+static constexpr unsigned NFS_MOUNT_TIMEOUT = 60;
+
 inline bool
 NfsConnection::CancellableCallback::Stat(nfs_context *ctx,
 					 const char *path,
 					 Error &error)
 {
+	assert(connection.GetEventLoop().IsInside());
+
 	int result = nfs_stat_async(ctx, path, Callback, this);
 	if (result < 0) {
 		error.Format(nfs_domain, "nfs_stat_async() failed: %s",
@@ -54,6 +58,8 @@ NfsConnection::CancellableCallback::OpenDirectory(nfs_context *ctx,
 						  const char *path,
 						  Error &error)
 {
+	assert(connection.GetEventLoop().IsInside());
+
 	int result = nfs_opendir_async(ctx, path, Callback, this);
 	if (result < 0) {
 		error.Format(nfs_domain, "nfs_opendir_async() failed: %s",
@@ -69,6 +75,8 @@ NfsConnection::CancellableCallback::Open(nfs_context *ctx,
 					 const char *path, int flags,
 					 Error &error)
 {
+	assert(connection.GetEventLoop().IsInside());
+
 	int result = nfs_open_async(ctx, path, flags,
 				    Callback, this);
 	if (result < 0) {
@@ -85,6 +93,8 @@ NfsConnection::CancellableCallback::Stat(nfs_context *ctx,
 					 struct nfsfh *fh,
 					 Error &error)
 {
+	assert(connection.GetEventLoop().IsInside());
+
 	int result = nfs_fstat_async(ctx, fh, Callback, this);
 	if (result < 0) {
 		error.Format(nfs_domain, "nfs_fstat_async() failed: %s",
@@ -100,6 +110,8 @@ NfsConnection::CancellableCallback::Read(nfs_context *ctx, struct nfsfh *fh,
 					 uint64_t offset, size_t size,
 					 Error &error)
 {
+	assert(connection.GetEventLoop().IsInside());
+
 	int result = nfs_pread_async(ctx, fh, offset, size, Callback, this);
 	if (result < 0) {
 		error.Format(nfs_domain, "nfs_pread_async() failed: %s",
@@ -113,6 +125,7 @@ NfsConnection::CancellableCallback::Read(nfs_context *ctx, struct nfsfh *fh,
 inline void
 NfsConnection::CancellableCallback::CancelAndScheduleClose(struct nfsfh *fh)
 {
+	assert(connection.GetEventLoop().IsInside());
 	assert(!open);
 	assert(close_fh == nullptr);
 	assert(fh != nullptr);
@@ -121,9 +134,22 @@ NfsConnection::CancellableCallback::CancelAndScheduleClose(struct nfsfh *fh)
 	Cancel();
 }
 
+inline void
+NfsConnection::CancellableCallback::PrepareDestroyContext()
+{
+	assert(IsCancelled());
+
+	if (close_fh != nullptr) {
+		connection.InternalClose(close_fh);
+		close_fh = nullptr;
+	}
+}
+
 inline void
 NfsConnection::CancellableCallback::Callback(int err, void *data)
 {
+	assert(connection.GetEventLoop().IsInside());
+
 	if (!IsCancelled()) {
 		assert(close_fh == nullptr);
 
@@ -143,8 +169,10 @@ NfsConnection::CancellableCallback::Callback(int err, void *data)
 			   allocated file handle immediately */
 			assert(close_fh == nullptr);
 
-			struct nfsfh *fh = (struct nfsfh *)data;
-			connection.Close(fh);
+			if (err >= 0) {
+				struct nfsfh *fh = (struct nfsfh *)data;
+				connection.Close(fh);
+			}
 		} else if (close_fh != nullptr)
 			connection.DeferClose(close_fh);
 
@@ -209,6 +237,7 @@ NfsConnection::RemoveLease(NfsLease &lease)
 bool
 NfsConnection::Stat(const char *path, NfsCallback &callback, Error &error)
 {
+	assert(GetEventLoop().IsInside());
 	assert(!callbacks.Contains(callback));
 
 	auto &c = callbacks.Add(callback, *this, false);
@@ -225,6 +254,7 @@ bool
 NfsConnection::OpenDirectory(const char *path, NfsCallback &callback,
 			     Error &error)
 {
+	assert(GetEventLoop().IsInside());
 	assert(!callbacks.Contains(callback));
 
 	auto &c = callbacks.Add(callback, *this, true);
@@ -240,12 +270,16 @@ NfsConnection::OpenDirectory(const char *path, NfsCallback &callback,
 const struct nfsdirent *
 NfsConnection::ReadDirectory(struct nfsdir *dir)
 {
+	assert(GetEventLoop().IsInside());
+
 	return nfs_readdir(context, dir);
 }
 
 void
 NfsConnection::CloseDirectory(struct nfsdir *dir)
 {
+	assert(GetEventLoop().IsInside());
+
 	return nfs_closedir(context, dir);
 }
 
@@ -253,6 +287,7 @@ bool
 NfsConnection::Open(const char *path, int flags, NfsCallback &callback,
 		    Error &error)
 {
+	assert(GetEventLoop().IsInside());
 	assert(!callbacks.Contains(callback));
 
 	auto &c = callbacks.Add(callback, *this, true);
@@ -268,6 +303,7 @@ NfsConnection::Open(const char *path, int flags, NfsCallback &callback,
 bool
 NfsConnection::Stat(struct nfsfh *fh, NfsCallback &callback, Error &error)
 {
+	assert(GetEventLoop().IsInside());
 	assert(!callbacks.Contains(callback));
 
 	auto &c = callbacks.Add(callback, *this, false);
@@ -284,6 +320,7 @@ bool
 NfsConnection::Read(struct nfsfh *fh, uint64_t offset, size_t size,
 		    NfsCallback &callback, Error &error)
 {
+	assert(GetEventLoop().IsInside());
 	assert(!callbacks.Contains(callback));
 
 	auto &c = callbacks.Add(callback, *this, false);
@@ -307,10 +344,22 @@ DummyCallback(int, struct nfs_context *, void *, void *)
 {
 }
 
+inline void
+NfsConnection::InternalClose(struct nfsfh *fh)
+{
+	assert(GetEventLoop().IsInside());
+	assert(context != nullptr);
+	assert(fh != nullptr);
+
+	nfs_close_async(context, fh, DummyCallback, nullptr);
+}
+
 void
 NfsConnection::Close(struct nfsfh *fh)
 {
-	nfs_close_async(context, fh, DummyCallback, nullptr);
+	assert(GetEventLoop().IsInside());
+
+	InternalClose(fh);
 	ScheduleSocket();
 }
 
@@ -327,12 +376,26 @@ NfsConnection::DestroyContext()
 	assert(GetEventLoop().IsInside());
 	assert(context != nullptr);
 
+#ifndef NDEBUG
+	assert(!in_destroy);
+	in_destroy = true;
+#endif
+
+	if (!mount_finished) {
+		assert(TimeoutMonitor::IsActive());
+		TimeoutMonitor::Cancel();
+	}
+
 	/* cancel pending DeferredMonitor that was scheduled to notify
 	   new leases */
 	DeferredMonitor::Cancel();
 
 	if (SocketMonitor::IsDefined())
-		SocketMonitor::Cancel();
+		SocketMonitor::Steal();
+
+	callbacks.ForEach([](CancellableCallback &c){
+			c.PrepareDestroyContext();
+		});
 
 	nfs_destroy_context(context);
 	context = nullptr;
@@ -341,8 +404,11 @@ NfsConnection::DestroyContext()
 inline void
 NfsConnection::DeferClose(struct nfsfh *fh)
 {
+	assert(GetEventLoop().IsInside());
 	assert(in_event);
 	assert(in_service);
+	assert(context != nullptr);
+	assert(fh != nullptr);
 
 	deferred_close.push_front(fh);
 }
@@ -350,6 +416,7 @@ NfsConnection::DeferClose(struct nfsfh *fh)
 void
 NfsConnection::ScheduleSocket()
 {
+	assert(GetEventLoop().IsInside());
 	assert(context != nullptr);
 
 	if (!SocketMonitor::IsDefined()) {
@@ -364,9 +431,35 @@ NfsConnection::ScheduleSocket()
 	SocketMonitor::Schedule(libnfs_to_events(nfs_which_events(context)));
 }
 
+inline int
+NfsConnection::Service(unsigned flags)
+{
+	assert(GetEventLoop().IsInside());
+	assert(context != nullptr);
+
+#ifndef NDEBUG
+	assert(!in_event);
+	in_event = true;
+
+	assert(!in_service);
+	in_service = true;
+#endif
+
+	int result = nfs_service(context, events_to_libnfs(flags));
+
+#ifndef NDEBUG
+	assert(context != nullptr);
+	assert(in_service);
+	in_service = false;
+#endif
+
+	return result;
+}
+
 bool
 NfsConnection::OnSocketReady(unsigned flags)
 {
+	assert(GetEventLoop().IsInside());
 	assert(deferred_close.empty());
 
 	bool closed = false;
@@ -378,21 +471,10 @@ NfsConnection::OnSocketReady(unsigned flags)
 		   re-register it each time */
 		SocketMonitor::Steal();
 
-	assert(!in_event);
-	in_event = true;
-
-	assert(!in_service);
-	in_service = true;
-
-	int result = nfs_service(context, events_to_libnfs(flags));
-
-	assert(context != nullptr);
-	assert(in_service);
-	in_service = false;
+	const int result = Service(flags);
 
 	while (!deferred_close.empty()) {
-		nfs_close_async(context, deferred_close.front(),
-				DummyCallback, nullptr);
+		InternalClose(deferred_close.front());
 		deferred_close.pop_front();
 	}
 
@@ -413,9 +495,9 @@ NfsConnection::OnSocketReady(unsigned flags)
 
 		DestroyContext();
 		closed = true;
-	} else if (SocketMonitor::IsDefined() && nfs_get_fd(context) < 0) {
+	} else if (nfs_get_fd(context) < 0) {
 		/* this happens when rpc_reconnect_requeue() is called
-		   after the connection broke, but autoreconnet was
+		   after the connection broke, but autoreconnect was
 		   disabled - nfs_service() returns 0 */
 		Error error;
 		const char *msg = nfs_get_error(context);
@@ -431,8 +513,12 @@ NfsConnection::OnSocketReady(unsigned flags)
 		closed = true;
 	}
 
+	assert(context == nullptr || nfs_get_fd(context) >= 0);
+
+#ifndef NDEBUG
 	assert(in_event);
 	in_event = false;
+#endif
 
 	if (context != nullptr)
 		ScheduleSocket();
@@ -444,10 +530,14 @@ inline void
 NfsConnection::MountCallback(int status, gcc_unused nfs_context *nfs,
 			     gcc_unused void *data)
 {
+	assert(GetEventLoop().IsInside());
 	assert(context == nfs);
 
 	mount_finished = true;
 
+	assert(TimeoutMonitor::IsActive() || in_destroy);
+	TimeoutMonitor::Cancel();
+
 	if (status < 0) {
 		postponed_mount_error.Format(nfs_domain, status,
 					     "nfs_mount_async() failed: %s",
@@ -468,6 +558,7 @@ NfsConnection::MountCallback(int status, nfs_context *nfs, void *data,
 inline bool
 NfsConnection::MountInternal(Error &error)
 {
+	assert(GetEventLoop().IsInside());
 	assert(context == nullptr);
 
 	context = nfs_init_context();
@@ -478,8 +569,14 @@ NfsConnection::MountInternal(Error &error)
 
 	postponed_mount_error.Clear();
 	mount_finished = false;
+
+	TimeoutMonitor::ScheduleSeconds(NFS_MOUNT_TIMEOUT);
+
+#ifndef NDEBUG
 	in_service = false;
 	in_event = false;
+	in_destroy = false;
+#endif
 
 	if (nfs_mount_async(context, server.c_str(), export_name.c_str(),
 			    MountCallback, this) != 0) {
@@ -535,9 +632,23 @@ NfsConnection::BroadcastError(Error &&error)
 	BroadcastMountError(std::move(error));
 }
 
+void
+NfsConnection::OnTimeout()
+{
+	assert(GetEventLoop().IsInside());
+	assert(!mount_finished);
+
+	mount_finished = true;
+	DestroyContext();
+
+	BroadcastMountError(Error(nfs_domain, "Mount timeout"));
+}
+
 void
 NfsConnection::RunDeferred()
 {
+	assert(GetEventLoop().IsInside());
+
 	if (context == nullptr) {
 		Error error;
 		if (!MountInternal(error)) {

src/lib/nfs/Connection.hxx

@@ -23,6 +23,7 @@
 #include "Lease.hxx"
 #include "Cancellable.hxx"
 #include "event/SocketMonitor.hxx"
+#include "event/TimeoutMonitor.hxx"
 #include "event/DeferredMonitor.hxx"
 #include "util/Error.hxx"
 
@@ -40,7 +41,7 @@ class NfsCallback;
 /**
  * An asynchronous connection to a NFS server.
  */
-class NfsConnection : SocketMonitor, DeferredMonitor {
+class NfsConnection : SocketMonitor, TimeoutMonitor, DeferredMonitor {
 	class CancellableCallback : public CancellablePointer<NfsCallback> {
 		NfsConnection &connection;
 
@@ -84,6 +85,13 @@ class NfsConnection : SocketMonitor, DeferredMonitor {
 		 */
 		void CancelAndScheduleClose(struct nfsfh *fh);
 
+		/**
+		 * Called by NfsConnection::DestroyContext() right
+		 * before nfs_destroy_context().  This object is given
+		 * a chance to prepare for the latter.
+		 */
+		void PrepareDestroyContext();
+
 	private:
 		static void Callback(int err, struct nfs_context *nfs,
 				     void *data, void *private_data);
@@ -111,6 +119,7 @@ class NfsConnection : SocketMonitor, DeferredMonitor {
 
 	Error postponed_mount_error;
 
+#ifndef NDEBUG
 	/**
 	 * True when nfs_service() is being called.
 	 */
@@ -122,13 +131,20 @@ class NfsConnection : SocketMonitor, DeferredMonitor {
 	 */
 	bool in_event;
 
+	/**
+	 * True when DestroyContext() is being called.
+	 */
+	bool in_destroy;
+#endif
+
 	bool mount_finished;
 
 public:
 	gcc_nonnull_all
 	NfsConnection(EventLoop &_loop,
 		      const char *_server, const char *_export_name)
-		:SocketMonitor(_loop), DeferredMonitor(_loop),
+		:SocketMonitor(_loop), TimeoutMonitor(_loop),
+		 DeferredMonitor(_loop),
 		 server(_server), export_name(_export_name),
 		 context(nullptr) {}
 
@@ -184,6 +200,11 @@ protected:
 private:
 	void DestroyContext();
 
+	/**
+	 * Wrapper for nfs_close_async().
+	 */
+	void InternalClose(struct nfsfh *fh);
+
 	/**
 	 * Invoke nfs_close_async() after nfs_service() returns.
 	 */
@@ -200,9 +221,17 @@ private:
 
 	void ScheduleSocket();
 
+	/**
+	 * Wrapper for nfs_service().
+	 */
+	int Service(unsigned flags);
+
 	/* virtual methods from SocketMonitor */
 	virtual bool OnSocketReady(unsigned flags) override;
 
+	/* virtual methods from TimeoutMonitor */
+	void OnTimeout() final;
+
 	/* virtual methods from DeferredMonitor */
 	virtual void RunDeferred() override;
 };

src/output/Init.cxx

@@ -48,6 +48,7 @@
 
 AudioOutput::AudioOutput(const AudioOutputPlugin &_plugin)
 	:plugin(_plugin),
+	 mixer(nullptr),
 	 enabled(true), really_enabled(false),
 	 open(false),
 	 pause(false),

src/playlist/Print.cxx

@@ -43,12 +43,13 @@ playlist_provider_print(Client &client, const char *uri,
 	DetachedSong *song;
 	while ((song = e.NextSong()) != nullptr) {
 		if (playlist_check_translate_song(*song, base_uri.c_str(),
-						  loader)) {
-			if (detail)
-				song_print_info(client, *song);
-			else
-				song_print_uri(client, *song);
-		}
+						  loader) &&
+		    detail)
+			song_print_info(client, *song);
+		else
+			/* fallback if no detail was requested or no
+			   detail was available */
+			song_print_uri(client, *song);
 
 		delete song;
 	}

src/playlist/plugins/EmbeddedCuePlaylistPlugin.cxx

@@ -178,7 +178,7 @@ const struct playlist_plugin embcue_playlist_plugin = {
 	embcue_playlist_open_uri,
 	nullptr,
 
+	nullptr,
 	embcue_playlist_suffixes,
 	nullptr,
-	nullptr,
 };

src/storage/plugins/NfsStorage.cxx

@@ -146,6 +146,7 @@ private:
 
 		const ScopeLock protect(mutex);
 		state = _state;
+		last_error.Clear();
 		last_error.Set(error);
 		cond.broadcast();
 	}

src/thread/Id.hxx

@@ -75,7 +75,7 @@ public:
 #ifdef WIN32
 		return ::GetCurrentThreadId();
 #else
-		return ::pthread_self();
+		return pthread_self();
 #endif
 	}
 
@@ -84,7 +84,7 @@ public:
 #ifdef WIN32
 		return id == other.id;
 #else
-		return ::pthread_equal(id, other.id);
+		return pthread_equal(id, other.id);
 #endif
 	}
 

src/util/HugeAllocator.hxx

@@ -70,7 +70,10 @@ gcc_malloc
 static inline void *
 HugeAllocate(size_t size)
 {
-	return VirtualAlloc(nullptr, size, MEM_LARGE_PAGES, PAGE_READWRITE);
+	// TODO: use MEM_LARGE_PAGES
+	return VirtualAlloc(nullptr, size,
+			    MEM_COMMIT|MEM_RESERVE,
+			    PAGE_READWRITE);
 }
 
 static inline void