comparison layer/SpectrogramLayer.cpp @ 1025:c02de0e34233 spectrogram-minor-refactor

Make paint method do its own timing and abandon if it's taking too long (still needs some work on queueing correct repaints of the remainder)

 
 #include <QPainter>
 #include <QImage>
 #include <QPixmap>
 #include <QRect>
-#include <QTimer>
 #include <QApplication>
 #include <QMessageBox>
 #include <QMouseEvent>
 #include <QTextStream>
 #include <QSettings>

 
 #ifndef __GNUC__
 #include <alloca.h>
 #endif
 
-//#define DEBUG_SPECTROGRAM_REPAINT 1
-
-using std::vector;
+#define DEBUG_SPECTROGRAM_REPAINT 1
+
+using namespace std;
 
 SpectrogramLayer::SpectrogramLayer(Configuration config) :
     m_model(0),
     m_channel(0),
     m_windowSize(1024),

     m_binDisplay(AllBins),
     m_normalization(NoNormalization),
     m_lastEmittedZoomStep(-1),
     m_synchronous(false),
     m_haveDetailedScale(false),
-    m_lastPaintBlockWidth(0),
     m_exiting(false),
     m_sliceableModel(0)
 {
     QString colourConfigName = "spectrogram-colour";
     int colourConfigDefault = int(ColourMapper::Green);

 
 void
 SpectrogramLayer::invalidateMagnitudes()
 {
     m_viewMags.clear();
-    for (std::vector<MagnitudeRange>::iterator i = m_columnMags.begin();
+    for (vector<MagnitudeRange>::iterator i = m_columnMags.begin();
          i != m_columnMags.end(); ++i) {
         *i = MagnitudeRange();
     }
 }
 

 
     if (!getXBinRange(v, x1, s10, s11)) {
         s10 = s11 = double(m_model->getEndFrame()) / getWindowIncrement();
     }
 
-    int s0 = int(std::min(s00, s10) + 0.0001);
-    int s1 = int(std::max(s01, s11) + 0.0001);
+    int s0 = int(min(s00, s10) + 0.0001);
+    int s1 = int(max(s01, s11) + 0.0001);
 
 //    SVDEBUG << "SpectrogramLayer::updateViewMagnitudes: x0 = " << x0 << ", x1 = " << x1 << ", s00 = " << s00 << ", s11 = " << s11 << " s0 = " << s0 << ", s1 = " << s1 << endl;
 
     if (int(m_columnMags.size()) <= s1) {
         m_columnMags.resize(s1 + 1);

         cerr << "SpectrogramLayer: magnitude range changed to [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << endl;
 #endif
         if (m_normalization == NormalizeVisibleArea) {
             cache.validArea = QRect();
         }
-    }
-
-    if (cache.zoomLevel != zoomLevel) {
-        // no matter what we do with the cache, we'll need to
-        // recalculate our paint width again because each block will
-        // take a different time to render from previously
-        m_lastPaintBlockWidth = 0;
     }
     
     if (cache.validArea.width() > 0) {
 
         int cw = cache.image.width();

     if (recreateWholeImageCache) {
         x0 = 0;
         x1 = v->getPaintWidth();
     }
 
-    auto mainPaintStart = std::chrono::steady_clock::now();
-
-    int paintBlockWidth = m_lastPaintBlockWidth;
-
-    if (m_synchronous) {
-        if (paintBlockWidth < x1 - x0) {
-            // always paint full width
-            paintBlockWidth = x1 - x0;
-        }
-    } else {
-        if (paintBlockWidth == 0) {
-            paintBlockWidth = (300000 / zoomLevel);
-        } else {
-            double lastTime = m_lastPaintTime;
-            while (lastTime > 0.2 &&
-                   paintBlockWidth > 30) {
-                paintBlockWidth /= 2;
-                lastTime = lastTime / 2;
-            }
-            while (lastTime < 0.09 &&
-                   paintBlockWidth < std::max(50, 1200000 / zoomLevel) &&
-                   paintBlockWidth < 1500) {
-                paintBlockWidth *= 2;
-                lastTime = lastTime * 2;
-            }
-        }
-        
-        if (paintBlockWidth < 20) paintBlockWidth = 20;
-    }
-
-//#ifdef DEBUG_SPECTROGRAM_REPAINT
-    cerr << "[" << this << "]: last paint width: " << m_lastPaintBlockWidth << ", last paint time: " << m_lastPaintTime << ", new paint width: " << paintBlockWidth << endl;
-//#endif
-
     // We always paint the full height when refreshing the cache.
     // Smaller heights can be used when painting direct from cache
     // (further up in this function), but we want to ensure the cache
     // is coherent without having to worry about vertical matching of
     // required and valid areas as well as horizontal.
 
     int h = v->getPaintHeight();
 
+    /*
+    auto mainPaintStart = chrono::steady_clock::now();
+
+    //!!! nb full-width case goes like
+                paintBlockWidth = x1 - x0;
+
     if (cache.validArea.width() > 0) {
 
         // If part of the cache is known to be valid, select a strip
         // immediately to left or right of the valid part
 

         int vx0 = 0, vx1 = 0;
         vx0 = cache.validArea.x();
         vx1 = cache.validArea.x() + cache.validArea.width();
         
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        cerr << "x0 " << x0 << ", x1 " << x1 << ", vx0 " << vx0 << ", vx1 " << vx1 << ", paintBlockWidth " << paintBlockWidth << endl;
+        cerr << "x0 " << x0 << ", x1 " << x1 << ", vx0 " << vx0 << ", vx1 " << vx1 << endl;
 #endif         
         if (x0 < vx0) {
             if (x0 + paintBlockWidth < vx0) {
                 x0 = vx0 - paintBlockWidth;
             }

                 x0 = mid - paintBlockWidth/2;
                 x1 = x0 + paintBlockWidth;
             }
         }
     }
-
+    */
+    
     int repaintWidth = x1 - x0;
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-    cerr << "x0 " << x0 << ", x1 " << x1 << ", w " << w << ", h " << h << endl;
+    cerr << "x0 " << x0 << ", x1 " << x1
+         << ", repaintWidth " << repaintWidth << ", h " << h << endl;
 #endif
 
     sv_samplerate_t sr = m_model->getSampleRate();
 
     // Set minFreq and maxFreq to the frequency extents of the possibly

                                            logarithmic,
                                            overallMag, overallMagChanged);
     }
 
     int failedToRepaint = bufwid - attainedBufwid;
-    if (failedToRepaint < 0) {
+    if (failedToRepaint > 0) {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+        cerr << "Failed to repaint " << failedToRepaint << " of " << bufwid
+             << " columns in time" << endl;
+#endif
+    } else if (failedToRepaint < 0) {
         cerr << "WARNING: failedToRepaint < 0 (= " << failedToRepaint << ")"
              << endl;
         failedToRepaint = 0;
     }
     

     }
 
     // update cache valid area based on painted area
     if (cache.validArea.width() > 0) {
         
-        int left = std::min(cache.validArea.x(), x0);
-
-        int wid  = std::max(cache.validArea.x() + cache.validArea.width() - left,
-                            x1 - left);
-
+        int left = min(cache.validArea.x(), x0);
+
+        int wid = max(cache.validArea.x() + cache.validArea.width() - left,
+                      x1 - left);
         wid = wid - failedToRepaint;
         if (wid < 0) wid = 0;
         
         cache.validArea = QRect
             (left, cache.validArea.y(), wid, cache.validArea.height());
 
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-        cerr << "Valid area becomes " << cache.validArea.x()
-                  << ", " << cache.validArea.y() << ", "
-                  << cache.validArea.width() << "x"
-                  << cache.validArea.height() << endl;
-#endif
-
     } else {
 
-        cache.validArea = QRect(x0, 0, x1 - x0, h);
-
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-        cerr << "Valid area becomes " << x0 << ", 0, " << (x1-x0)
-                  << "x" << h << endl;
-#endif
-    }
+        int wid = x1 - x0;
+        wid = wid - failedToRepaint;
+        if (wid < 0) wid = 0;
+        
+        cache.validArea = QRect(x0, 0, wid, h);
+    }
+
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+    cerr << "Cache valid area becomes " << cache.validArea.x()
+         << ", " << cache.validArea.y() << ", "
+         << cache.validArea.width() << "x"
+         << cache.validArea.height() << endl;
+#endif
 
     QRect pr = rect & cache.validArea;
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     cerr << "Painting " << pr.width() << "x" << pr.height()

     illuminateLocalFeatures(v, paint);
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     cerr << "SpectrogramLayer::paint() returning" << endl;
 #endif
