comparison layer/Colour3DPlotRenderer.cpp @ 1500:ac5a82e57d23

More debug bits

     SVDEBUG << "render " << m_sources.source
             << ": cache start " << m_cache.getStartFrame()
             << " valid left " << m_cache.getValidLeft()
             << " valid right " << m_cache.getValidRight()
             << endl;
-    SVDEBUG << " view start " << startFrame
+    SVDEBUG << "render " << m_sources.source
+            << ": view start " << startFrame
             << " x0 " << x0
             << " x1 " << x1
             << endl;
 #endif
 

             v->getXForFrame(startFrame) &&
             m_cache.getValidLeft() <= x0 &&
             m_cache.getValidRight() >= x1) {
 
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-            SVDEBUG << "cache hit" << endl;
+            SVDEBUG << "render " << m_sources.source
+                    << ": cache hit" << endl;
 #endif
             count.hit();
             
             // cache is valid for the complete requested area
             paint.drawImage(rect, m_cache.getImage(), rect);

 
             return { rect, range };
 
         } else {
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-            SVDEBUG << "cache partial hit" << endl;
+            SVDEBUG << "render " << m_sources.source
+                    << ": cache partial hit" << endl;
 #endif
             count.partial();
             
             // cache doesn't begin at the right frame or doesn't
             // contain the complete view, but might be scrollable or

         renderToCacheBinResolution(v, x0, x1 - x0);
 
     } else { // must be DrawBufferPixelResolution, handled DirectTranslucent earlier
 
         if (timeConstrained && justInvalidated) {
-            SVDEBUG << "render " << m_sources.source << ": just invalidated cache in time-constrained context, that's all we're doing for now - wait for next update to start filling" << endl;
+            SVDEBUG << "render " << m_sources.source
+                    << ": invalidated cache in time-constrained context, that's all we're doing for now - wait for next update to start filling" << endl;
         } else {
             renderToCachePixelResolution(v, x0, x1 - x0, rightToLeft, timeConstrained);
         }
     }
 

             (m_sources.peakCaches[ix]);
         if (!peakCache) continue;
         int bpp = peakCache->getColumnsPerPeak();
         ZoomLevel equivZoom(ZoomLevel::FramesPerPixel, binResolution * bpp);
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-        SVDEBUG << "getPreferredPeakCache: zoomLevel = " << zoomLevel
+        SVDEBUG << "render " << m_sources.source
+                << ": getPreferredPeakCache: zoomLevel = " << zoomLevel
                 << ", cache " << ix << " has bpp = " << bpp
                 << " for equivZoom = " << equivZoom << endl;
 #endif
         if (zoomLevel >= equivZoom) {
             // this peak cache would work, though it might not be best

                                                    bool timeConstrained)
 {
     Profiler profiler("Colour3DPlotRenderer::renderToCachePixelResolution");
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
     SVDEBUG << "render " << m_sources.source
-            << ": renderToCachePixelResolution" << endl;
+            << ": [PIXEL] renderToCachePixelResolution" << endl;
 #endif
     
     // Draw to the draw buffer, and then copy from there. The draw
     // buffer is at the same resolution as the target in the cache, so
     // no extra scaling needed.

                                                  int x0, int repaintWidth)
 {
     Profiler profiler("Colour3DPlotRenderer::renderToCacheBinResolution");
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
     SVDEBUG << "render " << m_sources.source
-            << ": renderToCacheBinResolution" << endl;
+            << ": [BIN] renderToCacheBinResolution" << endl;
 #endif
     
     // Draw to the draw buffer, and then scale-copy from there. Draw
     // buffer is at bin resolution, i.e. buffer x == source column
     // number. We use toolkit smooth scaling for interpolation.

     for (int x = 0; x < drawBufferWidth; ++x) {
         binforx[x] = int(leftBoundaryFrame / binResolution) + x;
     }
 
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-    SVDEBUG << "[BIN] binResolution " << binResolution << endl;
+    SVDEBUG << "render " << m_sources.source
+            << ": binResolution " << binResolution << endl;
 #endif
     
     for (int y = 0; y < h; ++y) {
         binfory[y] = m_sources.verticalBinLayer->getBinForY(v, h - y - 1);
     }

 
     int scaledLeft = v->getXForFrame(leftBoundaryFrame);
     int scaledRight = v->getXForFrame(rightBoundaryFrame);
 
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-    SVDEBUG << "scaling draw buffer from width " << m_drawBuffer.width()
+    SVDEBUG << "render " << m_sources.source
+            << ": scaling draw buffer from width " << m_drawBuffer.width()
             << " to " << (scaledRight - scaledLeft)
             << " (nb drawBufferWidth = "
             << drawBufferWidth << ", attainedWidth = "
             << attainedWidth << ")" << endl;
 #endif

     if (sourceLeft < 0) {
         sourceLeft = 0;
     }
 
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-    SVDEBUG << "leftBoundaryFrame = " << leftBoundaryFrame
+    SVDEBUG << "render " << m_sources.source
+            << ": leftBoundaryFrame = " << leftBoundaryFrame
             << ", leftCropFrame = " << leftCropFrame
             << ", scaledLeft = " << scaledLeft
             << ", scaledLeftCrop = " << scaledLeftCrop
             << endl;
-    SVDEBUG << "rightBoundaryFrame = " << rightBoundaryFrame
+    SVDEBUG << "render " << m_sources.source
+            << ": rightBoundaryFrame = " << rightBoundaryFrame
             << ", rightCropFrame = " << rightCropFrame
             << ", scaledRight = " << scaledRight
             << ", scaledRightCrop = " << scaledRightCrop
             << endl;
 #endif
     
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-    SVDEBUG << "x0 = " << x0
+    SVDEBUG << "render " << m_sources.source
+            << ": x0 = " << x0
             << ", repaintWidth = " << repaintWidth
             << ", targetLeft = " << targetLeft 
             << ", targetWidth = " << targetWidth << endl;
 #endif
     

     }
     
     if (!sourceModel) return 0;
 
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-    SVDEBUG << "renderDrawBuffer: w = " << w << ", h = " << h
+    SVDEBUG << "render " << m_sources.source
+            << ": renderDrawBuffer: w = " << w << ", h = " << h
             << ", peakCacheIndex = " << peakCacheIndex << " (divisor = "
             << divisor << "), rightToLeft = " << rightToLeft
             << ", timeConstrained = " << timeConstrained << endl;
