InputStream: make various methods abstract

Replace InputPlugin attributes.

11 files changed, 184 insertions, 441 deletions

diff --git a/src/input/plugins/AlsaInputPlugin.cxx b/src/input/plugins/AlsaInputPlugin.cxx
index 2049c5635..b4673afcf 100644
--- a/src/input/plugins/AlsaInputPlugin.cxx
+++ b/src/input/plugins/AlsaInputPlugin.cxx
@@ -116,7 +116,13 @@ public:
 	static InputStream *Create(const char *uri, Mutex &mutex, Cond &cond,
 				   Error &error);
 
-	bool Available() {
+	/* virtual methods from InputStream */
+
+	bool IsEOF() override {
+		return eof;
+	}
+
+	bool IsAvailable() override {
 		if (snd_pcm_avail(capture_handle) > frames_to_read)
 			return true;
 
@@ -126,11 +132,7 @@ public:
 		return false;
 	}
 
-	size_t Read(void *ptr, size_t size, Error &error);
-
-	bool IsEOF() {
-		return eof;
-	}
+	size_t Read(void *ptr, size_t size, Error &error) override;
 
 private:
 	static snd_pcm_t *OpenDevice(const char *device, int rate,
@@ -181,7 +183,7 @@ AlsaInputStream::Create(const char *uri, Mutex &mutex, Cond &cond,
 				   handle, frame_size);
 }
 
-inline size_t
+size_t
 AlsaInputStream::Read(void *ptr, size_t read_size, Error &error)
 {
 	assert(ptr != nullptr);
@@ -373,37 +375,9 @@ alsa_input_open(const char *uri, Mutex &mutex, Cond &cond, Error &error)
 	return AlsaInputStream::Create(uri, mutex, cond, error);
 }
 
-static bool
-alsa_input_available(InputStream *is)
-{
-	AlsaInputStream *ais = (AlsaInputStream *)is;
-	return ais->Available();
-}
-
-static size_t
-alsa_input_read(InputStream *is, void *ptr, size_t size, Error &error)
-{
-	AlsaInputStream *ais = (AlsaInputStream *)is;
-	return ais->Read(ptr, size, error);
-}
-
-static bool
-alsa_input_eof(gcc_unused InputStream *is)
-{
-	AlsaInputStream *ais = (AlsaInputStream *)is;
-	return ais->IsEOF();
-}
-
 const struct InputPlugin input_plugin_alsa = {
 	"alsa",
 	nullptr,
 	nullptr,
 	alsa_input_open,
-	nullptr,
-	nullptr,
-	nullptr,
-	alsa_input_available,
-	alsa_input_read,
-	alsa_input_eof,
-	nullptr,
 };
diff --git a/src/input/plugins/ArchiveInputPlugin.cxx b/src/input/plugins/ArchiveInputPlugin.cxx
index 8a8be5b2f..b51dc6835 100644
--- a/src/input/plugins/ArchiveInputPlugin.cxx
+++ b/src/input/plugins/ArchiveInputPlugin.cxx
@@ -89,11 +89,4 @@ const InputPlugin input_plugin_archive = {
 	nullptr,
 	nullptr,
 	input_archive_open,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
 };
diff --git a/src/input/plugins/CdioParanoiaInputPlugin.cxx b/src/input/plugins/CdioParanoiaInputPlugin.cxx
index c5b238320..a5c848f68 100644
--- a/src/input/plugins/CdioParanoiaInputPlugin.cxx
+++ b/src/input/plugins/CdioParanoiaInputPlugin.cxx
@@ -79,6 +79,11 @@ struct CdioParanoiaInputStream final : public InputStream {
 		if (cdio != nullptr)
 			cdio_destroy(cdio);
 	}
+
+	/* virtual methods from InputStream */
+	bool IsEOF() override;
+	size_t Read(void *ptr, size_t size, Error &error) override;
+	bool Seek(offset_type offset, int whence, Error &error) override;
 };
 
 static constexpr Domain cdio_domain("cdio");
@@ -266,48 +271,44 @@ input_cdio_open(const char *uri,
 	return i;
 }
 
