oysteikt/mpd
0
0
Fork 0
Code Issues Pull Requests Releases Activity

filter/Internal: return std::unique_ptr<Filter>

Browse Source
This commit is contained in:
Max Kellermann
2017-12-27 11:42:14 +01:00
parent e2621d5e44
commit edef62df86
12 changed files with 64 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/filter/FilterInternal.hxx
View File

@@ -27,8 +27,9 @@
#include "AudioFormat.hxx"
#include <memory>
#include <assert.h>
#include <stddef.h>
struct AudioFormat;
template<typename T> struct ConstBuffer;
@@ -84,7 +85,7 @@ public:
* plugin may modify the object to enforce another input
* format
*/
virtual Filter *Open(AudioFormat &af) = 0;
virtual std::unique_ptr<Filter> Open(AudioFormat &af) = 0;
};
#endif

18
src/filter/Observer.cxx
View File

@@ -50,26 +50,25 @@ public:
Filter *Get();
Filter *Open(AudioFormat &af) override;
std::unique_ptr<Filter> Open(AudioFormat &af) override;
};
class FilterObserver::Proxy final : public Filter {
PreparedProxy &parent;
Filter *const filter;
std::unique_ptr<Filter> filter;
public:
Proxy(PreparedProxy &_parent, Filter *_filter)
Proxy(PreparedProxy &_parent, std::unique_ptr<Filter> _filter)
:Filter(_filter->GetOutAudioFormat()),
parent(_parent), filter(_filter) {}
parent(_parent), filter(std::move(_filter)) {}
~Proxy() {
parent.Clear(this);
delete filter;
}
Filter *Get() {
return filter;
return filter.get();
}
ConstBuffer<void> FilterPCM(ConstBuffer<void> src) override {
@@ -85,13 +84,14 @@ FilterObserver::PreparedProxy::Get()
: nullptr;
}
Filter *
std::unique_ptr<Filter>
FilterObserver::PreparedProxy::Open(AudioFormat &af)
{
assert(child == nullptr);
Filter *f = prepared_filter->Open(af);
return child = new Proxy(*this, f);
auto c = std::make_unique<Proxy>(*this, prepared_filter->Open(af));
child = c.get();
return c;
}
std::unique_ptr<PreparedFilter>

10
src/filter/plugins/AutoConvertFilterPlugin.cxx
View File

@@ -68,10 +68,10 @@ public:
PreparedAutoConvertFilter(std::unique_ptr<PreparedFilter> _filter) noexcept
:filter(std::move(_filter)) {}
Filter *Open(AudioFormat &af) override;
std::unique_ptr<Filter> Open(AudioFormat &af) override;
};
Filter *
std::unique_ptr<Filter>
PreparedAutoConvertFilter::Open(AudioFormat &in_audio_format)
{
assert(in_audio_format.IsValid());
@@ -79,7 +79,7 @@ PreparedAutoConvertFilter::Open(AudioFormat &in_audio_format)
/* open the "real" filter */
AudioFormat child_audio_format = in_audio_format;
std::unique_ptr<Filter> new_filter(filter->Open(child_audio_format));
auto new_filter = filter->Open(child_audio_format);
/* need to convert? */
@@ -91,8 +91,8 @@ PreparedAutoConvertFilter::Open(AudioFormat &in_audio_format)
child_audio_format));
}
return new AutoConvertFilter(std::move(new_filter),
std::move(convert));
return std::make_unique<AutoConvertFilter>(std::move(new_filter),
std::move(convert));
}
ConstBuffer<void>

38
src/filter/plugins/ChainFilterPlugin.cxx
View File

@@ -33,16 +33,10 @@
class ChainFilter final : public Filter {
struct Child {
const char *name;
Filter *filter;
std::unique_ptr<Filter> filter;
Child(const char *_name, Filter *_filter)
:name(_name), filter(_filter) {}
~Child() {
delete filter;
}
Child(const Child &) = delete;
Child &operator=(const Child &) = delete;
Child(const char *_name, std::unique_ptr<Filter> _filter)
:name(_name), filter(std::move(_filter)) {}
};
std::list<Child> children;
@@ -51,12 +45,12 @@ public:
explicit ChainFilter(AudioFormat _audio_format)
:Filter(_audio_format) {}
void Append(const char *name, Filter *filter) {
void Append(const char *name, std::unique_ptr<Filter> filter) {
assert(out_audio_format.IsValid());
out_audio_format = filter->GetOutAudioFormat();
assert(out_audio_format.IsValid());
children.emplace_back(name, filter);
children.emplace_back(name, std::move(filter));
}
/* virtual methods from class Filter */
@@ -76,7 +70,7 @@ class PreparedChainFilter final : public PreparedFilter {
Child(const Child &) = delete;
Child &operator=(const Child &) = delete;
Filter *Open(const AudioFormat &prev_audio_format);
std::unique_ptr<Filter> Open(const AudioFormat &prev_audio_format);
};
std::list<Child> children;
@@ -88,38 +82,34 @@ public:
}
/* virtual methods from class PreparedFilter */
Filter *Open(AudioFormat &af) override;
std::unique_ptr<Filter> Open(AudioFormat &af) override;
};
Filter *
std::unique_ptr<Filter>
PreparedChainFilter::Child::Open(const AudioFormat &prev_audio_format)
{
AudioFormat conv_audio_format = prev_audio_format;
Filter *new_filter = filter->Open(conv_audio_format);
if (conv_audio_format != prev_audio_format) {
delete new_filter;
auto new_filter = filter->Open(conv_audio_format);
if (conv_audio_format != prev_audio_format)
throw FormatRuntimeError("Audio format not supported by filter '%s': %s",
name,
ToString(prev_audio_format).c_str());
}
return new_filter;
}
Filter *
std::unique_ptr<Filter>
PreparedChainFilter::Open(AudioFormat &in_audio_format)
{
std::unique_ptr<ChainFilter> chain(new ChainFilter(in_audio_format));
auto chain = std::make_unique<ChainFilter>(in_audio_format);
for (auto &child : children) {
AudioFormat audio_format = chain->GetOutAudioFormat();
auto *filter = child.Open(audio_format);
chain->Append(child.name, filter);
chain->Append(child.name, child.Open(audio_format));
}
return chain.release();
return chain;
}
void

