annotate src/vamp-hostsdk/PluginBufferingAdapter.cpp @ 281:c860f892c3d7

* add some missing descriptions (pointed out by vamp-plugin-tester)
author cannam
date Wed, 18 Mar 2009 12:20:04 +0000
parents 91821a3ab0b6
children e0b7a35ea18e
rev   line source
cannam@233 1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
cannam@233 2
cannam@233 3 /*
cannam@233 4 Vamp
cannam@233 5
cannam@233 6 An API for audio analysis and feature extraction plugins.
cannam@233 7
cannam@233 8 Centre for Digital Music, Queen Mary, University of London.
cannam@233 9 Copyright 2006-2007 Chris Cannam and QMUL.
cannam@233 10 This file by Mark Levy and Chris Cannam, Copyright 2007-2008 QMUL.
cannam@233 11
cannam@233 12 Permission is hereby granted, free of charge, to any person
cannam@233 13 obtaining a copy of this software and associated documentation
cannam@233 14 files (the "Software"), to deal in the Software without
cannam@233 15 restriction, including without limitation the rights to use, copy,
cannam@233 16 modify, merge, publish, distribute, sublicense, and/or sell copies
cannam@233 17 of the Software, and to permit persons to whom the Software is
cannam@233 18 furnished to do so, subject to the following conditions:
cannam@233 19
cannam@233 20 The above copyright notice and this permission notice shall be
cannam@233 21 included in all copies or substantial portions of the Software.
cannam@233 22
cannam@233 23 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
cannam@233 24 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
cannam@233 25 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
cannam@233 26 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
cannam@233 27 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
cannam@233 28 CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
cannam@233 29 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
cannam@233 30
cannam@233 31 Except as contained in this notice, the names of the Centre for
cannam@233 32 Digital Music; Queen Mary, University of London; and Chris Cannam
cannam@233 33 shall not be used in advertising or otherwise to promote the sale,
cannam@233 34 use or other dealings in this Software without prior written
cannam@233 35 authorization.
cannam@233 36 */
cannam@233 37
cannam@233 38 #include <vector>
cannam@233 39 #include <map>
cannam@233 40
cannam@233 41 #include <vamp-hostsdk/PluginBufferingAdapter.h>
cannam@233 42
cannam@233 43 using std::vector;
cannam@233 44 using std::map;
cannam@233 45
cannam@263 46 _VAMP_SDK_HOSTSPACE_BEGIN(PluginBufferingAdapter.cpp)
cannam@263 47
cannam@233 48 namespace Vamp {
cannam@233 49
cannam@233 50 namespace HostExt {
cannam@233 51
cannam@233 52 class PluginBufferingAdapter::Impl
cannam@233 53 {
cannam@233 54 public:
cannam@233 55 Impl(Plugin *plugin, float inputSampleRate);
cannam@233 56 ~Impl();
cannam@233 57
cannam@233 58 void setPluginStepSize(size_t stepSize);
cannam@233 59 void setPluginBlockSize(size_t blockSize);
cannam@233 60
cannam@233 61 bool initialise(size_t channels, size_t stepSize, size_t blockSize);
cannam@233 62
cannam@233 63 void getActualStepAndBlockSizes(size_t &stepSize, size_t &blockSize);
cannam@233 64
cannam@233 65 OutputList getOutputDescriptors() const;
cannam@233 66
cannam@267 67 void setParameter(std::string, float);
cannam@267 68 void selectProgram(std::string);
cannam@267 69
cannam@233 70 void reset();
cannam@233 71
cannam@233 72 FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
cannam@233 73
cannam@233 74 FeatureSet getRemainingFeatures();
cannam@233 75
cannam@233 76 protected:
cannam@233 77 class RingBuffer
cannam@233 78 {
cannam@233 79 public:
cannam@233 80 RingBuffer(int n) :
cannam@233 81 m_buffer(new float[n+1]), m_writer(0), m_reader(0), m_size(n+1) { }
cannam@233 82 virtual ~RingBuffer() { delete[] m_buffer; }
cannam@233 83
cannam@233 84 int getSize() const { return m_size-1; }
cannam@233 85 void reset() { m_writer = 0; m_reader = 0; }
cannam@233 86
cannam@233 87 int getReadSpace() const {
cannam@233 88 int writer = m_writer, reader = m_reader, space;
cannam@233 89 if (writer > reader) space = writer - reader;
cannam@233 90 else if (writer < reader) space = (writer + m_size) - reader;
cannam@233 91 else space = 0;
cannam@233 92 return space;
cannam@233 93 }
cannam@233 94
cannam@233 95 int getWriteSpace() const {
cannam@233 96 int writer = m_writer;
cannam@233 97 int reader = m_reader;
cannam@233 98 int space = (reader + m_size - writer - 1);
cannam@233 99 if (space >= m_size) space -= m_size;
cannam@233 100 return space;
cannam@233 101 }
cannam@233 102
cannam@233 103 int peek(float *destination, int n) const {
cannam@233 104
cannam@233 105 int available = getReadSpace();
cannam@233 106
cannam@233 107 if (n > available) {
cannam@233 108 for (int i = available; i < n; ++i) {
cannam@233 109 destination[i] = 0.f;
cannam@233 110 }
cannam@233 111 n = available;
cannam@233 112 }
cannam@233 113 if (n == 0) return n;
cannam@233 114
cannam@233 115 int reader = m_reader;
cannam@233 116 int here = m_size - reader;
cannam@233 117 const float *const bufbase = m_buffer + reader;
cannam@233 118
cannam@233 119 if (here >= n) {
cannam@233 120 for (int i = 0; i < n; ++i) {
cannam@233 121 destination[i] = bufbase[i];
cannam@233 122 }
cannam@233 123 } else {
cannam@233 124 for (int i = 0; i < here; ++i) {
cannam@233 125 destination[i] = bufbase[i];
cannam@233 126 }
cannam@233 127 float *const destbase = destination + here;
cannam@233 128 const int nh = n - here;
cannam@233 129 for (int i = 0; i < nh; ++i) {
cannam@233 130 destbase[i] = m_buffer[i];
cannam@233 131 }
cannam@233 132 }
cannam@233 133
cannam@233 134 return n;
cannam@233 135 }
cannam@233 136
cannam@233 137 int skip(int n) {
cannam@233 138
cannam@233 139 int available = getReadSpace();
cannam@233 140 if (n > available) {
cannam@233 141 n = available;
cannam@233 142 }
cannam@233 143 if (n == 0) return n;
cannam@233 144
cannam@233 145 int reader = m_reader;
cannam@233 146 reader += n;
cannam@233 147 while (reader >= m_size) reader -= m_size;
cannam@233 148 m_reader = reader;
cannam@233 149 return n;
cannam@233 150 }
cannam@233 151
cannam@233 152 int write(const float *source, int n) {
cannam@233 153
cannam@233 154 int available = getWriteSpace();
cannam@233 155 if (n > available) {
cannam@233 156 n = available;
cannam@233 157 }
cannam@233 158 if (n == 0) return n;
cannam@233 159
cannam@233 160 int writer = m_writer;
cannam@233 161 int here = m_size - writer;
cannam@233 162 float *const bufbase = m_buffer + writer;
cannam@233 163
cannam@233 164 if (here >= n) {
cannam@233 165 for (int i = 0; i < n; ++i) {
cannam@233 166 bufbase[i] = source[i];
cannam@233 167 }
cannam@233 168 } else {
cannam@233 169 for (int i = 0; i < here; ++i) {
cannam@233 170 bufbase[i] = source[i];
cannam@233 171 }
cannam@233 172 const int nh = n - here;
cannam@233 173 const float *const srcbase = source + here;
cannam@233 174 float *const buf = m_buffer;
cannam@233 175 for (int i = 0; i < nh; ++i) {
cannam@233 176 buf[i] = srcbase[i];
cannam@233 177 }
cannam@233 178 }
cannam@233 179
cannam@233 180 writer += n;
cannam@233 181 while (writer >= m_size) writer -= m_size;
cannam@233 182 m_writer = writer;
cannam@233 183
cannam@233 184 return n;
cannam@233 185 }
cannam@233 186
cannam@233 187 int zero(int n) {
cannam@233 188
cannam@233 189 int available = getWriteSpace();
cannam@233 190 if (n > available) {
cannam@233 191 n = available;
cannam@233 192 }
cannam@233 193 if (n == 0) return n;
cannam@233 194
cannam@233 195 int writer = m_writer;
cannam@233 196 int here = m_size - writer;
cannam@233 197 float *const bufbase = m_buffer + writer;
cannam@233 198
cannam@233 199 if (here >= n) {
cannam@233 200 for (int i = 0; i < n; ++i) {
cannam@233 201 bufbase[i] = 0.f;
cannam@233 202 }
cannam@233 203 } else {
cannam@233 204 for (int i = 0; i < here; ++i) {
cannam@233 205 bufbase[i] = 0.f;
cannam@233 206 }
cannam@233 207 const int nh = n - here;
cannam@233 208 for (int i = 0; i < nh; ++i) {
cannam@233 209 m_buffer[i] = 0.f;
cannam@233 210 }
cannam@233 211 }
cannam@233 212
cannam@233 213 writer += n;
cannam@233 214 while (writer >= m_size) writer -= m_size;
cannam@233 215 m_writer = writer;
cannam@233 216
cannam@233 217 return n;
cannam@233 218 }
cannam@233 219
cannam@233 220 protected:
cannam@233 221 float *m_buffer;
cannam@233 222 int m_writer;
cannam@233 223 int m_reader;
cannam@233 224 int m_size;
cannam@233 225
cannam@233 226 private:
cannam@233 227 RingBuffer(const RingBuffer &); // not provided
cannam@233 228 RingBuffer &operator=(const RingBuffer &); // not provided
cannam@233 229 };
cannam@233 230
cannam@233 231 Plugin *m_plugin;
cannam@233 232 size_t m_inputStepSize; // value passed to wrapper initialise()
cannam@233 233 size_t m_inputBlockSize; // value passed to wrapper initialise()
cannam@233 234 size_t m_setStepSize; // value passed to setPluginStepSize()
cannam@233 235 size_t m_setBlockSize; // value passed to setPluginBlockSize()
cannam@233 236 size_t m_stepSize; // value actually used to initialise plugin
cannam@233 237 size_t m_blockSize; // value actually used to initialise plugin
cannam@233 238 size_t m_channels;
cannam@233 239 vector<RingBuffer *> m_queue;
cannam@233 240 float **m_buffers;
cannam@233 241 float m_inputSampleRate;
cannam@233 242 long m_frame;
cannam@233 243 bool m_unrun;
cannam@233 244 mutable OutputList m_outputs;
cannam@233 245 mutable std::map<int, bool> m_rewriteOutputTimes;
cannam@233 246
cannam@233 247 void processBlock(FeatureSet& allFeatureSets);
cannam@233 248 };
cannam@233 249
cannam@233 250 PluginBufferingAdapter::PluginBufferingAdapter(Plugin *plugin) :
cannam@233 251 PluginWrapper(plugin)
cannam@233 252 {
cannam@233 253 m_impl = new Impl(plugin, m_inputSampleRate);
cannam@233 254 }
cannam@233 255
cannam@233 256 PluginBufferingAdapter::~PluginBufferingAdapter()
cannam@233 257 {
cannam@233 258 delete m_impl;
cannam@233 259 }
cannam@233 260
cannam@233 261 size_t
cannam@233 262 PluginBufferingAdapter::getPreferredStepSize() const
cannam@233 263 {
cannam@233 264 return getPreferredBlockSize();
cannam@233 265 }
cannam@233 266
cannam@233 267 size_t
cannam@233 268 PluginBufferingAdapter::getPreferredBlockSize() const
cannam@233 269 {
cannam@233 270 return PluginWrapper::getPreferredBlockSize();
cannam@233 271 }
cannam@233 272
cannam@233 273 size_t
cannam@233 274 PluginBufferingAdapter::getPluginPreferredStepSize() const
cannam@233 275 {
cannam@233 276 return PluginWrapper::getPreferredStepSize();
cannam@233 277 }
cannam@233 278
cannam@233 279 size_t
cannam@233 280 PluginBufferingAdapter::getPluginPreferredBlockSize() const
cannam@233 281 {
cannam@233 282 return PluginWrapper::getPreferredBlockSize();
cannam@233 283 }
cannam@233 284
cannam@233 285 void
cannam@233 286 PluginBufferingAdapter::setPluginStepSize(size_t stepSize)
cannam@233 287 {
cannam@233 288 m_impl->setPluginStepSize(stepSize);
cannam@233 289 }
cannam@233 290
cannam@233 291 void
cannam@233 292 PluginBufferingAdapter::setPluginBlockSize(size_t blockSize)
cannam@233 293 {
cannam@233 294 m_impl->setPluginBlockSize(blockSize);
cannam@233 295 }
cannam@233 296
cannam@233 297 void
cannam@233 298 PluginBufferingAdapter::getActualStepAndBlockSizes(size_t &stepSize,
cannam@233 299 size_t &blockSize)
cannam@233 300 {
cannam@233 301 m_impl->getActualStepAndBlockSizes(stepSize, blockSize);
cannam@233 302 }
cannam@233 303
cannam@233 304 bool
cannam@233 305 PluginBufferingAdapter::initialise(size_t channels, size_t stepSize, size_t blockSize)
cannam@233 306 {
cannam@233 307 return m_impl->initialise(channels, stepSize, blockSize);
cannam@233 308 }
cannam@233 309
cannam@233 310 PluginBufferingAdapter::OutputList
cannam@233 311 PluginBufferingAdapter::getOutputDescriptors() const
cannam@233 312 {
cannam@233 313 return m_impl->getOutputDescriptors();
cannam@233 314 }
cannam@233 315
cannam@233 316 void
cannam@267 317 PluginBufferingAdapter::setParameter(std::string name, float value)
cannam@267 318 {
cannam@267 319 m_impl->setParameter(name, value);
cannam@267 320 }
cannam@267 321
cannam@267 322 void
cannam@267 323 PluginBufferingAdapter::selectProgram(std::string name)
cannam@267 324 {
cannam@267 325 m_impl->selectProgram(name);
cannam@267 326 }
cannam@267 327
cannam@267 328 void
cannam@233 329 PluginBufferingAdapter::reset()
cannam@233 330 {
cannam@233 331 m_impl->reset();
cannam@233 332 }
cannam@233 333
cannam@233 334 PluginBufferingAdapter::FeatureSet
cannam@233 335 PluginBufferingAdapter::process(const float *const *inputBuffers,
cannam@233 336 RealTime timestamp)
cannam@233 337 {
cannam@233 338 return m_impl->process(inputBuffers, timestamp);
cannam@233 339 }
cannam@233 340
cannam@233 341 PluginBufferingAdapter::FeatureSet
cannam@233 342 PluginBufferingAdapter::getRemainingFeatures()
cannam@233 343 {
cannam@233 344 return m_impl->getRemainingFeatures();
cannam@233 345 }
cannam@233 346
cannam@233 347 PluginBufferingAdapter::Impl::Impl(Plugin *plugin, float inputSampleRate) :
cannam@233 348 m_plugin(plugin),
cannam@233 349 m_inputStepSize(0),
cannam@233 350 m_inputBlockSize(0),
cannam@233 351 m_setStepSize(0),
cannam@233 352 m_setBlockSize(0),
cannam@233 353 m_stepSize(0),
cannam@233 354 m_blockSize(0),
cannam@233 355 m_channels(0),
cannam@233 356 m_queue(0),
cannam@233 357 m_buffers(0),
cannam@233 358 m_inputSampleRate(inputSampleRate),
cannam@233 359 m_frame(0),
cannam@233 360 m_unrun(true)
cannam@233 361 {
cannam@233 362 (void)getOutputDescriptors(); // set up m_outputs and m_rewriteOutputTimes
cannam@233 363 }
cannam@233 364
cannam@233 365 PluginBufferingAdapter::Impl::~Impl()
cannam@233 366 {
cannam@233 367 // the adapter will delete the plugin
cannam@233 368
cannam@233 369 for (size_t i = 0; i < m_channels; ++i) {
cannam@233 370 delete m_queue[i];
cannam@233 371 delete[] m_buffers[i];
cannam@233 372 }
cannam@233 373 delete[] m_buffers;
cannam@233 374 }
cannam@233 375
cannam@233 376 void
cannam@233 377 PluginBufferingAdapter::Impl::setPluginStepSize(size_t stepSize)
cannam@233 378 {
cannam@233 379 if (m_inputStepSize != 0) {
cannam@233 380 std::cerr << "PluginBufferingAdapter::setPluginStepSize: ERROR: Cannot be called after initialise()" << std::endl;
cannam@233 381 return;
cannam@233 382 }
cannam@233 383 m_setStepSize = stepSize;
cannam@233 384 }
cannam@233 385
cannam@233 386 void
cannam@233 387 PluginBufferingAdapter::Impl::setPluginBlockSize(size_t blockSize)
cannam@233 388 {
cannam@233 389 if (m_inputBlockSize != 0) {
cannam@233 390 std::cerr << "PluginBufferingAdapter::setPluginBlockSize: ERROR: Cannot be called after initialise()" << std::endl;
cannam@233 391 return;
cannam@233 392 }
cannam@233 393 m_setBlockSize = blockSize;
cannam@233 394 }
cannam@233 395
cannam@233 396 void
cannam@233 397 PluginBufferingAdapter::Impl::getActualStepAndBlockSizes(size_t &stepSize,
cannam@233 398 size_t &blockSize)
cannam@233 399 {
cannam@233 400 stepSize = m_stepSize;
cannam@233 401 blockSize = m_blockSize;
cannam@233 402 }
cannam@233 403
cannam@233 404 bool
cannam@233 405 PluginBufferingAdapter::Impl::initialise(size_t channels, size_t stepSize, size_t blockSize)
cannam@233 406 {
cannam@233 407 if (stepSize != blockSize) {
cannam@233 408 std::cerr << "PluginBufferingAdapter::initialise: input stepSize must be equal to blockSize for this adapter (stepSize = " << stepSize << ", blockSize = " << blockSize << ")" << std::endl;
cannam@233 409 return false;
cannam@233 410 }
cannam@233 411
cannam@233 412 m_channels = channels;
cannam@233 413 m_inputStepSize = stepSize;
cannam@233 414 m_inputBlockSize = blockSize;
cannam@233 415
cannam@233 416 // if the user has requested particular step or block sizes, use
cannam@233 417 // those; otherwise use the step and block sizes which the plugin
cannam@233 418 // prefers
cannam@233 419
cannam@233 420 m_stepSize = 0;
cannam@233 421 m_blockSize = 0;
cannam@233 422
cannam@233 423 if (m_setStepSize > 0) {
cannam@233 424 m_stepSize = m_setStepSize;
cannam@233 425 }
cannam@233 426 if (m_setBlockSize > 0) {
cannam@233 427 m_blockSize = m_setBlockSize;
cannam@233 428 }
cannam@233 429
cannam@233 430 if (m_stepSize == 0 && m_blockSize == 0) {
cannam@233 431 m_stepSize = m_plugin->getPreferredStepSize();
cannam@233 432 m_blockSize = m_plugin->getPreferredBlockSize();
cannam@233 433 }
cannam@233 434
cannam@233 435 bool freq = (m_plugin->getInputDomain() == Vamp::Plugin::FrequencyDomain);
cannam@233 436
cannam@233 437 // or sensible defaults if it has no preference
cannam@233 438 if (m_blockSize == 0) {
cannam@233 439 if (m_stepSize == 0) {
cannam@233 440 m_blockSize = 1024;
cannam@269 441 if (freq) {
cannam@269 442 m_stepSize = m_blockSize / 2;
cannam@269 443 } else {
cannam@269 444 m_stepSize = m_blockSize;
cannam@269 445 }
cannam@233 446 } else if (freq) {
cannam@233 447 m_blockSize = m_stepSize * 2;
cannam@233 448 } else {
cannam@233 449 m_blockSize = m_stepSize;
cannam@233 450 }
cannam@233 451 } else if (m_stepSize == 0) { // m_blockSize != 0 (that was handled above)
cannam@233 452 if (freq) {
cannam@233 453 m_stepSize = m_blockSize/2;
cannam@233 454 } else {
cannam@233 455 m_stepSize = m_blockSize;
cannam@233 456 }
cannam@233 457 }
cannam@233 458
cannam@233 459 // current implementation breaks if step is greater than block
cannam@233 460 if (m_stepSize > m_blockSize) {
cannam@233 461 size_t newBlockSize;
cannam@233 462 if (freq) {
cannam@233 463 newBlockSize = m_stepSize * 2;
cannam@233 464 } else {
cannam@233 465 newBlockSize = m_stepSize;
cannam@233 466 }
cannam@233 467 std::cerr << "PluginBufferingAdapter::initialise: WARNING: step size " << m_stepSize << " is greater than block size " << m_blockSize << ": cannot handle this in adapter; adjusting block size to " << newBlockSize << std::endl;
cannam@233 468 m_blockSize = newBlockSize;
cannam@233 469 }
cannam@233 470
cannam@233 471 std::cerr << "PluginBufferingAdapter::initialise: NOTE: stepSize " << m_inputStepSize << " -> " << m_stepSize
cannam@233 472 << ", blockSize " << m_inputBlockSize << " -> " << m_blockSize << std::endl;
cannam@233 473
cannam@233 474 m_buffers = new float *[m_channels];
cannam@233 475
cannam@233 476 for (size_t i = 0; i < m_channels; ++i) {
cannam@233 477 m_queue.push_back(new RingBuffer(m_blockSize + m_inputBlockSize));
cannam@233 478 m_buffers[i] = new float[m_blockSize];
cannam@233 479 }
cannam@233 480
cannam@267 481 bool success = m_plugin->initialise(m_channels, m_stepSize, m_blockSize);
cannam@267 482
cannam@269 483 // std::cerr << "PluginBufferingAdapter::initialise: success = " << success << std::endl;
cannam@268 484
cannam@267 485 if (success) {
cannam@267 486 // Re-query outputs; properties such as bin count may have
cannam@267 487 // changed on initialise
cannam@267 488 m_outputs.clear();
cannam@267 489 (void)getOutputDescriptors();
cannam@267 490 }
cannam@267 491
cannam@267 492 return success;
cannam@233 493 }
cannam@233 494
cannam@233 495 PluginBufferingAdapter::OutputList
cannam@233 496 PluginBufferingAdapter::Impl::getOutputDescriptors() const
cannam@233 497 {
cannam@233 498 if (m_outputs.empty()) {
cannam@269 499 // std::cerr << "PluginBufferingAdapter::getOutputDescriptors: querying anew" << std::endl;
cannam@268 500
cannam@233 501 m_outputs = m_plugin->getOutputDescriptors();
cannam@233 502 }
cannam@233 503
cannam@233 504 PluginBufferingAdapter::OutputList outs = m_outputs;
cannam@233 505
cannam@233 506 for (size_t i = 0; i < outs.size(); ++i) {
cannam@233 507
cannam@233 508 switch (outs[i].sampleType) {
cannam@233 509
cannam@233 510 case OutputDescriptor::OneSamplePerStep:
cannam@233 511 outs[i].sampleType = OutputDescriptor::FixedSampleRate;
cannam@233 512 outs[i].sampleRate = (1.f / m_inputSampleRate) * m_stepSize;
cannam@233 513 m_rewriteOutputTimes[i] = true;
cannam@233 514 break;
cannam@233 515
cannam@233 516 case OutputDescriptor::FixedSampleRate:
cannam@233 517 if (outs[i].sampleRate == 0.f) {
cannam@233 518 outs[i].sampleRate = (1.f / m_inputSampleRate) * m_stepSize;
cannam@233 519 }
cannam@233 520 // We actually only need to rewrite output times for
cannam@233 521 // features that don't have timestamps already, but we
cannam@233 522 // can't tell from here whether our features will have
cannam@233 523 // timestamps or not
cannam@233 524 m_rewriteOutputTimes[i] = true;
cannam@233 525 break;
cannam@233 526
cannam@233 527 case OutputDescriptor::VariableSampleRate:
cannam@233 528 m_rewriteOutputTimes[i] = false;
cannam@233 529 break;
cannam@233 530 }
cannam@233 531 }
cannam@233 532
cannam@233 533 return outs;
cannam@233 534 }
cannam@233 535
cannam@233 536 void
cannam@267 537 PluginBufferingAdapter::Impl::setParameter(std::string name, float value)
cannam@267 538 {
cannam@267 539 m_plugin->setParameter(name, value);
cannam@267 540
cannam@267 541 // Re-query outputs; properties such as bin count may have changed
cannam@267 542 m_outputs.clear();
cannam@267 543 (void)getOutputDescriptors();
cannam@267 544 }
cannam@267 545
cannam@267 546 void
cannam@267 547 PluginBufferingAdapter::Impl::selectProgram(std::string name)
cannam@267 548 {
cannam@267 549 m_plugin->selectProgram(name);
cannam@267 550
cannam@267 551 // Re-query outputs; properties such as bin count may have changed
cannam@267 552 m_outputs.clear();
cannam@267 553 (void)getOutputDescriptors();
cannam@267 554 }
cannam@267 555
cannam@267 556 void
cannam@233 557 PluginBufferingAdapter::Impl::reset()
cannam@233 558 {
cannam@233 559 m_frame = 0;
cannam@233 560 m_unrun = true;
cannam@233 561
cannam@233 562 for (size_t i = 0; i < m_queue.size(); ++i) {
cannam@233 563 m_queue[i]->reset();
cannam@233 564 }
cannam@233 565
cannam@233 566 m_plugin->reset();
cannam@233 567 }
cannam@233 568
cannam@233 569 PluginBufferingAdapter::FeatureSet
cannam@233 570 PluginBufferingAdapter::Impl::process(const float *const *inputBuffers,
cannam@233 571 RealTime timestamp)
cannam@233 572 {
cannam@233 573 if (m_inputStepSize == 0) {
cannam@233 574 std::cerr << "PluginBufferingAdapter::process: ERROR: Plugin has not been initialised" << std::endl;
cannam@233 575 return FeatureSet();
cannam@233 576 }
cannam@233 577
cannam@233 578 FeatureSet allFeatureSets;
cannam@233 579
cannam@233 580 if (m_unrun) {
cannam@233 581 m_frame = RealTime::realTime2Frame(timestamp,
cannam@233 582 int(m_inputSampleRate + 0.5));
cannam@233 583 m_unrun = false;
cannam@233 584 }
cannam@233 585
cannam@233 586 // queue the new input
cannam@233 587
cannam@233 588 for (size_t i = 0; i < m_channels; ++i) {
cannam@233 589 int written = m_queue[i]->write(inputBuffers[i], m_inputBlockSize);
cannam@233 590 if (written < int(m_inputBlockSize) && i == 0) {
cannam@233 591 std::cerr << "WARNING: PluginBufferingAdapter::Impl::process: "
cannam@233 592 << "Buffer overflow: wrote " << written
cannam@233 593 << " of " << m_inputBlockSize
cannam@233 594 << " input samples (for plugin step size "
cannam@233 595 << m_stepSize << ", block size " << m_blockSize << ")"
cannam@233 596 << std::endl;
cannam@233 597 }
cannam@233 598 }
cannam@233 599
cannam@233 600 // process as much as we can
cannam@233 601
cannam@233 602 while (m_queue[0]->getReadSpace() >= int(m_blockSize)) {
cannam@233 603 processBlock(allFeatureSets);
cannam@233 604 }
cannam@233 605
cannam@233 606 return allFeatureSets;
cannam@233 607 }
cannam@233 608
cannam@233 609 PluginBufferingAdapter::FeatureSet
cannam@233 610 PluginBufferingAdapter::Impl::getRemainingFeatures()
cannam@233 611 {
cannam@233 612 FeatureSet allFeatureSets;
cannam@233 613
cannam@233 614 // process remaining samples in queue
cannam@233 615 while (m_queue[0]->getReadSpace() >= int(m_blockSize)) {
cannam@233 616 processBlock(allFeatureSets);
cannam@233 617 }
cannam@233 618
cannam@233 619 // pad any last samples remaining and process
cannam@233 620 if (m_queue[0]->getReadSpace() > 0) {
cannam@233 621 for (size_t i = 0; i < m_channels; ++i) {
cannam@233 622 m_queue[i]->zero(m_blockSize - m_queue[i]->getReadSpace());
cannam@233 623 }
cannam@233 624 processBlock(allFeatureSets);
cannam@233 625 }
cannam@233 626
cannam@233 627 // get remaining features
cannam@233 628
cannam@233 629 FeatureSet featureSet = m_plugin->getRemainingFeatures();
cannam@233 630
cannam@233 631 for (map<int, FeatureList>::iterator iter = featureSet.begin();
cannam@233 632 iter != featureSet.end(); ++iter) {
cannam@233 633 FeatureList featureList = iter->second;
cannam@233 634 for (size_t i = 0; i < featureList.size(); ++i) {
cannam@233 635 allFeatureSets[iter->first].push_back(featureList[i]);
cannam@233 636 }
cannam@233 637 }
cannam@233 638
cannam@233 639 return allFeatureSets;
cannam@233 640 }
cannam@233 641
cannam@233 642 void
cannam@233 643 PluginBufferingAdapter::Impl::processBlock(FeatureSet& allFeatureSets)
cannam@233 644 {
cannam@233 645 for (size_t i = 0; i < m_channels; ++i) {
cannam@233 646 m_queue[i]->peek(m_buffers[i], m_blockSize);
cannam@233 647 }
cannam@233 648
cannam@233 649 long frame = m_frame;
cannam@233 650 RealTime timestamp = RealTime::frame2RealTime
cannam@233 651 (frame, int(m_inputSampleRate + 0.5));
cannam@233 652
cannam@233 653 FeatureSet featureSet = m_plugin->process(m_buffers, timestamp);
cannam@233 654
cannam@233 655 for (FeatureSet::iterator iter = featureSet.begin();
cannam@233 656 iter != featureSet.end(); ++iter) {
cannam@233 657
cannam@233 658 int outputNo = iter->first;
cannam@233 659
cannam@233 660 if (m_rewriteOutputTimes[outputNo]) {
cannam@233 661
cannam@233 662 FeatureList featureList = iter->second;
cannam@233 663
cannam@233 664 for (size_t i = 0; i < featureList.size(); ++i) {
cannam@233 665
cannam@233 666 switch (m_outputs[outputNo].sampleType) {
cannam@233 667
cannam@233 668 case OutputDescriptor::OneSamplePerStep:
cannam@233 669 // use our internal timestamp, always
cannam@233 670 featureList[i].timestamp = timestamp;
cannam@233 671 featureList[i].hasTimestamp = true;
cannam@233 672 break;
cannam@233 673
cannam@233 674 case OutputDescriptor::FixedSampleRate:
cannam@233 675 // use our internal timestamp if feature lacks one
cannam@233 676 if (!featureList[i].hasTimestamp) {
cannam@233 677 featureList[i].timestamp = timestamp;
cannam@233 678 featureList[i].hasTimestamp = true;
cannam@233 679 }
cannam@233 680 break;
cannam@233 681
cannam@233 682 case OutputDescriptor::VariableSampleRate:
cannam@233 683 break; // plugin must set timestamp
cannam@233 684
cannam@233 685 default:
cannam@233 686 break;
cannam@233 687 }
cannam@233 688
cannam@233 689 allFeatureSets[outputNo].push_back(featureList[i]);
cannam@233 690 }
cannam@233 691 } else {
cannam@233 692 for (size_t i = 0; i < iter->second.size(); ++i) {
cannam@233 693 allFeatureSets[outputNo].push_back(iter->second[i]);
cannam@233 694 }
cannam@233 695 }
cannam@233 696 }
cannam@233 697
cannam@233 698 // step forward
cannam@233 699
cannam@233 700 for (size_t i = 0; i < m_channels; ++i) {
cannam@233 701 m_queue[i]->skip(m_stepSize);
cannam@233 702 }
cannam@233 703
cannam@233 704 // increment internal frame counter each time we step forward
cannam@233 705 m_frame += m_stepSize;
cannam@233 706 }
cannam@233 707
cannam@233 708 }
cannam@233 709
cannam@233 710 }
cannam@233 711
cannam@263 712 _VAMP_SDK_HOSTSPACE_END(PluginBufferingAdapter.cpp)