-
+/*!!!
     if (!m_synchronous) {
-        auto mainPaintEnd = std::chrono::steady_clock::now();
+        auto mainPaintEnd = chrono::steady_clock::now();
         auto diff = mainPaintEnd - mainPaintStart;
-        m_lastPaintTime = std::chrono::duration<double>(diff).count();
-        m_lastPaintBlockWidth = paintBlockWidth;
-    }
+        m_lastPaintTime = chrono::duration<double>(diff).count();
+    }
+*/
 }
 
 int
 SpectrogramLayer::paintDrawBufferPeakFrequencies(LayerGeometryProvider *v,
                                                  int w,

                                   MagnitudeRange &overallMag,
                                   bool &overallMagChanged) const
 {
     Profiler profiler("SpectrogramLayer::paintDrawBuffer");
 
+    //!!! todo: propagate to paintDrawBufferPeakFrequencies
+
+    int minColumns = 4;
+    double maxTime = 0.1; // seconds; only for non-synchronous drawing
+
+    auto startTime = chrono::steady_clock::now();
+    
     int minbin = int(binfory[0] + 0.0001);
     int maxbin = int(binfory[h-1]);
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     cerr << "paintDrawBuffer: minbin " << minbin << ", maxbin " << maxbin << "; w " << w << ", h " << h << endl;

             
             unsigned char peakpix = getDisplayValue(v, peak);
 
             m_drawBuffer.setPixel(x, h-y-1, peakpix);
         }
