1 files changed, 45 insertions, 82 deletions

diff --git a/src/filter/AutoConvertFilterPlugin.cxx b/src/filter/AutoConvertFilterPlugin.cxx
index 2a183b57..55ee4694 100644
--- a/src/filter/AutoConvertFilterPlugin.cxx
+++ b/src/filter/AutoConvertFilterPlugin.cxx
@@ -27,143 +27,106 @@
 
 #include <assert.h>
 
-struct AutoConvertFilter {
-	struct filter base;
-
+class AutoConvertFilter final : public Filter {
 	/**
 	 * The audio format being fed to the underlying filter.  This
 	 * plugin actually doesn't need this variable, we have it here
 	 * just so our open() method doesn't return a stack pointer.
 	 */
-	struct audio_format in_audio_format;
+	audio_format child_audio_format;
 
 	/**
 	 * The underlying filter.
 	 */
-	struct filter *filter;
+	Filter *filter;
 
 	/**
 	 * A convert_filter, just in case conversion is needed.  nullptr
 	 * if unused.
 	 */
-	struct filter *convert;
-
-	AutoConvertFilter(const filter_plugin &plugin, struct filter *_filter)
-		:filter(_filter) {
-		filter_init(&base, &plugin);
-	}
+	Filter *convert;
 
+public:
+	AutoConvertFilter(Filter *_filter):filter(_filter) {}
 	~AutoConvertFilter() {
-		filter_free(filter);
+		delete filter;
 	}
-};
 
-static void
-autoconvert_filter_finish(struct filter *_filter)
-{
-	AutoConvertFilter *filter = (AutoConvertFilter *)_filter;
-
-	delete filter;
-}
+	virtual const audio_format *Open(audio_format &af, GError **error_r);
+	virtual void Close();
+	virtual const void *FilterPCM(const void *src, size_t src_size,
+				      size_t *dest_size_r, GError **error_r);
+};
 
-static const struct audio_format *
-autoconvert_filter_open(struct filter *_filter,
-			struct audio_format *in_audio_format,
-			GError **error_r)
+const struct audio_format *
+AutoConvertFilter::Open(audio_format &in_audio_format, GError **error_r)
 {
-	AutoConvertFilter *filter = (AutoConvertFilter *)_filter;
-	const struct audio_format *out_audio_format;
-
-	assert(audio_format_valid(in_audio_format));
+	assert(audio_format_valid(&in_audio_format));
 
 	/* open the "real" filter */
 
-	filter->in_audio_format = *in_audio_format;
-
-	out_audio_format = filter_open(filter->filter,
-				       &filter->in_audio_format, error_r);
+	child_audio_format = in_audio_format;
+	const audio_format *out_audio_format =
+		filter->Open(child_audio_format, error_r);
 	if (out_audio_format == nullptr)
 		return nullptr;
 
 	/* need to convert? */
 
-	if (!audio_format_equals(&filter->in_audio_format, in_audio_format)) {
+	if (!audio_format_equals(&child_audio_format, &in_audio_format)) {
 		/* yes - create a convert_filter */
-		struct audio_format audio_format2 = *in_audio_format;
-		const struct audio_format *audio_format3;
 
-		filter->convert = filter_new(&convert_filter_plugin, nullptr,
-					     error_r);
-		if (filter->convert == nullptr) {
-			filter_close(filter->filter);
+		convert = filter_new(&convert_filter_plugin, nullptr, error_r);
+		if (convert == nullptr) {
+			filter->Close();
 			return nullptr;
 		}
 
-		audio_format3 = filter_open(filter->convert, &audio_format2,
-					    error_r);
+		audio_format audio_format2 = in_audio_format;
+		const audio_format *audio_format3 =
+			convert->Open(audio_format2, error_r);
 		if (audio_format3 == nullptr) {
-			filter_free(filter->convert);
-			filter_close(filter->filter);
+			delete convert;
+			filter->Close();
 			return nullptr;
 		}
 
-		assert(audio_format_equals(&audio_format2, in_audio_format));
+		assert(audio_format_equals(&audio_format2, &in_audio_format));
 
-		convert_filter_set(filter->convert, &filter->in_audio_format);
+		convert_filter_set(convert, child_audio_format);
 	} else
 		/* no */
-		filter->convert = nullptr;
+		convert = nullptr;
 
 	return out_audio_format;
 }
 
-static void
-autoconvert_filter_close(struct filter *_filter)
+void
+AutoConvertFilter::Close()
 {
-	AutoConvertFilter *filter =
-		(AutoConvertFilter *)_filter;
-
-	if (filter->convert != nullptr) {
-		filter_close(filter->convert);
-		filter_free(filter->convert);
+	if (convert != nullptr) {
+		convert->Close();
+		delete convert;
 	}
 
-	filter_close(filter->filter);
+	filter->Close();
 }
 
-static const void *
-autoconvert_filter_filter(struct filter *_filter, const void *src,
-			  size_t src_size, size_t *dest_size_r,
-			  GError **error_r)
+const void *
+AutoConvertFilter::FilterPCM(const void *src, size_t src_size,
+			     size_t *dest_size_r, GError **error_r)
 {
-	AutoConvertFilter *filter = (AutoConvertFilter *)_filter;
-
-	if (filter->convert != nullptr) {
-		src = filter_filter(filter->convert, src, src_size, &src_size,
-				    error_r);
+	if (convert != nullptr) {
+		src = convert->FilterPCM(src, src_size, &src_size, error_r);
 		if (src == nullptr)
 			return nullptr;
 	}
 
-	return filter_filter(filter->filter, src, src_size, dest_size_r,
-			     error_r);
+	return filter->FilterPCM(src, src_size, dest_size_r, error_r);
 }
 
-static const struct filter_plugin autoconvert_filter_plugin = {
-	"convert",
-	nullptr,
-	autoconvert_filter_finish,
-	autoconvert_filter_open,
-	autoconvert_filter_close,
-	autoconvert_filter_filter,
-};
-
-struct filter *
-autoconvert_filter_new(struct filter *_filter)
+Filter *
+autoconvert_filter_new(Filter *filter)
 {
-	AutoConvertFilter *filter =
-		new AutoConvertFilter(autoconvert_filter_plugin,
-				      _filter);
-
-	return &filter->base;
+	return new AutoConvertFilter(filter);
 }