comparison dsp/tempotracking/DownBeat.cpp @ 505:930b5b0f707d

Merge branch 'codestyle-and-tidy'

 #include "maths/KLDivergence.h"
 #include "dsp/transforms/FFT.h"
 
 #include <iostream>
 #include <cstdlib>
+
+using std::vector;
 
 DownBeat::DownBeat(float originalSampleRate,
                    size_t decimationFactor,
                    size_t dfIncrement) :
     m_bpb(0),

     m_beatframesize = MathUtilities::nextPowerOfTwo
         (int((m_rate / decimationFactor) * 1.3));
     if (m_beatframesize < 2) {
         m_beatframesize = 2;
     }
-//    std::cerr << "rate = " << m_rate << ", dec = " << decimationFactor << ", bfs = " << m_beatframesize << std::endl;
     m_beatframe = new double[m_beatframesize];
     m_fftRealOut = new double[m_beatframesize];
     m_fftImagOut = new double[m_beatframesize];
     m_fft = new FFTReal(m_beatframesize);
 }

 }
 
 void
 DownBeat::makeDecimators()
 {
-//    std::cerr << "m_factor = " << m_factor << std::endl;
     if (m_factor < 2) return;
     size_t highest = Decimator::getHighestSupportedFactor();
     if (m_factor <= highest) {
         m_decimator1 = new Decimator(m_increment, m_factor);
-//        std::cerr << "DownBeat: decimator 1 factor " << m_factor << ", size " << m_increment << std::endl;
         return;
     }
     m_decimator1 = new Decimator(m_increment, highest);
-//    std::cerr << "DownBeat: decimator 1 factor " << highest << ", size " << m_increment << std::endl;
     m_decimator2 = new Decimator(m_increment / highest, m_factor / highest);
-//    std::cerr << "DownBeat: decimator 2 factor " << m_factor / highest << ", size " << m_increment / highest << std::endl;
     m_decbuf = new float[m_increment / highest];
 }
 
 void
 DownBeat::pushAudioBlock(const float *audio)

         if (m_bufsiz == 0) m_bufsiz = m_increment * 16;
         else m_bufsiz = m_bufsiz * 2;
         if (!m_buffer) {
             m_buffer = (float *)malloc(m_bufsiz * sizeof(float));
         } else {
-//            std::cerr << "DownBeat::pushAudioBlock: realloc m_buffer to " << m_bufsiz << std::endl;
             m_buffer = (float *)realloc(m_buffer, m_bufsiz * sizeof(float));
         }
     }
-    if (!m_decimator1 && m_factor > 1) makeDecimators();
-//    float rmsin = 0, rmsout = 0;
-//    for (int i = 0; i < m_increment; ++i) {
-//        rmsin += audio[i] * audio[i];
-//    }
+    if (!m_decimator1 && m_factor > 1) {
+        makeDecimators();
+    }
     if (m_decimator2) {
         m_decimator1->process(audio, m_decbuf);
         m_decimator2->process(m_decbuf, m_buffer + m_buffill);
     } else if (m_decimator1) {
         m_decimator1->process(audio, m_buffer + m_buffill);

         // just copy across (m_factor is presumably 1)
         for (size_t i = 0; i < m_increment; ++i) {
             (m_buffer + m_buffill)[i] = audio[i];
         }
     }
-//    for (int i = 0; i < m_increment / m_factor; ++i) {
-//        rmsout += m_buffer[m_buffill + i] * m_buffer[m_buffill + i];
-//    }
-//    std::cerr << "pushAudioBlock: rms in " << sqrt(rmsin) << ", out " << sqrt(rmsout) << std::endl;
     m_buffill += m_increment / m_factor;
 }
     
 const float *
 DownBeat::getBufferedAudio(size_t &length) const

 }
 
 void
 DownBeat::resetAudioBuffer()
 {
-    if (m_buffer) free(m_buffer);
+    if (m_buffer) {
+        free(m_buffer);
+    }
     m_buffer = 0;
     m_buffill = 0;
     m_bufsiz = 0;
 }
 

         // Also apply a Hanning window to the beat frame buffer, sized
         // to the beat extents rather than the frame size.  (Because
         // the size varies, it's easier to do this by hand than use
         // our Window abstraction.)
 
