annotate TempogramPlugin.cpp @ 31:f795b84c1ff2

This include change seems necessary for my compiler
author Chris Cannam
date Thu, 04 Sep 2014 10:08:09 +0100
parents 36cffe6493e4
children 023d12fb71b1
rev   line source
c@0 1
c@0 2 // This is a skeleton file for use in creating your own plugin
c@0 3 // libraries. Replace MyPlugin and myPlugin throughout with the name
c@0 4 // of your first plugin class, and fill in the gaps as appropriate.
c@0 5
c@0 6
c@14 7 #include "TempogramPlugin.h"
c@25 8
c@4 9
c@0 10 using Vamp::FFT;
c@7 11 using Vamp::RealTime;
c@0 12 using namespace std;
c@0 13
c@14 14 TempogramPlugin::TempogramPlugin(float inputSampleRate) :
c@0 15 Plugin(inputSampleRate),
c@18 16 m_inputBlockSize(0), //host parameter
c@18 17 m_inputStepSize(0), //host parameter
c@29 18 m_noveltyCurveMinDB(-74), //parameter
c@29 19 m_noveltyCurveMinV(0), //set in initialise()
c@18 20 m_noveltyCurveCompressionConstant(1000), //parameter
c@18 21 m_tempogramLog2WindowLength(10), //parameter
c@29 22 m_tempogramWindowLength(0), //set in initialise()
c@18 23 m_tempogramLog2FftLength(m_tempogramLog2WindowLength), //parameter
c@29 24 m_tempogramFftLength(0), //set in initialise()
c@18 25 m_tempogramLog2HopSize(6), //parameter
c@29 26 m_tempogramHopSize(0), //set in initialise()
c@18 27 m_tempogramMinBPM(30), //parameter
c@18 28 m_tempogramMaxBPM(480), //parameter
c@18 29 m_tempogramMinBin(0), //set in initialise()
c@18 30 m_tempogramMaxBin(0), //set in initialise()
c@29 31 m_tempogramMinLag(0), //set in initialise()
c@29 32 m_tempogramMaxLag(0), //set in initialise()
c@18 33 m_cyclicTempogramMinBPM(30), //reset in initialise()
c@18 34 m_cyclicTempogramNumberOfOctaves(0), //set in initialise()
c@18 35 m_cyclicTempogramOctaveDivider(30) //parameter
c@0 36
c@0 37 // Also be sure to set your plugin parameters (presumably stored
c@0 38 // in member variables) to their default values here -- the host
c@0 39 // will not do that for you
c@0 40 {
c@0 41 }
c@0 42
c@14 43 TempogramPlugin::~TempogramPlugin()
c@0 44 {
c@0 45 //delete stuff
c@0 46 }
c@0 47
c@0 48 string
c@14 49 TempogramPlugin::getIdentifier() const
c@0 50 {
c@0 51 return "tempogram";
c@0 52 }
c@0 53
c@0 54 string
c@14 55 TempogramPlugin::getName() const
c@0 56 {
c@0 57 return "Tempogram";
c@0 58 }
c@0 59
c@0 60 string
c@14 61 TempogramPlugin::getDescription() const
c@0 62 {
c@0 63 // Return something helpful here!
c@0 64 return "Cyclic Tempogram as described by Peter Grosche and Meinard Muller";
c@0 65 }
c@0 66
c@0 67 string
c@14 68 TempogramPlugin::getMaker() const
c@0 69 {
c@0 70 //Your name here
c@0 71 return "Carl Bussey";
c@0 72 }
c@0 73
c@0 74 int
c@14 75 TempogramPlugin::getPluginVersion() const
c@0 76 {
c@0 77 // Increment this each time you release a version that behaves
c@0 78 // differently from the previous one
c@0 79 return 1;
c@0 80 }
c@0 81
c@0 82 string
c@14 83 TempogramPlugin::getCopyright() const
c@0 84 {
c@0 85 // This function is not ideally named. It does not necessarily
c@0 86 // need to say who made the plugin -- getMaker does that -- but it
c@0 87 // should indicate the terms under which it is distributed. For
c@0 88 // example, "Copyright (year). All Rights Reserved", or "GPL"
c@0 89 return "";
c@0 90 }
c@0 91
c@14 92 TempogramPlugin::InputDomain
c@14 93 TempogramPlugin::getInputDomain() const
c@0 94 {
c@0 95 return FrequencyDomain;
c@0 96 }
c@0 97
c@0 98 size_t
c@14 99 TempogramPlugin::getPreferredBlockSize() const
c@0 100 {
c@9 101 return 2048; // 0 means "I can handle any block size"
c@0 102 }
c@0 103
c@0 104 size_t
c@14 105 TempogramPlugin::getPreferredStepSize() const
c@0 106 {
c@9 107 return 1024; // 0 means "anything sensible"; in practice this
c@0 108 // means the same as the block size for TimeDomain
c@0 109 // plugins, or half of it for FrequencyDomain plugins
c@0 110 }
c@0 111
c@0 112 size_t
c@14 113 TempogramPlugin::getMinChannelCount() const
c@0 114 {
c@0 115 return 1;
c@0 116 }
c@0 117
c@0 118 size_t
c@14 119 TempogramPlugin::getMaxChannelCount() const
c@0 120 {
c@0 121 return 1;
c@0 122 }
c@0 123
c@14 124 TempogramPlugin::ParameterList
c@14 125 TempogramPlugin::getParameterDescriptors() const
c@0 126 {
c@0 127 ParameterList list;
c@0 128
c@0 129 // If the plugin has no adjustable parameters, return an empty
c@0 130 // list here (and there's no need to provide implementations of
c@0 131 // getParameter and setParameter in that case either).
c@0 132
c@0 133 // Note that it is your responsibility to make sure the parameters
c@0 134 // start off having their default values (e.g. in the constructor
c@0 135 // above). The host needs to know the default value so it can do
c@0 136 // things like provide a "reset to default" function, but it will
c@0 137 // not explicitly set your parameters to their defaults for you if
c@0 138 // they have not changed in the mean time.
c@0 139
c@14 140 ParameterDescriptor d1;
c@14 141 d1.identifier = "C";
c@15 142 d1.name = "Novelty Curve Spectrogram Compression Constant";
c@14 143 d1.description = "Spectrogram compression constant, C, used when retrieving the novelty curve from the audio.";
c@14 144 d1.unit = "";
c@14 145 d1.minValue = 2;
c@14 146 d1.maxValue = 10000;
c@14 147 d1.defaultValue = 1000;
c@14 148 d1.isQuantized = false;
c@14 149 list.push_back(d1);
c@29 150
c@29 151 ParameterDescriptor d2;
c@29 152 d2.identifier = "minDB";
c@29 153 d2.name = "Novelty Curve Minimum DB";
c@29 154 d2.description = "Spectrogram minimum DB used when removing unwanted peaks in the Spectrogram when retrieving the novelty curve from the audio.";
c@29 155 d2.unit = "";
c@29 156 d2.minValue = -100;
c@29 157 d2.maxValue = -50;
c@29 158 d2.defaultValue = -74;
c@29 159 d2.isQuantized = false;
c@29 160 list.push_back(d2);
c@9 161
c@14 162 ParameterDescriptor d3;
c@29 163 d3.identifier = "log2TN";
c@29 164 d3.name = "Tempogram Window Length";
c@29 165 d3.description = "FFT window length when analysing the novelty curve and extracting the tempogram time-frequency function.";
c@14 166 d3.unit = "";
c@29 167 d3.minValue = 7;
c@14 168 d3.maxValue = 12;
c@29 169 d3.defaultValue = 10;
c@14 170 d3.isQuantized = true;
c@14 171 d3.quantizeStep = 1;
c@14 172 for (int i = d3.minValue; i <= d3.maxValue; i++){
c@14 173 d3.valueNames.push_back(floatToString(pow((float)2,(float)i)));
c@14 174 }
c@14 175 list.push_back(d3);
c@9 176
c@14 177 ParameterDescriptor d4;
c@29 178 d4.identifier = "log2HopSize";
c@29 179 d4.name = "Tempogram Hopsize";
c@29 180 d4.description = "FFT hopsize when analysing the novelty curve and extracting the tempogram time-frequency function.";
c@14 181 d4.unit = "";
c@14 182 d4.minValue = 6;
c@14 183 d4.maxValue = 12;
c@29 184 d4.defaultValue = 6;
c@14 185 d4.isQuantized = true;
c@14 186 d4.quantizeStep = 1;
c@14 187 for (int i = d4.minValue; i <= d4.maxValue; i++){
c@14 188 d4.valueNames.push_back(floatToString(pow((float)2,(float)i)));
c@14 189 }
c@14 190 list.push_back(d4);
c@14 191
c@14 192 ParameterDescriptor d5;
c@29 193 d5.identifier = "log2FftLength";
c@29 194 d5.name = "Tempogram FFT Length";
c@29 195 d5.description = "FFT length when analysing the novelty curve and extracting the tempogram time-frequency function. This parameter determines the amount of zero padding.";
c@14 196 d5.unit = "";
c@29 197 d5.minValue = 6;
c@29 198 d5.maxValue = 12;
c@29 199 d5.defaultValue = d2.defaultValue;
c@14 200 d5.isQuantized = true;
c@29 201 d5.quantizeStep = 1;
c@29 202 for (int i = d5.minValue; i <= d5.maxValue; i++){
c@29 203 d4.valueNames.push_back(floatToString(pow((float)2,(float)i)));
c@29 204 }
c@14 205 list.push_back(d5);
c@14 206
c@14 207 ParameterDescriptor d6;
c@29 208 d6.identifier = "minBPM";
c@29 209 d6.name = "(Cyclic) Tempogram Minimum BPM";
c@29 210 d6.description = "The minimum BPM of the tempogram output bins.";
c@14 211 d6.unit = "";
c@29 212 d6.minValue = 0;
c@14 213 d6.maxValue = 2000;
c@29 214 d6.defaultValue = 30;
c@14 215 d6.isQuantized = true;
c@14 216 d6.quantizeStep = 5;
c@14 217 list.push_back(d6);
c@18 218
c@18 219 ParameterDescriptor d7;
c@29 220 d7.identifier = "maxBPM";
c@29 221 d7.name = "(Cyclic) Tempogram Maximum BPM";
c@29 222 d7.description = "The maximum BPM of the tempogram output bins.";
c@18 223 d7.unit = "";
c@29 224 d7.minValue = 30;
c@29 225 d7.maxValue = 2000;
c@29 226 d7.defaultValue = 480;
c@18 227 d7.isQuantized = true;
c@29 228 d7.quantizeStep = 5;
c@18 229 list.push_back(d7);
c@29 230
c@29 231 ParameterDescriptor d8;
c@29 232 d8.identifier = "octDiv";
c@29 233 d8.name = "Cyclic Tempogram Octave Divider";
c@29 234 d8.description = "The number bins within each octave.";
c@29 235 d8.unit = "";
c@29 236 d8.minValue = 5;
c@29 237 d8.maxValue = 60;
c@29 238 d8.defaultValue = 30;
c@29 239 d8.isQuantized = true;
c@29 240 d8.quantizeStep = 1;
c@29 241 list.push_back(d8);
c@0 242
c@0 243 return list;
c@0 244 }
c@0 245
c@0 246 float
c@14 247 TempogramPlugin::getParameter(string identifier) const
c@0 248 {
c@0 249 if (identifier == "C") {
c@18 250 return m_noveltyCurveCompressionConstant; // return the ACTUAL current value of your parameter here!
c@0 251 }
c@29 252 else if (identifier == "minDB"){
c@29 253 return m_noveltyCurveMinDB;
c@29 254 }
c@14 255 else if (identifier == "log2TN"){
c@18 256 return m_tempogramLog2WindowLength;
c@9 257 }
c@14 258 else if (identifier == "log2HopSize"){
c@18 259 return m_tempogramLog2HopSize;
c@14 260 }
c@14 261 else if (identifier == "log2FftLength"){
c@18 262 return m_tempogramLog2FftLength;
c@14 263 }
c@14 264 else if (identifier == "minBPM") {
c@18 265 return m_tempogramMinBPM;
c@9 266 }
c@14 267 else if (identifier == "maxBPM"){
c@18 268 return m_tempogramMaxBPM;
c@18 269 }
c@18 270 else if (identifier == "octDiv"){
c@18 271 return m_cyclicTempogramOctaveDivider;
c@0 272 }
c@0 273
c@0 274 return 0;
c@0 275 }
c@0 276
c@0 277 void
c@14 278 TempogramPlugin::setParameter(string identifier, float value)
c@0 279 {
c@9 280
c@0 281 if (identifier == "C") {
c@18 282 m_noveltyCurveCompressionConstant = value; // set the actual value of your parameter
c@0 283 }
c@29 284 else if (identifier == "minDB"){
c@29 285 m_noveltyCurveMinDB = value;
c@29 286 }
c@14 287 else if (identifier == "log2TN") {
c@18 288 m_tempogramLog2WindowLength = value;
c@0 289 }
c@14 290 else if (identifier == "log2HopSize"){
c@30 291 m_tempogramLog2HopSize = value;
c@14 292 }
c@18 293 else if (identifier == "log2FftLength"){
c@30 294 m_tempogramLog2FftLength = value;
c@14 295 }
c@14 296 else if (identifier == "minBPM") {
c@18 297 m_tempogramMinBPM = value;
c@9 298 }
c@14 299 else if (identifier == "maxBPM"){
c@18 300 m_tempogramMaxBPM = value;
c@18 301 }
c@18 302 else if (identifier == "octDiv"){
c@18 303 m_cyclicTempogramOctaveDivider = value;
c@9 304 }
c@9 305
c@9 306 }
c@9 307
c@14 308 TempogramPlugin::ProgramList
c@14 309 TempogramPlugin::getPrograms() const
c@0 310 {
c@0 311 ProgramList list;
c@0 312
c@0 313 // If you have no programs, return an empty list (or simply don't
c@0 314 // implement this function or getCurrentProgram/selectProgram)
c@0 315
c@0 316 return list;
c@0 317 }
c@0 318
c@0 319 string
c@14 320 TempogramPlugin::getCurrentProgram() const
c@0 321 {
c@0 322 return ""; // no programs
c@0 323 }
c@0 324
c@0 325 void
c@14 326 TempogramPlugin::selectProgram(string name)
c@0 327 {
c@0 328 }
c@0 329
c@14 330 TempogramPlugin::OutputList
c@14 331 TempogramPlugin::getOutputDescriptors() const
c@0 332 {
c@0 333 OutputList list;
c@0 334
c@0 335 // See OutputDescriptor documentation for the possibilities here.
c@0 336 // Every plugin must have at least one output.
c@1 337
c@7 338 float d_sampleRate;
c@18 339 float tempogramInputSampleRate = (float)m_inputSampleRate/m_inputStepSize;
c@7 340
c@25 341 OutputDescriptor d1;
c@25 342 d1.identifier = "cyclicTempogram";
c@25 343 d1.name = "Cyclic Tempogram";
c@25 344 d1.description = "Cyclic Tempogram";
c@25 345 d1.unit = "";
c@25 346 d1.hasFixedBinCount = true;
c@25 347 d1.binCount = m_cyclicTempogramOctaveDivider > 0 && !isnan(m_cyclicTempogramOctaveDivider) ? m_cyclicTempogramOctaveDivider : 0;
c@25 348 d1.hasKnownExtents = false;
c@25 349 d1.isQuantized = false;
c@25 350 d1.sampleType = OutputDescriptor::FixedSampleRate;
c@25 351 d_sampleRate = tempogramInputSampleRate/m_tempogramHopSize;
c@25 352 d1.sampleRate = d_sampleRate > 0.0 && !isnan(d_sampleRate) ? d_sampleRate : 0;
c@25 353 d1.hasDuration = false;
c@25 354 list.push_back(d1);
c@25 355
c@25 356 OutputDescriptor d2;
c@25 357 d2.identifier = "tempogramDFT";
c@25 358 d2.name = "Tempogram via DFT";
c@25 359 d2.description = "Tempogram via DFT";
c@25 360 d2.unit = "BPM";
c@25 361 d2.hasFixedBinCount = true;
c@25 362 d2.binCount = m_tempogramMaxBin - m_tempogramMinBin + 1;
c@25 363 d2.hasKnownExtents = false;
c@25 364 d2.isQuantized = false;
c@25 365 d2.sampleType = OutputDescriptor::FixedSampleRate;
c@25 366 d_sampleRate = tempogramInputSampleRate/m_tempogramHopSize;
c@25 367 d2.sampleRate = d_sampleRate > 0.0 && !isnan(d_sampleRate) ? d_sampleRate : 0.0;
c@25 368 for(int i = m_tempogramMinBin; i <= (int)m_tempogramMaxBin; i++){
c@25 369 float w = ((float)i/m_tempogramFftLength)*(tempogramInputSampleRate);
c@25 370 d2.binNames.push_back(floatToString(w*60));
c@25 371 }
c@25 372 d2.hasDuration = false;
c@25 373 list.push_back(d2);
c@25 374
c@21 375 OutputDescriptor d3;
c@25 376 d3.identifier = "tempogramACT";
c@25 377 d3.name = "Tempogram via ACT";
c@25 378 d3.description = "Tempogram via ACT";
c@25 379 d3.unit = "BPM";
c@21 380 d3.hasFixedBinCount = true;
c@28 381 d3.binCount = m_tempogramMaxLag - m_tempogramMinLag + 1;
c@21 382 d3.hasKnownExtents = false;
c@21 383 d3.isQuantized = false;
c@21 384 d3.sampleType = OutputDescriptor::FixedSampleRate;
c@21 385 d_sampleRate = tempogramInputSampleRate/m_tempogramHopSize;
c@25 386 d3.sampleRate = d_sampleRate > 0.0 && !isnan(d_sampleRate) ? d_sampleRate : 0.0;
c@28 387 for(int lag = m_tempogramMaxLag; lag >= (int)m_tempogramMinLag; lag--){
c@28 388 d3.binNames.push_back(floatToString(60/(m_inputStepSize*(lag/m_inputSampleRate))));
c@25 389 }
c@21 390 d3.hasDuration = false;
c@21 391 list.push_back(d3);
c@21 392
c@25 393 OutputDescriptor d4;
c@25 394 d4.identifier = "nc";
c@25 395 d4.name = "Novelty Curve";
c@25 396 d4.description = "Novelty Curve";
c@25 397 d4.unit = "";
c@25 398 d4.hasFixedBinCount = true;
c@25 399 d4.binCount = 1;
c@25 400 d4.hasKnownExtents = false;
c@25 401 d4.isQuantized = false;
c@25 402 d4.sampleType = OutputDescriptor::FixedSampleRate;
c@9 403 d_sampleRate = tempogramInputSampleRate;
c@25 404 d4.sampleRate = d_sampleRate > 0 && !isnan(d_sampleRate) ? d_sampleRate : 0;
c@25 405 d4.hasDuration = false;
c@25 406 list.push_back(d4);
c@18 407
c@0 408 return list;
c@0 409 }
c@0 410
c@20 411 bool
c@20 412 TempogramPlugin::initialise(size_t channels, size_t stepSize, size_t blockSize)
c@20 413 {
c@20 414 if (channels < getMinChannelCount() ||
c@20 415 channels > getMaxChannelCount()) return false;
c@20 416
c@20 417 // Real initialisation work goes here!
c@20 418 m_inputBlockSize = blockSize;
c@20 419 m_inputStepSize = stepSize;
c@20 420
c@24 421 //m_spectrogram = Spectrogram(m_inputBlockSize/2 + 1);
c@21 422 if (!handleParameterValues()) return false;
c@19 423 //cout << m_cyclicTempogramOctaveDivider << endl;
c@4 424
c@0 425 return true;
c@0 426 }
c@0 427
c@0 428 void
c@14 429 TempogramPlugin::reset()
c@0 430 {
c@0 431 // Clear buffers, reset stored values, etc
c@19 432 m_spectrogram.clear();
c@21 433 handleParameterValues();
c@0 434 }
c@0 435
c@14 436 TempogramPlugin::FeatureSet
c@14 437 TempogramPlugin::process(const float *const *inputBuffers, Vamp::RealTime timestamp)
c@0 438 {
c@23 439 int n = m_inputBlockSize/2 + 1;
c@0 440 const float *in = inputBuffers[0];
c@3 441
c@9 442 //calculate magnitude of FrequencyDomain input
c@22 443 vector<float> fftCoefficients;
c@23 444 for (int i = 0; i < n; i++){
c@0 445 float magnitude = sqrt(in[2*i] * in[2*i] + in[2*i + 1] * in[2*i + 1]);
c@29 446 magnitude = magnitude > m_noveltyCurveMinV ? magnitude : m_noveltyCurveMinV;
c@22 447 fftCoefficients.push_back(magnitude);
c@0 448 }
c@22 449 m_spectrogram.push_back(fftCoefficients);
c@24 450 //m_spectrogram.push_back(fftCoefficients);
c@21 451
c@23 452 return FeatureSet();
c@0 453 }
c@0 454
c@14 455 TempogramPlugin::FeatureSet
c@14 456 TempogramPlugin::getRemainingFeatures()
c@11 457 {
c@0 458
c@18 459 float * hannWindow = new float[m_tempogramWindowLength];
c@20 460 for (int i = 0; i < (int)m_tempogramWindowLength; i++){
c@14 461 hannWindow[i] = 0.0;
c@4 462 }
c@11 463
c@1 464 FeatureSet featureSet;
c@0 465
c@19 466 //initialise novelty curve processor
c@23 467 int numberOfBlocks = m_spectrogram.size();
c@20 468 //cerr << numberOfBlocks << endl;
c@22 469 NoveltyCurveProcessor nc(m_inputSampleRate, m_inputBlockSize, m_noveltyCurveCompressionConstant);
c@21 470 vector<float> noveltyCurve = nc.spectrogramToNoveltyCurve(m_spectrogram); //calculate novelty curvefrom magnitude data
c@4 471
c@9 472 //push novelty curve data to featureset 1 and set timestamps
c@23 473 for (int i = 0; i < numberOfBlocks; i++){
c@19 474 Feature noveltyCurveFeature;
c@19 475 noveltyCurveFeature.values.push_back(noveltyCurve[i]);
c@19 476 noveltyCurveFeature.hasTimestamp = false;
c@25 477 featureSet[3].push_back(noveltyCurveFeature);
c@21 478 assert(!isnan(noveltyCurveFeature.values.back()));
c@4 479 }
c@4 480
c@9 481 //window function for spectrogram
c@18 482 WindowFunction::hanning(hannWindow, m_tempogramWindowLength);
c@9 483
c@9 484 //initialise spectrogram processor
c@18 485 SpectrogramProcessor spectrogramProcessor(m_tempogramWindowLength, m_tempogramFftLength, m_tempogramHopSize);
c@9 486 //compute spectrogram from novelty curve data (i.e., tempogram)
c@25 487 Tempogram tempogramDFT = spectrogramProcessor.process(&noveltyCurve[0], numberOfBlocks, hannWindow);
c@18 488 delete []hannWindow;
c@18 489 hannWindow = 0;
c@0 490
c@25 491 int tempogramLength = tempogramDFT.size();
c@7 492
c@9 493 //push tempogram data to featureset 0 and set timestamps.
c@7 494 for (int block = 0; block < tempogramLength; block++){
c@25 495 Feature tempogramDFTFeature;
c@28 496
c@28 497 assert(tempogramDFT[block].size() == (m_tempogramFftLength/2 + 1));
c@28 498 for(int k = m_tempogramMinBin; k <= (int)m_tempogramMaxBin; k++){
c@28 499 tempogramDFTFeature.values.push_back(tempogramDFT[block][k]);
c@28 500 }
c@28 501 tempogramDFTFeature.hasTimestamp = false;
c@28 502 featureSet[1].push_back(tempogramDFTFeature);
c@28 503 }
c@28 504
c@28 505 AutocorrelationProcessor autocorrelationProcessor(m_tempogramWindowLength, m_tempogramHopSize);
c@28 506 Tempogram tempogramACT = autocorrelationProcessor.process(&noveltyCurve[0], numberOfBlocks);
c@28 507
c@28 508 for (int block = 0; block < tempogramLength; block++){
c@25 509 Feature tempogramACTFeature;
c@0 510
c@28 511 for(int k = m_tempogramMaxLag; k >= (int)m_tempogramMinLag; k--){
c@25 512 tempogramACTFeature.values.push_back(tempogramACT[block][k]);
c@0 513 }
c@25 514 tempogramACTFeature.hasTimestamp = false;
c@25 515 featureSet[2].push_back(tempogramACTFeature);
c@0 516 }
c@0 517
c@18 518 //Calculate cyclic tempogram
c@22 519 vector< vector<unsigned int> > logBins = calculateTempogramNearestNeighbourLogBins();
c@18 520
c@22 521 //assert((int)logBins.size() == m_cyclicTempogramOctaveDivider*m_cyclicTempogramNumberOfOctaves);
c@18 522 for (int block = 0; block < tempogramLength; block++){
c@19 523 Feature cyclicTempogramFeature;
c@18 524
c@23 525 for (int i = 0; i < m_cyclicTempogramOctaveDivider; i++){
c@18 526 float sum = 0;
c@21 527
c@23 528 for (int j = 0; j < m_cyclicTempogramNumberOfOctaves; j++){
c@25 529 sum += tempogramDFT[block][logBins[j][i]];
c@18 530 }
c@19 531 cyclicTempogramFeature.values.push_back(sum/m_cyclicTempogramNumberOfOctaves);
c@21 532 assert(!isnan(cyclicTempogramFeature.values.back()));
c@18 533 }
c@18 534
c@19 535 cyclicTempogramFeature.hasTimestamp = false;
c@21 536 featureSet[0].push_back(cyclicTempogramFeature);
c@18 537 }
c@0 538
c@0 539 return featureSet;
c@0 540 }
c@22 541
c@22 542 vector< vector<unsigned int> > TempogramPlugin::calculateTempogramNearestNeighbourLogBins() const
c@22 543 {
c@22 544 vector< vector<unsigned int> > logBins;
c@22 545
c@22 546 for (int octave = 0; octave < (int)m_cyclicTempogramNumberOfOctaves; octave++){
c@22 547 vector<unsigned int> octaveBins;
c@22 548
c@22 549 for (int bin = 0; bin < (int)m_cyclicTempogramOctaveDivider; bin++){
c@22 550 float bpm = m_cyclicTempogramMinBPM*pow(2.0f, octave+(float)bin/m_cyclicTempogramOctaveDivider);
c@22 551 octaveBins.push_back(bpmToBin(bpm));
c@23 552 //cout << octaveBins.back() << endl;
c@22 553 }
c@22 554 logBins.push_back(octaveBins);
c@22 555 }
c@22 556
c@22 557 //cerr << logBins.size() << endl;
c@22 558
c@22 559 return logBins;
c@22 560 }
c@22 561
c@22 562 unsigned int TempogramPlugin::bpmToBin(const float &bpm) const
c@22 563 {
c@22 564 float w = (float)bpm/60;
c@22 565 float sampleRate = m_inputSampleRate/m_inputStepSize;
c@22 566 int bin = floor((float)m_tempogramFftLength*w/sampleRate + 0.5);
c@22 567
c@22 568 if(bin < 0) bin = 0;
c@22 569 else if(bin > m_tempogramFftLength/2.0f) bin = m_tempogramFftLength;
c@22 570
c@22 571 return bin;
c@22 572 }
c@22 573
c@22 574 float TempogramPlugin::binToBPM(const int &bin) const
c@22 575 {
c@22 576 float sampleRate = m_inputSampleRate/m_inputStepSize;
c@22 577
c@22 578 return (bin*sampleRate/m_tempogramFftLength)*60;
c@22 579 }
c@22 580
c@22 581 bool TempogramPlugin::handleParameterValues(){
c@22 582
c@30 583 if (m_tempogramLog2HopSize <= 0) return false;
c@22 584 if (m_tempogramLog2FftLength <= 0) return false;
c@22 585
c@22 586 if (m_tempogramMinBPM >= m_tempogramMaxBPM){
c@22 587 m_tempogramMinBPM = 30;
c@22 588 m_tempogramMaxBPM = 480;
c@22 589 }
c@22 590
c@29 591 m_noveltyCurveMinV = pow(10,(float)m_noveltyCurveMinDB/20);
c@29 592
c@29 593 m_tempogramWindowLength = pow(2,m_tempogramLog2WindowLength);
c@29 594 m_tempogramHopSize = pow(2,m_tempogramLog2HopSize);
c@29 595 m_tempogramFftLength = pow(2,m_tempogramLog2FftLength);
c@29 596
c@30 597 if (m_tempogramFftLength < m_tempogramWindowLength){
c@30 598 m_tempogramFftLength = m_tempogramWindowLength;
c@30 599 }
c@30 600
c@22 601 float tempogramInputSampleRate = (float)m_inputSampleRate/m_inputStepSize;
c@28 602 m_tempogramMinBin = (max((int)floor(((m_tempogramMinBPM/60)/tempogramInputSampleRate)*m_tempogramFftLength), 0));
c@28 603 m_tempogramMaxBin = (min((int)ceil(((m_tempogramMaxBPM/60)/tempogramInputSampleRate)*m_tempogramFftLength), (int)(m_tempogramFftLength/2)));
c@28 604
c@28 605 m_tempogramMinLag = max((int)ceil((60/(m_inputStepSize * m_tempogramMaxBPM))*m_inputSampleRate), 0);
c@28 606 m_tempogramMaxLag = min((int)floor((60/(m_inputStepSize * m_tempogramMinBPM))*m_inputSampleRate), (int)m_tempogramWindowLength);
c@22 607
c@25 608 if (m_tempogramMinBPM > m_cyclicTempogramMinBPM) m_cyclicTempogramMinBPM = m_tempogramMinBPM; //m_cyclicTempogram can't be less than default = 30
c@22 609 float cyclicTempogramMaxBPM = 480;
c@22 610 if (m_tempogramMaxBPM < cyclicTempogramMaxBPM) cyclicTempogramMaxBPM = m_tempogramMaxBPM;
c@22 611
c@22 612 m_cyclicTempogramNumberOfOctaves = floor(log2(cyclicTempogramMaxBPM/m_cyclicTempogramMinBPM));
c@22 613
c@22 614 return true;
c@22 615 }
c@22 616
c@22 617 string TempogramPlugin::floatToString(float value) const
c@22 618 {
c@22 619 ostringstream ss;
c@22 620
c@22 621 if(!(ss << value)) throw runtime_error("TempogramPlugin::floatToString(): invalid conversion from float to string");
c@22 622 return ss.str();
c@22 623 }