Mercurial > hg > svcore
comparison transform/FeatureExtractionPluginTransform.cpp @ 66:7afcfe666910
* Modify to use Vamp SDK for proper feature extraction plugins.
Requires that the vamp-plugin-sdk directory tree be present below
plugin/ (it's separate in Subversion).
author | Chris Cannam |
---|---|
date | Fri, 31 Mar 2006 15:56:35 +0000 |
parents | 4d59dc469b0f |
children | eb530055ed55 |
comparison
equal
deleted
inserted
replaced
65:e1aad27029e3 | 66:7afcfe666910 |
---|---|
15 */ | 15 */ |
16 | 16 |
17 #include "FeatureExtractionPluginTransform.h" | 17 #include "FeatureExtractionPluginTransform.h" |
18 | 18 |
19 #include "plugin/FeatureExtractionPluginFactory.h" | 19 #include "plugin/FeatureExtractionPluginFactory.h" |
20 #include "plugin/FeatureExtractionPlugin.h" | 20 #include "plugin/PluginXml.h" |
21 #include "vamp-sdk/Plugin.h" | |
21 | 22 |
22 #include "base/Model.h" | 23 #include "base/Model.h" |
23 #include "model/SparseOneDimensionalModel.h" | 24 #include "model/SparseOneDimensionalModel.h" |
24 #include "model/SparseTimeValueModel.h" | 25 #include "model/SparseTimeValueModel.h" |
25 #include "model/DenseThreeDimensionalModel.h" | 26 #include "model/DenseThreeDimensionalModel.h" |
56 << pluginId.toStdString() << "\"" << std::endl; | 57 << pluginId.toStdString() << "\"" << std::endl; |
57 return; | 58 return; |
58 } | 59 } |
59 | 60 |
60 if (configurationXml != "") { | 61 if (configurationXml != "") { |
61 m_plugin->setParametersFromXml(configurationXml); | 62 PluginXml(m_plugin).setParametersFromXml(configurationXml); |
62 } | 63 } |
63 | 64 |
64 FeatureExtractionPlugin::OutputList outputs = | 65 Vamp::Plugin::OutputList outputs = |
65 m_plugin->getOutputDescriptors(); | 66 m_plugin->getOutputDescriptors(); |
66 | 67 |
67 if (outputs.empty()) { | 68 if (outputs.empty()) { |
68 std::cerr << "FeatureExtractionPluginTransform: Plugin \"" | 69 std::cerr << "FeatureExtractionPluginTransform: Plugin \"" |
69 << pluginId.toStdString() << "\" has no outputs" << std::endl; | 70 << pluginId.toStdString() << "\" has no outputs" << std::endl; |
71 } | 72 } |
72 | 73 |
73 for (size_t i = 0; i < outputs.size(); ++i) { | 74 for (size_t i = 0; i < outputs.size(); ++i) { |
74 if (outputName == "" || outputs[i].name == outputName.toStdString()) { | 75 if (outputName == "" || outputs[i].name == outputName.toStdString()) { |
75 m_outputFeatureNo = i; | 76 m_outputFeatureNo = i; |
76 m_descriptor = new FeatureExtractionPlugin::OutputDescriptor | 77 m_descriptor = new Vamp::Plugin::OutputDescriptor |
77 (outputs[i]); | 78 (outputs[i]); |
78 break; | 79 break; |
79 } | 80 } |
80 } | 81 } |
81 | 82 |
104 size_t modelRate = m_input->getSampleRate(); | 105 size_t modelRate = m_input->getSampleRate(); |
105 size_t modelResolution = 1; | 106 size_t modelResolution = 1; |
106 | 107 |
107 switch (m_descriptor->sampleType) { | 108 switch (m_descriptor->sampleType) { |
108 | 109 |
109 case FeatureExtractionPlugin::OutputDescriptor::VariableSampleRate: | 110 case Vamp::Plugin::OutputDescriptor::VariableSampleRate: |
110 if (m_descriptor->sampleRate != 0.0) { | 111 if (m_descriptor->sampleRate != 0.0) { |
111 modelResolution = size_t(modelRate / m_descriptor->sampleRate + 0.001); | 112 modelResolution = size_t(modelRate / m_descriptor->sampleRate + 0.001); |
112 } | 113 } |
113 break; | 114 break; |
114 | 115 |
115 case FeatureExtractionPlugin::OutputDescriptor::OneSamplePerStep: | 116 case Vamp::Plugin::OutputDescriptor::OneSamplePerStep: |
116 modelResolution = m_plugin->getPreferredStepSize(); | 117 modelResolution = m_plugin->getPreferredStepSize(); |
117 break; | 118 break; |
118 | 119 |
119 case FeatureExtractionPlugin::OutputDescriptor::FixedSampleRate: | 120 case Vamp::Plugin::OutputDescriptor::FixedSampleRate: |
120 modelRate = m_descriptor->sampleRate; | 121 modelRate = m_descriptor->sampleRate; |
121 break; | 122 break; |
122 } | 123 } |
123 | 124 |
124 if (valueCount == 0) { | 125 if (valueCount == 0) { |
128 | 129 |
129 } else if (valueCount == 1 || | 130 } else if (valueCount == 1 || |
130 | 131 |
131 // We don't have a sparse 3D model | 132 // We don't have a sparse 3D model |
132 m_descriptor->sampleType == | 133 m_descriptor->sampleType == |
133 FeatureExtractionPlugin::OutputDescriptor::VariableSampleRate) { | 134 Vamp::Plugin::OutputDescriptor::VariableSampleRate) { |
134 | 135 |
135 SparseTimeValueModel *model = new SparseTimeValueModel | 136 SparseTimeValueModel *model = new SparseTimeValueModel |
136 (modelRate, modelResolution, minValue, maxValue, false); | 137 (modelRate, modelResolution, minValue, maxValue, false); |
137 model->setScaleUnits(outputs[m_outputFeatureNo].unit.c_str()); | 138 model->setScaleUnits(outputs[m_outputFeatureNo].unit.c_str()); |
138 | 139 |
237 buffers[ch][got++] = 0.0; | 238 buffers[ch][got++] = 0.0; |
238 } | 239 } |
239 } | 240 } |
240 } | 241 } |
241 | 242 |
242 FeatureExtractionPlugin::FeatureSet features = m_plugin->process | 243 Vamp::Plugin::FeatureSet features = m_plugin->process |
243 (buffers, RealTime::frame2RealTime(blockFrame, sampleRate)); | 244 (buffers, Vamp::RealTime::frame2RealTime(blockFrame, sampleRate)); |
244 | 245 |
245 for (size_t fi = 0; fi < features[m_outputFeatureNo].size(); ++fi) { | 246 for (size_t fi = 0; fi < features[m_outputFeatureNo].size(); ++fi) { |
246 FeatureExtractionPlugin::Feature feature = | 247 Vamp::Plugin::Feature feature = |
247 features[m_outputFeatureNo][fi]; | 248 features[m_outputFeatureNo][fi]; |
248 addFeature(blockFrame, feature); | 249 addFeature(blockFrame, feature); |
249 } | 250 } |
250 | 251 |
251 if (blockFrame == startFrame || completion > prevCompletion) { | 252 if (blockFrame == startFrame || completion > prevCompletion) { |
254 } | 255 } |
255 | 256 |
256 blockFrame += stepSize; | 257 blockFrame += stepSize; |
257 } | 258 } |
258 | 259 |
259 FeatureExtractionPlugin::FeatureSet features = m_plugin->getRemainingFeatures(); | 260 Vamp::Plugin::FeatureSet features = m_plugin->getRemainingFeatures(); |
260 | 261 |
261 for (size_t fi = 0; fi < features[m_outputFeatureNo].size(); ++fi) { | 262 for (size_t fi = 0; fi < features[m_outputFeatureNo].size(); ++fi) { |
262 FeatureExtractionPlugin::Feature feature = | 263 Vamp::Plugin::Feature feature = |
263 features[m_outputFeatureNo][fi]; | 264 features[m_outputFeatureNo][fi]; |
264 addFeature(blockFrame, feature); | 265 addFeature(blockFrame, feature); |
265 } | 266 } |
266 | 267 |
267 setCompletion(100); | 268 setCompletion(100); |
268 } | 269 } |
269 | 270 |
270 | 271 |
271 void | 272 void |
272 FeatureExtractionPluginTransform::addFeature(size_t blockFrame, | 273 FeatureExtractionPluginTransform::addFeature(size_t blockFrame, |
273 const FeatureExtractionPlugin::Feature &feature) | 274 const Vamp::Plugin::Feature &feature) |
274 { | 275 { |
275 size_t inputRate = m_input->getSampleRate(); | 276 size_t inputRate = m_input->getSampleRate(); |
276 | 277 |
277 // std::cerr << "FeatureExtractionPluginTransform::addFeature(" | 278 // std::cerr << "FeatureExtractionPluginTransform::addFeature(" |
278 // << blockFrame << ")" << std::endl; | 279 // << blockFrame << ")" << std::endl; |
283 } | 284 } |
284 | 285 |
285 size_t frame = blockFrame; | 286 size_t frame = blockFrame; |
286 | 287 |
287 if (m_descriptor->sampleType == | 288 if (m_descriptor->sampleType == |
288 FeatureExtractionPlugin::OutputDescriptor::VariableSampleRate) { | 289 Vamp::Plugin::OutputDescriptor::VariableSampleRate) { |
289 | 290 |
290 if (!feature.hasTimestamp) { | 291 if (!feature.hasTimestamp) { |
291 std::cerr | 292 std::cerr |
292 << "WARNING: FeatureExtractionPluginTransform::addFeature: " | 293 << "WARNING: FeatureExtractionPluginTransform::addFeature: " |
293 << "Feature has variable sample rate but no timestamp!" | 294 << "Feature has variable sample rate but no timestamp!" |
294 << std::endl; | 295 << std::endl; |
295 return; | 296 return; |
296 } else { | 297 } else { |
297 frame = RealTime::realTime2Frame(feature.timestamp, inputRate); | 298 frame = Vamp::RealTime::realTime2Frame(feature.timestamp, inputRate); |
298 } | 299 } |
299 | 300 |
300 } else if (m_descriptor->sampleType == | 301 } else if (m_descriptor->sampleType == |
301 FeatureExtractionPlugin::OutputDescriptor::FixedSampleRate) { | 302 Vamp::Plugin::OutputDescriptor::FixedSampleRate) { |
302 | 303 |
303 if (feature.hasTimestamp) { | 304 if (feature.hasTimestamp) { |
304 //!!! warning: sampleRate may be non-integral | 305 //!!! warning: sampleRate may be non-integral |
305 frame = RealTime::realTime2Frame(feature.timestamp, | 306 frame = Vamp::RealTime::realTime2Frame(feature.timestamp, |
306 m_descriptor->sampleRate); | 307 m_descriptor->sampleRate); |
307 } else { | 308 } else { |
308 frame = m_output->getEndFrame() + 1; | 309 frame = m_output->getEndFrame() + 1; |
309 } | 310 } |
310 } | 311 } |
311 | 312 |
315 if (!model) return; | 316 if (!model) return; |
316 model->addPoint(SparseOneDimensionalModel::Point(frame, feature.label.c_str())); | 317 model->addPoint(SparseOneDimensionalModel::Point(frame, feature.label.c_str())); |
317 | 318 |
318 } else if (valueCount == 1 || | 319 } else if (valueCount == 1 || |
319 m_descriptor->sampleType == | 320 m_descriptor->sampleType == |
320 FeatureExtractionPlugin::OutputDescriptor::VariableSampleRate) { | 321 Vamp::Plugin::OutputDescriptor::VariableSampleRate) { |
321 | 322 |
322 float value = 0.0; | 323 float value = 0.0; |
323 if (feature.values.size() > 0) value = feature.values[0]; | 324 if (feature.values.size() > 0) value = feature.values[0]; |
324 | 325 |
325 SparseTimeValueModel *model = getOutput<SparseTimeValueModel>(); | 326 SparseTimeValueModel *model = getOutput<SparseTimeValueModel>(); |
351 if (!model) return; | 352 if (!model) return; |
352 model->setCompletion(completion); | 353 model->setCompletion(completion); |
353 | 354 |
354 } else if (valueCount == 1 || | 355 } else if (valueCount == 1 || |
355 m_descriptor->sampleType == | 356 m_descriptor->sampleType == |
356 FeatureExtractionPlugin::OutputDescriptor::VariableSampleRate) { | 357 Vamp::Plugin::OutputDescriptor::VariableSampleRate) { |
357 | 358 |
358 SparseTimeValueModel *model = getOutput<SparseTimeValueModel>(); | 359 SparseTimeValueModel *model = getOutput<SparseTimeValueModel>(); |
359 if (!model) return; | 360 if (!model) return; |
360 model->setCompletion(completion); | 361 model->setCompletion(completion); |
361 | 362 |