c@0: 
c@0: // This is a skeleton file for use in creating your own plugin
c@0: // libraries.  Replace MyPlugin and myPlugin throughout with the name
c@0: // of your first plugin class, and fill in the gaps as appropriate.
c@0: 
c@0: 
c@14: #include "TempogramPlugin.h"
c@9: #include <sstream>
c@9: #include <stdexcept>
c@4: 
c@0: using Vamp::FFT;
c@7: using Vamp::RealTime;
c@0: using namespace std;
c@0: 
c@14: TempogramPlugin::TempogramPlugin(float inputSampleRate) :
c@0:     Plugin(inputSampleRate),
c@18:     m_inputBlockSize(0), //host parameter
c@18:     m_inputStepSize(0), //host parameter
c@19:     m_noveltyCurveMinDB(pow(10,(float)-74/20)), //set in initialise()
c@18:     m_noveltyCurveCompressionConstant(1000), //parameter
c@18:     m_tempogramLog2WindowLength(10), //parameter
c@18:     m_tempogramWindowLength(pow((float)2,m_tempogramLog2WindowLength)),
c@18:     m_tempogramLog2FftLength(m_tempogramLog2WindowLength), //parameter
c@18:     m_tempogramFftLength(m_tempogramWindowLength),
c@18:     m_tempogramLog2HopSize(6), //parameter
c@18:     m_tempogramHopSize(pow((float)2,m_tempogramLog2HopSize)),
c@18:     m_tempogramMinBPM(30), //parameter
c@18:     m_tempogramMaxBPM(480), //parameter
c@18:     m_tempogramMinBin(0), //set in initialise()
c@18:     m_tempogramMaxBin(0), //set in initialise()
c@18:     m_cyclicTempogramMinBPM(30), //reset in initialise()
c@18:     m_cyclicTempogramNumberOfOctaves(0), //set in initialise()
c@18:     m_cyclicTempogramOctaveDivider(30) //parameter
c@0: 
c@0:     // Also be sure to set your plugin parameters (presumably stored
c@0:     // in member variables) to their default values here -- the host
c@0:     // will not do that for you
c@0: {
c@0: }
c@0: 
c@14: TempogramPlugin::~TempogramPlugin()
c@0: {
c@0:     //delete stuff
c@19:     
c@0: }
c@0: 
c@0: string
c@14: TempogramPlugin::getIdentifier() const
c@0: {
c@0:     return "tempogram";
c@0: }
c@0: 
c@0: string
c@14: TempogramPlugin::getName() const
c@0: {
c@0:     return "Tempogram";
c@0: }
c@0: 
c@0: string
c@14: TempogramPlugin::getDescription() const
c@0: {
c@0:     // Return something helpful here!
c@0:     return "Cyclic Tempogram as described by Peter Grosche and Meinard Muller";
c@0: }
c@0: 
c@0: string
c@14: TempogramPlugin::getMaker() const
c@0: {
c@0:     //Your name here
c@0:     return "Carl Bussey";
c@0: }
c@0: 
c@0: int
c@14: TempogramPlugin::getPluginVersion() const
c@0: {
c@0:     // Increment this each time you release a version that behaves
c@0:     // differently from the previous one
c@0:     return 1;
c@0: }
c@0: 
c@0: string
c@14: TempogramPlugin::getCopyright() const
c@0: {
c@0:     // This function is not ideally named.  It does not necessarily
c@0:     // need to say who made the plugin -- getMaker does that -- but it
c@0:     // should indicate the terms under which it is distributed.  For
c@0:     // example, "Copyright (year). All Rights Reserved", or "GPL"
c@0:     return "";
c@0: }
c@0: 
c@14: TempogramPlugin::InputDomain
c@14: TempogramPlugin::getInputDomain() const
c@0: {
c@0:     return FrequencyDomain;
c@0: }
c@0: 
c@0: size_t
c@14: TempogramPlugin::getPreferredBlockSize() const
c@0: {
c@9:     return 2048; // 0 means "I can handle any block size"
c@0: }
c@0: 
c@0: size_t 
c@14: TempogramPlugin::getPreferredStepSize() const
c@0: {
c@9:     return 1024; // 0 means "anything sensible"; in practice this
c@0:               // means the same as the block size for TimeDomain
c@0:               // plugins, or half of it for FrequencyDomain plugins
c@0: }
c@0: 
c@0: size_t
c@14: TempogramPlugin::getMinChannelCount() const
c@0: {
c@0:     return 1;
c@0: }
c@0: 
c@0: size_t
c@14: TempogramPlugin::getMaxChannelCount() const
c@0: {
c@0:     return 1;
c@0: }
c@0: 
c@14: TempogramPlugin::ParameterList
c@14: TempogramPlugin::getParameterDescriptors() const
c@0: {
c@0:     ParameterList list;
c@0: 
c@0:     // If the plugin has no adjustable parameters, return an empty
c@0:     // list here (and there's no need to provide implementations of
c@0:     // getParameter and setParameter in that case either).
c@0: 
c@0:     // Note that it is your responsibility to make sure the parameters
c@0:     // start off having their default values (e.g. in the constructor
c@0:     // above).  The host needs to know the default value so it can do
c@0:     // things like provide a "reset to default" function, but it will
c@0:     // not explicitly set your parameters to their defaults for you if
c@0:     // they have not changed in the mean time.
c@0: 
c@14:     ParameterDescriptor d1;
c@14:     d1.identifier = "C";
c@15:     d1.name = "Novelty Curve Spectrogram Compression Constant";
c@14:     d1.description = "Spectrogram compression constant, C, used when retrieving the novelty curve from the audio.";
c@14:     d1.unit = "";
c@14:     d1.minValue = 2;
c@14:     d1.maxValue = 10000;
c@14:     d1.defaultValue = 1000;
c@14:     d1.isQuantized = false;
c@14:     list.push_back(d1);
c@9: 
c@14:     ParameterDescriptor d2;
c@14:     d2.identifier = "log2TN";
c@14:     d2.name = "Tempogram Window Length";
c@14:     d2.description = "FFT window length when analysing the novelty curve and extracting the tempogram time-frequency function.";
c@14:     d2.unit = "";
c@14:     d2.minValue = 7;
c@14:     d2.maxValue = 12;
c@14:     d2.defaultValue = 10;
c@14:     d2.isQuantized = true;
c@14:     d2.quantizeStep = 1;
c@14:     for (int i = d2.minValue; i <= d2.maxValue; i++){
c@14:         d2.valueNames.push_back(floatToString(pow((float)2,(float)i)));
c@13:     }
c@14:     list.push_back(d2);
c@0:     
c@14:     ParameterDescriptor d3;
c@14:     d3.identifier = "log2HopSize";
c@14:     d3.name = "Tempogram Hopsize";
c@14:     d3.description = "FFT hopsize when analysing the novelty curve and extracting the tempogram time-frequency function.";
c@14:     d3.unit = "";
c@14:     d3.minValue = 6;
c@14:     d3.maxValue = 12;
c@14:     d3.defaultValue = 6;
c@14:     d3.isQuantized = true;
c@14:     d3.quantizeStep = 1;
c@14:     for (int i = d3.minValue; i <= d3.maxValue; i++){
c@14:         d3.valueNames.push_back(floatToString(pow((float)2,(float)i)));
c@14:     }
c@14:     list.push_back(d3);
c@9:     
c@14:     ParameterDescriptor d4;
c@14:     d4.identifier = "log2FftLength";
c@14:     d4.name = "Tempogram FFT Length";
c@14:     d4.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:     d4.unit = "";
c@14:     d4.minValue = 6;
c@14:     d4.maxValue = 12;
c@14:     d4.defaultValue = d2.defaultValue;
c@14:     d4.isQuantized = true;
c@14:     d4.quantizeStep = 1;
c@14:     for (int i = d4.minValue; i <= d4.maxValue; i++){
c@14:         d4.valueNames.push_back(floatToString(pow((float)2,(float)i)));
c@14:     }
c@14:     list.push_back(d4);
c@14:     
c@14:     ParameterDescriptor d5;
c@14:     d5.identifier = "minBPM";
c@18:     d5.name = "(Cyclic) Tempogram Minimum BPM";
c@14:     d5.description = "The minimum BPM of the tempogram output bins.";
c@14:     d5.unit = "";
c@14:     d5.minValue = 0;
c@14:     d5.maxValue = 2000;
c@14:     d5.defaultValue = 30;
c@14:     d5.isQuantized = true;
c@14:     d5.quantizeStep = 5;
c@14:     list.push_back(d5);
c@14:     
c@14:     ParameterDescriptor d6;
c@14:     d6.identifier = "maxBPM";
c@18:     d6.name = "(Cyclic) Tempogram Maximum BPM";
c@18:     d6.description = "The maximum BPM of the tempogram output bins.";
c@14:     d6.unit = "";
c@14:     d6.minValue = 30;
c@14:     d6.maxValue = 2000;
c@14:     d6.defaultValue = 480;
c@14:     d6.isQuantized = true;
c@14:     d6.quantizeStep = 5;
c@14:     list.push_back(d6);
c@18:     
c@18:     ParameterDescriptor d7;
c@18:     d7.identifier = "octDiv";
c@18:     d7.name = "Cyclic Tempogram Octave Divider";
c@18:     d7.description = "The number bins within each octave.";
c@18:     d7.unit = "";
c@18:     d7.minValue = 5;
c@18:     d7.maxValue = 60;
c@18:     d7.defaultValue = 30;
c@18:     d7.isQuantized = true;
c@18:     d7.quantizeStep = 1;
c@18:     list.push_back(d7);
c@0: 
c@0:     return list;
c@0: }
c@0: 
c@0: float
c@14: TempogramPlugin::getParameter(string identifier) const
c@0: {
c@0:     if (identifier == "C") {
c@18:         return m_noveltyCurveCompressionConstant; // return the ACTUAL current value of your parameter here!
c@0:     }
c@14:     else if (identifier == "log2TN"){
c@18:         return m_tempogramLog2WindowLength;
c@9:     }
c@14:     else if (identifier == "log2HopSize"){
c@18:         return m_tempogramLog2HopSize;
c@14:     }
c@14:     else if (identifier == "log2FftLength"){
c@18:         return m_tempogramLog2FftLength;
c@14:     }
c@14:     else if (identifier == "minBPM") {
c@18:         return m_tempogramMinBPM;
c@9:     }
c@14:     else if (identifier == "maxBPM"){
c@18:         return m_tempogramMaxBPM;
c@18:     }
c@18:     else if (identifier == "octDiv"){
c@18:         return m_cyclicTempogramOctaveDivider;
c@0:     }
c@0:     
c@0:     return 0;
c@0: }
c@0: 
c@0: void
c@14: TempogramPlugin::setParameter(string identifier, float value) 
c@0: {
c@9:     
c@0:     if (identifier == "C") {
c@18:         m_noveltyCurveCompressionConstant = value; // set the actual value of your parameter
c@0:     }
c@14:     else if (identifier == "log2TN") {
c@18:         m_tempogramWindowLength = pow(2,value);
c@18:         m_tempogramLog2WindowLength = value;
c@0:     }
c@14:     else if (identifier == "log2HopSize"){
c@18:         m_tempogramHopSize = pow(2,value);
c@18:         m_tempogramLog2HopSize = value;
c@14:     }
c@18:     else if (identifier == "log2FftLength"){
c@18:         m_tempogramFftLength = pow(2,value);
c@18:         m_tempogramLog2FftLength = value;
c@14:     }
c@14:     else if (identifier == "minBPM") {
c@18:         m_tempogramMinBPM = value;
c@9:     }
c@14:     else if (identifier == "maxBPM"){
c@18:         m_tempogramMaxBPM = value;
c@18:     }
c@18:     else if (identifier == "octDiv"){
c@18:         m_cyclicTempogramOctaveDivider = value;
c@9:     }
c@9:     
c@9: }
c@9: 
c@14: TempogramPlugin::ProgramList
c@14: TempogramPlugin::getPrograms() const
c@0: {
c@0:     ProgramList list;
c@0: 
c@0:     // If you have no programs, return an empty list (or simply don't
c@0:     // implement this function or getCurrentProgram/selectProgram)
c@0: 
c@0:     return list;
c@0: }
c@0: 
c@0: string
c@14: TempogramPlugin::getCurrentProgram() const
c@0: {
c@0:     return ""; // no programs
c@0: }
c@0: 
c@0: void
c@14: TempogramPlugin::selectProgram(string name)
c@0: {
c@0: }
c@0: 
c@14: string TempogramPlugin::floatToString(float value) const
c@9: {
c@9:     ostringstream ss;
c@9:     
c@14:     if(!(ss << value)) throw runtime_error("TempogramPlugin::floatToString(): invalid conversion from float to string");
c@9:     return ss.str();
c@9: }
c@9: 
c@14: TempogramPlugin::OutputList
c@14: TempogramPlugin::getOutputDescriptors() const
c@0: {
c@0:     OutputList list;
c@0: 
c@0:     // See OutputDescriptor documentation for the possibilities here.
c@0:     // Every plugin must have at least one output.
c@1:     
c@7:     float d_sampleRate;
c@18:     float tempogramInputSampleRate = (float)m_inputSampleRate/m_inputStepSize;
c@7:     
c@21:     OutputDescriptor d3;
c@21:     d3.identifier = "cyclicTempogram";
c@21:     d3.name = "Cyclic Tempogram";
c@21:     d3.description = "Cyclic Tempogram";
c@21:     d3.unit = "";
c@21:     d3.hasFixedBinCount = true;
c@21:     d3.binCount = m_cyclicTempogramOctaveDivider > 0 && !isnan(m_cyclicTempogramOctaveDivider) ? m_cyclicTempogramOctaveDivider : 0;
c@21:     d3.hasKnownExtents = false;
c@21:     d3.isQuantized = false;
c@21:     d3.sampleType = OutputDescriptor::FixedSampleRate;
c@21:     d_sampleRate = tempogramInputSampleRate/m_tempogramHopSize;
c@21:     d3.sampleRate = d_sampleRate > 0.0 && !isnan(d_sampleRate) ? d_sampleRate : 0;
c@21:     d3.hasDuration = false;
c@21:     list.push_back(d3);
c@21:     
c@21:     OutputDescriptor d1;
c@18:     d1.identifier = "tempogram";
c@18:     d1.name = "Tempogram";
c@18:     d1.description = "Tempogram";
c@18:     d1.unit = "BPM";
c@18:     d1.hasFixedBinCount = true;
c@18:     d1.binCount = m_tempogramMaxBin - m_tempogramMinBin + 1;
c@18:     d1.hasKnownExtents = false;
c@18:     d1.isQuantized = false;
c@18:     d1.sampleType = OutputDescriptor::FixedSampleRate;
c@18:     d_sampleRate = tempogramInputSampleRate/m_tempogramHopSize;
c@18:     d1.sampleRate = d_sampleRate > 0.0 && !isnan(d_sampleRate) ? d_sampleRate : 0.0;
c@18:     for(int i = m_tempogramMinBin; i <= (int)m_tempogramMaxBin; i++){
c@18:         float w = ((float)i/m_tempogramFftLength)*(tempogramInputSampleRate);
c@18:         d1.binNames.push_back(floatToString(w*60));
c@9:     }
c@18:     d1.hasDuration = false;
c@18:     list.push_back(d1);
c@7:     
c@18:     OutputDescriptor d2;
c@18:     d2.identifier = "nc";
c@18:     d2.name = "Novelty Curve";
c@18:     d2.description = "Novelty Curve";
c@18:     d2.unit = "";
c@18:     d2.hasFixedBinCount = true;
c@18:     d2.binCount = 1;
c@18:     d2.hasKnownExtents = false;
c@18:     d2.isQuantized = false;
c@18:     d2.sampleType = OutputDescriptor::FixedSampleRate;
c@9:     d_sampleRate = tempogramInputSampleRate;
c@18:     d2.sampleRate = d_sampleRate > 0 && !isnan(d_sampleRate) ? d_sampleRate : 0;
c@18:     d2.hasDuration = false;
c@18:     list.push_back(d2);
c@18:     
c@0:     return list;
c@0: }
c@0: 
c@21: bool TempogramPlugin::handleParameterValues(){
c@21:     
c@21:     if (m_tempogramHopSize <= 0) return false;
c@21:     if (m_tempogramLog2FftLength <= 0) return false;
c@0:     
c@18:     if (m_tempogramFftLength < m_tempogramWindowLength){
c@18:         m_tempogramFftLength = m_tempogramWindowLength;
c@14:     }
c@18:     if (m_tempogramMinBPM > m_tempogramMaxBPM){
c@18:         m_tempogramMinBPM = 30;
c@18:         m_tempogramMaxBPM = 480;
c@9:     }
c@9:     
c@18:     float tempogramInputSampleRate = (float)m_inputSampleRate/m_inputStepSize;
c@21:     m_tempogramMinBin = (max(floor(((m_tempogramMinBPM/60)/tempogramInputSampleRate)*m_tempogramFftLength), (float)0.0));
c@21:     m_tempogramMaxBin = (min(ceil(((m_tempogramMaxBPM/60)/tempogramInputSampleRate)*m_tempogramFftLength), (float)m_tempogramFftLength/2));
c@18:     
c@18:     if (m_tempogramMinBPM > m_cyclicTempogramMinBPM) m_cyclicTempogramMinBPM = m_tempogramMinBPM;
c@18:     float cyclicTempogramMaxBPM = 480;
c@18:     if (m_tempogramMaxBPM < cyclicTempogramMaxBPM) cyclicTempogramMaxBPM = m_tempogramMaxBPM;
c@18:     
c@18:     m_cyclicTempogramNumberOfOctaves = floor(log2(cyclicTempogramMaxBPM/m_cyclicTempogramMinBPM));
c@18:     int numberOfBinsInFirstOctave = bpmToBin(m_cyclicTempogramMinBPM);
c@19:     if (m_cyclicTempogramOctaveDivider > numberOfBinsInFirstOctave) m_cyclicTempogramOctaveDivider = numberOfBinsInFirstOctave;
c@19:     
c@21:     return true;
c@20: }
c@20: 
c@20: bool
c@20: TempogramPlugin::initialise(size_t channels, size_t stepSize, size_t blockSize)
c@20: {
c@20:     if (channels < getMinChannelCount() ||
c@20: 	channels > getMaxChannelCount()) return false;
c@20:     
c@20:     // Real initialisation work goes here!
c@20:     m_inputBlockSize = blockSize;
c@20:     m_inputStepSize = stepSize;
c@20:     
c@20:     m_spectrogram = SpectrogramTransposed(m_inputBlockSize/2.0f + 1);
c@21:     if (!handleParameterValues()) return false;
c@19:     //cout << m_cyclicTempogramOctaveDivider << endl;
c@4:     
c@0:     return true;
c@0: }
c@0: 
c@0: void
c@14: TempogramPlugin::reset()
c@0: {
c@0:     // Clear buffers, reset stored values, etc
c@19:     m_spectrogram.clear();
c@20:     m_spectrogram = SpectrogramTransposed(m_inputBlockSize/2.0f + 1);
c@21:     handleParameterValues();
c@0: }
c@0: 
c@14: TempogramPlugin::FeatureSet
c@14: TempogramPlugin::process(const float *const *inputBuffers, Vamp::RealTime timestamp)
c@0: {
c@21:     //cerr << "Here" << endl;
c@21: 
c@18:     size_t n = m_inputBlockSize/2 + 1;
c@0:     
c@0:     FeatureSet featureSet;
c@0:     Feature feature;
c@0:     
c@0:     const float *in = inputBuffers[0];
c@3: 
c@9:     //calculate magnitude of FrequencyDomain input
c@20:     for (int i = 0; i < (int)n; i++){
c@0:         float magnitude = sqrt(in[2*i] * in[2*i] + in[2*i + 1] * in[2*i + 1]);
c@18:         magnitude = magnitude > m_noveltyCurveMinDB ? magnitude : m_noveltyCurveMinDB;
c@13:         m_spectrogram[i].push_back(magnitude);
c@0:     }
c@21:     
c@2:     return featureSet;
c@0: }
c@0: 
c@18: vector<unsigned int> TempogramPlugin::calculateTempogramNearestNeighbourLogBins() const
c@18: {
c@18:     vector<unsigned int> logBins;
c@18:     
c@18:     for (int i = 0; i < (int)ceil(m_cyclicTempogramNumberOfOctaves*m_cyclicTempogramOctaveDivider); i++){
c@18:         float bpm = m_cyclicTempogramMinBPM*pow(2.0f, (float)i/m_cyclicTempogramOctaveDivider);
c@18:         int bin = bpmToBin(bpm);
c@18:         
c@18:         logBins.push_back(bin);
c@20:         //cerr << bin << endl;
c@18:     }
c@18:     
c@20:     //cerr << logBins.size() << endl;
c@19:     
c@18:     return logBins;
c@18: }
c@18: 
c@18: int TempogramPlugin::bpmToBin(const float &bpm) const
c@18: {
c@18:     float w = (float)bpm/60;
c@18:     float sampleRate = m_inputSampleRate/m_inputStepSize;
c@18:     int bin = floor((float)m_tempogramFftLength*w/sampleRate + 0.5);
c@18:     
c@18:     if(bin < 0) bin = 0;
c@20:     else if(bin > m_tempogramFftLength/2.0f) bin = m_tempogramFftLength;
c@18:     
c@18:     return bin;
c@18: }
c@18: 
c@21: float TempogramPlugin::binToBPM(const int &bin) const
c@21: {
c@21:     float sampleRate = m_inputSampleRate/m_inputStepSize;
c@21:     
c@21:     return (bin*sampleRate/m_tempogramFftLength)*60;
c@21: }
c@21: 
c@14: TempogramPlugin::FeatureSet
c@14: TempogramPlugin::getRemainingFeatures()
c@11: {
c@0:     
c@18:     float * hannWindow = new float[m_tempogramWindowLength];
c@20:     for (int i = 0; i < (int)m_tempogramWindowLength; i++){
c@14:         hannWindow[i] = 0.0;
c@4:     }
c@11:     
c@1:     FeatureSet featureSet;
c@0:     
c@19:     //initialise novelty curve processor
c@14:     size_t numberOfBlocks = m_spectrogram[0].size();
c@20:     //cerr << numberOfBlocks << endl;
c@18:     NoveltyCurveProcessor nc(m_inputSampleRate, m_inputBlockSize, numberOfBlocks, m_noveltyCurveCompressionConstant);
c@21:     vector<float> noveltyCurve = nc.spectrogramToNoveltyCurve(m_spectrogram); //calculate novelty curvefrom magnitude data
c@20:     //if(noveltyCurve.size() > 50) for (int i = 0; i < 50; i++) cerr << noveltyCurve[i] << endl;
c@4:     
c@9:     //push novelty curve data to featureset 1 and set timestamps
c@20:     for (int i = 0; i < (int)numberOfBlocks; i++){
c@19:         Feature noveltyCurveFeature;
c@19:         noveltyCurveFeature.values.push_back(noveltyCurve[i]);
c@19:         noveltyCurveFeature.hasTimestamp = false;
c@21:         featureSet[2].push_back(noveltyCurveFeature);
c@21:         assert(!isnan(noveltyCurveFeature.values.back()));
c@4:     }
c@4:     
c@9:     //window function for spectrogram
c@18:     WindowFunction::hanning(hannWindow, m_tempogramWindowLength);
c@9:     
c@9:     //initialise spectrogram processor
c@18:     SpectrogramProcessor spectrogramProcessor(m_tempogramWindowLength, m_tempogramFftLength, m_tempogramHopSize);
c@9:     //compute spectrogram from novelty curve data (i.e., tempogram)
c@19:     Tempogram tempogram = spectrogramProcessor.process(&noveltyCurve[0], numberOfBlocks, hannWindow);
c@18:     delete []hannWindow;
c@18:     hannWindow = 0;
c@0:     
c@14:     int tempogramLength = tempogram.size();
c@7:     
c@9:     //push tempogram data to featureset 0 and set timestamps.
c@7:     for (int block = 0; block < tempogramLength; block++){
c@19:         Feature tempogramFeature;
c@0:         
c@18:         assert(tempogram[block].size() == (m_tempogramFftLength/2 + 1));
c@18:         for(int k = m_tempogramMinBin; k < (int)m_tempogramMaxBin; k++){
c@19:             tempogramFeature.values.push_back(tempogram[block][k]);
c@21:             assert(!isnan(tempogramFeature.values.back()));
c@0:         }
c@19:         tempogramFeature.hasTimestamp = false;
c@21:         featureSet[1].push_back(tempogramFeature);
c@0:     }
c@0:     
c@18:     //Calculate cyclic tempogram
c@18:     vector<unsigned int> logBins = calculateTempogramNearestNeighbourLogBins();
c@18:     
c@20:     assert(logBins.back() <= m_tempogramFftLength/2.0f);
c@20:     assert((int)logBins.size() == m_cyclicTempogramOctaveDivider*m_cyclicTempogramNumberOfOctaves);
c@18:     for (int block = 0; block < tempogramLength; block++){
c@19:         Feature cyclicTempogramFeature;
c@18:         
c@20:         for (int i = 0; i < (int)m_cyclicTempogramOctaveDivider; i++){
c@18:             float sum = 0;
c@21:             
c@21:             //mcerr << floor(binToBPM(logBins[i]) + 0.5) << " " << floor(binToBPM(logBins[i + m_cyclicTempogramOctaveDivider]) + 0.5) << endl;
c@21:             
c@20:             for (int j = 0; j < (int)m_cyclicTempogramNumberOfOctaves; j++){
c@18:                 sum += tempogram[block][logBins[i+j*m_cyclicTempogramOctaveDivider]];
c@18:             }
c@19:             cyclicTempogramFeature.values.push_back(sum/m_cyclicTempogramNumberOfOctaves);
c@21:             assert(!isnan(cyclicTempogramFeature.values.back()));
c@18:         }
c@18: 
c@19:         cyclicTempogramFeature.hasTimestamp = false;
c@21:         featureSet[0].push_back(cyclicTempogramFeature);
c@18:     }
c@0:     
c@0:     return featureSet;
c@0: }