From 3a212412487e8868946e7c845b6830f880790f91 Mon Sep 17 00:00:00 2001 From: Max Kellermann Date: Wed, 22 Jun 2016 11:15:49 +0200 Subject: [PATCH] filter/FilterInternal: split class Filter, add class PreparedFilter For easier state management inside filter plugins. --- Makefile.am | 2 + src/filter/FilterConfig.cxx | 6 +- src/filter/FilterConfig.hxx | 4 +- src/filter/FilterInternal.hxx | 50 ++++--- src/filter/FilterPlugin.cxx | 4 +- src/filter/FilterPlugin.hxx | 8 +- src/filter/Observer.cxx | 115 ++++++++++++++++ src/filter/Observer.hxx | 47 +++++++ .../plugins/AutoConvertFilterPlugin.cxx | 85 +++++------- .../plugins/AutoConvertFilterPlugin.hxx | 6 +- src/filter/plugins/ChainFilterPlugin.cxx | 126 +++++++++--------- src/filter/plugins/ChainFilterPlugin.hxx | 7 +- src/filter/plugins/ConvertFilterPlugin.cxx | 78 ++++++----- src/filter/plugins/ConvertFilterPlugin.hxx | 5 + src/filter/plugins/NormalizeFilterPlugin.cxx | 37 ++--- src/filter/plugins/NullFilterPlugin.cxx | 19 +-- src/filter/plugins/ReplayGainFilterPlugin.cxx | 72 ++++++---- src/filter/plugins/ReplayGainFilterPlugin.hxx | 3 +- src/filter/plugins/RouteFilterPlugin.cxx | 108 ++++++++------- src/filter/plugins/VolumeFilterPlugin.cxx | 40 +++--- src/output/Finish.cxx | 6 +- src/output/Init.cxx | 56 ++++---- src/output/Internal.hxx | 21 ++- src/output/OutputControl.cxx | 9 -- src/output/OutputThread.cxx | 64 +++++---- test/run_filter.cxx | 25 ++-- 26 files changed, 615 insertions(+), 388 deletions(-) create mode 100644 src/filter/Observer.cxx create mode 100644 src/filter/Observer.hxx diff --git a/Makefile.am b/Makefile.am index dd47df7e8..4345a65b4 100644 --- a/Makefile.am +++ b/Makefile.am @@ -108,6 +108,7 @@ libmpd_a_SOURCES = \ src/filter/FilterPlugin.cxx src/filter/FilterPlugin.hxx \ src/filter/FilterInternal.hxx \ src/filter/FilterRegistry.cxx src/filter/FilterRegistry.hxx \ + src/filter/Observer.cxx src/filter/Observer.hxx \ src/client/Client.cxx src/client/Client.hxx \ src/client/ClientInternal.hxx \ src/client/ClientEvent.cxx \ @@ -2068,6 +2069,7 @@ test_run_output_SOURCES = test/run_output.cxx \ src/mixer/MixerType.cxx \ src/filter/FilterPlugin.cxx \ src/filter/FilterConfig.cxx \ + src/filter/Observer.cxx \ src/ReplayGainInfo.cxx test_read_mixer_LDADD = \ diff --git a/src/filter/FilterConfig.cxx b/src/filter/FilterConfig.cxx index fa5fcc8ff..236297eba 100644 --- a/src/filter/FilterConfig.cxx +++ b/src/filter/FilterConfig.cxx @@ -33,7 +33,7 @@ #include static bool -filter_chain_append_new(Filter &chain, const char *template_name, Error &error) +filter_chain_append_new(PreparedFilter &chain, const char *template_name, Error &error) { const auto *cfg = config_find_block(ConfigBlockOption::AUDIO_FILTER, "name", template_name); @@ -45,7 +45,7 @@ filter_chain_append_new(Filter &chain, const char *template_name, Error &error) } // Instantiate one of those filter plugins with the template name as a hint - Filter *f = filter_configured_new(*cfg, error); + PreparedFilter *f = filter_configured_new(*cfg, error); if (f == nullptr) // The error has already been set, just stop. return false; @@ -58,7 +58,7 @@ filter_chain_append_new(Filter &chain, const char *template_name, Error &error) } bool -filter_chain_parse(Filter &chain, const char *spec, Error &error) +filter_chain_parse(PreparedFilter &chain, const char *spec, Error &error) { const char *const end = spec + strlen(spec); diff --git a/src/filter/FilterConfig.hxx b/src/filter/FilterConfig.hxx index cd0455fef..6d6fb4744 100644 --- a/src/filter/FilterConfig.hxx +++ b/src/filter/FilterConfig.hxx @@ -25,7 +25,7 @@ #ifndef MPD_FILTER_CONFIG_HXX #define MPD_FILTER_CONFIG_HXX -class Filter; +class PreparedFilter; class Error; /** @@ -38,6 +38,6 @@ class Error; * @return true on success */ bool -filter_chain_parse(Filter &chain, const char *spec, Error &error); +filter_chain_parse(PreparedFilter &chain, const char *spec, Error &error); #endif diff --git a/src/filter/FilterInternal.hxx b/src/filter/FilterInternal.hxx index 5b204b7b0..701f73b5e 100644 --- a/src/filter/FilterInternal.hxx +++ b/src/filter/FilterInternal.hxx @@ -25,6 +25,8 @@ #ifndef MPD_FILTER_INTERNAL_HXX #define MPD_FILTER_INTERNAL_HXX +#include "AudioFormat.hxx" + #include struct AudioFormat; @@ -32,9 +34,39 @@ class Error; template struct ConstBuffer; class Filter { +protected: + AudioFormat out_audio_format; + + Filter() = default; + explicit Filter(AudioFormat _out_audio_format) + :out_audio_format(_out_audio_format) {} + public: virtual ~Filter() {} + /** + * Returns the #AudioFormat produced by FilterPCM(). + */ + const AudioFormat &GetOutAudioFormat() const { + return out_audio_format; + } + + /** + * Filters a block of PCM data. + * + * @param src the input buffer + * @param error location to store the error occurring + * @return the destination buffer on success (will be + * invalidated by deleting this object or the next FilterPCM() + * call), nullptr on error + */ + virtual ConstBuffer FilterPCM(ConstBuffer src, Error &error) = 0; +}; + +class PreparedFilter { +public: + virtual ~PreparedFilter() {} + /** * Opens the filter, preparing it for FilterPCM(). * @@ -45,23 +77,7 @@ public: * @return the format of outgoing data or * AudioFormat::Undefined() on error */ - virtual AudioFormat Open(AudioFormat &af, Error &error) = 0; - - /** - * Closes the filter. After that, you may call Open() again. - */ - virtual void Close() = 0; - - /** - * Filters a block of PCM data. - * - * @param src the input buffer - * @param error location to store the error occurring - * @return the destination buffer on success (will be - * invalidated by Close() or FilterPCM()), nullptr on - * error - */ - virtual ConstBuffer FilterPCM(ConstBuffer src, Error &error) = 0; + virtual Filter *Open(AudioFormat &af, Error &error) = 0; }; #endif diff --git a/src/filter/FilterPlugin.cxx b/src/filter/FilterPlugin.cxx index 6e21ca662..f43fee06c 100644 --- a/src/filter/FilterPlugin.cxx +++ b/src/filter/FilterPlugin.cxx @@ -26,7 +26,7 @@ #include -Filter * +PreparedFilter * filter_new(const struct filter_plugin *plugin, const ConfigBlock &block, Error &error) { @@ -36,7 +36,7 @@ filter_new(const struct filter_plugin *plugin, return plugin->init(block, error); } -Filter * +PreparedFilter * filter_configured_new(const ConfigBlock &block, Error &error) { assert(!error.IsDefined()); diff --git a/src/filter/FilterPlugin.hxx b/src/filter/FilterPlugin.hxx index 8c1f9da35..2ebca232b 100644 --- a/src/filter/FilterPlugin.hxx +++ b/src/filter/FilterPlugin.hxx @@ -27,7 +27,7 @@ #define MPD_FILTER_PLUGIN_HXX struct ConfigBlock; -class Filter; +class PreparedFilter; class Error; struct filter_plugin { @@ -36,7 +36,7 @@ struct filter_plugin { /** * Allocates and configures a filter. */ - Filter *(*init)(const ConfigBlock &block, Error &error); + PreparedFilter *(*init)(const ConfigBlock &block, Error &error); }; /** @@ -48,7 +48,7 @@ struct filter_plugin { * ignore errors. * @return a new filter object, or nullptr on error */ -Filter * +PreparedFilter * filter_new(const struct filter_plugin *plugin, const ConfigBlock &block, Error &error); @@ -61,7 +61,7 @@ filter_new(const struct filter_plugin *plugin, * ignore errors. * @return a new filter object, or nullptr on error */ -Filter * +PreparedFilter * filter_configured_new(const ConfigBlock &block, Error &error); #endif diff --git a/src/filter/Observer.cxx b/src/filter/Observer.cxx new file mode 100644 index 000000000..b3cadfb30 --- /dev/null +++ b/src/filter/Observer.cxx @@ -0,0 +1,115 @@ +/* + * Copyright 2003-2016 The Music Player Daemon Project + * http://www.musicpd.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include "config.h" +#include "Observer.hxx" +#include "FilterInternal.hxx" +#include "util/ConstBuffer.hxx" + +#include + +class FilterObserver::PreparedProxy final : public PreparedFilter { + FilterObserver &observer; + + PreparedFilter *const prepared_filter; + Proxy *child = nullptr; + +public: + PreparedProxy(FilterObserver &_observer, + PreparedFilter *_prepared_filter) + :observer(_observer), + prepared_filter(_prepared_filter) {} + + ~PreparedProxy() { + assert(child == nullptr); + assert(observer.proxy == this); + + observer.proxy = nullptr; + } + + void Clear(gcc_unused Proxy *_child) { + assert(child == _child); + child = nullptr; + } + + Filter *Get(); + + Filter *Open(AudioFormat &af, Error &error) override; +}; + +class FilterObserver::Proxy final : public Filter { + PreparedProxy &parent; + + Filter *const filter; + +public: + Proxy(PreparedProxy &_parent, Filter *_filter) + :Filter(_filter->GetOutAudioFormat()), + parent(_parent), filter(_filter) {} + + ~Proxy() { + parent.Clear(this); + delete filter; + } + + Filter *Get() { + return filter; + } + + ConstBuffer FilterPCM(ConstBuffer src, + Error &error) override { + return filter->FilterPCM(src, error); + } +}; + +Filter * +FilterObserver::PreparedProxy::Get() +{ + return child != nullptr + ? child->Get() + : nullptr; +} + +Filter * +FilterObserver::PreparedProxy::Open(AudioFormat &af, Error &error) +{ + assert(child == nullptr); + + Filter *f = prepared_filter->Open(af, error); + if (f == nullptr) + return f; + + return child = new Proxy(*this, f); +} + +PreparedFilter * +FilterObserver::Set(PreparedFilter *pf) +{ + assert(proxy == nullptr); + + return proxy = new PreparedProxy(*this, pf); +} + +Filter * +FilterObserver::Get() +{ + return proxy != nullptr + ? proxy->Get() + : nullptr; +} diff --git a/src/filter/Observer.hxx b/src/filter/Observer.hxx new file mode 100644 index 000000000..aad0c7927 --- /dev/null +++ b/src/filter/Observer.hxx @@ -0,0 +1,47 @@ +/* + * Copyright 2003-2016 The Music Player Daemon Project + * http://www.musicpd.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef MPD_FILTER_OBSERVER_HXX +#define MPD_FILTER_OBSERVER_HXX + +#include "check.h" + +class PreparedFilter; +class Filter; + +/** + * A helper class which observes calls to a #PreparedFilter and allows + * the caller to access the #Filter instances created by it. + */ +class FilterObserver { + class PreparedProxy; + class Proxy; + + PreparedProxy *proxy = nullptr; + +public: + /** + * @return a proxy object + */ + PreparedFilter *Set(PreparedFilter *pf); + + Filter *Get(); +}; + +#endif diff --git a/src/filter/plugins/AutoConvertFilterPlugin.cxx b/src/filter/plugins/AutoConvertFilterPlugin.cxx index 2400d6dd4..e3639e181 100644 --- a/src/filter/plugins/AutoConvertFilterPlugin.cxx +++ b/src/filter/plugins/AutoConvertFilterPlugin.cxx @@ -24,7 +24,6 @@ #include "filter/FilterInternal.hxx" #include "filter/FilterRegistry.hxx" #include "AudioFormat.hxx" -#include "config/Block.hxx" #include "util/ConstBuffer.hxx" #include @@ -33,82 +32,70 @@ class AutoConvertFilter final : public Filter { /** * The underlying filter. */ - Filter *filter; + Filter *const filter; /** * A convert_filter, just in case conversion is needed. nullptr * if unused. */ - Filter *convert; + Filter *const convert; public: - AutoConvertFilter(Filter *_filter):filter(_filter) {} + AutoConvertFilter(Filter *_filter, Filter *_convert) + :filter(_filter), convert(_convert) {} + ~AutoConvertFilter() { + delete convert; delete filter; } - virtual AudioFormat Open(AudioFormat &af, Error &error) override; - virtual void Close() override; virtual ConstBuffer FilterPCM(ConstBuffer src, Error &error) override; }; -AudioFormat -AutoConvertFilter::Open(AudioFormat &in_audio_format, Error &error) +class PreparedAutoConvertFilter final : public PreparedFilter { + /** + * The underlying filter. + */ + PreparedFilter *const filter; + +public: + PreparedAutoConvertFilter(PreparedFilter *_filter):filter(_filter) {} + ~PreparedAutoConvertFilter() { + delete filter; + } + + virtual Filter *Open(AudioFormat &af, Error &error) override; +}; + +Filter * +PreparedAutoConvertFilter::Open(AudioFormat &in_audio_format, Error &error) { assert(in_audio_format.IsValid()); /* open the "real" filter */ AudioFormat child_audio_format = in_audio_format; - AudioFormat out_audio_format = filter->Open(child_audio_format, error); - if (!out_audio_format.IsDefined()) - return out_audio_format; + auto *new_filter = filter->Open(child_audio_format, error); + if (new_filter == nullptr) + return nullptr; /* need to convert? */ + Filter *convert = nullptr; if (in_audio_format != child_audio_format) { /* yes - create a convert_filter */ - const ConfigBlock empty; - convert = filter_new(&convert_filter_plugin, empty, error); + convert = convert_filter_new(in_audio_format, + child_audio_format, + error); if (convert == nullptr) { - filter->Close(); - return AudioFormat::Undefined(); + delete new_filter; + return nullptr; } - - AudioFormat audio_format2 = in_audio_format; - AudioFormat audio_format3 = - convert->Open(audio_format2, error); - if (!audio_format3.IsDefined()) { - delete convert; - filter->Close(); - return AudioFormat::Undefined(); - } - - assert(audio_format2 == in_audio_format); - - if (!convert_filter_set(convert, child_audio_format, error)) { - delete convert; - filter->Close(); - return AudioFormat::Undefined(); - } - } else - /* no */ - convert = nullptr; - - return out_audio_format; -} - -void -AutoConvertFilter::Close() -{ - if (convert != nullptr) { - convert->Close(); - delete convert; } - filter->Close(); + return new AutoConvertFilter(new_filter, convert); } ConstBuffer @@ -123,8 +110,8 @@ AutoConvertFilter::FilterPCM(ConstBuffer src, Error &error) return filter->FilterPCM(src, error); } -Filter * -autoconvert_filter_new(Filter *filter) +PreparedFilter * +autoconvert_filter_new(PreparedFilter *filter) { - return new AutoConvertFilter(filter); + return new PreparedAutoConvertFilter(filter); } diff --git a/src/filter/plugins/AutoConvertFilterPlugin.hxx b/src/filter/plugins/AutoConvertFilterPlugin.hxx index acec195a1..6b831d3ce 100644 --- a/src/filter/plugins/AutoConvertFilterPlugin.hxx +++ b/src/filter/plugins/AutoConvertFilterPlugin.hxx @@ -20,7 +20,7 @@ #ifndef MPD_AUTOCONVERT_FILTER_PLUGIN_HXX #define MPD_AUTOCONVERT_FILTER_PLUGIN_HXX -class Filter; +class PreparedFilter; /** * Creates a new "autoconvert" filter. When opened, it ensures that @@ -28,7 +28,7 @@ class Filter; * requests a different format, it automatically creates a * convert_filter. */ -Filter * -autoconvert_filter_new(Filter *filter); +PreparedFilter * +autoconvert_filter_new(PreparedFilter *filter); #endif diff --git a/src/filter/plugins/ChainFilterPlugin.cxx b/src/filter/plugins/ChainFilterPlugin.cxx index 8bacc2a1f..4b79baf5b 100644 --- a/src/filter/plugins/ChainFilterPlugin.cxx +++ b/src/filter/plugins/ChainFilterPlugin.cxx @@ -27,6 +27,7 @@ #include "util/Domain.hxx" #include "util/ConstBuffer.hxx" +#include #include #include @@ -49,100 +50,98 @@ class ChainFilter final : public Filter { std::list children; public: + explicit ChainFilter(AudioFormat _audio_format) + :Filter(_audio_format) {} + void Append(const char *name, Filter *filter) { + assert(out_audio_format.IsValid()); + out_audio_format = filter->GetOutAudioFormat(); + assert(out_audio_format.IsValid()); + children.emplace_back(name, filter); } /* virtual methods from class Filter */ - AudioFormat Open(AudioFormat &af, Error &error) override; - void Close() override; ConstBuffer FilterPCM(ConstBuffer src, Error &error) override; +}; -private: - /** - * Close all filters in the chain until #until is reached. - * #until itself is not closed. - */ - void CloseUntil(const Filter *until); +class PreparedChainFilter final : public PreparedFilter { + struct Child { + const char *name; + PreparedFilter *filter; + + Child(const char *_name, PreparedFilter *_filter) + :name(_name), filter(_filter) {} + ~Child() { + delete filter; + } + + Child(const Child &) = delete; + Child &operator=(const Child &) = delete; + + Filter *Open(const AudioFormat &prev_audio_format, + Error &error); + }; + + std::list children; + +public: + void Append(const char *name, PreparedFilter *filter) { + children.emplace_back(name, filter); + } + + /* virtual methods from class PreparedFilter */ + Filter *Open(AudioFormat &af, Error &error) override; }; static constexpr Domain chain_filter_domain("chain_filter"); -static Filter * +static PreparedFilter * chain_filter_init(gcc_unused const ConfigBlock &block, gcc_unused Error &error) { - return new ChainFilter(); + return new PreparedChainFilter(); } -void -ChainFilter::CloseUntil(const Filter *until) -{ - for (auto &child : children) { - if (child.filter == until) - /* don't close this filter */ - return; - - /* close this filter */ - child.filter->Close(); - } - - /* this assertion fails if #until does not exist (anymore) */ - assert(false); - gcc_unreachable(); -} - -static AudioFormat -chain_open_child(const char *name, Filter *filter, - const AudioFormat &prev_audio_format, - Error &error) +Filter * +PreparedChainFilter::Child::Open(const AudioFormat &prev_audio_format, + Error &error) { AudioFormat conv_audio_format = prev_audio_format; - const AudioFormat next_audio_format = - filter->Open(conv_audio_format, error); - if (!next_audio_format.IsDefined()) - return next_audio_format; + Filter *new_filter = filter->Open(conv_audio_format, error); + if (new_filter == nullptr) + return nullptr; if (conv_audio_format != prev_audio_format) { + delete new_filter; + struct audio_format_string s; - - filter->Close(); - error.Format(chain_filter_domain, "Audio format not supported by filter '%s': %s", name, audio_format_to_string(prev_audio_format, &s)); - return AudioFormat::Undefined(); + return nullptr; } - return next_audio_format; + return new_filter; } -AudioFormat -ChainFilter::Open(AudioFormat &in_audio_format, Error &error) +Filter * +PreparedChainFilter::Open(AudioFormat &in_audio_format, Error &error) { - AudioFormat audio_format = in_audio_format; + std::unique_ptr chain(new ChainFilter(in_audio_format)); for (auto &child : children) { - audio_format = chain_open_child(child.name, child.filter, - audio_format, error); - if (!audio_format.IsDefined()) { - /* rollback, close all children */ - CloseUntil(child.filter); - break; - } + AudioFormat audio_format = chain->GetOutAudioFormat(); + auto *filter = child.Open(audio_format, error); + if (filter == nullptr) + return nullptr; + + chain->Append(child.name, filter); } - /* return the output format of the last filter */ - return audio_format; -} - -void -ChainFilter::Close() -{ - for (auto &child : children) - child.filter->Close(); + return chain.release(); } ConstBuffer @@ -165,16 +164,17 @@ const struct filter_plugin chain_filter_plugin = { chain_filter_init, }; -Filter * +PreparedFilter * filter_chain_new(void) { - return new ChainFilter(); + return new PreparedChainFilter(); } void -filter_chain_append(Filter &_chain, const char *name, Filter *filter) +filter_chain_append(PreparedFilter &_chain, const char *name, + PreparedFilter *filter) { - ChainFilter &chain = (ChainFilter &)_chain; + PreparedChainFilter &chain = (PreparedChainFilter &)_chain; chain.Append(name, filter); } diff --git a/src/filter/plugins/ChainFilterPlugin.hxx b/src/filter/plugins/ChainFilterPlugin.hxx index 6667127a2..5b29db920 100644 --- a/src/filter/plugins/ChainFilterPlugin.hxx +++ b/src/filter/plugins/ChainFilterPlugin.hxx @@ -27,12 +27,12 @@ #ifndef MPD_FILTER_CHAIN_HXX #define MPD_FILTER_CHAIN_HXX -class Filter; +class PreparedFilter; /** * Creates a new filter chain. */ -Filter * +PreparedFilter * filter_chain_new(); /** @@ -43,6 +43,7 @@ filter_chain_new(); * @param filter the filter to be appended to #chain */ void -filter_chain_append(Filter &chain, const char *name, Filter *filter); +filter_chain_append(PreparedFilter &chain, const char *name, + PreparedFilter *filter); #endif diff --git a/src/filter/plugins/ConvertFilterPlugin.cxx b/src/filter/plugins/ConvertFilterPlugin.cxx index e84cdf14b..b8a1b905d 100644 --- a/src/filter/plugins/ConvertFilterPlugin.cxx +++ b/src/filter/plugins/ConvertFilterPlugin.cxx @@ -38,31 +38,33 @@ class ConvertFilter final : public Filter { AudioFormat in_audio_format; /** - * The output audio format; the consumer of this plugin - * expects PCM data in this format. - * - * If this is AudioFormat::Undefined(), then the #PcmConvert - * attribute is not open. This can mean that Set() has failed - * or that no conversion is necessary. + * This object is only "open" if #in_audio_format != + * #out_audio_format. */ - AudioFormat out_audio_format; - - Manual state; + PcmConvert state; public: + ConvertFilter(const AudioFormat &audio_format); + ~ConvertFilter(); + bool Set(const AudioFormat &_out_audio_format, Error &error); - virtual AudioFormat Open(AudioFormat &af, Error &error) override; - virtual void Close() override; virtual ConstBuffer FilterPCM(ConstBuffer src, Error &error) override; }; -static Filter * +class PreparedConvertFilter final : public PreparedFilter { +public: + bool Set(const AudioFormat &_out_audio_format, Error &error); + + Filter *Open(AudioFormat &af, Error &error) override; +}; + +static PreparedFilter * convert_filter_init(gcc_unused const ConfigBlock &block, gcc_unused Error &error) { - return new ConvertFilter(); + return new PreparedConvertFilter(); } bool @@ -75,47 +77,41 @@ ConvertFilter::Set(const AudioFormat &_out_audio_format, Error &error) /* no change */ return true; - if (out_audio_format.IsValid()) { - out_audio_format.Clear(); - state->Close(); + if (out_audio_format != in_audio_format) { + out_audio_format = in_audio_format; + state.Close(); } if (_out_audio_format == in_audio_format) /* optimized special case: no-op */ return true; - if (!state->Open(in_audio_format, _out_audio_format, error)) + if (!state.Open(in_audio_format, _out_audio_format, error)) return false; out_audio_format = _out_audio_format; return true; } -AudioFormat -ConvertFilter::Open(AudioFormat &audio_format, gcc_unused Error &error) +ConvertFilter::ConvertFilter(const AudioFormat &audio_format) + :Filter(audio_format), in_audio_format(audio_format) +{ +} + +Filter * +PreparedConvertFilter::Open(AudioFormat &audio_format, gcc_unused Error &error) { assert(audio_format.IsValid()); - in_audio_format = audio_format; - out_audio_format.Clear(); - - state.Construct(); - - return in_audio_format; + return new ConvertFilter(audio_format); } -void -ConvertFilter::Close() +ConvertFilter::~ConvertFilter() { assert(in_audio_format.IsValid()); if (out_audio_format.IsValid()) - state->Close(); - - state.Destruct(); - - poison_undefined(&in_audio_format, sizeof(in_audio_format)); - poison_undefined(&out_audio_format, sizeof(out_audio_format)); + state.Close(); } ConstBuffer @@ -127,7 +123,7 @@ ConvertFilter::FilterPCM(ConstBuffer src, Error &error) /* optimized special case: no-op */ return src; - return state->Convert(src, error); + return state.Convert(src, error); } const struct filter_plugin convert_filter_plugin = { @@ -135,6 +131,20 @@ const struct filter_plugin convert_filter_plugin = { convert_filter_init, }; +Filter * +convert_filter_new(const AudioFormat in_audio_format, + const AudioFormat out_audio_format, + Error &error) +{ + auto *filter = new ConvertFilter(in_audio_format); + if (!filter->Set(out_audio_format, error)) { + delete filter; + return nullptr; + } + + return filter; +} + bool convert_filter_set(Filter *_filter, AudioFormat out_audio_format, Error &error) diff --git a/src/filter/plugins/ConvertFilterPlugin.hxx b/src/filter/plugins/ConvertFilterPlugin.hxx index a514ff388..6bdd5ef1b 100644 --- a/src/filter/plugins/ConvertFilterPlugin.hxx +++ b/src/filter/plugins/ConvertFilterPlugin.hxx @@ -24,6 +24,11 @@ class Filter; class Error; struct AudioFormat; +Filter * +convert_filter_new(AudioFormat in_audio_format, + AudioFormat out_audio_format, + Error &error); + /** * Sets the output audio format for the specified filter. You must * call this after the filter has been opened. Since this audio diff --git a/src/filter/plugins/NormalizeFilterPlugin.cxx b/src/filter/plugins/NormalizeFilterPlugin.cxx index 5f66330bf..e83b6553d 100644 --- a/src/filter/plugins/NormalizeFilterPlugin.cxx +++ b/src/filter/plugins/NormalizeFilterPlugin.cxx @@ -29,40 +29,43 @@ #include class NormalizeFilter final : public Filter { - struct Compressor *compressor; + Compressor *const compressor; PcmBuffer buffer; public: + NormalizeFilter(const AudioFormat &audio_format) + :Filter(audio_format), compressor(Compressor_new(0)) { + } + + ~NormalizeFilter() { + Compressor_delete(compressor); + } + /* virtual methods from class Filter */ - AudioFormat Open(AudioFormat &af, Error &error) override; - void Close() override; ConstBuffer FilterPCM(ConstBuffer src, Error &error) override; }; -static Filter * +class PreparedNormalizeFilter final : public PreparedFilter { +public: + /* virtual methods from class PreparedFilter */ + Filter *Open(AudioFormat &af, Error &error) override; +}; + +static PreparedFilter * normalize_filter_init(gcc_unused const ConfigBlock &block, gcc_unused Error &error) { - return new NormalizeFilter(); + return new PreparedNormalizeFilter(); } -AudioFormat -NormalizeFilter::Open(AudioFormat &audio_format, gcc_unused Error &error) +Filter * +PreparedNormalizeFilter::Open(AudioFormat &audio_format, gcc_unused Error &error) { audio_format.format = SampleFormat::S16; - compressor = Compressor_new(0); - - return audio_format; -} - -void -NormalizeFilter::Close() -{ - buffer.Clear(); - Compressor_delete(compressor); + return new NormalizeFilter(audio_format); } ConstBuffer diff --git a/src/filter/plugins/NullFilterPlugin.cxx b/src/filter/plugins/NullFilterPlugin.cxx index 26926f752..fc43bb7d1 100644 --- a/src/filter/plugins/NullFilterPlugin.cxx +++ b/src/filter/plugins/NullFilterPlugin.cxx @@ -34,12 +34,7 @@ class NullFilter final : public Filter { public: - virtual AudioFormat Open(AudioFormat &af, - gcc_unused Error &error) override { - return af; - } - - virtual void Close() override {} + explicit NullFilter(const AudioFormat &af):Filter(af) {} virtual ConstBuffer FilterPCM(ConstBuffer src, gcc_unused Error &error) override { @@ -47,11 +42,19 @@ public: } }; -static Filter * +class PreparedNullFilter final : public PreparedFilter { +public: + virtual Filter *Open(AudioFormat &af, + gcc_unused Error &error) override { + return new NullFilter(af); + } +}; + +static PreparedFilter * null_filter_init(gcc_unused const ConfigBlock &block, gcc_unused Error &error) { - return new NullFilter(); + return new PreparedNullFilter(); } const struct filter_plugin null_filter_plugin = { diff --git a/src/filter/plugins/ReplayGainFilterPlugin.cxx b/src/filter/plugins/ReplayGainFilterPlugin.cxx index b9527531e..7512c180d 100644 --- a/src/filter/plugins/ReplayGainFilterPlugin.cxx +++ b/src/filter/plugins/ReplayGainFilterPlugin.cxx @@ -41,13 +41,13 @@ class ReplayGainFilter final : public Filter { * If set, then this hardware mixer is used for applying * replay gain, instead of the software volume library. */ - Mixer *mixer = nullptr; + Mixer *const mixer; /** * The base volume level for scale=1.0, between 1 and 100 * (including). */ - unsigned base; + const unsigned base; ReplayGainMode mode = REPLAY_GAIN_OFF; @@ -68,17 +68,15 @@ class ReplayGainFilter final : public Filter { PcmVolume pv; public: - ReplayGainFilter() { + ReplayGainFilter(const AudioFormat &audio_format, + Mixer *_mixer, unsigned _base) + :Filter(audio_format), + mixer(_mixer), base(_base), mode(REPLAY_GAIN_OFF) { info.Clear(); } - void SetMixer(Mixer *_mixer, unsigned _base) { - assert(_mixer == nullptr || (_base > 0 && _base <= 100)); - - mixer = _mixer; - base = _base; - - Update(); + bool Open(Error &error) { + return pv.Open(out_audio_format.format, error); } void SetInfo(const ReplayGainInfo *_info) { @@ -110,12 +108,35 @@ public: void Update(); /* virtual methods from class Filter */ - AudioFormat Open(AudioFormat &af, Error &error) override; - void Close() override; ConstBuffer FilterPCM(ConstBuffer src, Error &error) override; }; +class PreparedReplayGainFilter final : public PreparedFilter { + /** + * If set, then this hardware mixer is used for applying + * replay gain, instead of the software volume library. + */ + Mixer *mixer = nullptr; + + /** + * The base volume level for scale=1.0, between 1 and 100 + * (including). + */ + unsigned base; + +public: + void SetMixer(Mixer *_mixer, unsigned _base) { + assert(_mixer == nullptr || (_base > 0 && _base <= 100)); + + mixer = _mixer; + base = _base; + } + + /* virtual methods from class Filter */ + Filter *Open(AudioFormat &af, Error &error) override; +}; + void ReplayGainFilter::Update() { @@ -146,26 +167,23 @@ ReplayGainFilter::Update() } } -static Filter * +static PreparedFilter * replay_gain_filter_init(gcc_unused const ConfigBlock &block, gcc_unused Error &error) { - return new ReplayGainFilter(); + return new PreparedReplayGainFilter(); } -AudioFormat -ReplayGainFilter::Open(AudioFormat &af, gcc_unused Error &error) +Filter * +PreparedReplayGainFilter::Open(AudioFormat &af, gcc_unused Error &error) { - if (!pv.Open(af.format, error)) - return AudioFormat::Undefined(); + auto *filter = new ReplayGainFilter(af, mixer, base); + if (!filter->Open(error)) { + delete filter; + return nullptr; + } - return af; -} - -void -ReplayGainFilter::Close() -{ - pv.Close(); + return filter; } ConstBuffer @@ -180,10 +198,10 @@ const struct filter_plugin replay_gain_filter_plugin = { }; void -replay_gain_filter_set_mixer(Filter *_filter, Mixer *mixer, +replay_gain_filter_set_mixer(PreparedFilter *_filter, Mixer *mixer, unsigned base) { - ReplayGainFilter *filter = (ReplayGainFilter *)_filter; + PreparedReplayGainFilter *filter = (PreparedReplayGainFilter *)_filter; filter->SetMixer(mixer, base); } diff --git a/src/filter/plugins/ReplayGainFilterPlugin.hxx b/src/filter/plugins/ReplayGainFilterPlugin.hxx index 90accd8ea..734f864af 100644 --- a/src/filter/plugins/ReplayGainFilterPlugin.hxx +++ b/src/filter/plugins/ReplayGainFilterPlugin.hxx @@ -23,6 +23,7 @@ #include "ReplayGainInfo.hxx" class Filter; +class PreparedFilter; class Mixer; /** @@ -34,7 +35,7 @@ class Mixer; * (including). */ void -replay_gain_filter_set_mixer(Filter *_filter, Mixer *mixer, +replay_gain_filter_set_mixer(PreparedFilter *_filter, Mixer *mixer, unsigned base); /** diff --git a/src/filter/plugins/RouteFilterPlugin.cxx b/src/filter/plugins/RouteFilterPlugin.cxx index 0f061e597..39986a376 100644 --- a/src/filter/plugins/RouteFilterPlugin.cxx +++ b/src/filter/plugins/RouteFilterPlugin.cxx @@ -59,6 +59,46 @@ #include class RouteFilter final : public Filter { + /** + * The set of copy operations to perform on each sample + * The index is an output channel to use, the value is + * a corresponding input channel from which to take the + * data. A -1 means "no source" + */ + const std::array sources; + + /** + * The actual input format of our signal, once opened + */ + const AudioFormat input_format; + + /** + * The size, in bytes, of each multichannel frame in the + * input buffer + */ + const size_t input_frame_size; + + /** + * The size, in bytes, of each multichannel frame in the + * output buffer + */ + size_t output_frame_size; + + /** + * The output buffer used last time around, can be reused if the size doesn't differ. + */ + PcmBuffer output_buffer; + +public: + RouteFilter(const AudioFormat &audio_format, unsigned out_channels, + const std::array &_sources); + + /* virtual methods from class Filter */ + ConstBuffer FilterPCM(ConstBuffer src, + Error &error) override; +}; + +class PreparedRouteFilter final : public PreparedFilter { /** * The minimum number of channels we need for output * to be able to perform all the copies the user has specified @@ -81,33 +121,6 @@ class RouteFilter final : public Filter { */ std::array sources; - /** - * The actual input format of our signal, once opened - */ - AudioFormat input_format; - - /** - * The decided upon output format, once opened - */ - AudioFormat output_format; - - /** - * The size, in bytes, of each multichannel frame in the - * input buffer - */ - size_t input_frame_size; - - /** - * The size, in bytes, of each multichannel frame in the - * output buffer - */ - size_t output_frame_size; - - /** - * The output buffer used last time around, can be reused if the size doesn't differ. - */ - PcmBuffer output_buffer; - public: /** * Parse the "routes" section, a string on the form @@ -120,16 +133,13 @@ public: */ bool Configure(const ConfigBlock &block, Error &error); - /* virtual methods from class Filter */ - AudioFormat Open(AudioFormat &af, Error &error) override; - void Close() override; - ConstBuffer FilterPCM(ConstBuffer src, - Error &error) override; + /* virtual methods from class PreparedFilter */ + Filter *Open(AudioFormat &af, Error &error) override; }; bool -RouteFilter::Configure(const ConfigBlock &block, Error &error) { - +PreparedRouteFilter::Configure(const ConfigBlock &block, Error &error) +{ /* TODO: * With a more clever way of marking "don't copy to output N", * This could easily be merged into a single loop with some @@ -204,10 +214,10 @@ RouteFilter::Configure(const ConfigBlock &block, Error &error) { return true; } -static Filter * +static PreparedFilter * route_filter_init(const ConfigBlock &block, Error &error) { - RouteFilter *filter = new RouteFilter(); + auto *filter = new PreparedRouteFilter(); if (!filter->Configure(block, error)) { delete filter; return nullptr; @@ -216,28 +226,24 @@ route_filter_init(const ConfigBlock &block, Error &error) return filter; } -AudioFormat -RouteFilter::Open(AudioFormat &audio_format, gcc_unused Error &error) +RouteFilter::RouteFilter(const AudioFormat &audio_format, + unsigned out_channels, + const std::array &_sources) + :Filter(audio_format), sources(_sources), input_format(audio_format), + input_frame_size(input_format.GetFrameSize()) { - // Copy the input format for later reference - input_format = audio_format; - input_frame_size = input_format.GetFrameSize(); - // Decide on an output format which has enough channels, // and is otherwise identical - output_format = audio_format; - output_format.channels = min_output_channels; + out_audio_format.channels = out_channels; // Precalculate this simple value, to speed up allocation later - output_frame_size = output_format.GetFrameSize(); - - return output_format; + output_frame_size = out_audio_format.GetFrameSize(); } -void -RouteFilter::Close() +Filter * +PreparedRouteFilter::Open(AudioFormat &audio_format, gcc_unused Error &error) { - output_buffer.Clear(); + return new RouteFilter(audio_format, min_output_channels, sources); } ConstBuffer @@ -261,7 +267,7 @@ RouteFilter::FilterPCM(ConstBuffer src, gcc_unused Error &error) for (unsigned int s=0; s= input_format.channels) { // No source for this destination output, diff --git a/src/filter/plugins/VolumeFilterPlugin.cxx b/src/filter/plugins/VolumeFilterPlugin.cxx index c29c92886..7e7fa2a4a 100644 --- a/src/filter/plugins/VolumeFilterPlugin.cxx +++ b/src/filter/plugins/VolumeFilterPlugin.cxx @@ -30,6 +30,13 @@ class VolumeFilter final : public Filter { PcmVolume pv; public: + explicit VolumeFilter(const AudioFormat &audio_format) + :Filter(audio_format) {} + + bool Open(Error &error) { + return pv.Open(out_audio_format.format, error); + } + unsigned GetVolume() const { return pv.GetVolume(); } @@ -39,32 +46,35 @@ public: } /* virtual methods from class Filter */ - AudioFormat Open(AudioFormat &af, Error &error) override; - void Close() override; ConstBuffer FilterPCM(ConstBuffer src, Error &error) override; }; -static Filter * +class PreparedVolumeFilter final : public PreparedFilter { + PcmVolume pv; + +public: + /* virtual methods from class Filter */ + Filter *Open(AudioFormat &af, Error &error) override; +}; + +static PreparedFilter * volume_filter_init(gcc_unused const ConfigBlock &block, gcc_unused Error &error) { - return new VolumeFilter(); + return new PreparedVolumeFilter(); } -AudioFormat -VolumeFilter::Open(AudioFormat &audio_format, Error &error) +Filter * +PreparedVolumeFilter::Open(AudioFormat &audio_format, Error &error) { - if (!pv.Open(audio_format.format, error)) - return AudioFormat::Undefined(); + auto *filter = new VolumeFilter(audio_format); + if (!filter->Open(error)) { + delete filter; + return nullptr; + } - return audio_format; -} - -void -VolumeFilter::Close() -{ - pv.Close(); + return filter; } ConstBuffer diff --git a/src/output/Finish.cxx b/src/output/Finish.cxx index a92718734..13c1c82bc 100644 --- a/src/output/Finish.cxx +++ b/src/output/Finish.cxx @@ -34,9 +34,9 @@ AudioOutput::~AudioOutput() if (mixer != nullptr) mixer_free(mixer); - delete replay_gain_filter; - delete other_replay_gain_filter; - delete filter; + delete prepared_replay_gain_filter; + delete prepared_other_replay_gain_filter; + delete prepared_filter; } void diff --git a/src/output/Init.cxx b/src/output/Init.cxx index 5bfb4d109..00dc9d569 100644 --- a/src/output/Init.cxx +++ b/src/output/Init.cxx @@ -102,7 +102,7 @@ audio_output_mixer_type(const ConfigBlock &block) "hardware")); } -static Filter * +static PreparedFilter * CreateVolumeFilter() { return filter_new(&volume_filter_plugin, ConfigBlock(), @@ -113,12 +113,10 @@ static Mixer * audio_output_load_mixer(EventLoop &event_loop, AudioOutput &ao, const ConfigBlock &block, const MixerPlugin *plugin, - Filter &filter_chain, + PreparedFilter &filter_chain, MixerListener &listener, Error &error) { - assert(ao.volume_filter == nullptr); - Mixer *mixer; switch (audio_output_mixer_type(block)) { @@ -144,13 +142,8 @@ audio_output_load_mixer(EventLoop &event_loop, AudioOutput &ao, IgnoreError()); assert(mixer != nullptr); - ao.volume_filter = CreateVolumeFilter(); - assert(ao.volume_filter != nullptr); - filter_chain_append(filter_chain, "software_mixer", - ao.volume_filter); - - software_mixer_set_filter(*mixer, ao.volume_filter); + ao.volume_filter.Set(CreateVolumeFilter())); return mixer; } @@ -190,23 +183,23 @@ AudioOutput::Configure(const ConfigBlock &block, Error &error) /* set up the filter chain */ - filter = filter_chain_new(); - assert(filter != nullptr); + prepared_filter = filter_chain_new(); + assert(prepared_filter != nullptr); /* create the normalization filter (if configured) */ if (config_get_bool(ConfigOption::VOLUME_NORMALIZATION, false)) { - Filter *normalize_filter = + auto *normalize_filter = filter_new(&normalize_filter_plugin, ConfigBlock(), IgnoreError()); assert(normalize_filter != nullptr); - filter_chain_append(*filter, "normalize", + filter_chain_append(*prepared_filter, "normalize", autoconvert_filter_new(normalize_filter)); } Error filter_error; - filter_chain_parse(*filter, + filter_chain_parse(*prepared_filter, block.GetBlockValue(AUDIO_FILTERS, ""), filter_error); @@ -235,21 +228,21 @@ audio_output_setup(EventLoop &event_loop, AudioOutput &ao, block.GetBlockValue("replay_gain_handler", "software"); if (strcmp(replay_gain_handler, "none") != 0) { - ao.replay_gain_filter = filter_new(&replay_gain_filter_plugin, - block, IgnoreError()); - assert(ao.replay_gain_filter != nullptr); + ao.prepared_replay_gain_filter = filter_new(&replay_gain_filter_plugin, + block, IgnoreError()); + assert(ao.prepared_replay_gain_filter != nullptr); ao.replay_gain_serial = 0; - ao.other_replay_gain_filter = filter_new(&replay_gain_filter_plugin, - block, - IgnoreError()); - assert(ao.other_replay_gain_filter != nullptr); + ao.prepared_other_replay_gain_filter = filter_new(&replay_gain_filter_plugin, + block, + IgnoreError()); + assert(ao.prepared_other_replay_gain_filter != nullptr); ao.other_replay_gain_serial = 0; } else { - ao.replay_gain_filter = nullptr; - ao.other_replay_gain_filter = nullptr; + ao.prepared_replay_gain_filter = nullptr; + ao.prepared_other_replay_gain_filter = nullptr; } /* set up the mixer */ @@ -257,7 +250,7 @@ audio_output_setup(EventLoop &event_loop, AudioOutput &ao, Error mixer_error; ao.mixer = audio_output_load_mixer(event_loop, ao, block, ao.plugin.mixer_plugin, - *ao.filter, + *ao.prepared_filter, mixer_listener, mixer_error); if (ao.mixer == nullptr && mixer_error.IsDefined()) @@ -269,13 +262,13 @@ audio_output_setup(EventLoop &event_loop, AudioOutput &ao, if (strcmp(replay_gain_handler, "mixer") == 0) { if (ao.mixer != nullptr) - replay_gain_filter_set_mixer(ao.replay_gain_filter, + replay_gain_filter_set_mixer(ao.prepared_replay_gain_filter, ao.mixer, 100); else FormatError(output_domain, "No such mixer for output '%s'", ao.name); } else if (strcmp(replay_gain_handler, "software") != 0 && - ao.replay_gain_filter != nullptr) { + ao.prepared_replay_gain_filter != nullptr) { error.Set(config_domain, "Invalid \"replay_gain_handler\" value"); return false; @@ -283,11 +276,12 @@ audio_output_setup(EventLoop &event_loop, AudioOutput &ao, /* the "convert" filter must be the last one in the chain */ - ao.convert_filter = filter_new(&convert_filter_plugin, ConfigBlock(), - IgnoreError()); - assert(ao.convert_filter != nullptr); + auto *f = filter_new(&convert_filter_plugin, ConfigBlock(), + IgnoreError()); + assert(f != nullptr); - filter_chain_append(*ao.filter, "convert", ao.convert_filter); + filter_chain_append(*ao.prepared_filter, "convert", + ao.convert_filter.Set(f)); return true; } diff --git a/src/output/Internal.hxx b/src/output/Internal.hxx index 0caa1235a..c9b0be5ed 100644 --- a/src/output/Internal.hxx +++ b/src/output/Internal.hxx @@ -24,12 +24,14 @@ #include "pcm/PcmBuffer.hxx" #include "pcm/PcmDither.hxx" #include "ReplayGainInfo.hxx" +#include "filter/Observer.hxx" #include "thread/Mutex.hxx" #include "thread/Cond.hxx" #include "thread/Thread.hxx" #include "system/PeriodClock.hxx" class Error; +class PreparedFilter; class Filter; class MusicPipe; class EventLoop; @@ -147,6 +149,8 @@ struct AudioOutput { */ bool woken_for_play = false; + ReplayGainMode replay_gain_mode = REPLAY_GAIN_OFF; + /** * If not nullptr, the device has failed, and this timer is used * to estimate how long it should stay disabled (unless @@ -187,19 +191,21 @@ struct AudioOutput { * The filter object of this audio output. This is an * instance of chain_filter_plugin. */ - Filter *filter = nullptr; + PreparedFilter *prepared_filter = nullptr; + Filter *filter_instance; /** * The #VolumeFilter instance of this audio output. It is * used by the #SoftwareMixer. */ - Filter *volume_filter = nullptr; + FilterObserver volume_filter; /** * The replay_gain_filter_plugin instance of this audio * output. */ - Filter *replay_gain_filter = nullptr; + PreparedFilter *prepared_replay_gain_filter = nullptr; + Filter *replay_gain_filter_instance; /** * The serial number of the last replay gain info. 0 means no @@ -212,7 +218,8 @@ struct AudioOutput { * output, to be applied to the second chunk during * cross-fading. */ - Filter *other_replay_gain_filter = nullptr; + PreparedFilter *prepared_other_replay_gain_filter = nullptr; + Filter *other_replay_gain_filter_instance; /** * The serial number of the last replay gain info by the @@ -226,7 +233,7 @@ struct AudioOutput { * for converting the input data into the appropriate format * for this audio output. */ - Filter *convert_filter; + FilterObserver convert_filter; /** * The thread handle, or nullptr if the output thread isn't @@ -346,7 +353,9 @@ struct AudioOutput { */ void LockRelease(); - void SetReplayGainMode(ReplayGainMode mode); + void SetReplayGainMode(ReplayGainMode _mode) { + replay_gain_mode = _mode; + } /** * Caller must lock the mutex. diff --git a/src/output/OutputControl.cxx b/src/output/OutputControl.cxx index 47d1be300..090db35d9 100644 --- a/src/output/OutputControl.cxx +++ b/src/output/OutputControl.cxx @@ -68,15 +68,6 @@ AudioOutput::LockCommandWait(Command cmd) CommandWait(cmd); } -void -AudioOutput::SetReplayGainMode(ReplayGainMode mode) -{ - if (replay_gain_filter != nullptr) - replay_gain_filter_set_mode(replay_gain_filter, mode); - if (other_replay_gain_filter != nullptr) - replay_gain_filter_set_mode(other_replay_gain_filter, mode); -} - void AudioOutput::LockEnableWait() { diff --git a/src/output/OutputThread.cxx b/src/output/OutputThread.cxx index 4b2f336e8..53fc2edfb 100644 --- a/src/output/OutputThread.cxx +++ b/src/output/OutputThread.cxx @@ -27,6 +27,8 @@ #include "filter/FilterInternal.hxx" #include "filter/plugins/ConvertFilterPlugin.hxx" #include "filter/plugins/ReplayGainFilterPlugin.hxx" +#include "mixer/MixerInternal.hxx" +#include "mixer/plugins/SoftwareMixerPlugin.hxx" #include "player/Control.hxx" #include "MusicPipe.hxx" #include "MusicChunk.hxx" @@ -94,37 +96,44 @@ AudioOutput::OpenFilter(AudioFormat &format, Error &error_r) assert(format.IsValid()); /* the replay_gain filter cannot fail here */ - if (replay_gain_filter != nullptr && - !replay_gain_filter->Open(format, error_r).IsDefined()) - return AudioFormat::Undefined(); + if (prepared_replay_gain_filter != nullptr) { + replay_gain_filter_instance = + prepared_replay_gain_filter->Open(format, error_r); + if (replay_gain_filter_instance == nullptr) + return AudioFormat::Undefined(); + } - if (other_replay_gain_filter != nullptr && - !other_replay_gain_filter->Open(format, error_r).IsDefined()) { - if (replay_gain_filter != nullptr) - replay_gain_filter->Close(); + if (prepared_other_replay_gain_filter != nullptr) { + other_replay_gain_filter_instance = + prepared_other_replay_gain_filter->Open(format, error_r); + if (other_replay_gain_filter_instance == nullptr) { + delete replay_gain_filter_instance; + return AudioFormat::Undefined(); + } + } + + filter_instance = prepared_filter->Open(format, error_r); + if (filter_instance == nullptr) { + delete other_replay_gain_filter_instance; + delete replay_gain_filter_instance; return AudioFormat::Undefined(); } - const AudioFormat af = filter->Open(format, error_r); - if (!af.IsDefined()) { - if (replay_gain_filter != nullptr) - replay_gain_filter->Close(); - if (other_replay_gain_filter != nullptr) - other_replay_gain_filter->Close(); - } + if (mixer != nullptr && mixer->IsPlugin(software_mixer_plugin)) + software_mixer_set_filter(*mixer, volume_filter.Get()); - return af; + return filter_instance->GetOutAudioFormat(); } void AudioOutput::CloseFilter() { - if (replay_gain_filter != nullptr) - replay_gain_filter->Close(); - if (other_replay_gain_filter != nullptr) - other_replay_gain_filter->Close(); + if (mixer != nullptr && mixer->IsPlugin(software_mixer_plugin)) + software_mixer_set_filter(*mixer, nullptr); - filter->Close(); + delete replay_gain_filter_instance; + delete other_replay_gain_filter_instance; + delete filter_instance; } inline void @@ -186,7 +195,7 @@ AudioOutput::Open() return; } - if (!convert_filter_set(convert_filter, out_audio_format, + if (!convert_filter_set(convert_filter.Get(), out_audio_format, error)) { FormatError(error, "Failed to convert for \"%s\" [%s]", name, plugin.name); @@ -282,7 +291,7 @@ AudioOutput::ReopenFilter() const AudioFormat filter_audio_format = OpenFilter(in_audio_format, error); if (!filter_audio_format.IsDefined() || - !convert_filter_set(convert_filter, out_audio_format, + !convert_filter_set(convert_filter.Get(), out_audio_format, error)) { FormatError(error, "Failed to open filter for \"%s\" [%s]", @@ -368,6 +377,9 @@ ao_chunk_data(AudioOutput *ao, const MusicChunk *chunk, assert(data.size % ao->in_audio_format.GetFrameSize() == 0); if (!data.IsEmpty() && replay_gain_filter != nullptr) { + replay_gain_filter_set_mode(replay_gain_filter, + ao->replay_gain_mode); + if (chunk->replay_gain_serial != *replay_gain_serial_p) { replay_gain_filter_set_info(replay_gain_filter, chunk->replay_gain_serial != 0 @@ -390,7 +402,7 @@ static ConstBuffer ao_filter_chunk(AudioOutput *ao, const MusicChunk *chunk) { ConstBuffer data = - ao_chunk_data(ao, chunk, ao->replay_gain_filter, + ao_chunk_data(ao, chunk, ao->replay_gain_filter_instance, &ao->replay_gain_serial); if (data.IsEmpty()) return data; @@ -400,7 +412,7 @@ ao_filter_chunk(AudioOutput *ao, const MusicChunk *chunk) if (chunk->other != nullptr) { ConstBuffer other_data = ao_chunk_data(ao, chunk->other, - ao->other_replay_gain_filter, + ao->other_replay_gain_filter_instance, &ao->other_replay_gain_serial); if (other_data.IsNull()) return nullptr; @@ -443,7 +455,7 @@ ao_filter_chunk(AudioOutput *ao, const MusicChunk *chunk) /* apply filter chain */ Error error; - data = ao->filter->FilterPCM(data, error); + data = ao->filter_instance->FilterPCM(data, error); if (data.IsNull()) { FormatError(error, "\"%s\" [%s] failed to filter", ao->name, ao->plugin.name); @@ -456,7 +468,7 @@ ao_filter_chunk(AudioOutput *ao, const MusicChunk *chunk) inline bool AudioOutput::PlayChunk(const MusicChunk *chunk) { - assert(filter != nullptr); + assert(filter_instance != nullptr); if (tags && gcc_unlikely(chunk->tag != nullptr)) { mutex.unlock(); diff --git a/test/run_filter.cxx b/test/run_filter.cxx index a4e9c3653..0fa414e39 100644 --- a/test/run_filter.cxx +++ b/test/run_filter.cxx @@ -32,6 +32,8 @@ #include "system/FatalError.hxx" #include "Log.hxx" +#include + #include #include #include @@ -46,7 +48,7 @@ mixer_set_volume(gcc_unused Mixer *mixer, return true; } -static Filter * +static PreparedFilter * load_filter(const char *name) { const auto *param = config_find_block(ConfigBlockOption::AUDIO_FILTER, @@ -57,7 +59,7 @@ load_filter(const char *name) } Error error; - Filter *filter = filter_configured_new(*param, error); + auto *filter = filter_configured_new(*param, error); if (filter == NULL) { LogError(error, "Failed to load filter"); return NULL; @@ -97,20 +99,22 @@ try { /* initialize the filter */ - Filter *filter = load_filter(argv[2]); - if (filter == NULL) + std::unique_ptr prepared_filter(load_filter(argv[2])); + if (!prepared_filter) return EXIT_FAILURE; /* open the filter */ Error error; - const AudioFormat out_audio_format = filter->Open(audio_format, error); - if (!out_audio_format.IsDefined()) { + std::unique_ptr filter(prepared_filter->Open(audio_format, + error)); + if (!filter) { LogError(error, "Failed to open filter"); - delete filter; return EXIT_FAILURE; } + const AudioFormat out_audio_format = filter->GetOutAudioFormat(); + fprintf(stderr, "audio_format=%s\n", audio_format_to_string(out_audio_format, &af_string)); @@ -127,8 +131,6 @@ try { error); if (dest.IsNull()) { LogError(error, "filter/Filter failed"); - filter->Close(); - delete filter; return EXIT_FAILURE; } @@ -136,17 +138,12 @@ try { if (nbytes < 0) { fprintf(stderr, "Failed to write: %s\n", strerror(errno)); - filter->Close(); - delete filter; return 1; } } /* cleanup and exit */ - filter->Close(); - delete filter; - config_global_finish(); return EXIT_SUCCESS;