comparison layer/SpectrogramLayer.cpp @ 484:a926fca1f280

* Make use of peak cache in spectrogram

 
 /*
     Sonic Visualiser
     An audio file viewer and annotation editor.
     Centre for Digital Music, Queen Mary, University of London.
-    This file copyright 2006 Chris Cannam and QMUL.
+    This file copyright 2006-2009 Chris Cannam and QMUL.
     
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.  See the file

 #include "base/RangeMapper.h"
 #include "base/LogRange.h"
 #include "widgets/CommandHistory.h"
 #include "ColourMapper.h"
 #include "ImageRegionFinder.h"
+#include "data/model/Dense3DModelPeakCache.h"
 
 #include <QPainter>
 #include <QImage>
 #include <QPixmap>
 #include <QRect>

                 if (!replaced) emit sliceableModelReplaced(m_sliceableModel, 0);
             }
 
             delete m_fftModels[v].first;
             m_fftModels.erase(v);
+
+            delete m_peakCaches[v];
+            m_peakCaches.erase(v);
         }
 	
     } else {
 
         Layer::setLayerDormant(v, false);

 #ifdef DEBUG_SPECTROGRAM_REPAINT
             std::cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found a model with the wrong height (" << m_fftModels[v].first->getHeight() << ", wanted " << (fftSize / 2 + 1) << ")" << std::endl;
 #endif
             delete m_fftModels[v].first;
             m_fftModels.erase(v);
+            delete m_peakCaches[v];
+            m_peakCaches.erase(v);
         } else {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
             std::cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found a good model of height " << m_fftModels[v].first->getHeight() << std::endl;
 #endif
             return m_fftModels[v].first;

     }
 
     return m_fftModels[v].first;
 }
 
+Dense3DModelPeakCache *
+SpectrogramLayer::getPeakCache(const View *v) const
+{
+    if (!m_peakCaches[v]) {
+        FFTModel *f = getFFTModel(v);
+        if (!f) return 0;
+        m_peakCaches[v] = new Dense3DModelPeakCache(f, 8);
+    }
+    return m_peakCaches[v];
+}
+
 const Model *
 SpectrogramLayer::getSliceableModel() const
 {
     if (m_sliceableModel) return m_sliceableModel;
     if (m_fftModels.empty()) return 0;

     // in the cache-fill thread above.
     //!!! no longer use cache-fill thread
     const_cast<SpectrogramLayer *>(this)->Layer::setLayerDormant(v, false);
 
     size_t fftSize = getFFTSize(v);
+/*
     FFTModel *fft = getFFTModel(v);
     if (!fft) {
 	std::cerr << "ERROR: SpectrogramLayer::paint(): No FFT model, returning" << std::endl;
 	return;
     }
-
+*/
     ImageCache &cache = m_imageCaches[v];
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     std::cerr << "SpectrogramLayer::paint(): image cache valid area " << cache.
 

     }
 
     int binforx[bufwid];
     int binfory[h];
 
+    bool usePeaksCache = false;
+
     if (bufferBinResolution) {
         for (int x = 0; x < bufwid; ++x) {
             binforx[x] = (leftBoundaryFrame / increment) + x;
 //            cerr << "binforx[" << x << "] = " << binforx[x] << endl;
         }

             }
         }
         if (m_drawBuffer.width() < bufwid || m_drawBuffer.height() < h) {
             m_drawBuffer = QImage(bufwid, h, QImage::Format_Indexed8);
         }
+        usePeaksCache = (increment * 8) < zoomLevel;
     }
 
     m_drawBuffer.setNumColors(256);
     for (int pixel = 0; pixel < 256; ++pixel) {
         m_drawBuffer.setColor(pixel, m_palette.getColour(pixel).rgb());

         } else {
             binfory[y] = int(q0 + 0.0001);
         }
     }
 