6
src/filter/plugins/ConvertFilterPlugin.cxx
View File

@@ -59,7 +59,7 @@ public:
class PreparedConvertFilter final : public PreparedFilter {
public:
Filter *Open(AudioFormat &af) override;
std::unique_ptr<Filter> Open(AudioFormat &af) override;
};
void
@@ -91,12 +91,12 @@ ConvertFilter::ConvertFilter(const AudioFormat &audio_format)
{
}
Filter *
std::unique_ptr<Filter>
PreparedConvertFilter::Open(AudioFormat &audio_format)
{
assert(audio_format.IsValid());
return new ConvertFilter(audio_format);
return std::make_unique<ConvertFilter>(audio_format);
}
ConvertFilter::~ConvertFilter()

6
src/filter/plugins/NormalizeFilterPlugin.cxx
View File

@@ -50,7 +50,7 @@ public:
class PreparedNormalizeFilter final : public PreparedFilter {
public:
/* virtual methods from class PreparedFilter */
Filter *Open(AudioFormat &af) override;
std::unique_ptr<Filter> Open(AudioFormat &af) override;
};
static std::unique_ptr<PreparedFilter>
@@ -59,12 +59,12 @@ normalize_filter_init(gcc_unused const ConfigBlock &block)
return std::make_unique<PreparedNormalizeFilter>();
}
Filter *
std::unique_ptr<Filter>
PreparedNormalizeFilter::Open(AudioFormat &audio_format)
{
audio_format.format = SampleFormat::S16;
return new NormalizeFilter(audio_format);
return std::make_unique<NormalizeFilter>(audio_format);
}
ConstBuffer<void>

4
src/filter/plugins/NullFilterPlugin.cxx
View File

@@ -43,8 +43,8 @@ public:
class PreparedNullFilter final : public PreparedFilter {
public:
virtual Filter *Open(AudioFormat &af) override {
return new NullFilter(af);
virtual std::unique_ptr<Filter> Open(AudioFormat &af) override {
return std::make_unique<NullFilter>(af);
}
};

6
src/filter/plugins/ReplayGainFilterPlugin.cxx
View File

@@ -138,7 +138,7 @@ public:
}
/* virtual methods from class Filter */
Filter *Open(AudioFormat &af) override;
std::unique_ptr<Filter> Open(AudioFormat &af) override;
};
void
@@ -177,10 +177,10 @@ NewReplayGainFilter(const ReplayGainConfig &config) noexcept
return std::make_unique<PreparedReplayGainFilter>(config);
}
Filter *
std::unique_ptr<Filter>
PreparedReplayGainFilter::Open(AudioFormat &af)
{
return new ReplayGainFilter(config, af, mixer, base);
return std::make_unique<ReplayGainFilter>(config, af, mixer, base);
}
ConstBuffer<void>

7
src/filter/plugins/RouteFilterPlugin.cxx
View File

@@ -134,7 +134,7 @@ public:
PreparedRouteFilter(const ConfigBlock &block);
/* virtual methods from class PreparedFilter */
Filter *Open(AudioFormat &af) override;
std::unique_ptr<Filter> Open(AudioFormat &af) override;
};
PreparedRouteFilter::PreparedRouteFilter(const ConfigBlock &block)
@@ -216,10 +216,11 @@ RouteFilter::RouteFilter(const AudioFormat &audio_format,
output_frame_size = out_audio_format.GetFrameSize();
}
Filter *
std::unique_ptr<Filter>
PreparedRouteFilter::Open(AudioFormat &audio_format)
{
return new RouteFilter(audio_format, min_output_channels, sources);
return std::make_unique<RouteFilter>(audio_format, min_output_channels,
sources);
}
ConstBuffer<void>

6
src/filter/plugins/VolumeFilterPlugin.cxx
View File

@@ -50,13 +50,13 @@ public:
class PreparedVolumeFilter final : public PreparedFilter {
public:
/* virtual methods from class Filter */
Filter *Open(AudioFormat &af) override;
std::unique_ptr<Filter> Open(AudioFormat &af) override;
};
Filter *
std::unique_ptr<Filter>
PreparedVolumeFilter::Open(AudioFormat &audio_format)
{
return new VolumeFilter(audio_format);
return std::make_unique<VolumeFilter>(audio_format);
}
ConstBuffer<void>