Filter: FilterPCM() returns ConstBuffer

API simplification.  We can now avoid abusing a "size_t*" as
additional return value.

src/filter/FilterInternal.hxx

@@ -29,6 +29,7 @@
 
 struct AudioFormat;
 class Error;
+template<typename T> struct ConstBuffer;
 
 class Filter {
 public:
@@ -58,17 +59,13 @@ public:
 	 *
 	 * @param filter the filter object
 	 * @param src the input buffer
-	 * @param src_size the size of #src_buffer in bytes
-	 * @param dest_size_r the size of the returned buffer
 	 * @param error location to store the error occurring, or nullptr
 	 * to ignore errors.
 	 * @return the destination buffer on success (will be
 	 * invalidated by Close() or FilterPCM()), nullptr on
 	 * error
 	 */
-	virtual const void *FilterPCM(const void *src, size_t src_size,
-				      size_t *dest_size_r,
-				      Error &error) = 0;
+	virtual ConstBuffer<void> FilterPCM(ConstBuffer<void> src, Error &error) = 0;
 };
 
 #endif

src/filter/plugins/AutoConvertFilterPlugin.cxx

@@ -25,6 +25,7 @@
 #include "filter/FilterRegistry.hxx"
 #include "AudioFormat.hxx"
 #include "config/ConfigData.hxx"
+#include "util/ConstBuffer.hxx"
 
 #include <assert.h>
 
@@ -48,9 +49,8 @@ public:
 
 	virtual AudioFormat Open(AudioFormat &af, Error &error) override;
 	virtual void Close() override;
-	virtual const void *FilterPCM(const void *src, size_t src_size,
-				      size_t *dest_size_r,
-				      Error &error) override;
+	virtual ConstBuffer<void> FilterPCM(ConstBuffer<void> src,
+					    Error &error) override;
 };
 
 AudioFormat
@@ -111,17 +111,16 @@ AutoConvertFilter::Close()
 	filter->Close();
 }
 
-const void *
-AutoConvertFilter::FilterPCM(const void *src, size_t src_size,
-			     size_t *dest_size_r, Error &error)
+ConstBuffer<void>
+AutoConvertFilter::FilterPCM(ConstBuffer<void> src, Error &error)
 {
 	if (convert != nullptr) {
-		src = convert->FilterPCM(src, src_size, &src_size, error);
-		if (src == nullptr)
+		src = convert->FilterPCM(src, error);
+		if (src.IsNull())
 			return nullptr;
 	}
 
-	return filter->FilterPCM(src, src_size, dest_size_r, error);
+	return filter->FilterPCM(src, error);
 }
 
 Filter *

src/filter/plugins/ChainFilterPlugin.cxx

@@ -25,6 +25,7 @@
 #include "AudioFormat.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
+#include "util/ConstBuffer.hxx"
 
 #include <list>
 
@@ -54,8 +55,8 @@ public:
 
 	virtual AudioFormat Open(AudioFormat &af, Error &error) override;
 	virtual void Close();
-	virtual const void *FilterPCM(const void *src, size_t src_size,
-				      size_t *dest_size_r, Error &error);
+	virtual ConstBuffer<void> FilterPCM(ConstBuffer<void> src,
+					    Error &error);
 
 private:
 	/**
@@ -143,21 +144,18 @@ ChainFilter::Close()
 		child.filter->Close();
 }
 
-const void *
-ChainFilter::FilterPCM(const void *src, size_t src_size,
-		       size_t *dest_size_r, Error &error)
+ConstBuffer<void>
+ChainFilter::FilterPCM(ConstBuffer<void> src, Error &error)
 {
 	for (auto &child : children) {
 		/* feed the output of the previous filter as input
 		   into the current one */
-		src = child.filter->FilterPCM(src, src_size, &src_size,
-					      error);
-		if (src == nullptr)
+		src = child.filter->FilterPCM(src, error);
+		if (src.IsNull())
 			return nullptr;
 	}
 
 	/* return the output of the last filter */
-	*dest_size_r = src_size;
 	return src;
 }
 

src/filter/plugins/ConvertFilterPlugin.cxx

