comparison layer/SpectrogramLayer.cpp @ 1212:a1ee3108d1d3 3.0-integration

Make the colour 3d plot renderer able to support more than one level of peak cache; introduce a second "peak" cache for the spectrogram layer that actually has a 1-1 column relationship with the underlying FFT model, and use it in addition to the existing peak cache if memory is plentiful. Makes spectrograms appear much faster in many common situations.

 #include "base/Preferences.h"
 #include "base/RangeMapper.h"
 #include "base/LogRange.h"
 #include "base/ColumnOp.h"
 #include "base/Strings.h"
+#include "base/StorageAdviser.h"
+#include "base/Exceptions.h"
 #include "widgets/CommandHistory.h"
 #include "data/model/Dense3DModelPeakCache.h"
 
 #include "ColourMapper.h"
 #include "PianoScale.h"

     m_lastEmittedZoomStep(-1),
     m_synchronous(false),
     m_haveDetailedScale(false),
     m_exiting(false),
     m_fftModel(0),
+    m_wholeCache(0),
     m_peakCache(0),
     m_peakCacheDivisor(8)
 {
     QString colourConfigName = "spectrogram-colour";
     int colourConfigDefault = int(ColourMapper::Green);

 {
     invalidateRenderers();
 
     delete m_fftModel;
     delete m_peakCache;
+    delete m_wholeCache;
 }
 
 pair<ColourScaleType, double>
 SpectrogramLayer::convertToColourScale(int value)
 {

     m_windowHopLevel = v;
     
     recreateFFTModel();
 
     emit layerParametersChanged();
-
-//    fillCache();
 }
 
 int
 SpectrogramLayer::getWindowHopLevel() const
 {

 
     if (!m_model || !m_model->isOK()) {
         emit sliceableModelReplaced(m_fftModel, 0);
         delete m_fftModel;
         delete m_peakCache;
+        delete m_wholeCache;
         m_fftModel = 0;
         m_peakCache = 0;
+        m_wholeCache = 0;
         return;
     }
 
     FFTModel *oldModel = m_fftModel;
 

                               getWindowIncrement(),
                               getFFTSize());
 
     delete m_peakCache;
     m_peakCache = 0;
+
+    delete m_wholeCache;
+    m_wholeCache = 0;
     
     if (!m_fftModel->isOK()) {
         QMessageBox::critical
             (0, tr("FFT cache failed"),
              tr("Failed to create the FFT model for this spectrogram.\n"
                 "There may be insufficient memory or disc space to continue."));
         delete m_fftModel;
         m_fftModel = 0;
         return;
     }
-    
-    m_peakCache = new Dense3DModelPeakCache(m_fftModel, m_peakCacheDivisor);
+
+    if (canStoreWholeCache()) { // i.e. if enough memory
+        m_wholeCache = new Dense3DModelPeakCache(m_fftModel, 1);
+        m_peakCache = new Dense3DModelPeakCache(m_wholeCache, m_peakCacheDivisor);
+    } else {
+        m_peakCache = new Dense3DModelPeakCache(m_fftModel, m_peakCacheDivisor);
+    }
 
     emit sliceableModelReplaced(oldModel, m_fftModel);
 
     delete oldModel;
+}
+
+bool
+SpectrogramLayer::canStoreWholeCache() const
+{
+    if (!m_fftModel) {
+        return false; // or true, doesn't really matter
+    }
+
+    size_t sz =
+        size_t(m_fftModel->getWidth()) *
+        size_t(m_fftModel->getHeight()) *
+        sizeof(float);
+
+    try {
+        SVDEBUG << "Requesting advice from StorageAdviser on whether to create whole-model cache" << endl;
+        StorageAdviser::Recommendation recommendation =
+            StorageAdviser::recommend
+            (StorageAdviser::Criteria(StorageAdviser::SpeedCritical |
+                                      StorageAdviser::PrecisionCritical |
+                                      StorageAdviser::FrequentLookupLikely),
+             sz / 1024, sz / 1024);
+        if ((recommendation & StorageAdviser::UseDisc) ||
+            (recommendation & StorageAdviser::ConserveSpace)) {
+            SVDEBUG << "Seems inadvisable to create whole-model cache" << endl;
+            return false;
+        } else {
+            SVDEBUG << "Seems fine to create whole-model cache" << endl;
+            return true;
+        }
+    } catch (const InsufficientDiscSpace &) {
+        SVDEBUG << "Seems like a terrible idea to create whole-model cache" << endl;
+        return false;
+    }
 }
 
 const Model *
 SpectrogramLayer::getSliceableModel() const
 {

 
         Colour3DPlotRenderer::Sources sources;
         sources.verticalBinLayer = this;
         sources.fft = getFFTModel();
         sources.source = sources.fft;
-        sources.peakCache = getPeakCache();
+        if (m_peakCache) sources.peakCaches.push_back(m_peakCache);
+        if (m_wholeCache) sources.peakCaches.push_back(m_wholeCache);
 
         ColourScale::Parameters cparams;
         cparams.colourMap = m_colourMap;
         cparams.scaleType = m_colourScale;
         cparams.multiple = m_colourScaleMultiple;