-static bool
-input_cdio_seek(InputStream *is,
-		InputPlugin::offset_type offset, int whence, Error &error)
+bool
+CdioParanoiaInputStream::Seek(InputPlugin::offset_type new_offset,
+			      int whence, Error &error)
 {
-	CdioParanoiaInputStream *cis = (CdioParanoiaInputStream *)is;
-
 	/* calculate absolute offset */
 	switch (whence) {
 	case SEEK_SET:
 		break;
 	case SEEK_CUR:
-		offset += cis->offset;
+		new_offset += offset;
 		break;
 	case SEEK_END:
-		offset += cis->size;
+		new_offset += size;
 		break;
 	}
 
-	if (offset < 0 || offset > cis->size) {
+	if (new_offset < 0 || new_offset > size) {
 		error.Format(cdio_domain, "Invalid offset to seek %ld (%ld)",
-			     (long int)offset, (long int)cis->size);
+			     (long int)new_offset, (long int)size);
 		return false;
 	}
 
 	/* simple case */
-	if (offset == cis->offset)
+	if (new_offset == offset)
 		return true;
 
 	/* calculate current LSN */
-	cis->lsn_relofs = offset / CDIO_CD_FRAMESIZE_RAW;
-	cis->offset = offset;
+	lsn_relofs = new_offset / CDIO_CD_FRAMESIZE_RAW;
+	offset = new_offset;
 
-	cdio_paranoia_seek(cis->para, cis->lsn_from + cis->lsn_relofs, SEEK_SET);
+	cdio_paranoia_seek(para, lsn_from + lsn_relofs, SEEK_SET);
 
 	return true;
 }
 