@@ -54,9 +54,8 @@ public:
 
 	virtual AudioFormat Open(AudioFormat &af, Error &error) override;
 	virtual void Close() override;
-	virtual const void *FilterPCM(const void *src, size_t src_size,
-				      size_t *dest_size_r,
-				      Error &error) override;
+	virtual ConstBuffer<void> FilterPCM(ConstBuffer<void> src,
+					    Error &error) override;
 };
 
 static Filter *
@@ -119,21 +118,16 @@ ConvertFilter::Close()
 	poison_undefined(&out_audio_format, sizeof(out_audio_format));
 }
 
-const void *
-ConvertFilter::FilterPCM(const void *src, size_t src_size,
-			 size_t *dest_size_r, Error &error)
+ConstBuffer<void>
+ConvertFilter::FilterPCM(ConstBuffer<void> src, Error &error)
 {
 	assert(in_audio_format.IsValid());
 
-	if (!out_audio_format.IsValid()) {
+	if (!out_audio_format.IsValid())
 		/* optimized special case: no-op */
-		*dest_size_r = src_size;
 		return src;
-	}
 
-	auto result = state->Convert({src, src_size}, error);
-	*dest_size_r = result.size;
-	return result.data;
+	return state->Convert(src, error);
 }
 
 const struct filter_plugin convert_filter_plugin = {

src/filter/plugins/NormalizeFilterPlugin.cxx

@@ -24,6 +24,7 @@
 #include "pcm/PcmBuffer.hxx"
 #include "AudioFormat.hxx"
 #include "AudioCompress/compress.h"
+#include "util/ConstBuffer.hxx"
 
 #include <string.h>
 
@@ -35,8 +36,8 @@ class NormalizeFilter final : public Filter {
 public:
 	virtual AudioFormat Open(AudioFormat &af, Error &error) override;
 	virtual void Close();
-	virtual const void *FilterPCM(const void *src, size_t src_size,
-				      size_t *dest_size_r, Error &error);
+	virtual ConstBuffer<void> FilterPCM(ConstBuffer<void> src,
+					    Error &error) override;
 };
 
 static Filter *
@@ -63,17 +64,14 @@ NormalizeFilter::Close()
 	Compressor_delete(compressor);
 }
 
-const void *
-NormalizeFilter::FilterPCM(const void *src, size_t src_size,
-			   size_t *dest_size_r, gcc_unused Error &error)
+ConstBuffer<void>
+NormalizeFilter::FilterPCM(ConstBuffer<void> src, gcc_unused Error &error)
 {
-	int16_t *dest = (int16_t *)buffer.Get(src_size);
-	memcpy(dest, src, src_size);
+	int16_t *dest = (int16_t *)buffer.Get(src.size);
+	memcpy(dest, src.data, src.size);
 
-	Compressor_Process_int16(compressor, dest, src_size / 2);
-
-	*dest_size_r = src_size;
-	return dest;
+	Compressor_Process_int16(compressor, dest, src.size / 2);
+	return { (const void *)dest, src.size };
 }
 
 const struct filter_plugin normalize_filter_plugin = {

src/filter/plugins/NullFilterPlugin.cxx

@@ -30,6 +30,7 @@
 #include "filter/FilterRegistry.hxx"
 #include "AudioFormat.hxx"
 #include "Compiler.h"
+#include "util/ConstBuffer.hxx"
 
 class NullFilter final : public Filter {
 public:
@@ -40,10 +41,8 @@ public:
 
 	virtual void Close() override {}
 
-	virtual const void *FilterPCM(const void *src, size_t src_size,
-				      size_t *dest_size_r,
-				      gcc_unused Error &error) override {
-		*dest_size_r = src_size;
+	virtual ConstBuffer<void> FilterPCM(ConstBuffer<void> src,
+					    gcc_unused Error &error) override {
 		return src;
 	}
 };

src/filter/plugins/ReplayGainFilterPlugin.cxx

@@ -114,8 +114,8 @@ public:
 
 	virtual AudioFormat Open(AudioFormat &af, Error &error) override;
 	virtual void Close();
-	virtual const void *FilterPCM(const void *src, size_t src_size,
-				      size_t *dest_size_r, Error &error);
+	virtual ConstBuffer<void> FilterPCM(ConstBuffer<void> src,
+					    Error &error) override;
 };
 
 void
@@ -170,13 +170,10 @@ ReplayGainFilter::Close()
 	pv.Close();
 }
 
