From a9ce0218c1879a752c9d9ec6ef21fcf44eab51ab Mon Sep 17 00:00:00 2001 From: Max Kellermann Date: Fri, 1 Feb 2013 18:40:36 +0100 Subject: FilterInternal: convert struct filter to a OO interface --- src/filter/AutoConvertFilterPlugin.cxx | 127 ++++++++++++--------------------- 1 file changed, 45 insertions(+), 82 deletions(-) (limited to 'src/filter/AutoConvertFilterPlugin.cxx') 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 -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); } -- cgit v1.2.3