comparison layer/SpectrogramLayer.cpp @ 1459:42c87368287c

Merge from branch single-point

     }
 
     FFTModel *oldModel = m_fftModel;
     m_fftModel = newModel;
 
-    if (canStoreWholeCache()) { // i.e. if enough memory
+    bool createWholeCache = false;
+    checkCacheSpace(&m_peakCacheDivisor, &createWholeCache);
+    
+    if (createWholeCache) {
         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
-    }
+void
+SpectrogramLayer::checkCacheSpace(int *suggestedPeakDivisor,
+                                  bool *createWholeCache) const
+{
+    *suggestedPeakDivisor = 8;
+    *createWholeCache = false;
+    
+    if (!m_fftModel) return;
 
     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;
+        // The lower amount here is the amount required for the
+        // slightly higher-resolution version of the peak cache
+        // without a whole-model cache; the higher amount is that for
+        // the whole-model cache. The factors of 1024 are because
+        // StorageAdviser rather stupidly works in kilobytes
         StorageAdviser::Recommendation recommendation =
             StorageAdviser::recommend
             (StorageAdviser::Criteria(StorageAdviser::SpeedCritical |
                                       StorageAdviser::PrecisionCritical |
                                       StorageAdviser::FrequentLookupLikely),
-             sz / 1024, sz / 1024);
-        if ((recommendation & StorageAdviser::UseDisc) ||
-            (recommendation & StorageAdviser::ConserveSpace)) {
+             (sz / 8) / 1024, sz / 1024);
+        if (recommendation & StorageAdviser::UseDisc) {
             SVDEBUG << "Seems inadvisable to create whole-model cache" << endl;
-            return false;
-        } else {
+        } else if (recommendation & StorageAdviser::ConserveSpace) {
+            SVDEBUG << "Seems inadvisable to create whole-model cache but acceptable to use the slightly higher-resolution peak cache" << endl;
+            *suggestedPeakDivisor = 4;
+        } else  {
             SVDEBUG << "Seems fine to create whole-model cache" << endl;
-            return true;
+            *createWholeCache = true;
         }
     } catch (const InsufficientDiscSpace &) {
         SVDEBUG << "Seems like a terrible idea to create whole-model cache" << endl;
-        return false;
     }
 }
 
 const Model *
 SpectrogramLayer::getSliceableModel() const

     sv_frame_t right = left + resolution;
 
     switch (snap) {
     case SnapLeft:  frame = left;  break;
     case SnapRight: frame = right; break;
-    case SnapNearest:
     case SnapNeighbouring:
         if (frame - left > right - frame) frame = right;
         else frame = left;
         break;
     }

 void
 SpectrogramLayer::paintCrosshairs(LayerGeometryProvider *v, QPainter &paint,
                                   QPoint cursorPos) const
 {
     paint.save();
-
+    
     int sw = getVerticalScaleWidth(v, m_haveDetailedScale, paint);
 
     QFont fn = paint.font();
     if (fn.pointSize() > 8) {
         fn.setPointSize(fn.pointSize() - 1);