comparison data/model/FFTModel.cpp @ 1527:710e6250a401 zoom

Merge from default branch

 #include "DenseTimeValueModel.h"
 
 #include "base/Profiler.h"
 #include "base/Pitch.h"
 #include "base/HitCount.h"
+#include "base/Debug.h"
 
 #include <algorithm>
 
 #include <cassert>
 #include <deque>

     m_windowSize(windowSize),
     m_windowIncrement(windowIncrement),
     m_fftSize(fftSize),
     m_windower(windowType, windowSize),
     m_fft(fftSize),
+    m_cacheWriteIndex(0),
     m_cacheSize(3)
 {
+    while (m_cached.size() < m_cacheSize) {
+        m_cached.push_back({ -1, cvec(m_fftSize / 2 + 1) });
+    }
+    
     if (m_windowSize > m_fftSize) {
-        cerr << "ERROR: FFTModel::FFTModel: window size (" << m_windowSize
-             << ") must be at least FFT size (" << m_fftSize << ")" << endl;
+        SVCERR << "ERROR: FFTModel::FFTModel: window size (" << m_windowSize
+               << ") must be at least FFT size (" << m_fftSize << ")" << endl;
         throw invalid_argument("FFTModel window size must be at least FFT size");
     }
 
     m_fft.initFloat();
 

 
 void
 FFTModel::sourceModelAboutToBeDeleted()
 {
     if (m_model) {
-        cerr << "FFTModel[" << this << "]::sourceModelAboutToBeDeleted(" << m_model << ")" << endl;
+        SVDEBUG << "FFTModel[" << this << "]::sourceModelAboutToBeDeleted(" << m_model << ")" << endl;
         m_model = 0;
     }
 }
 
 int

         imags[i] = col[minbin + i].imag();
     }
     return true;
 }
 
-vector<float>
+FFTModel::fvec
 FFTModel::getSourceSamples(int column) const
 {
     // m_fftSize may be greater than m_windowSize, but not the reverse
 
 //    cerr << "getSourceSamples(" << column << ")" << endl;

 
     if (off == 0) {
         return data;
     } else {
         vector<float> pad(off, 0.f);
-        vector<float> padded;
+        fvec padded;
         padded.reserve(m_fftSize);
         padded.insert(padded.end(), pad.begin(), pad.end());
         padded.insert(padded.end(), data.begin(), data.end());
         padded.insert(padded.end(), pad.begin(), pad.end());
         return padded;
     }
 }
 
-vector<float>
+FFTModel::fvec
 FFTModel::getSourceData(pair<sv_frame_t, sv_frame_t> range) const
 {
 //    cerr << "getSourceData(" << range.first << "," << range.second
 //         << "): saved range is (" << m_savedData.range.first
 //         << "," << m_savedData.range.second << ")" << endl;

 
         inSourceCache.partial();
         
         sv_frame_t discard = range.first - m_savedData.range.first;
 
-        vector<float> acc(m_savedData.data.begin() + discard,
-                          m_savedData.data.end());
-
-        vector<float> rest =
-            getSourceDataUncached({ m_savedData.range.second, range.second });
-
-        acc.insert(acc.end(), rest.begin(), rest.end());
+        fvec data;
+        data.reserve(range.second - range.first);
+
+        data.insert(data.end(),
+                    m_savedData.data.begin() + discard,
+                    m_savedData.data.end());
+
+        fvec rest = getSourceDataUncached
+            ({ m_savedData.range.second, range.second });
+
+        data.insert(data.end(), rest.begin(), rest.end());
         
-        m_savedData = { range, acc };
-        return acc;
+        m_savedData = { range, data };
+        return data;
 
     } else {
 
         inSourceCache.miss();
         

         m_savedData = { range, data };
         return data;
     }
 }
 
-vector<float>
+FFTModel::fvec
 FFTModel::getSourceDataUncached(pair<sv_frame_t, sv_frame_t> range) const
 {
+    Profiler profiler("FFTModel::getSourceDataUncached");
+    
     decltype(range.first) pfx = 0;
     if (range.first < 0) {
         pfx = -range.first;
         range = { 0, range.second };
     }

         vector<float> pad(pfx, 0.f);
         data.insert(data.begin(), pad.begin(), pad.end());
     }
     
     if (m_channel == -1) {
-	int channels = m_model->getChannelCount();
-	if (channels > 1) {
+        int channels = m_model->getChannelCount();
+        if (channels > 1) {
             int n = int(data.size());
             float factor = 1.f / float(channels);
             // use mean instead of sum for fft model input
-	    for (int i = 0; i < n; ++i) {
-		data[i] *= factor;
-	    }
-	}
+            for (int i = 0; i < n; ++i) {
+                data[i] *= factor;
+            }
+        }
     }
     
     return data;
 }
 
-vector<complex<float>>
+const FFTModel::cvec &
 FFTModel::getFFTColumn(int n) const
 {
     // The small cache (i.e. the m_cached deque) is for cases where
     // values are looked up individually, and for e.g. peak-frequency
     // spectrograms where values from two consecutive columns are

     
     auto samples = getSourceSamples(n);
     m_windower.cut(samples.data());
     breakfastquay::v_fftshift(samples.data(), m_fftSize);
 
-    vector<complex<float>> col(m_fftSize/2 + 1);
+    cvec &col = m_cached[m_cacheWriteIndex].col;
     
     m_fft.forwardInterleaved(samples.data(),
                              reinterpret_cast<float *>(col.data()));
 
-    SavedColumn sc { n, col };
-    if (m_cached.size() >= m_cacheSize) {
-        m_cached.pop_front();
-    }
-    m_cached.push_back(sc);
+    m_cached[m_cacheWriteIndex].n = n;
+
+    m_cacheWriteIndex = (m_cacheWriteIndex + 1) % m_cacheSize;
 
     return col;
 }
 
 bool