+
+        if (!m_synchronous) {
+            if (x >= minColumns) {
+                auto t = chrono::steady_clock::now();
+                double diff = chrono::duration<double>(t - startTime).count();
+                if (diff > maxTime) {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+                    cerr << "Max time " << maxTime << " sec exceeded after "
+                         << x << " columns with time " << diff << endl;
+#endif
+                    return x;
+                }
+            }
+        }
     }
 
     return w;
 }
 

 }
 
 bool
 SpectrogramLayer::getCrosshairExtents(LayerGeometryProvider *v, QPainter &paint,
                                       QPoint cursorPos,
-                                      std::vector<QRect> &extents) const
+                                      vector<QRect> &extents) const
 {
     QRect vertical(cursorPos.x() - 12, 0, 12, v->getPaintHeight());
     extents.push_back(vertical);
 
     QRect horizontal(0, cursorPos.y(), cursorPos.x(), 1);

 	QString text = QString("%1").arg(freq);
 	if (bin == 1) text = tr("%1Hz").arg(freq); // bin 0 is DC
 	paint.drawLine(cw + 7, h - vy, w - pkw - 1, h - vy);
 
 	if (h - vy - textHeight >= -2) {
-	    int tx = w - 3 - paint.fontMetrics().width(text) - std::max(tickw, pkw);
+	    int tx = w - 3 - paint.fontMetrics().width(text) - max(tickw, pkw);
 	    paint.drawText(tx, h - vy + toff, text);
 	}
 
 	py = vy;
     }