comparison data/model/FFTModel.cpp @ 1780:6d6740b075c3

Support optional max frequency setting, useful when we want to store caches of very constrained frequency ranges (as in melodic-range spectrogram, potentially)

                    WindowType windowType,
                    int windowSize,
                    int windowIncrement,
                    int fftSize) :
     m_model(modelId),
+    m_sampleRate(0),
     m_channel(channel),
     m_windowType(windowType),
     m_windowSize(windowSize),
     m_windowIncrement(windowIncrement),
     m_fftSize(fftSize),
     m_windower(windowType, windowSize),
     m_fft(fftSize),
+    m_maximumFrequency(0.0),
     m_cacheWriteIndex(0),
     m_cacheSize(3)
 {
     while (m_cached.size() < m_cacheSize) {
         m_cached.push_back({ -1, cvec(m_fftSize / 2 + 1) });

 
     m_fft.initFloat();
 
     auto model = ModelById::getAs<DenseTimeValueModel>(m_model);
     if (model) {
+        m_sampleRate = model->getSampleRate();
+        
         connect(model.get(), SIGNAL(modelChanged(ModelId)),
                 this, SIGNAL(modelChanged(ModelId)));
         connect(model.get(), SIGNAL(modelChangedWithin(ModelId, sv_frame_t, sv_frame_t)),
                 this, SIGNAL(modelChangedWithin(ModelId, sv_frame_t, sv_frame_t)));
     }

 }
 
 sv_samplerate_t
 FFTModel::getSampleRate() const
 {
-    auto model = ModelById::getAs<DenseTimeValueModel>(m_model);
-    if (model) return model->getSampleRate();
-    else return 0;
+    return m_sampleRate;
+}
+
+void
+FFTModel::setMaximumFrequency(double freq)
+{
+    m_maximumFrequency = freq;
 }
 
 int
 FFTModel::getWidth() const
 {

 }
 
 int
 FFTModel::getHeight() const
 {
-    return m_fftSize / 2 + 1;
+    int height = m_fftSize / 2 + 1;
+    if (m_maximumFrequency != 0.0) {
+        int maxBin = int(ceil(m_maximumFrequency * m_fftSize) / m_sampleRate);
+        if (maxBin >= 0 && maxBin < height) {
+            return maxBin + 1;
+        }
+    }
+    return height;
 }
 
 QString
 FFTModel::getBinName(int n) const
 {
     sv_samplerate_t sr = getSampleRate();
     if (!sr) return "";
-    QString name = tr("%1 Hz").arg((n * sr) / ((getHeight()-1) * 2));
+    QString name = tr("%1 Hz").arg((double(n) * sr) / m_fftSize);
     return name;
 }
 
 FFTModel::Column
 FFTModel::getColumn(int x) const

 }
 
 void
 FFTModel::getValuesAt(int x, int y, float &re, float &im) const
 {
+    if (x < 0 || x >= getWidth() || y < 0 || y >= getHeight()) {
+        re = 0.f;
+        im = 0.f;
+        return;
+    }
     auto col = getFFTColumn(x);
     re = col[y].real();
     im = col[y].imag();
 }
 

     }
     
     return data;
 }
 
-const FFTModel::cvec &
+FFTModel::cvec
 FFTModel::getFFTColumn(int n) const
 {
+    int h = getHeight();
+    bool truncate = (h < m_fftSize / 2 + 1);
+    
     // 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
     // needed at once. This cache gets essentially no hits when
     // scrolling through a magnitude spectrogram, but 95%+ hits with a
     // peak-frequency spectrogram or spectrum.
     for (const auto &incache : m_cached) {
         if (incache.n == n) {
             inSmallCache.hit();
-            return incache.col;
+            if (!truncate) {
+                return incache.col;
+            } else {
+                return cvec(incache.col.begin(), incache.col.begin() + h);
+            }
         }
     }
     inSmallCache.miss();
 
     Profiler profiler("FFTModel::getFFTColumn (cache miss)");

 
     m_cached[m_cacheWriteIndex].n = n;
 
     m_cacheWriteIndex = (m_cacheWriteIndex + 1) % m_cacheSize;
 
-    return col;
+    if (!truncate) {
+        return col;
+    } else {
+        return cvec(col.begin(), col.begin() + h);
+    }
 }
 
 bool
 FFTModel::estimateStableFrequency(int x, int y, double &frequency)
 {