comparison layer/SpectrogramLayer.cpp @ 1039:bfce7940c017 spectrogram-minor-refactor

Don't use partial paints when zoomed in far enough to have boundary alignment concerns. (But boundary calculations are still wrong, leading to a logic error exception.)

     // If (getFrameForX(x) / increment) * increment ==
     // getFrameForX(x), then x is a time-bin boundary.  We want two
     // such boundaries at either side of the draw buffer -- one which
     // we draw up to, and one which we subsequently crop at.
 
-    bool bufferBinResolution = false;
-    if (increment > zoomLevel) bufferBinResolution = true;
+    bool bufferIsBinResolution = false;
+    if (increment > zoomLevel) bufferIsBinResolution = true;
 
     sv_frame_t leftBoundaryFrame = -1, leftCropFrame = -1;
     sv_frame_t rightBoundaryFrame = -1, rightCropFrame = -1;
 
     int bufwid;
 
-    if (bufferBinResolution) {
+    if (bufferIsBinResolution) {
 
         for (int x = x0; ; --x) {
             sv_frame_t f = v->getFrameForX(x);
             if ((f / increment) * increment == f) {
                 if (leftCropFrame == -1) leftCropFrame = f;

     vector<int> binforx(bufwid);
     vector<double> binfory(h);
     
     bool usePeaksCache = false;
 
-    if (bufferBinResolution) {
+    if (bufferIsBinResolution) {
         for (int x = 0; x < bufwid; ++x) {
             binforx[x] = int(leftBoundaryFrame / increment) + x;
         }
         m_drawBuffer = QImage(bufwid, h, QImage::Format_Indexed8);
     } else {

                               m_palette.getColour((unsigned char)pixel).rgb());
     }
 
     m_drawBuffer.fill(0);
     int attainedBufwid = bufwid;
-    
+
+    double softTimeLimit;
+
+    if (m_synchronous) {
+
+        // must paint the whole thing for synchronous mode, so give
+        // "no timeout"
+        softTimeLimit = 0.0;
+        
+    } else if (bufferIsBinResolution) {
+        
+        // calculating boundaries later will be too fiddly for partial
+        // paints, and painting should be fast anyway when this is the
+        // case because it means we're well zoomed in
+        softTimeLimit = 0.0;
+
+    } else {
+
+        // neither limitation applies, so use a short soft limit
+
+        if (m_binDisplay == PeakFrequencies) {
+            softTimeLimit = 0.15;
+        } else {
+            softTimeLimit = 0.1;
+        }
+    }
+
     if (m_binDisplay != PeakFrequencies) {
 
         for (int y = 0; y < h; ++y) {
             double q0 = 0, q1 = 0;
             if (!getSmoothedYBinRange(v, h-y-1, q0, q1)) {

 
         attainedBufwid = 
             paintDrawBuffer(v, bufwid, h, binforx, binfory,
                             usePeaksCache,
                             overallMag, overallMagChanged,
-                            rightToLeft);
+                            rightToLeft,
+                            softTimeLimit);
 
     } else {
 
         attainedBufwid = 
             paintDrawBufferPeakFrequencies(v, bufwid, h, binforx,
                                            minbin, maxbin,
                                            displayMinFreq, displayMaxFreq,
                                            logarithmic,
                                            overallMag, overallMagChanged,
-                                           rightToLeft);
+                                           rightToLeft,
+                                           softTimeLimit);
     }
 
     int failedToRepaint = bufwid - attainedBufwid;
 
     int paintedLeft = x0;

                   << " from draw buffer at " << paintedLeft - x0 << "," << 0
                   << " to " << paintedWidth << "x" << h << " on cache at "
                   << x0 << "," << 0 << endl;
 #endif
 
-        if (bufferBinResolution) {
+        if (bufferIsBinResolution) {
 
             int scaledLeft = v->getXForFrame(leftBoundaryFrame);
             int scaledRight = v->getXForFrame(rightBoundaryFrame);
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT

                                                  double displayMinFreq,
                                                  double displayMaxFreq,
                                                  bool logarithmic,
                                                  MagnitudeRange &overallMag,
                                                  bool &overallMagChanged,
-                                                 bool rightToLeft) const
+                                                 bool rightToLeft,
+                                                 double softTimeLimit) const
 {
     Profiler profiler("SpectrogramLayer::paintDrawBufferPeakFrequencies");
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     cerr << "SpectrogramLayer::paintDrawBufferPeakFrequencies: minbin " << minbin << ", maxbin " << maxbin << "; w " << w << ", h " << h << endl;

 #else
     float *values = (float *)alloca((maxbin - minbin + 1) * sizeof(float));
 #endif
 
     int minColumns = 4;
-    double softTimeLimit = 0.15; // seconds; only for non-synchronous drawing
+    bool haveTimeLimits = (softTimeLimit > 0.0);
     double hardTimeLimit = softTimeLimit * 2.0;
     bool overridingSoftLimit = false;
     auto startTime = chrono::steady_clock::now();
     
     int start = 0;

                     if (overallMag.sample(mag)) overallMagChanged = true;
                 }
             }
         }
 
-        if (!m_synchronous) {
+        if (haveTimeLimits) {
             if (columnCount >= minColumns) {
                 auto t = chrono::steady_clock::now();
                 double diff = chrono::duration<double>(t - startTime).count();
                 if (diff > hardTimeLimit) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT

                                   const vector<int> &binforx,
                                   const vector<double> &binfory,
                                   bool usePeaksCache,
                                   MagnitudeRange &overallMag,
                                   bool &overallMagChanged,
-                                  bool rightToLeft) const
+                                  bool rightToLeft,
+                                  double softTimeLimit) const
 {
     Profiler profiler("SpectrogramLayer::paintDrawBuffer");
 
     int minbin = int(binfory[0] + 0.0001);
     int maxbin = int(binfory[h-1]);

 
     const float *values = autoarray;
     DenseThreeDimensionalModel::Column c;
 
     int minColumns = 4;
-    double softTimeLimit = 0.1; // seconds; only for non-synchronous drawing
+    bool haveTimeLimits = (softTimeLimit > 0.0);
     double hardTimeLimit = softTimeLimit * 2.0;
     bool overridingSoftLimit = false;
     auto startTime = chrono::steady_clock::now();
     
     int start = 0;

             unsigned char peakpix = getDisplayValue(v, peak);
 
             m_drawBuffer.setPixel(x, h-y-1, peakpix);
         }
 
-        if (!m_synchronous) {
+        if (haveTimeLimits) {
             if (columnCount >= minColumns) {
                 auto t = chrono::steady_clock::now();
                 double diff = chrono::duration<double>(t - startTime).count();
                 if (diff > hardTimeLimit) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT