1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
#include "catch/catch.hpp"
#include "vamp-client/Loader.h"
#include "vamp-client/PluginClient.h"
#include "vamp-client/PiperVampPlugin.h"
#include "vamp-support/RequestResponse.h"
#include <vector>
using namespace piper_vamp;
using namespace piper_vamp::client;
using AudioBuffer = std::vector<std::vector<float>>;
// This stub fakes the interaction with a Piper server
// Here we only need to implement the configure method
// due to testing only the initialise implemention of PiperVampPlugin
class StubClient : public PluginClient
{
public:
StubClient(PluginStaticData staticData) : m_staticData(staticData) {}
ConfigurationResponse
configure(PiperVampPlugin* plugin,
PluginConfiguration config) override
{
const float scale = plugin->getParameter("framing-scale");
ConfigurationResponse cr;
cr.plugin = plugin;
// we want to return different framing sizes than config provides
// there isn't really any need to be doing this with a plugin param
cr.framing.blockSize = config.framing.blockSize * scale;
cr.framing.stepSize = config.framing.stepSize * scale;
// just return some outputs anyway
// to avoid a failure case we are not testing here.
Vamp::Plugin::OutputDescriptor output;
const auto basic = m_staticData.basicOutputInfo[0];
output.identifier = basic.identifier;
output.name = basic.name;
output.description = basic.description;
cr.outputs = {output};
return cr;
}
Vamp::Plugin::FeatureSet
process(PiperVampPlugin* /*plugin*/,
AudioBuffer /*channels*/,
Vamp::RealTime /*timestamp*/) override
{
return {};
}
Vamp::Plugin::FeatureSet
finish(PiperVampPlugin* /*plugin*/) override
{
return {};
}
void
reset(PiperVampPlugin* /*plugin*/, PluginConfiguration /*config*/) override
{}
private:
PluginStaticData m_staticData;
};
TEST_CASE("Init plugin with parameter dependent preferred framing sizes") {
const std::size_t initialBlockSize = 1024;
const std::size_t initialStepSize = 512;
PluginConfiguration defaultConfig;
defaultConfig.channelCount = 1;
defaultConfig.framing.blockSize = initialBlockSize;
defaultConfig.framing.stepSize = initialStepSize;
defaultConfig.parameterValues = {{"framing-scale", 1.0}};
Vamp::PluginBase::ParameterDescriptor stubParam;
stubParam.identifier = "framing-scale";
stubParam.name = "Framing Scale Factor";
stubParam.description = "Scales the preferred framing sizes";
stubParam.maxValue = 2.0;
PluginStaticData staticData;
staticData.pluginKey = "stub";
staticData.basic = {"param-init", "Stub", "Testing init"};
staticData.maker = "Lucas Thompson";
staticData.copyright = "GPL";
staticData.pluginVersion = 1;
staticData.category = {"Test"};
staticData.minChannelCount = 1;
staticData.maxChannelCount = 1;
staticData.parameters = {stubParam};
staticData.inputDomain = Vamp::Plugin::InputDomain::TimeDomain;
staticData.basicOutputInfo = {{"output", "NA", "Not real"}};
PluginProgramParameters programParameters;
// none
StubClient stub {staticData};
PiperVampPlugin vampPiperAdapter {
&stub,
"stub", // plugin key
44100.0, // sample rate
0, // adapter flags, don't care here
staticData,
defaultConfig,
programParameters
};
const auto initWithPreferredFraming = [&]() -> bool {
return vampPiperAdapter.initialise(
1,
vampPiperAdapter.getPreferredStepSize(),
vampPiperAdapter.getPreferredBlockSize()
);
};
const AudioBuffer monoAudio {
std::vector<float>(vampPiperAdapter.getPreferredBlockSize())
};
const std::vector<const float*> channelPtrs {
monoAudio[0].data()
};
SECTION("Initialises with default parameters")
{
REQUIRE( initWithPreferredFraming() );
}
SECTION("Fails to init when changing framing influencing parameter")
{
const float scalingFactor = 2.0;
vampPiperAdapter.setParameter("framing-scale", scalingFactor);
REQUIRE( initWithPreferredFraming() == false );
const float configuredStepSize = vampPiperAdapter.getPreferredStepSize();
const float configuredBlockSize = vampPiperAdapter.getPreferredBlockSize();
REQUIRE( configuredStepSize == initialStepSize * scalingFactor );
REQUIRE( configuredBlockSize == initialBlockSize * scalingFactor );
}
SECTION("Cannot process after a failed init call (due to framing)")
{
const float scalingFactor = 2.0;
vampPiperAdapter.setParameter("framing-scale", scalingFactor);
REQUIRE( initWithPreferredFraming() == false );
REQUIRE_THROWS( vampPiperAdapter.process(channelPtrs.data(), {}) );
REQUIRE_THROWS( initWithPreferredFraming() );
}
SECTION("Can process after correctly initialising framing")
{
const float scalingFactor = 2.0;
vampPiperAdapter.setParameter("framing-scale", scalingFactor);
REQUIRE( initWithPreferredFraming() == false );
REQUIRE( initWithPreferredFraming() );
REQUIRE( vampPiperAdapter.process(channelPtrs.data(), {}).empty() );
}
}
|