-//        std::cerr << "beatlen = " << beatlen << std::endl;
-
-//        float rms = 0;
         for (size_t j = 0; j < beatlen && j < m_beatframesize; ++j) {
             double mul = 0.5 * (1.0 - cos(TWO_PI * (double(j) / double(beatlen))));
             m_beatframe[j] = audio[beatstart + j] * mul;
-//            rms += m_beatframe[j] * m_beatframe[j];
-        }
-//        rms = sqrt(rms);
-//        std::cerr << "beat " << i << ": audio rms " << rms << std::endl;
+        }
 
         for (size_t j = beatlen; j < m_beatframesize; ++j) {
             m_beatframe[j] = 0.0;
         }
 

 
         // Calculate JS divergence between new and old spectral frames
 
         if (i > 0) { // otherwise we have no previous frame
             m_beatsd.push_back(measureSpecDiff(oldspec, newspec));
-//            std::cerr << "specdiff: " << m_beatsd[m_beatsd.size()-1] << std::endl;
         }
 
         // Copy newspec across to old
 
         for (size_t j = 0; j < m_beatframesize/2; ++j) {

        for (int example = beat-1; example < (int)m_beatsd.size(); example += timesig) {
            if (example < 0) continue;
            dbcand[beat] += (m_beatsd[example]) / timesig;
            ++count;
        }
-       if (count > 0) dbcand[beat] /= count;
-//        std::cerr << "dbcand[" << beat << "] = " << dbcand[beat] << std::endl;
+       if (count > 0) {
+           dbcand[beat] /= count;
+       }
    }
 
     // first downbeat is beat at index of maximum value of dbcand
     int dbind = MathUtilities::getMax(dbcand);
 

 double
 DownBeat::measureSpecDiff(d_vec_t oldspec, d_vec_t newspec)
 {
     // JENSEN-SHANNON DIVERGENCE BETWEEN SPECTRAL FRAMES
 
-    unsigned int SPECSIZE = 512;   // ONLY LOOK AT FIRST 512 SAMPLES OF SPECTRUM. 
-    if (SPECSIZE > oldspec.size()/4) {
-        SPECSIZE = oldspec.size()/4;
+    int SPECSIZE = 512;   // ONLY LOOK AT FIRST 512 SAMPLES OF SPECTRUM. 
+    if (SPECSIZE > int(oldspec.size())/4) {
+        SPECSIZE = int(oldspec.size())/4;
     }
     double SD = 0.;
     double sd1 = 0.;
 
     double sumnew = 0.;
     double sumold = 0.;
   
-    for (unsigned int i = 0;i < SPECSIZE;i++)
-    {
+    for (int i = 0;i < SPECSIZE;i++) {
+        
         newspec[i] +=EPS;
         oldspec[i] +=EPS;
         
         sumnew+=newspec[i];
         sumold+=oldspec[i];
     } 
     
-    for (unsigned int i = 0;i < SPECSIZE;i++)
-    {
+    for (int i = 0;i < SPECSIZE;i++) {
+        
         newspec[i] /= (sumnew);
         oldspec[i] /= (sumold);
         
         // IF ANY SPECTRAL VALUES ARE 0 (SHOULDN'T BE ANY!) SET THEM TO 1
-        if (newspec[i] == 0)
-        {
+        if (newspec[i] == 0) {
             newspec[i] = 1.;
         }
         
-        if (oldspec[i] == 0)
-        {
+        if (oldspec[i] == 0) {
             oldspec[i] = 1.;
         }
         
         // JENSEN-SHANNON CALCULATION
-        sd1 = 0.5*oldspec[i] + 0.5*newspec[i];	
-        SD = SD + (-sd1*log(sd1)) + (0.5*(oldspec[i]*log(oldspec[i]))) + (0.5*(newspec[i]*log(newspec[i])));
+        sd1 = 0.5*oldspec[i] + 0.5*newspec[i];  
+        SD = SD + (-sd1*log(sd1)) +
+            (0.5*(oldspec[i]*log(oldspec[i]))) +
+            (0.5*(newspec[i]*log(newspec[i])));
     }
     
     return SD;
 }
 
 void
 DownBeat::getBeatSD(vector<double> &beatsd) const
 {
-    for (int i = 0; i < (int)m_beatsd.size(); ++i) beatsd.push_back(m_beatsd[i]);
-}
-
+    for (int i = 0; i < (int)m_beatsd.size(); ++i) {
+        beatsd.push_back(m_beatsd[i]);
+    }
+}
+