-const void *
-ReplayGainFilter::FilterPCM(const void *src, size_t src_size,
-			    size_t *dest_size_r, gcc_unused Error &error)
+ConstBuffer<void>
+ReplayGainFilter::FilterPCM(ConstBuffer<void> src, gcc_unused Error &error)
 {
-	const auto dest = pv.Apply({src, src_size});
-	*dest_size_r = dest.size;
-	return dest.data;
+	return pv.Apply(src);
 }
 
 const struct filter_plugin replay_gain_filter_plugin = {

src/filter/plugins/RouteFilterPlugin.cxx

@@ -49,6 +49,7 @@
 #include "pcm/PcmBuffer.hxx"
 #include "util/StringUtil.hxx"
 #include "util/Error.hxx"
+#include "util/ConstBuffer.hxx"
 
 #include <algorithm>
 
@@ -121,8 +122,8 @@ public:
 
 	virtual AudioFormat Open(AudioFormat &af, Error &error) override;
 	virtual void Close();
-	virtual const void *FilterPCM(const void *src, size_t src_size,
-				      size_t *dest_size_r, Error &error);
+	virtual ConstBuffer<void> FilterPCM(ConstBuffer<void> src,
+					    Error &error) override;
 };
 
 bool
@@ -238,20 +239,19 @@ RouteFilter::Close()
 	output_buffer.Clear();
 }
 
-const void *
-RouteFilter::FilterPCM(const void *src, size_t src_size,
-		       size_t *dest_size_r, gcc_unused Error &error)
+ConstBuffer<void>
+RouteFilter::FilterPCM(ConstBuffer<void> src, gcc_unused Error &error)
 {
-	size_t number_of_frames = src_size / input_frame_size;
+	size_t number_of_frames = src.size / input_frame_size;
 
 	const size_t bytes_per_frame_per_channel = input_format.GetSampleSize();
 
 	// A moving pointer that always refers to channel 0 in the input, at the currently handled frame
-	const uint8_t *base_source = (const uint8_t *)src;
+	const uint8_t *base_source = (const uint8_t *)src.data;
 
 	// Grow our reusable buffer, if needed, and set the moving pointer
-	*dest_size_r = number_of_frames * output_frame_size;
-	void *const result = output_buffer.Get(*dest_size_r);
+	const size_t result_size = number_of_frames * output_frame_size;
+	void *const result = output_buffer.Get(result_size);
 
 	// A moving pointer that always refers to the currently filled channel of the currently handled frame, in the output
 	uint8_t *chan_destination = (uint8_t *)result;
@@ -287,7 +287,7 @@ RouteFilter::FilterPCM(const void *src, size_t src_size,
 	}
 
 	// Here it is, ladies and gentlemen! Rerouted data!
-	return result;
+	return { result, result_size };
 }
 
 const struct filter_plugin route_filter_plugin = {

src/filter/plugins/VolumeFilterPlugin.cxx

@@ -45,8 +45,8 @@ public:
 
 	virtual AudioFormat Open(AudioFormat &af, Error &error) override;
 	virtual void Close();
-	virtual const void *FilterPCM(const void *src, size_t src_size,
-				      size_t *dest_size_r, Error &error);
+	virtual ConstBuffer<void> FilterPCM(ConstBuffer<void> src,
+					    Error &error) override;
 };
 
 static constexpr Domain volume_domain("pcm_volume");
@@ -73,13 +73,10 @@ VolumeFilter::Close()
 	pv.Close();
 }
 
-const void *
-VolumeFilter::FilterPCM(const void *src, size_t src_size,
-			size_t *dest_size_r, gcc_unused Error &error)
+ConstBuffer<void>
+VolumeFilter::FilterPCM(ConstBuffer<void> src, gcc_unused Error &error)
 {
-	const auto dest = pv.Apply({src, src_size});
-	*dest_size_r = dest.size;
-	return dest.data;
+	return pv.Apply(src);
 }
 
 const struct filter_plugin volume_filter_plugin = {