comparison layer/SpectrogramLayer.cpp @ 1037:6f7a471826d1 spectrogram-minor-refactor

Timing tweaks to reduce the number of repaints

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

     invalidateImageCaches();
     invalidateMagnitudes();
 }
 
 void
-SpectrogramLayer::cacheInvalid(sv_frame_t from, sv_frame_t to)
+SpectrogramLayer::cacheInvalid(
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+    sv_frame_t from, sv_frame_t to
+#else 
+    sv_frame_t     , sv_frame_t
+#endif
+    )
 {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     cerr << "SpectrogramLayer::cacheInvalid(" << from << ", " << to << ")" << endl;
 #endif
 

     if (!cache.isValid()) {
         if (!m_synchronous) {
             // When rendering the whole thing, start from somewhere near
             // the middle so that the region of interest appears first
             if (x0 == 0 && x1 == v->getPaintWidth()) {
-                x0 = int(x1 * 0.4);
+                x0 = int(x1 * 0.3);
             }
         }
     } else {
         // When rendering only a part of the cache, we need to make
         // sure that the part we're rendering is adjacent to (or

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

 
         if (!m_synchronous) {
             if (columnCount >= minColumns) {
                 auto t = chrono::steady_clock::now();
                 double diff = chrono::duration<double>(t - startTime).count();
-                if (diff > maxTime) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-                    cerr << "SpectrogramLayer::paintDrawBufferPeakFrequencies: Max time " << maxTime << " sec exceeded after "
+                if (diff > hardTimeLimit) {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+                    cerr << "SpectrogramLayer::paintDrawBufferPeakFrequencies: hard limit " << hardTimeLimit << " sec exceeded after "
                          << columnCount << " columns with time " << diff << endl;
 #endif
                     return columnCount;
-                }
+                } else if (diff > softTimeLimit && !overridingSoftLimit) {
+                    // If we're more than half way through by the time
+                    // we reach the soft limit, ignore it (though
+                    // still respect the hard limit, above). Otherwise
+                    // respect the soft limit and return now.
+                    if (columnCount > w/2) {
+                        overridingSoftLimit = true;
+                    } else {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+                        cerr << "SpectrogramLayer::paintDrawBufferPeakFrequencies: soft limit " << softTimeLimit << " sec exceeded after "
+                             << columnCount << " columns with time " << diff << endl;
+#endif
+                        return columnCount;
+                    }
+                }                        
             }
         }
     }
 
     return columnCount;

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

 
         if (!m_synchronous) {
             if (columnCount >= minColumns) {
                 auto t = chrono::steady_clock::now();
                 double diff = chrono::duration<double>(t - startTime).count();
-                if (diff > maxTime) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-                    cerr << "SpectrogramLayer::paintDrawBuffer: Max time " << maxTime << " sec exceeded after "
+                if (diff > hardTimeLimit) {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+                    cerr << "SpectrogramLayer::paintDrawBuffer: hard limit " << hardTimeLimit << " sec exceeded after "
                          << columnCount << " columns with time " << diff << endl;
 #endif
                     return columnCount;
-                }
+                } else if (diff > softTimeLimit && !overridingSoftLimit) {
+                    // If we're more than half way through by the time
+                    // we reach the soft limit, ignore it (though
+                    // still respect the hard limit, above). Otherwise
+                    // respect the soft limit and return now.
+                    if (columnCount > w/2) {
+                        overridingSoftLimit = true;
+                    } else {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+                        cerr << "SpectrogramLayer::paintDrawBuffer: soft limit " << softTimeLimit << " sec exceeded after "
+                             << columnCount << " columns with time " << diff << endl;
+#endif
+                        return columnCount;
+                    }
+                }                        
             }
         }
     }
 
     return columnCount;