comparison layer/SpectrogramLayer.cpp @ 381:44670ce11a0c spectrogram-cache-rejig

* Some debug output and tweaks

 
 
 // Plan:
 //
 // - the QImage cache is managed by the GUI thread (which creates,
-// sizes and destroys it).
+// sizes and destroys it)
 //
 // - but the cache is drawn on by another thread (paint thread)
 //
 // - the GUI thread paint method should always just draw straight from
 // cache without any lock, but it needs to check whether the cache is

     // cache mutex only long enough to look up the cache object in the
     // map, and then release it, retaining the specific mutex while it
     // paints.  The GUI thread should then never modify the cache
     // image without holding its specific mutex.)
 
-    Profiler profiler("SpectrogramLayer::paint", false);
+    Profiler profiler("SpectrogramLayer::paint", true);
+
+    std::cerr << "SpectrogramLayer::paint entering" << std::endl;
 
     QMutexLocker locker(&m_pixmapCacheMutex);
 
     rect = v->rect(); //!!!
 
     float ratio = float(v->getZoomLevel()) / float(getWindowIncrement());
     int imageWidth = lrintf(v->width() * ratio);
+
+    std::cerr << "SpectrogramLayer::paint: view width = " << v->width() << ", ratio = " << ratio << ", imageWidth = " << imageWidth << std::endl;
 
     PixmapCache *cache = m_pixmapCaches[v];
     if (!cache) {
         cache = new PixmapCache;
         cache->pixmap = 0;

         cache->pixmap = new QImage(imageWidth, v->height(),
                                    QImage::Format_RGB32);
         cache->mutex.unlock();
 #ifdef DEBUG_SPECTROGRAM_REPAINT
         std::cerr << "SpectrogramLayer::paint: Created new cache, size "
-                  << v->width() << "x" << v->height() << " ("
-                  << v->width() * v->height() * 4 << " bytes)" << std::endl;
+                  << imageWidth << "x" << v->height() << " ("
+                  << imageWidth * v->height() * 4 << " bytes)" << std::endl;
 #endif
         return; //!!! prod paint thread
     }
 
     long myStartFrame = v->getStartFrame();

             if (m_exiting) break;
         }
 
         if (!m_exiting) {
             //!!! wait on condition
-            if (workToDo) ; // usleep(100);
-            else sleep(1);
+            if (workToDo) {
+                // usleep(100);
+                std::cerr << "SpectrogramLayer::PaintThread::run: still work to do, continuing" << std::endl;
+            } else {
+                sleep(10);
+            }
         }
     }
 }
 
 // return true if no more work to do, or can do no more
 
 bool
 SpectrogramLayer::paintCache(View *v) const
 {
-    Profiler profiler("SpectrogramLayer::paintCache", false);
+    Profiler profiler("SpectrogramLayer::paintCache", true);
 
     m_pixmapCacheMutex.lock();
     
     PixmapCache *cacheptr = m_pixmapCaches[v];
     if (!cacheptr || !cacheptr->pixmap || cacheptr->pixmap->width() == 0) {

     }
 
     PixmapCache &cache = *cacheptr;
     QMutexLocker locker(&cache.mutex);
     m_pixmapCacheMutex.unlock();
+
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+        std::cerr << "SpectrogramLayer::paintCache(): Have cache to paint onto"
+                  << std::endl;
+#endif
 
     QImage &image = *cache.pixmap; //!!! rename to cache.image
 
     const DenseTimeValueModel *model = m_model;
     if (!model || !model->isOK() || !model->isReady()) {

             interpolate = true;
         }
     }
 
     bool runOutOfData = false;
+    int runOutOfDataAt = x1;
 
     std::cerr << "painting from " << x0 << " to " << x1 << std::endl;
 
     for (int x = 0; x < (x1 - x0); ++x) {
 

         if (!fft->isColumnAvailable(col)) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
             std::cerr << "Met unavailable column at col " << col << std::endl;
 #endif
             runOutOfData = true;
+            runOutOfDataAt = x0 + x;
             break;
         }
 
 /*            
             if (!fftSuspended) {

 #ifdef DEBUG_SPECTROGRAM_REPAINT
         std::cerr << "Overall mag unchanged at [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << std::endl;
 #endif
     }
 */
+
+    if (runOutOfData) {
+        std::cerr << "ran out of data, setting x1 to " << runOutOfDataAt
+                  << std::endl;
+        x1 = runOutOfDataAt;
+    }
+
     if (cache.validArea.width() > 0) {
         
         int vx0 = 0, vx1 = 0;
         vx0 = cache.validArea.x();
         vx1 = cache.validArea.x() + cache.validArea.width();
+
+        std::cerr << "set cache valid region from "
+                  << cache.validArea.x() << " -> " << cache.validArea.x() + cache.validArea.width();
         
         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());
 
+        std::cerr << " to "
+                  << cache.validArea.x() << " -> " << cache.validArea.x() + cache.validArea.width()
+                  << std::endl;
+        
     } else {
         
         cache.validArea = QRect(x0, 0, x1 - x0, h);
+
+        std::cerr << "set cache valid region from empty to "
+                  << cache.validArea.x() << " -> " << cache.validArea.x() + cache.validArea.width()
+                  << std::endl;
     }
         
 /*
     Profiler profiler2("SpectrogramLayer::paintCache: draw image", true);
 

         std::cerr << "x0 " << x0 << ", x1 " << x1 << ", vx0 " << vx0 << ", vx1 " << vx1 << ", paintBlockWidth " << paintBlockWidth << std::endl;
 #endif            
         if (x0 < vx0) {
             if (x0 + paintBlockWidth < vx0) {
                 x0 = vx0 - paintBlockWidth;
-//            } else {
-//                x0 = 0;
             }
             x1 = vx0;
         } else if (x0 >= vx1) {
             x0 = vx1;
             if (x1 > x0 + paintBlockWidth) {

                 x0 = mid - paintBlockWidth/2;
                 x1 = x0 + paintBlockWidth;
 //            }
         }
     }
+
+    std::cerr << "SpectrogramLayer::selectPaintStrip: returning " << x0 << " -> " << x1 << std::endl;
 }
 
 void
 SpectrogramLayer::illuminateLocalFeatures(View *v, QPainter &paint) const
 {