-    SVDEBUG << "renderDrawBuffer: normalization = " << int(m_params.normalization)
+    SVDEBUG << "render " << m_sources.source
+            << ": renderDrawBuffer: normalization = " << int(m_params.normalization)
             << ", binDisplay = " << int(m_params.binDisplay)
             << ", binScale = " << int(m_params.binScale)
             << ", alwaysOpaque = " << m_params.alwaysOpaque
             << ", interpolate = " << m_params.interpolate << endl;
 #endif

 
     int nbins  = int(binfory[h-1] + 0.0001) - minbin + 1;
     if (minbin + nbins > sh) nbins = sh - minbin;
 
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-    SVDEBUG << "minbin = " << minbin << ", nbins = " << nbins << ", last binfory = "
-         << binfory[h-1] << " (rounds to " << int(binfory[h-1]) << ") (model height " << sh << ")" << endl;
+    SVDEBUG << "render " << m_sources.source
+            << ": minbin = " << minbin << ", nbins = " << nbins
+            << ", last binfory = " << binfory[h-1]
+            << " (rounds to " << int(binfory[h-1])
+            << ") (model height " << sh << ")" << endl;
 #endif
     
     int psx = -1;
 
     int start = 0;

     vector<float> preparedColumn;
 
     int modelWidth = sourceModel->getWidth();
 
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-    SVDEBUG << "modelWidth " << modelWidth << ", divisor " << divisor << endl;
-    SVDEBUG << "start = " << start << ", finish = " << finish << ", step = " << step << endl;
+    SVDEBUG << "render " << m_sources.source
+            << ": modelWidth " << modelWidth << ", divisor " << divisor << endl;
+    SVDEBUG << "render " << m_sources.source
+            << ": start = " << start << ", finish = " << finish << ", step = " << step << endl;
 #endif
     
     for (int x = start; x != finish; x += step) {
 
         // x is the on-canvas pixel coord; sx (later) will be the

         }
 
         double fractionComplete = double(xPixelCount) / double(w);
         if (timer.outOfTime(fractionComplete)) {
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-            SVDEBUG << "out of time with xPixelCount = " << xPixelCount << endl;
+            SVDEBUG << "render " << m_sources.source
+                    << ": out of time with xPixelCount = " << xPixelCount << endl;
 #endif
             updateTimings(timer, xPixelCount);
             return xPixelCount;
         }
     }
 
     updateTimings(timer, xPixelCount);
 
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-    SVDEBUG << "completed with xPixelCount = " << xPixelCount << endl;
+    SVDEBUG << "render " << m_sources.source
+            << ": completed with xPixelCount = " << xPixelCount << endl;
 #endif
     return xPixelCount;
 }
 
 int

                                                       const vector<int> &binforx,
                                                       const vector<double> &binfory,
                                                       bool rightToLeft,
                                                       bool timeConstrained)
 {
+#ifdef DEBUG_COLOUR_PLOT_REPAINT
+    SVDEBUG << "render " << m_sources.source
+            << ": [PEAK] renderDrawBufferPeakFrequencies" << endl;
+#endif
+
     // Callers must have checked that the appropriate subset of
     // Sources data members are set for the supplied flags (e.g. that
     // fft model exists)
     
     RenderTimer timer(timeConstrained ?

     
     vector<float> preparedColumn;
 
     int modelWidth = fft->getWidth();
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-    SVDEBUG << "modelWidth " << modelWidth << endl;
+    SVDEBUG << "render " << m_sources.source
+            << ": modelWidth " << modelWidth << endl;
 #endif
     
     double minFreq =
         (double(minbin) * fft->getSampleRate()) / fft->getFFTSize();
     double maxFreq =
         (double(minbin + nbins - 1) * fft->getSampleRate()) / fft->getFFTSize();
 
     bool logarithmic = (m_params.binScale == BinScale::Log);
 
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-    SVDEBUG << "start = " << start << ", finish = " << finish
+    SVDEBUG << "render " << m_sources.source
+            << ": start = " << start << ", finish = " << finish
             << ", step = " << step << endl;
 #endif
     
     for (int x = start; x != finish; x += step) {
         

 
             m_magRanges.push_back(magRange);
 
         } else {
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-            SVDEBUG << "pixel peak column for range " << sx0 << " to " << sx1
+            SVDEBUG << "render " << m_sources.source
+                    << ": pixel peak column for range " << sx0 << " to " << sx1
                     << " is empty" << endl;
 #endif
         }
 
         double fractionComplete = double(xPixelCount) / double(w);
         if (timer.outOfTime(fractionComplete)) {
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-            SVDEBUG << "out of time" << endl;
+            SVDEBUG << "render " << m_sources.source
+                    << ": out of time" << endl;
 #endif
             updateTimings(timer, xPixelCount);
             return xPixelCount;
         }
     }

     if (valid) {
         m_secondsPerXPixel = secondsPerXPixel;
         m_secondsPerXPixelValid = true;
     
 #ifdef DEBUG_COLOUR_PLOT_REPAINT
-    SVDEBUG << "across " << xPixelCount << " x-pixels, seconds per x-pixel = "
+    SVDEBUG << "render " << m_sources.source
+            << ": across " << xPixelCount
+            << " x-pixels, seconds per x-pixel = "
             << m_secondsPerXPixel << " (total = "
             << (xPixelCount * m_secondsPerXPixel) << ")" << endl;
 #endif
     }
 }