-static size_t
-input_cdio_read(InputStream *is, void *ptr, size_t length,
-		Error &error)
+size_t
+CdioParanoiaInputStream::Read(void *ptr, size_t length, Error &error)
 {
-	CdioParanoiaInputStream *cis = (CdioParanoiaInputStream *)is;
 	size_t nbytes = 0;
 	int diff;
 	size_t len, maxwrite;
@@ -319,20 +320,20 @@ input_cdio_read(InputStream *is, void *ptr, size_t length,
 
 
 		/* end of track ? */
-		if (cis->lsn_from + cis->lsn_relofs > cis->lsn_to)
+		if (lsn_from + lsn_relofs > lsn_to)
 			break;
 
 		//current sector was changed ?
-		if (cis->lsn_relofs != cis->buffer_lsn) {
-			rbuf = cdio_paranoia_read(cis->para, nullptr);
+		if (lsn_relofs != buffer_lsn) {
+			rbuf = cdio_paranoia_read(para, nullptr);
 
-			s_err = cdda_errors(cis->drv);
+			s_err = cdda_errors(drv);
 			if (s_err) {
 				FormatError(cdio_domain,
 					    "paranoia_read: %s", s_err);
 				free(s_err);
 			}
-			s_mess = cdda_messages(cis->drv);
+			s_mess = cdda_messages(drv);
 			if (s_mess) {
 				free(s_mess);
 			}
@@ -342,15 +343,15 @@ input_cdio_read(InputStream *is, void *ptr, size_t length,
 				return 0;
 			}
 			//store current buffer
-			memcpy(cis->buffer, rbuf, CDIO_CD_FRAMESIZE_RAW);
-			cis->buffer_lsn = cis->lsn_relofs;
+			memcpy(buffer, rbuf, CDIO_CD_FRAMESIZE_RAW);
+			buffer_lsn = lsn_relofs;
 		} else {
 			//use cached sector
-			rbuf = (int16_t*) cis->buffer;
+			rbuf = (int16_t *)buffer;
 		}
 
 		//correct offset
-		diff = cis->offset - cis->lsn_relofs * CDIO_CD_FRAMESIZE_RAW;
+		diff = offset - lsn_relofs * CDIO_CD_FRAMESIZE_RAW;
 
 		assert(diff >= 0 && diff < CDIO_CD_FRAMESIZE_RAW);
 
@@ -364,8 +365,8 @@ input_cdio_read(InputStream *is, void *ptr, size_t length,
 		nbytes += len;
 
 		//update offset
-		cis->offset += len;
-		cis->lsn_relofs = cis->offset / CDIO_CD_FRAMESIZE_RAW;
+		offset += len;
+		lsn_relofs = offset / CDIO_CD_FRAMESIZE_RAW;
 		//update length
 		length -= len;
 	}
@@ -373,12 +374,10 @@ input_cdio_read(InputStream *is, void *ptr, size_t length,
 	return nbytes;
 }
 
-static bool
-input_cdio_eof(InputStream *is)
+bool
+CdioParanoiaInputStream::IsEOF()
 {
-	CdioParanoiaInputStream *cis = (CdioParanoiaInputStream *)is;
-
-	return (cis->lsn_from + cis->lsn_relofs > cis->lsn_to);
+	return lsn_from + lsn_relofs > lsn_to;
 }
 
 const InputPlugin input_plugin_cdio_paranoia = {
@@ -386,11 +385,4 @@ const InputPlugin input_plugin_cdio_paranoia = {
 	input_cdio_init,
 	nullptr,
 	input_cdio_open,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	input_cdio_read,
-	input_cdio_eof,
-	input_cdio_seek,
 };
diff --git a/src/input/plugins/CurlInputPlugin.cxx b/src/input/plugins/CurlInputPlugin.cxx
index fa93a1d7e..bb7ddcfdb 100644
--- a/src/input/plugins/CurlInputPlugin.cxx
+++ b/src/input/plugins/CurlInputPlugin.cxx
@@ -120,23 +120,6 @@ struct CurlInputStream final : public InputStream {
 	static InputStream *Open(const char *url, Mutex &mutex, Cond &cond,
 				 Error &error);
 
-	bool Check(Error &error);
-
-	bool IsEOF() const {
-		return easy == nullptr && buffer.IsEmpty();
-	}
-
-	bool Seek(InputPlugin::offset_type offset, int whence, Error &error);
-
-	Tag *ReadTag();
-
-	bool IsAvailable() const {
-		return postponed_error.IsDefined() || easy == nullptr ||
-			!buffer.IsEmpty();
-	}
-
-	size_t Read(void *ptr, size_t size, Error &error);
-
 	bool InitEasy(Error &error);
 
 	/**
@@ -180,6 +163,23 @@ struct CurlInputStream final : public InputStream {
 	 * Runs in the I/O thread.  The caller must not hold locks.
 	 */
 	void RequestDone(CURLcode result, long status);
+
+	/* virtual methods from InputStream */
+	bool Check(Error &error) override;
+
+	bool IsEOF() override {
+		return easy == nullptr && buffer.IsEmpty();
+	}
+
+	Tag *ReadTag() override;
+
+	bool IsAvailable() override {
+		return postponed_error.IsDefined() || easy == nullptr ||
+			!buffer.IsEmpty();
+	}
+
+	size_t Read(void *ptr, size_t size, Error &error) override;
+	bool Seek(offset_type offset, int whence, Error &error) override;
 };
 
 class CurlMulti;
@@ -660,14 +660,7 @@ CurlInputStream::Check(Error &error)
 	return success;
 }
 
-static bool
-input_curl_check(InputStream *is, Error &error)
-{
-	CurlInputStream &c = *(CurlInputStream *)is;
-	return c.Check(error);
-}
-
-inline Tag *
+Tag *
 CurlInputStream::ReadTag()
 {
 	Tag *result = tag;
@@ -675,13 +668,6 @@ CurlInputStream::ReadTag()
 	return result;
 }
 
-static Tag *
-input_curl_tag(InputStream *is)
-{
-	CurlInputStream &c = *(CurlInputStream *)is;
-	return c.ReadTag();
-}
-
 inline bool
 CurlInputStream::FillBuffer(Error &error)
 {
@@ -758,14 +744,7 @@ CurlInputStream::CopyIcyTag()
 	tag = new_tag;
 }
 
-static bool
-input_curl_available(InputStream *is)
-{
-	const CurlInputStream &c = *(const CurlInputStream *)is;
-	return c.IsAvailable();
-}
-
-inline size_t
+size_t
 CurlInputStream::Read(void *ptr, size_t read_size, Error &error)
 {
 	size_t nbytes;
@@ -797,21 +776,6 @@ CurlInputStream::Read(void *ptr, size_t read_size, Error &error)
 	return nbytes;
 }
 
-static size_t
-input_curl_read(InputStream *is, void *ptr, size_t size,
-		Error &error)
-{
-	CurlInputStream &c = *(CurlInputStream *)is;
-	return c.Read(ptr, size, error);
-}
-
-static bool
-input_curl_eof(gcc_unused InputStream *is)
-{
-	const CurlInputStream &c = *(const CurlInputStream *)is;
-	return c.IsEOF();
-}
-
 inline void
 CurlInputStream::HeaderReceived(const char *name, std::string &&value)
 {
@@ -1091,15 +1055,6 @@ CurlInputStream::Seek(InputPlugin::offset_type new_offset, int whence,
 	return true;
 }
 
-static bool
-input_curl_seek(InputStream *is, InputPlugin::offset_type offset,
-		int whence,
-		Error &error)
-{
-	CurlInputStream &c = *(CurlInputStream *)is;
-	return c.Seek(offset, whence, error);
-}
-
 inline InputStream *
 CurlInputStream::Open(const char *url, Mutex &mutex, Cond &cond,
 		      Error &error)
@@ -1136,11 +1091,4 @@ const struct InputPlugin input_plugin_curl = {
 	input_curl_init,
 	input_curl_finish,
 	input_curl_open,
-	input_curl_check,
-	nullptr,
-	input_curl_tag,
-	input_curl_available,
-	input_curl_read,
-	input_curl_eof,
-	input_curl_seek,
 };
diff --git a/src/input/plugins/DespotifyInputPlugin.cxx b/src/input/plugins/DespotifyInputPlugin.cxx
index 86fbbbad3..faceb6057 100644
--- a/src/input/plugins/DespotifyInputPlugin.cxx
+++ b/src/input/plugins/DespotifyInputPlugin.cxx
@@ -66,13 +66,15 @@ public:
 	static InputStream *Open(const char *url, Mutex &mutex, Cond &cond,
 				 Error &error);
 
-	bool IsEOF() const {
+	void Callback(int sig);
+
+	/* virtual methods from InputStream */
+
+	bool IsEOF() override {
 		return eof;
 	}
 
-	size_t Read(void *ptr, size_t size, Error &error);
-
-	Tag *ReadTag() {
+	Tag *ReadTag() override {
 		if (tag.IsEmpty())
 			return nullptr;
 
@@ -81,7 +83,7 @@ public:
 		return result;
 	}
 
-	void Callback(int sig);
+	size_t Read(void *ptr, size_t size, Error &error) override;
 
 private:
 	void FillBuffer();
@@ -201,7 +203,7 @@ input_despotify_open(const char *url, Mutex &mutex, Cond &cond, Error &error)
 	return DespotifyInputStream::Open(url, mutex, cond, error);
 }
 
-inline size_t
+size_t
 DespotifyInputStream::Read(void *ptr, size_t read_size,
 			   gcc_unused Error &error)
 {
@@ -217,39 +219,9 @@ DespotifyInputStream::Read(void *ptr, size_t read_size,
 	return to_cpy;
 }
 
-static size_t
-input_despotify_read(InputStream *is, void *ptr, size_t size, Error &error)
-{
-	DespotifyInputStream *ctx = (DespotifyInputStream *)is;
-	return ctx->Read(ptr, size, error);
-}
-
-static bool
-input_despotify_eof(InputStream *is)
-{
-	DespotifyInputStream *ctx = (DespotifyInputStream *)is;
-
-	return ctx->IsEOF();
-}
-
-static Tag *
-input_despotify_tag(InputStream *is)
-{
-	DespotifyInputStream *ctx = (DespotifyInputStream *)is;
-
-	return ctx->ReadTag();
-}
-
 const InputPlugin input_plugin_despotify = {
 	"despotify",
 	nullptr,
 	nullptr,
 	input_despotify_open,
-	nullptr,
-	nullptr,
-	input_despotify_tag,
-	nullptr,
-	input_despotify_read,
-	input_despotify_eof,
-	nullptr,
 };
diff --git a/src/input/plugins/FfmpegInputPlugin.cxx b/src/input/plugins/FfmpegInputPlugin.cxx
index 366a99f46..de79a09ed 100644
--- a/src/input/plugins/FfmpegInputPlugin.cxx
+++ b/src/input/plugins/FfmpegInputPlugin.cxx
@@ -56,6 +56,11 @@ struct FfmpegInputStream final : public InputStream {
 	~FfmpegInputStream() {
 		avio_close(h);
 	}
+
+	/* virtual methods from InputStream */
+	bool IsEOF() override;
+	size_t Read(void *ptr, size_t size, Error &error) override;
+	bool Seek(offset_type offset, int whence, Error &error) override;
 };
 
 static constexpr Domain ffmpeg_domain("ffmpeg");
@@ -106,43 +111,35 @@ input_ffmpeg_open(const char *uri,
 	return new FfmpegInputStream(uri, mutex, cond, h);
 }
 
-static size_t
-input_ffmpeg_read(InputStream *is, void *ptr, size_t size,
-		  Error &error)
+size_t
+FfmpegInputStream::Read(void *ptr, size_t read_size, Error &error)
 {
-	FfmpegInputStream *i = (FfmpegInputStream *)is;
-
-	int ret = avio_read(i->h, (unsigned char *)ptr, size);
+	int ret = avio_read(h, (unsigned char *)ptr, read_size);
 	if (ret <= 0) {
 		if (ret < 0)
 			error.Set(ffmpeg_domain, "avio_read() failed");
 
-		i->eof = true;
+		eof = true;
 		return false;
 	}
 
-	is->offset += ret;
+	offset += ret;
 	return (size_t)ret;
 }
 
-static bool
-input_ffmpeg_eof(InputStream *is)
+bool
+FfmpegInputStream::IsEOF()
 {
-	FfmpegInputStream *i = (FfmpegInputStream *)is;
-
-	return i->eof;
+	return eof;
 }
 
-static bool
-input_ffmpeg_seek(InputStream *is, InputPlugin::offset_type offset,
-		  int whence,
-		  Error &error)
+bool
+FfmpegInputStream::Seek(offset_type new_offset, int whence, Error &error)
 {
-	FfmpegInputStream *i = (FfmpegInputStream *)is;
-	int64_t ret = avio_seek(i->h, offset, whence);
+	int64_t ret = avio_seek(h, new_offset, whence);
 
 	if (ret >= 0) {
-		i->eof = false;
+		eof = false;
 		return true;
 	} else {
 		error.Set(ffmpeg_domain, "avio_seek() failed");
@@ -155,11 +152,4 @@ const InputPlugin input_plugin_ffmpeg = {
 	input_ffmpeg_init,
 	nullptr,
 	input_ffmpeg_open,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	input_ffmpeg_read,
-	input_ffmpeg_eof,
-	input_ffmpeg_seek,
 };
diff --git a/src/input/plugins/FileInputPlugin.cxx b/src/input/plugins/FileInputPlugin.cxx
index e96347c6e..7c7b4e85f 100644
--- a/src/input/plugins/FileInputPlugin.cxx
+++ b/src/input/plugins/FileInputPlugin.cxx
@@ -48,6 +48,15 @@ struct FileInputStream final : public InputStream {
 	~FileInputStream() {
 		close(fd);
 	}
+
+	/* virtual methods from InputStream */
+
+	bool IsEOF() override {
+		return GetOffset() >= GetSize();
+	}
+
+	size_t Read(void *ptr, size_t size, Error &error) override;
+	bool Seek(offset_type offset, int whence, Error &error) override;
 };
 
 static InputStream *
@@ -89,56 +98,37 @@ input_file_open(const char *filename,
 	return new FileInputStream(filename, fd, st.st_size, mutex, cond);
 }
 
-static bool
-input_file_seek(InputStream *is, InputPlugin::offset_type offset,
-		int whence,
-		Error &error)
+bool
+FileInputStream::Seek(InputPlugin::offset_type new_offset, int whence,
+		      Error &error)
 {
-	FileInputStream *fis = (FileInputStream *)is;
-
-	offset = (InputPlugin::offset_type)lseek(fis->fd, (off_t)offset, whence);
-	if (offset < 0) {
+	new_offset = (InputPlugin::offset_type)lseek(fd, (off_t)new_offset,
+						     whence);
+	if (new_offset < 0) {
 		error.SetErrno("Failed to seek");
 		return false;
 	}
 
-	is->offset = offset;
+	offset = new_offset;
 	return true;
 }
 
-static size_t
-input_file_read(InputStream *is, void *ptr, size_t size,
-		Error &error)
+size_t
+FileInputStream::Read(void *ptr, size_t read_size, Error &error)
 {
-	FileInputStream *fis = (FileInputStream *)is;
-	ssize_t nbytes;
-
-	nbytes = read(fis->fd, ptr, size);
+	ssize_t nbytes = read(fd, ptr, read_size);
 	if (nbytes < 0) {
 		error.SetErrno("Failed to read");
 		return 0;
 	}
 
-	is->offset += nbytes;
+	offset += nbytes;
 	return (size_t)nbytes;
 }
 
-static bool
-input_file_eof(InputStream *is)
-{
-	return is->GetOffset() >= is->GetSize();
-}
-
 const InputPlugin input_plugin_file = {
 	"file",
 	nullptr,
 	nullptr,
 	input_file_open,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	input_file_read,
-	input_file_eof,
-	input_file_seek,
 };
diff --git a/src/input/plugins/MmsInputPlugin.cxx b/src/input/plugins/MmsInputPlugin.cxx
index a5d4bc09d..b1ff6a890 100644
--- a/src/input/plugins/MmsInputPlugin.cxx
+++ b/src/input/plugins/MmsInputPlugin.cxx
@@ -40,7 +40,8 @@ public:
 
 protected:
 	virtual bool Open(gcc_unused Error &error) override;
-	virtual size_t Read(void *ptr, size_t size, Error &error) override;
+	virtual size_t ThreadRead(void *ptr, size_t size,
+				  Error &error) override;
 
 	virtual void Close() {
 		mmsx_close(mms);
@@ -89,7 +90,7 @@ input_mms_open(const char *url,
 }
 
 size_t
-MmsInputStream::Read(void *ptr, size_t read_size, Error &error)
+MmsInputStream::ThreadRead(void *ptr, size_t read_size, Error &error)
 {
 	int nbytes = mmsx_read(nullptr, mms, (char *)ptr, read_size);
 	if (nbytes <= 0) {
@@ -106,11 +107,4 @@ const InputPlugin input_plugin_mms = {
 	nullptr,
 	nullptr,
 	input_mms_open,
-	ThreadInputStream::Check,
-	nullptr,
-	nullptr,
-	ThreadInputStream::Available,
-	ThreadInputStream::Read,
-	ThreadInputStream::IsEOF,
-	nullptr,
 };
diff --git a/src/input/plugins/NfsInputPlugin.cxx b/src/input/plugins/NfsInputPlugin.cxx
index 19eda0605..d667e8f2d 100644
--- a/src/input/plugins/NfsInputPlugin.cxx
+++ b/src/input/plugins/NfsInputPlugin.cxx
@@ -54,33 +54,42 @@ public:
 		nfs_destroy_context(ctx);
 	}
 
-	bool IsEOF() const {
+	/* virtual methods from InputStream */
+
+	bool IsEOF() override {
 		return offset >= size;
 	}
 
-	size_t Read(void *ptr, size_t read_size, Error &error) {
-		int nbytes = nfs_read(ctx, fh, read_size, (char *)ptr);
-		if (nbytes < 0) {
-			error.SetErrno(-nbytes, "nfs_read() failed");
-			nbytes = 0;
-		}
+	size_t Read(void *ptr, size_t size, Error &error) override;
+	bool Seek(offset_type offset, int whence, Error &error) override;
+};
 
-		return nbytes;
+size_t
+NfsInputStream::Read(void *ptr, size_t read_size, Error &error)
+{
+	int nbytes = nfs_read(ctx, fh, read_size, (char *)ptr);
+	if (nbytes < 0) {
+		error.SetErrno(-nbytes, "nfs_read() failed");
+		nbytes = 0;
 	}
 
-	bool Seek(InputStream::offset_type new_offset, int whence, Error &error) {
-		uint64_t current_offset;
-		int result = nfs_lseek(ctx, fh, new_offset, whence,
-				       &current_offset);
-		if (result < 0) {
-			error.SetErrno(-result, "smbc_lseek() failed");
-			return false;
-		}
-
-		offset = current_offset;
-		return true;
+	return nbytes;
+}
+
+bool
+NfsInputStream::Seek(offset_type new_offset, int whence, Error &error)
+{
+	uint64_t current_offset;
+	int result = nfs_lseek(ctx, fh, new_offset, whence,
+			       &current_offset);
+	if (result < 0) {
+		error.SetErrno(-result, "smbc_lseek() failed");
+		return false;
 	}
-};
+
+	offset = current_offset;
+	return true;
+}
 
 /*
  * InputPlugin methods
@@ -148,40 +157,9 @@ input_nfs_open(const char *uri,
 	return new NfsInputStream(uri, mutex, cond, ctx, fh, st.st_size);
 }
 
-static size_t
-input_nfs_read(InputStream *is, void *ptr, size_t size,
-		     Error &error)
-{
-	NfsInputStream &s = *(NfsInputStream *)is;
-	return s.Read(ptr, size, error);
-}
-
-static bool
-input_nfs_eof(InputStream *is)
-{
-	NfsInputStream &s = *(NfsInputStream *)is;
-	return s.IsEOF();
-}
-
-static bool
-input_nfs_seek(InputStream *is,
-		     InputPlugin::offset_type offset, int whence,
-		     Error &error)
-{
-	NfsInputStream &s = *(NfsInputStream *)is;
-	return s.Seek(offset, whence, error);
-}
-
 const InputPlugin input_plugin_nfs = {
 	"nfs",
 	nullptr,
 	nullptr,
 	input_nfs_open,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	input_nfs_read,
-	input_nfs_eof,
-	input_nfs_seek,
 };
diff --git a/src/input/plugins/RewindInputPlugin.cxx b/src/input/plugins/RewindInputPlugin.cxx
index b1ec3ab62..b11fd8b80 100644
--- a/src/input/plugins/RewindInputPlugin.cxx
+++ b/src/input/plugins/RewindInputPlugin.cxx
@@ -26,7 +26,12 @@
 #include <string.h>
 #include <stdio.h>
 
-extern const InputPlugin rewind_input_plugin;
+static const InputPlugin rewind_input_plugin = {
+	nullptr,
+	nullptr,
+	nullptr,
+	nullptr,
+};
 
 class RewindInputStream final : public InputStream {
 	InputStream *input;
@@ -63,30 +68,31 @@ public:
 		delete input;
 	}
 
-	bool Check(Error &error) {
+	/* virtual methods from InputStream */
+
+	bool Check(Error &error) override {
 		return input->Check(error);
 	}
 
-	void Update() {
+	void Update() override {
 		if (!ReadingFromBuffer())
 			CopyAttributes();
 	}
 
-	Tag *ReadTag() {
-		return input->ReadTag();
+	bool IsEOF() override {
+		return !ReadingFromBuffer() && input->IsEOF();
 	}
 
-	bool IsAvailable() {
-		return input->IsAvailable();
+	Tag *ReadTag() override {
+		return input->ReadTag();
 	}
 
-	size_t Read(void *ptr, size_t size, Error &error);
-
-	bool IsEOF() {
-		return !ReadingFromBuffer() && input->IsEOF();
+	bool IsAvailable() override {
+		return input->IsAvailable();
 	}
 
-	bool Seek(InputPlugin::offset_type offset, int whence, Error &error);
+	size_t Read(void *ptr, size_t size, Error &error) override;
+	bool Seek(offset_type offset, int whence, Error &error) override;
 
 private:
 	/**
@@ -121,39 +127,7 @@ private:
 	}
 };
 
-static bool
-input_rewind_check(InputStream *is, Error &error)
-{
-	RewindInputStream *r = (RewindInputStream *)is;
-
-	return r->Check(error);
-}
-
-static void
-input_rewind_update(InputStream *is)
-{
-	RewindInputStream *r = (RewindInputStream *)is;
-
-	r->Update();
-}
-
-static Tag *
-input_rewind_tag(InputStream *is)
-{
-	RewindInputStream *r = (RewindInputStream *)is;
-
-	return r->ReadTag();
-}
-
-static bool
-input_rewind_available(InputStream *is)
-{
-	RewindInputStream *r = (RewindInputStream *)is;
-
-	return r->IsAvailable();
-}
-
-inline size_t
+size_t
 RewindInputStream::Read(void *ptr, size_t read_size, Error &error)
 {
 	if (ReadingFromBuffer()) {
@@ -193,23 +167,6 @@ RewindInputStream::Read(void *ptr, size_t read_size, Error &error)
 	}
 }
 
-static size_t
-input_rewind_read(InputStream *is, void *ptr, size_t size,
-		  Error &error)
-{
-	RewindInputStream *r = (RewindInputStream *)is;
-
-	return r->Read(ptr, size, error);
-}
-
-static bool
-input_rewind_eof(InputStream *is)
-{
-	RewindInputStream *r = (RewindInputStream *)is;
-
-	return r->IsEOF();
-}
-
 inline bool
 RewindInputStream::Seek(InputPlugin::offset_type new_offset, int whence,
 			Error &error)
@@ -240,30 +197,6 @@ RewindInputStream::Seek(InputPlugin::offset_type new_offset, int whence,
 	}
 }
 
-static bool
-input_rewind_seek(InputStream *is, InputPlugin::offset_type offset,
-		  int whence,
-		  Error &error)
-{
-	RewindInputStream *r = (RewindInputStream *)is;
-
-	return r->Seek(offset, whence, error);
-}
-
-const InputPlugin rewind_input_plugin = {
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	input_rewind_check,
-	input_rewind_update,
-	input_rewind_tag,
-	input_rewind_available,
-	input_rewind_read,
-	input_rewind_eof,
-	input_rewind_seek,
-};
-
 InputStream *
 input_rewind_open(InputStream *is)
 {
diff --git a/src/input/plugins/SmbclientInputPlugin.cxx b/src/input/plugins/SmbclientInputPlugin.cxx
index 07ffb83c4..01ee2616a 100644
--- a/src/input/plugins/SmbclientInputPlugin.cxx
+++ b/src/input/plugins/SmbclientInputPlugin.cxx
@@ -50,34 +50,14 @@ public:
 		smbclient_mutex.unlock();
 	}
 
-	bool IsEOF() const {
-		return offset >= size;
-	}
-
-	size_t Read(void *ptr, size_t read_size, Error &error) {
-		smbclient_mutex.lock();
-		ssize_t nbytes = smbc_read(fd, ptr, read_size);
-		smbclient_mutex.unlock();
-		if (nbytes < 0) {
-			error.SetErrno("smbc_read() failed");
-			nbytes = 0;
-		}
+	/* virtual methods from InputStream */
 
-		return nbytes;
+	bool IsEOF() override {
+		return offset >= size;
 	}
 
-	bool Seek(InputStream::offset_type new_offset, int whence, Error &error) {
-		smbclient_mutex.lock();
-		off_t result = smbc_lseek(fd, new_offset, whence);
-		smbclient_mutex.unlock();
-		if (result < 0) {
-			error.SetErrno("smbc_lseek() failed");
-			return false;
-		}
-
-		offset = result;
-		return true;
-	}
+	size_t Read(void *ptr, size_t size, Error &error) override;
+	bool Seek(offset_type offset, int whence, Error &error) override;
 };
 
 /*
@@ -141,28 +121,34 @@ input_smbclient_open(const char *uri,
 	return new SmbclientInputStream(uri, mutex, cond, ctx, fd, st);
 }
 
-static size_t
-input_smbclient_read(InputStream *is, void *ptr, size_t size,
-		     Error &error)
+size_t
+SmbclientInputStream::Read(void *ptr, size_t read_size, Error &error)
 {
-	SmbclientInputStream &s = *(SmbclientInputStream *)is;
-	return s.Read(ptr, size, error);
-}
+	smbclient_mutex.lock();
+	ssize_t nbytes = smbc_read(fd, ptr, read_size);
+	smbclient_mutex.unlock();
+	if (nbytes < 0) {
+		error.SetErrno("smbc_read() failed");
+		nbytes = 0;
+	}
 
-static bool
-input_smbclient_eof(InputStream *is)
-{
-	SmbclientInputStream &s = *(SmbclientInputStream *)is;
-	return s.IsEOF();
+	return nbytes;
 }
 
-static bool
-input_smbclient_seek(InputStream *is,
-		     InputPlugin::offset_type offset, int whence,
-		     Error &error)
+bool
+SmbclientInputStream::Seek(InputStream::offset_type new_offset,
+			   int whence, Error &error)
 {
-	SmbclientInputStream &s = *(SmbclientInputStream *)is;
-	return s.Seek(offset, whence, error);
+	smbclient_mutex.lock();
+	off_t result = smbc_lseek(fd, new_offset, whence);
+	smbclient_mutex.unlock();
+	if (result < 0) {
+		error.SetErrno("smbc_lseek() failed");
+		return false;
+	}
+
+	offset = result;
+	return true;
 }
 
 const InputPlugin input_plugin_smbclient = {
@@ -170,11 +156,4 @@ const InputPlugin input_plugin_smbclient = {
 	input_smbclient_init,
 	nullptr,
 	input_smbclient_open,
-	nullptr,
-	nullptr,
-	nullptr,
-	nullptr,
-	input_smbclient_read,
-	input_smbclient_eof,
-	input_smbclient_seek,
 };