comparison layer/SpectrogramLayer.cpp @ 1024:3bce4c45b681 spectrogram-minor-refactor

Rearrange cache update calculations so as to use the actual painted width returned by paint functions (though they only ever return the same width as requested, at this point)

                 }
             } else {
                 x1 = x0; // it's all valid, paint nothing
             }
         }
-         
-        cache.validArea = QRect
-            (std::min(vx0, x0), cache.validArea.y(),
-             std::max(vx1 - std::min(vx0, x0),
-                       x1 - std::min(vx0, x0)),
-             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 {
         if (x1 > x0 + paintBlockWidth) {
             int sfx = x1;
             if (startFrame < 0) sfx = v->getXForFrame(0);

                 int mid = (x1 + x0) / 2;
                 x0 = mid - paintBlockWidth/2;
                 x1 = x0 + paintBlockWidth;
             }
         }
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-        cerr << "Valid area becomes " << x0 << ", 0, " << (x1-x0)
-                  << "x" << h << endl;
-#endif
-        cache.validArea = QRect(x0, 0, x1 - x0, h);
-    }
-
-/*
-    if (xPixelRatio != 1.f) {
-        x0 = int((int(x0 / xPixelRatio) - 4) * xPixelRatio + 0.0001);
-        x1 = int((int(x1 / xPixelRatio) + 4) * xPixelRatio + 0.0001);
-    }
-*/
-    int w = x1 - x0;
+    }
+
+    int repaintWidth = x1 - x0;
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     cerr << "x0 " << x0 << ", x1 " << x1 << ", w " << w << ", h " << h << endl;
 #endif
 

 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     cerr << ((double(v->getFrameForX(1) - v->getFrameForX(0))) / increment) << " bin(s) per pixel" << endl;
 #endif
 
-    if (w == 0) {
-        SVDEBUG << "*** NOTE: w == 0" << endl;
+    if (repaintWidth == 0) {
+        SVDEBUG << "*** NOTE: repaintWidth == 0" << endl;
     }
 
     Profiler outerprof("SpectrogramLayer::paint: all cols");
 
     // The draw buffer contains a fragment at either our pixel

 
         for (int x = x0; ; --x) {
             sv_frame_t f = v->getFrameForX(x);
             if ((f / increment) * increment == f) {
                 if (leftCropFrame == -1) leftCropFrame = f;
-                else if (x < x0 - 2) { leftBoundaryFrame = f; break; }
+                else if (x < x0 - 2) {
+                    leftBoundaryFrame = f;
+                    break;
+                }
             }
         }
-        for (int x = x0 + w; ; ++x) {
+        for (int x = x0 + repaintWidth; ; ++x) {
             sv_frame_t f = v->getFrameForX(x);
             if ((f / increment) * increment == f) {
                 if (rightCropFrame == -1) rightCropFrame = f;
-                else if (x > x0 + w + 2) { rightBoundaryFrame = f; break; }
+                else if (x > x0 + repaintWidth + 2) {
+                    rightBoundaryFrame = f;
+                    break;
+                }
             }
         }
 #ifdef DEBUG_SPECTROGRAM_REPAINT
         cerr << "Left: crop: " << leftCropFrame << " (bin " << leftCropFrame/increment << "); boundary: " << leftBoundaryFrame << " (bin " << leftBoundaryFrame/increment << ")" << endl;
         cerr << "Right: crop: " << rightCropFrame << " (bin " << rightCropFrame/increment << "); boundary: " << rightBoundaryFrame << " (bin " << rightBoundaryFrame/increment << ")" << endl;

 
         bufwid = int((rightBoundaryFrame - leftBoundaryFrame) / increment);
 
     } else {
         
-        bufwid = w;
+        bufwid = repaintWidth;
     }
 
     vector<int> binforx(bufwid);
     vector<double> binfory(h);
     

         m_drawBuffer.setColor((unsigned char)pixel,
                               m_palette.getColour((unsigned char)pixel).rgb());
     }
 
     m_drawBuffer.fill(0);
+    int attainedBufwid = bufwid;
     
     if (m_binDisplay != PeakFrequencies) {
 
         for (int y = 0; y < h; ++y) {
             double q0 = 0, q1 = 0;

             } else {
                 binfory[y] = q0;
             }
         }
 
