Chris@0
|
1
|
Chris@49
|
2 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
|
Chris@0
|
3
|
Chris@0
|
4 /*
|
Chris@52
|
5 Sonic Visualiser
|
Chris@52
|
6 An audio file viewer and annotation editor.
|
Chris@52
|
7 Centre for Digital Music, Queen Mary, University of London.
|
Chris@52
|
8 This file copyright 2006 Chris Cannam.
|
Chris@0
|
9
|
Chris@52
|
10 This program is free software; you can redistribute it and/or
|
Chris@52
|
11 modify it under the terms of the GNU General Public License as
|
Chris@52
|
12 published by the Free Software Foundation; either version 2 of the
|
Chris@52
|
13 License, or (at your option) any later version. See the file
|
Chris@52
|
14 COPYING included with this distribution for more information.
|
Chris@0
|
15 */
|
Chris@0
|
16
|
Chris@0
|
17 #include "FeatureExtractionPluginTransform.h"
|
Chris@0
|
18
|
Chris@0
|
19 #include "plugin/FeatureExtractionPluginFactory.h"
|
Chris@66
|
20 #include "plugin/PluginXml.h"
|
Chris@66
|
21 #include "vamp-sdk/Plugin.h"
|
Chris@0
|
22
|
Chris@0
|
23 #include "base/Model.h"
|
Chris@67
|
24 #include "base/Window.h"
|
Chris@0
|
25 #include "model/SparseOneDimensionalModel.h"
|
Chris@0
|
26 #include "model/SparseTimeValueModel.h"
|
Chris@0
|
27 #include "model/DenseThreeDimensionalModel.h"
|
Chris@0
|
28 #include "model/DenseTimeValueModel.h"
|
Chris@0
|
29
|
Chris@67
|
30 #include <fftw3.h>
|
Chris@67
|
31
|
Chris@0
|
32 #include <iostream>
|
Chris@0
|
33
|
Chris@0
|
34 FeatureExtractionPluginTransform::FeatureExtractionPluginTransform(Model *inputModel,
|
Chris@0
|
35 QString pluginId,
|
Chris@64
|
36 int channel,
|
Chris@56
|
37 QString configurationXml,
|
Chris@0
|
38 QString outputName) :
|
Chris@0
|
39 Transform(inputModel),
|
Chris@0
|
40 m_plugin(0),
|
Chris@64
|
41 m_channel(channel),
|
Chris@68
|
42 m_stepSize(0),
|
Chris@68
|
43 m_blockSize(0),
|
Chris@0
|
44 m_descriptor(0),
|
Chris@0
|
45 m_outputFeatureNo(0)
|
Chris@0
|
46 {
|
Chris@0
|
47 std::cerr << "FeatureExtractionPluginTransform::FeatureExtractionPluginTransform: plugin " << pluginId.toStdString() << ", outputName " << outputName.toStdString() << std::endl;
|
Chris@0
|
48
|
Chris@0
|
49 FeatureExtractionPluginFactory *factory =
|
Chris@0
|
50 FeatureExtractionPluginFactory::instanceFor(pluginId);
|
Chris@0
|
51
|
Chris@0
|
52 if (!factory) {
|
Chris@0
|
53 std::cerr << "FeatureExtractionPluginTransform: No factory available for plugin id \""
|
Chris@0
|
54 << pluginId.toStdString() << "\"" << std::endl;
|
Chris@0
|
55 return;
|
Chris@0
|
56 }
|
Chris@0
|
57
|
Chris@0
|
58 m_plugin = factory->instantiatePlugin(pluginId, m_input->getSampleRate());
|
Chris@0
|
59
|
Chris@0
|
60 if (!m_plugin) {
|
Chris@0
|
61 std::cerr << "FeatureExtractionPluginTransform: Failed to instantiate plugin \""
|
Chris@0
|
62 << pluginId.toStdString() << "\"" << std::endl;
|
Chris@0
|
63 return;
|
Chris@0
|
64 }
|
Chris@0
|
65
|
Chris@56
|
66 if (configurationXml != "") {
|
Chris@66
|
67 PluginXml(m_plugin).setParametersFromXml(configurationXml);
|
Chris@56
|
68 }
|
Chris@56
|
69
|
Chris@68
|
70 m_blockSize = m_plugin->getPreferredBlockSize();
|
Chris@68
|
71 m_stepSize = m_plugin->getPreferredStepSize();
|
Chris@68
|
72
|
Chris@68
|
73 if (m_blockSize == 0) m_blockSize = 1024; //!!! todo: ask user
|
Chris@68
|
74 if (m_stepSize == 0) m_stepSize = m_blockSize; //!!! likewise
|
Chris@68
|
75
|
Chris@114
|
76 DenseTimeValueModel *input = getInput();
|
Chris@114
|
77 if (!input) return;
|
Chris@114
|
78
|
Chris@114
|
79 size_t channelCount = input->getChannelCount();
|
Chris@114
|
80 if (m_plugin->getMaxChannelCount() < channelCount) {
|
Chris@114
|
81 channelCount = 1;
|
Chris@114
|
82 }
|
Chris@114
|
83 if (m_plugin->getMinChannelCount() > channelCount) {
|
Chris@114
|
84 std::cerr << "FeatureExtractionPluginTransform:: "
|
Chris@114
|
85 << "Can't provide enough channels to plugin (plugin min "
|
Chris@114
|
86 << m_plugin->getMinChannelCount() << ", max "
|
Chris@114
|
87 << m_plugin->getMaxChannelCount() << ", input model has "
|
Chris@114
|
88 << input->getChannelCount() << ")" << std::endl;
|
Chris@114
|
89 return;
|
Chris@114
|
90 }
|
Chris@114
|
91
|
Chris@114
|
92 if (!m_plugin->initialise(channelCount, m_stepSize, m_blockSize)) {
|
Chris@114
|
93 std::cerr << "FeatureExtractionPluginTransform: Plugin "
|
Chris@114
|
94 << m_plugin->getName() << " failed to initialise!" << std::endl;
|
Chris@114
|
95 return;
|
Chris@114
|
96 }
|
Chris@114
|
97
|
Chris@74
|
98 //!!! cope with plugins that request non-power-of-2 block sizes in
|
Chris@74
|
99 // the frequency domain!
|
Chris@74
|
100
|
Chris@74
|
101 Vamp::Plugin::OutputList outputs = m_plugin->getOutputDescriptors();
|
Chris@0
|
102
|
Chris@0
|
103 if (outputs.empty()) {
|
Chris@0
|
104 std::cerr << "FeatureExtractionPluginTransform: Plugin \""
|
Chris@0
|
105 << pluginId.toStdString() << "\" has no outputs" << std::endl;
|
Chris@0
|
106 return;
|
Chris@0
|
107 }
|
Chris@0
|
108
|
Chris@0
|
109 for (size_t i = 0; i < outputs.size(); ++i) {
|
Chris@0
|
110 if (outputName == "" || outputs[i].name == outputName.toStdString()) {
|
Chris@0
|
111 m_outputFeatureNo = i;
|
Chris@66
|
112 m_descriptor = new Vamp::Plugin::OutputDescriptor
|
Chris@0
|
113 (outputs[i]);
|
Chris@0
|
114 break;
|
Chris@0
|
115 }
|
Chris@0
|
116 }
|
Chris@0
|
117
|
Chris@0
|
118 if (!m_descriptor) {
|
Chris@0
|
119 std::cerr << "FeatureExtractionPluginTransform: Plugin \""
|
Chris@0
|
120 << pluginId.toStdString() << "\" has no output named \""
|
Chris@0
|
121 << outputName.toStdString() << "\"" << std::endl;
|
Chris@0
|
122 return;
|
Chris@0
|
123 }
|
Chris@0
|
124
|
Chris@0
|
125 std::cerr << "FeatureExtractionPluginTransform: output sample type "
|
Chris@0
|
126 << m_descriptor->sampleType << std::endl;
|
Chris@0
|
127
|
Chris@70
|
128 int binCount = 1;
|
Chris@0
|
129 float minValue = 0.0, maxValue = 0.0;
|
Chris@0
|
130
|
Chris@70
|
131 if (m_descriptor->hasFixedBinCount) {
|
Chris@70
|
132 binCount = m_descriptor->binCount;
|
Chris@0
|
133 }
|
Chris@0
|
134
|
Chris@114
|
135 std::cerr << "FeatureExtractionPluginTransform: output bin count "
|
Chris@114
|
136 << binCount << std::endl;
|
Chris@114
|
137
|
Chris@70
|
138 if (binCount > 0 && m_descriptor->hasKnownExtents) {
|
Chris@0
|
139 minValue = m_descriptor->minValue;
|
Chris@0
|
140 maxValue = m_descriptor->maxValue;
|
Chris@0
|
141 }
|
Chris@0
|
142
|
Chris@0
|
143 size_t modelRate = m_input->getSampleRate();
|
Chris@0
|
144 size_t modelResolution = 1;
|
Chris@0
|
145
|
Chris@0
|
146 switch (m_descriptor->sampleType) {
|
Chris@0
|
147
|
Chris@66
|
148 case Vamp::Plugin::OutputDescriptor::VariableSampleRate:
|
Chris@0
|
149 if (m_descriptor->sampleRate != 0.0) {
|
Chris@0
|
150 modelResolution = size_t(modelRate / m_descriptor->sampleRate + 0.001);
|
Chris@0
|
151 }
|
Chris@0
|
152 break;
|
Chris@0
|
153
|
Chris@66
|
154 case Vamp::Plugin::OutputDescriptor::OneSamplePerStep:
|
Chris@72
|
155 modelResolution = m_stepSize;
|
Chris@0
|
156 break;
|
Chris@0
|
157
|
Chris@66
|
158 case Vamp::Plugin::OutputDescriptor::FixedSampleRate:
|
Chris@73
|
159 modelRate = size_t(m_descriptor->sampleRate + 0.001);
|
Chris@0
|
160 break;
|
Chris@0
|
161 }
|
Chris@0
|
162
|
Chris@70
|
163 if (binCount == 0) {
|
Chris@0
|
164
|
Chris@20
|
165 m_output = new SparseOneDimensionalModel(modelRate, modelResolution,
|
Chris@20
|
166 false);
|
Chris@0
|
167
|
Chris@70
|
168 } else if (binCount == 1 ||
|
Chris@0
|
169
|
Chris@0
|
170 // We don't have a sparse 3D model
|
Chris@0
|
171 m_descriptor->sampleType ==
|
Chris@66
|
172 Vamp::Plugin::OutputDescriptor::VariableSampleRate) {
|
Chris@0
|
173
|
Chris@63
|
174 SparseTimeValueModel *model = new SparseTimeValueModel
|
Chris@63
|
175 (modelRate, modelResolution, minValue, maxValue, false);
|
Chris@63
|
176 model->setScaleUnits(outputs[m_outputFeatureNo].unit.c_str());
|
Chris@63
|
177
|
Chris@63
|
178 m_output = model;
|
Chris@0
|
179
|
Chris@0
|
180 } else {
|
Chris@0
|
181
|
Chris@0
|
182 m_output = new DenseThreeDimensionalModel(modelRate, modelResolution,
|
Chris@70
|
183 binCount, false);
|
Chris@20
|
184
|
Chris@70
|
185 if (!m_descriptor->binNames.empty()) {
|
Chris@20
|
186 std::vector<QString> names;
|
Chris@70
|
187 for (size_t i = 0; i < m_descriptor->binNames.size(); ++i) {
|
Chris@70
|
188 names.push_back(m_descriptor->binNames[i].c_str());
|
Chris@20
|
189 }
|
Chris@20
|
190 (dynamic_cast<DenseThreeDimensionalModel *>(m_output))
|
Chris@20
|
191 ->setBinNames(names);
|
Chris@20
|
192 }
|
Chris@0
|
193 }
|
Chris@0
|
194 }
|
Chris@0
|
195
|
Chris@0
|
196 FeatureExtractionPluginTransform::~FeatureExtractionPluginTransform()
|
Chris@0
|
197 {
|
Chris@0
|
198 delete m_plugin;
|
Chris@0
|
199 delete m_descriptor;
|
Chris@0
|
200 }
|
Chris@0
|
201
|
Chris@0
|
202 DenseTimeValueModel *
|
Chris@0
|
203 FeatureExtractionPluginTransform::getInput()
|
Chris@0
|
204 {
|
Chris@0
|
205 DenseTimeValueModel *dtvm =
|
Chris@0
|
206 dynamic_cast<DenseTimeValueModel *>(getInputModel());
|
Chris@0
|
207 if (!dtvm) {
|
Chris@0
|
208 std::cerr << "FeatureExtractionPluginTransform::getInput: WARNING: Input model is not conformable to DenseTimeValueModel" << std::endl;
|
Chris@0
|
209 }
|
Chris@0
|
210 return dtvm;
|
Chris@0
|
211 }
|
Chris@0
|
212
|
Chris@0
|
213 void
|
Chris@0
|
214 FeatureExtractionPluginTransform::run()
|
Chris@0
|
215 {
|
Chris@0
|
216 DenseTimeValueModel *input = getInput();
|
Chris@0
|
217 if (!input) return;
|
Chris@0
|
218
|
Chris@0
|
219 if (!m_output) return;
|
Chris@0
|
220
|
Chris@114
|
221 size_t sampleRate = m_input->getSampleRate();
|
Chris@114
|
222
|
Chris@0
|
223 size_t channelCount = input->getChannelCount();
|
Chris@0
|
224 if (m_plugin->getMaxChannelCount() < channelCount) {
|
Chris@0
|
225 channelCount = 1;
|
Chris@0
|
226 }
|
Chris@0
|
227
|
Chris@0
|
228 float **buffers = new float*[channelCount];
|
Chris@0
|
229 for (size_t ch = 0; ch < channelCount; ++ch) {
|
Chris@68
|
230 buffers[ch] = new float[m_blockSize];
|
Chris@0
|
231 }
|
Chris@0
|
232
|
Chris@67
|
233 double *fftInput = 0;
|
Chris@67
|
234 fftw_complex *fftOutput = 0;
|
Chris@67
|
235 fftw_plan fftPlan = 0;
|
Chris@68
|
236 Window<double> windower(HanningWindow, m_blockSize);
|
Chris@67
|
237
|
Chris@67
|
238 if (m_plugin->getInputDomain() == Vamp::Plugin::FrequencyDomain) {
|
Chris@67
|
239
|
Chris@68
|
240 fftInput = (double *)fftw_malloc(m_blockSize * sizeof(double));
|
Chris@68
|
241 fftOutput = (fftw_complex *)fftw_malloc(m_blockSize * sizeof(fftw_complex));
|
Chris@68
|
242 fftPlan = fftw_plan_dft_r2c_1d(m_blockSize, fftInput, fftOutput,
|
Chris@67
|
243 FFTW_ESTIMATE);
|
Chris@67
|
244 if (!fftPlan) {
|
Chris@67
|
245 std::cerr << "ERROR: FeatureExtractionPluginTransform::run(): fftw_plan failed! Results will be garbage" << std::endl;
|
Chris@67
|
246 }
|
Chris@67
|
247 }
|
Chris@67
|
248
|
Chris@70
|
249 long startFrame = m_input->getStartFrame();
|
Chris@70
|
250 long endFrame = m_input->getEndFrame();
|
Chris@70
|
251 long blockFrame = startFrame;
|
Chris@0
|
252
|
Chris@70
|
253 long prevCompletion = 0;
|
Chris@0
|
254
|
Chris@70
|
255 while (1) {
|
Chris@70
|
256
|
Chris@70
|
257 if (fftPlan) {
|
Chris@73
|
258 if (blockFrame - int(m_blockSize)/2 > endFrame) break;
|
Chris@70
|
259 } else {
|
Chris@70
|
260 if (blockFrame >= endFrame) break;
|
Chris@70
|
261 }
|
Chris@0
|
262
|
Chris@0
|
263 // std::cerr << "FeatureExtractionPluginTransform::run: blockFrame "
|
Chris@0
|
264 // << blockFrame << std::endl;
|
Chris@0
|
265
|
Chris@70
|
266 long completion =
|
Chris@68
|
267 (((blockFrame - startFrame) / m_stepSize) * 99) /
|
Chris@68
|
268 ( (endFrame - startFrame) / m_stepSize);
|
Chris@0
|
269
|
Chris@0
|
270 // channelCount is either m_input->channelCount or 1
|
Chris@0
|
271
|
Chris@73
|
272 for (size_t ch = 0; ch < channelCount; ++ch) {
|
Chris@70
|
273 if (fftPlan) {
|
Chris@70
|
274 getFrames(ch, channelCount,
|
Chris@70
|
275 blockFrame - m_blockSize/2, m_blockSize, buffers[ch]);
|
Chris@70
|
276 } else {
|
Chris@70
|
277 getFrames(ch, channelCount,
|
Chris@70
|
278 blockFrame, m_blockSize, buffers[ch]);
|
Chris@70
|
279 }
|
Chris@70
|
280 }
|
Chris@70
|
281
|
Chris@67
|
282 if (fftPlan) {
|
Chris@73
|
283 for (size_t ch = 0; ch < channelCount; ++ch) {
|
Chris@73
|
284 for (size_t i = 0; i < m_blockSize; ++i) {
|
Chris@67
|
285 fftInput[i] = buffers[ch][i];
|
Chris@67
|
286 }
|
Chris@67
|
287 windower.cut(fftInput);
|
Chris@73
|
288 for (size_t i = 0; i < m_blockSize/2; ++i) {
|
Chris@67
|
289 double temp = fftInput[i];
|
Chris@68
|
290 fftInput[i] = fftInput[i + m_blockSize/2];
|
Chris@68
|
291 fftInput[i + m_blockSize/2] = temp;
|
Chris@67
|
292 }
|
Chris@67
|
293 fftw_execute(fftPlan);
|
Chris@73
|
294 for (size_t i = 0; i < m_blockSize/2; ++i) {
|
Chris@67
|
295 buffers[ch][i*2] = fftOutput[i][0];
|
Chris@67
|
296 buffers[ch][i*2 + 1] = fftOutput[i][1];
|
Chris@67
|
297 }
|
Chris@67
|
298 }
|
Chris@67
|
299 }
|
Chris@67
|
300
|
Chris@66
|
301 Vamp::Plugin::FeatureSet features = m_plugin->process
|
Chris@66
|
302 (buffers, Vamp::RealTime::frame2RealTime(blockFrame, sampleRate));
|
Chris@0
|
303
|
Chris@0
|
304 for (size_t fi = 0; fi < features[m_outputFeatureNo].size(); ++fi) {
|
Chris@66
|
305 Vamp::Plugin::Feature feature =
|
Chris@0
|
306 features[m_outputFeatureNo][fi];
|
Chris@0
|
307 addFeature(blockFrame, feature);
|
Chris@0
|
308 }
|
Chris@0
|
309
|
Chris@0
|
310 if (blockFrame == startFrame || completion > prevCompletion) {
|
Chris@0
|
311 setCompletion(completion);
|
Chris@0
|
312 prevCompletion = completion;
|
Chris@0
|
313 }
|
Chris@0
|
314
|
Chris@68
|
315 blockFrame += m_stepSize;
|
Chris@0
|
316 }
|
Chris@0
|
317
|
Chris@67
|
318 if (fftPlan) {
|
Chris@67
|
319 fftw_destroy_plan(fftPlan);
|
Chris@67
|
320 fftw_free(fftInput);
|
Chris@67
|
321 fftw_free(fftOutput);
|
Chris@67
|
322 }
|
Chris@67
|
323
|
Chris@66
|
324 Vamp::Plugin::FeatureSet features = m_plugin->getRemainingFeatures();
|
Chris@0
|
325
|
Chris@0
|
326 for (size_t fi = 0; fi < features[m_outputFeatureNo].size(); ++fi) {
|
Chris@66
|
327 Vamp::Plugin::Feature feature =
|
Chris@0
|
328 features[m_outputFeatureNo][fi];
|
Chris@0
|
329 addFeature(blockFrame, feature);
|
Chris@0
|
330 }
|
Chris@0
|
331
|
Chris@0
|
332 setCompletion(100);
|
Chris@0
|
333 }
|
Chris@0
|
334
|
Chris@70
|
335 void
|
Chris@70
|
336 FeatureExtractionPluginTransform::getFrames(int channel, int channelCount,
|
Chris@70
|
337 long startFrame, long size,
|
Chris@70
|
338 float *buffer)
|
Chris@70
|
339 {
|
Chris@70
|
340 long offset = 0;
|
Chris@70
|
341
|
Chris@70
|
342 if (startFrame < 0) {
|
Chris@70
|
343 for (int i = 0; i < size && startFrame + i < 0; ++i) {
|
Chris@70
|
344 buffer[i] = 0.0f;
|
Chris@70
|
345 }
|
Chris@70
|
346 offset = -startFrame;
|
Chris@70
|
347 size -= offset;
|
Chris@70
|
348 if (size <= 0) return;
|
Chris@70
|
349 startFrame = 0;
|
Chris@70
|
350 }
|
Chris@70
|
351
|
Chris@73
|
352 long got = getInput()->getValues
|
Chris@70
|
353 ((channelCount == 1 ? m_channel : channel),
|
Chris@70
|
354 startFrame, startFrame + size, buffer + offset);
|
Chris@70
|
355
|
Chris@70
|
356 while (got < size) {
|
Chris@70
|
357 buffer[offset + got] = 0.0;
|
Chris@70
|
358 ++got;
|
Chris@70
|
359 }
|
Chris@74
|
360
|
Chris@74
|
361 if (m_channel == -1 && channelCount == 1 &&
|
Chris@74
|
362 getInput()->getChannelCount() > 1) {
|
Chris@74
|
363 // use mean instead of sum, as plugin input
|
Chris@74
|
364 int cc = getInput()->getChannelCount();
|
Chris@74
|
365 for (long i = 0; i < size; ++i) {
|
Chris@74
|
366 buffer[i] /= cc;
|
Chris@74
|
367 }
|
Chris@74
|
368 }
|
Chris@70
|
369 }
|
Chris@0
|
370
|
Chris@0
|
371 void
|
Chris@0
|
372 FeatureExtractionPluginTransform::addFeature(size_t blockFrame,
|
Chris@66
|
373 const Vamp::Plugin::Feature &feature)
|
Chris@0
|
374 {
|
Chris@0
|
375 size_t inputRate = m_input->getSampleRate();
|
Chris@0
|
376
|
Chris@0
|
377 // std::cerr << "FeatureExtractionPluginTransform::addFeature("
|
Chris@0
|
378 // << blockFrame << ")" << std::endl;
|
Chris@0
|
379
|
Chris@70
|
380 int binCount = 1;
|
Chris@70
|
381 if (m_descriptor->hasFixedBinCount) {
|
Chris@70
|
382 binCount = m_descriptor->binCount;
|
Chris@0
|
383 }
|
Chris@0
|
384
|
Chris@0
|
385 size_t frame = blockFrame;
|
Chris@0
|
386
|
Chris@0
|
387 if (m_descriptor->sampleType ==
|
Chris@66
|
388 Vamp::Plugin::OutputDescriptor::VariableSampleRate) {
|
Chris@0
|
389
|
Chris@0
|
390 if (!feature.hasTimestamp) {
|
Chris@0
|
391 std::cerr
|
Chris@0
|
392 << "WARNING: FeatureExtractionPluginTransform::addFeature: "
|
Chris@0
|
393 << "Feature has variable sample rate but no timestamp!"
|
Chris@0
|
394 << std::endl;
|
Chris@0
|
395 return;
|
Chris@0
|
396 } else {
|
Chris@66
|
397 frame = Vamp::RealTime::realTime2Frame(feature.timestamp, inputRate);
|
Chris@0
|
398 }
|
Chris@0
|
399
|
Chris@0
|
400 } else if (m_descriptor->sampleType ==
|
Chris@66
|
401 Vamp::Plugin::OutputDescriptor::FixedSampleRate) {
|
Chris@0
|
402
|
Chris@0
|
403 if (feature.hasTimestamp) {
|
Chris@0
|
404 //!!! warning: sampleRate may be non-integral
|
Chris@66
|
405 frame = Vamp::RealTime::realTime2Frame(feature.timestamp,
|
Chris@66
|
406 m_descriptor->sampleRate);
|
Chris@0
|
407 } else {
|
Chris@0
|
408 frame = m_output->getEndFrame() + 1;
|
Chris@0
|
409 }
|
Chris@0
|
410 }
|
Chris@0
|
411
|
Chris@70
|
412 if (binCount == 0) {
|
Chris@0
|
413
|
Chris@0
|
414 SparseOneDimensionalModel *model = getOutput<SparseOneDimensionalModel>();
|
Chris@0
|
415 if (!model) return;
|
Chris@0
|
416 model->addPoint(SparseOneDimensionalModel::Point(frame, feature.label.c_str()));
|
Chris@0
|
417
|
Chris@70
|
418 } else if (binCount == 1 ||
|
Chris@0
|
419 m_descriptor->sampleType ==
|
Chris@66
|
420 Vamp::Plugin::OutputDescriptor::VariableSampleRate) {
|
Chris@0
|
421
|
Chris@0
|
422 float value = 0.0;
|
Chris@0
|
423 if (feature.values.size() > 0) value = feature.values[0];
|
Chris@0
|
424
|
Chris@0
|
425 SparseTimeValueModel *model = getOutput<SparseTimeValueModel>();
|
Chris@0
|
426 if (!model) return;
|
Chris@0
|
427 model->addPoint(SparseTimeValueModel::Point(frame, value, feature.label.c_str()));
|
Chris@0
|
428
|
Chris@0
|
429 } else {
|
Chris@0
|
430
|
Chris@0
|
431 DenseThreeDimensionalModel::BinValueSet values = feature.values;
|
Chris@0
|
432
|
Chris@0
|
433 DenseThreeDimensionalModel *model = getOutput<DenseThreeDimensionalModel>();
|
Chris@0
|
434 if (!model) return;
|
Chris@0
|
435
|
Chris@0
|
436 model->setBinValues(frame, values);
|
Chris@0
|
437 }
|
Chris@0
|
438 }
|
Chris@0
|
439
|
Chris@0
|
440 void
|
Chris@0
|
441 FeatureExtractionPluginTransform::setCompletion(int completion)
|
Chris@0
|
442 {
|
Chris@70
|
443 int binCount = 1;
|
Chris@70
|
444 if (m_descriptor->hasFixedBinCount) {
|
Chris@70
|
445 binCount = m_descriptor->binCount;
|
Chris@0
|
446 }
|
Chris@0
|
447
|
Chris@70
|
448 if (binCount == 0) {
|
Chris@0
|
449
|
Chris@0
|
450 SparseOneDimensionalModel *model = getOutput<SparseOneDimensionalModel>();
|
Chris@0
|
451 if (!model) return;
|
Chris@0
|
452 model->setCompletion(completion);
|
Chris@0
|
453
|
Chris@70
|
454 } else if (binCount == 1 ||
|
Chris@0
|
455 m_descriptor->sampleType ==
|
Chris@66
|
456 Vamp::Plugin::OutputDescriptor::VariableSampleRate) {
|
Chris@0
|
457
|
Chris@0
|
458 SparseTimeValueModel *model = getOutput<SparseTimeValueModel>();
|
Chris@0
|
459 if (!model) return;
|
Chris@0
|
460 model->setCompletion(completion);
|
Chris@0
|
461
|
Chris@0
|
462 } else {
|
Chris@0
|
463
|
Chris@19
|
464 DenseThreeDimensionalModel *model = getOutput<DenseThreeDimensionalModel>();
|
Chris@19
|
465 if (!model) return;
|
Chris@19
|
466 model->setCompletion(completion);
|
Chris@0
|
467 }
|
Chris@0
|
468 }
|
Chris@0
|
469
|