-    paintDrawBuffer(v, fft, bufwid, h, binforx, binfory);
+    paintDrawBuffer(v, bufwid, h, binforx, binfory, usePeaksCache);
 
 /*
     for (int x = 0; x < w / xPixelRatio; ++x) {
 
         Profiler innerprof("SpectrogramLayer::paint: 1 pixel column");

 //!!!    if (fftSuspended) fft->resume();
 }
 
 bool
 SpectrogramLayer::paintDrawBuffer(View *v,
-                                  FFTModel *fft,
                                   int w,
                                   int h,
                                   int *binforx,
-                                  int *binfory) const
+                                  int *binfory,
+                                  bool usePeaksCache) const
 {
     Profiler profiler("SpectrogramLayer::paintDrawBuffer");
 
     int minbin = binfory[0];
     int maxbin = binfory[h-1];
 
     cerr << "minbin " << minbin << ", maxbin " << maxbin << "; w " << w << ", h " << h << endl;
     if (minbin < 0) minbin = 0;
     if (maxbin < 0) maxbin = minbin+1;
 
+    DenseThreeDimensionalModel *sourceModel = 0;
+    FFTModel *fft = 0;
+    int divisor = 1;
+    cerr << "Note: bin display = " << m_binDisplay << ", w = " << w << ", binforx[" << w-1 << "] = " << binforx[w-1] << ", binforx[0] = " << binforx[0] << endl;
+    if (usePeaksCache) { //!!!
+        sourceModel = getPeakCache(v);
+        divisor = 8;//!!!
+        minbin = 0;
+        maxbin = sourceModel->getHeight();
+    } else {
+        sourceModel = fft = getFFTModel(v);
+    }
+
+    if (!sourceModel) return false;
+
     int psx = -1;
     float values[maxbin - minbin + 1];
+    DenseThreeDimensionalModel::Column c;
     float peaks[h];
 
     for (int x = 0; x < w; ++x) {
         
         if (binforx[x] < 0) continue;
 
-        int sx0 = binforx[x];
+        int sx0 = binforx[x] / divisor;
         int sx1 = sx0;
-        if (x+1 < w) sx1 = binforx[x+1];
+        if (x+1 < w) sx1 = binforx[x+1] / divisor;
         if (sx0 < 0) sx0 = sx1 - 1;
         if (sx0 < 0) continue;
         if (sx1 <= sx0) sx1 = sx0 + 1;
 
         for (int y = 0; y < h; ++y) peaks[y] = 0.f;
             
         for (int sx = sx0; sx < sx1; ++sx) {
 
-            if (sx < 0 || sx >= int(fft->getWidth())) continue;
+            if (sx < 0 || sx >= int(sourceModel->getWidth())) continue;
 
             if (!m_synchronous) {
-                if (!fft->isColumnAvailable(sx)) {
+                if (!sourceModel->isColumnAvailable(sx)) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
                     std::cerr << "Met unavailable column at col " << sx << std::endl;
 #endif
                     return false;
                 }
             }
 
             if (sx != psx) {
-                cerr << "Retrieving column " << sx << endl;
-                fft->getMagnitudesAt(sx, values, minbin, maxbin - minbin + 1);
+                if (fft) {
+                    cerr << "Retrieving column " << sx << " from fft directly" << endl;
+                    fft->getMagnitudesAt(sx, values, minbin, maxbin - minbin + 1);
+                } else {
+                    cerr << "Retrieving column " << sx << " from peaks cache" << endl;
+                    c = sourceModel->getColumn(sx);
+                }
                 psx = sx;
             }
 
             for (int y = 0; y < h; ++y) {
 

                 //!!! magnitudes here, we can just use peak of the
                 //!!! float values
 
                 for (int sy = sy0; sy < sy1; ++sy) {
 
-                    float value = values[sy - minbin];
+                    float value = 0.f;
+                    if (fft) value = values[sy - minbin];
+                    else value = c[sy];
+
 /*
                     if (m_colourScale != PhaseColourScale) {
                         if (!m_normalizeColumns) {
                             value /= (m_fftSize/2.f);
                         }