-        paintDrawBuffer(v, bufwid, h, binforx, binfory, usePeaksCache,
-                        overallMag, overallMagChanged);
+        attainedBufwid = 
+            paintDrawBuffer(v, bufwid, h, binforx, binfory, usePeaksCache,
+                            overallMag, overallMagChanged);
 
     } else {
 
-        paintDrawBufferPeakFrequencies(v, bufwid, h, binforx,
-                                       minbin, maxbin,
-                                       displayMinFreq, displayMaxFreq,
-                                       logarithmic,
-                                       overallMag, overallMagChanged);
-    }
-
+        attainedBufwid = 
+            paintDrawBufferPeakFrequencies(v, bufwid, h, binforx,
+                                           minbin, maxbin,
+                                           displayMinFreq, displayMaxFreq,
+                                           logarithmic,
+                                           overallMag, overallMagChanged);
+    }
+
+    int failedToRepaint = bufwid - attainedBufwid;
+    if (failedToRepaint < 0) {
+        cerr << "WARNING: failedToRepaint < 0 (= " << failedToRepaint << ")"
+             << endl;
+        failedToRepaint = 0;
+    }
+    
     if (overallMagChanged) {
         m_viewMags[v] = overallMag;
 #ifdef DEBUG_SPECTROGRAM_REPAINT
         cerr << "Overall mag is now [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "] - will be updating" << endl;
 #endif

                   << ", height = " << h << endl;
 #endif
 	cache.image = QImage(v->getPaintWidth(), h, QImage::Format_ARGB32_Premultiplied);
     }
 
-    if (w > 0) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-        cerr << "Painting " << w << "x" << h
+    if (repaintWidth > 0) {
+
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+        cerr << "Painting " << repaintWidth << "x" << h
                   << " from draw buffer at " << 0 << "," << 0
-                  << " to " << w << "x" << h << " on cache at "
+                  << " to " << repaintWidth << "x" << h << " on cache at "
                   << x0 << "," << 0 << endl;
 #endif
 
         QPainter cachePainter(&cache.image);
 

                 (QRect(scaledLeftCrop, 0,
                        scaledRightCrop - scaledLeftCrop, h),
                  scaled,
                  QRect(scaledLeftCrop - scaledLeft, 0,
                        scaledRightCrop - scaledLeftCrop, h));
+
         } else {
-            cachePainter.drawImage(QRect(x0, 0, w, h),
+
+            cachePainter.drawImage(QRect(x0, 0, repaintWidth, h),
                                    m_drawBuffer,
-                                   QRect(0, 0, w, h));
+                                   QRect(0, 0, repaintWidth, h));
         }
 
         cachePainter.end();
+    }
+
+    // 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);
+
+        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
     }
 
     QRect pr = rect & cache.validArea;
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT

                           << ", "
                           << cache.image.width() - (cache.validArea.x() +
                                                      cache.validArea.width())
                           << ")" << endl;
 #endif
-                v->getView()->update(cache.validArea.x() + cache.validArea.width(),
-                          0,
-                          cache.image.width() - (cache.validArea.x() +
-                                                  cache.validArea.width()),
-                          h);
+                v->getView()->update
+                    (cache.validArea.x() + cache.validArea.width(),
+                     0,
+                     cache.image.width() - (cache.validArea.x() +
+                                            cache.validArea.width()),
+                     h);
             }
         } else {
             // overallMagChanged
             cerr << "\noverallMagChanged - updating all\n" << endl;
             cache.validArea = QRect();

         m_lastPaintTime = std::chrono::duration<double>(diff).count();
         m_lastPaintBlockWidth = paintBlockWidth;
     }
 }
 
-void
+int
 SpectrogramLayer::paintDrawBufferPeakFrequencies(LayerGeometryProvider *v,
                                                  int w,
                                                  int h,
                                                  const vector<int> &binforx,
                                                  int minbin,

 #endif
     if (minbin < 0) minbin = 0;
     if (maxbin < 0) maxbin = minbin+1;
 
     FFTModel *fft = getFFTModel(v);
-    if (!fft) return;
+    if (!fft) return 0;
 
     FFTModel::PeakSet peakfreqs;
 
     int psx = -1;
 

                     if (overallMag.sample(mag)) overallMagChanged = true;
                 }
             }
         }
     }
-}
-
-void
+
+    return w;
+}
+
+int
 SpectrogramLayer::paintDrawBuffer(LayerGeometryProvider *v,
                                   int w,
                                   int h,
                                   const vector<int> &binforx,
                                   const vector<double> &binfory,

         maxbin = sourceModel->getHeight();
     } else {
         sourceModel = fft = getFFTModel(v);
     }
 
-    if (!sourceModel) return;
+    if (!sourceModel) return 0;
 
     bool interpolate = false;
     Preferences::SpectrogramSmoothing smoothing = 
         Preferences::getInstance()->getSpectrogramSmoothing();
     if (smoothing == Preferences::SpectrogramInterpolated ||

             unsigned char peakpix = getDisplayValue(v, peak);
 
             m_drawBuffer.setPixel(x, h-y-1, peakpix);
         }
     }
+
+    return w;
 }
 
 void
 SpectrogramLayer::illuminateLocalFeatures(LayerGeometryProvider *v, QPainter &paint) const
 {