comparison layer/SpectrogramLayer.cpp @ 585:f4960f8ce798 debug-output

Convert many cerrs to DEBUGs

 
         //!!! when are views removed from the map? on setLayerDormant?
         const View *v = i->first;
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "SpectrogramLayer::invalidateImageCaches(" 
+        DEBUG << "SpectrogramLayer::invalidateImageCaches(" 
                   << startFrame << ", " << endFrame << "): view range is "
                   << v->getStartFrame() << ", " << v->getEndFrame()
-                  << std::endl;
+                  << endl;
 
         std::cerr << "Valid area was: " << i->second.validArea.x() << ", "
                   << i->second.validArea.y() << " "
                   << i->second.validArea.width() << "x"
                   << i->second.validArea.height() << std::endl;

 #endif
                 return;
             }
             int x = v->getXForFrame(startFrame);
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-            std::cerr << "clipping from 0 to " << x-1 << std::endl;
+            DEBUG << "clipping from 0 to " << x-1 << endl;
 #endif
             if (x > 1) {
                 i->second.validArea &=
                     QRect(0, 0, x-1, v->height());
             } else {

 #endif
                 return;
             }
             int x = v->getXForFrame(endFrame);
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-            std::cerr << "clipping from " << x+1 << " to " << v->width()
-                      << std::endl;
+            DEBUG << "clipping from " << x+1 << " to " << v->width()
+                      << endl;
 #endif
             if (x < v->width()) {
                 i->second.validArea &=
                     QRect(x+1, 0, v->width()-(x+1), v->height());
             } else {

 }
 
 void
 SpectrogramLayer::preferenceChanged(PropertyContainer::PropertyName name)
 {
-    std::cerr << "SpectrogramLayer::preferenceChanged(" << name << ")" << std::endl;
+    DEBUG << "SpectrogramLayer::preferenceChanged(" << name << ")" << endl;
 
     if (name == "Window Type") {
         setWindowType(Preferences::getInstance()->getWindowType());
         return;
     }

 }
 
 void
 SpectrogramLayer::setGain(float gain)
 {
-//    std::cerr << "SpectrogramLayer::setGain(" << gain << ") (my gain is now "
-//	      << m_gain << ")" << std::endl;
+//    DEBUG << "SpectrogramLayer::setGain(" << gain << ") (my gain is now "
+//	      << m_gain << ")" << endl;
 
     if (m_gain == gain) return;
 
     invalidateImageCaches();
     

 void
 SpectrogramLayer::setMinFrequency(size_t mf)
 {
     if (m_minFrequency == mf) return;
 
-//    std::cerr << "SpectrogramLayer::setMinFrequency: " << mf << std::endl;
+//    DEBUG << "SpectrogramLayer::setMinFrequency: " << mf << endl;
 
     invalidateImageCaches();
     invalidateMagnitudes();
     
     m_minFrequency = mf;

 void
 SpectrogramLayer::setMaxFrequency(size_t mf)
 {
     if (m_maxFrequency == mf) return;
 
-//    std::cerr << "SpectrogramLayer::setMaxFrequency: " << mf << std::endl;
+//    DEBUG << "SpectrogramLayer::setMaxFrequency: " << mf << endl;
 
     invalidateImageCaches();
     invalidateMagnitudes();
     
     m_maxFrequency = mf;

 }
 
 void
 SpectrogramLayer::setNormalizeVisibleArea(bool n)
 {
-    std::cerr << "SpectrogramLayer::setNormalizeVisibleArea(" << n
-              << ") (from " << m_normalizeVisibleArea << ")" << std::endl;
+    DEBUG << "SpectrogramLayer::setNormalizeVisibleArea(" << n
+              << ") (from " << m_normalizeVisibleArea << ")" << endl;
 
     if (m_normalizeVisibleArea == n) return;
 
     invalidateImageCaches();
     invalidateMagnitudes();

 SpectrogramLayer::setLayerDormant(const View *v, bool dormant)
 {
     if (dormant) {
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "SpectrogramLayer::setLayerDormant(" << dormant << ")"
-                  << std::endl;
+        DEBUG << "SpectrogramLayer::setLayerDormant(" << dormant << ")"
+                  << endl;
 #endif
 
         if (isLayerDormant(v)) {
             return;
         }

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

     if (!m_model) return;
 
     bool allDone = true;
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-    std::cerr << "SpectrogramLayer::fillTimerTimedOut: have " << m_fftModels.size() << " FFT models associated with views" << std::endl;
+    DEBUG << "SpectrogramLayer::fillTimerTimedOut: have " << m_fftModels.size() << " FFT models associated with views" << endl;
 #endif
 
     for (ViewFFTMap::iterator i = m_fftModels.begin();
          i != m_fftModels.end(); ++i) {
 

         if (model) {
 
             size_t fill = model->getFillExtent();
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-            std::cerr << "SpectrogramLayer::fillTimerTimedOut: extent for " << model << ": " << fill << ", last " << lastFill << ", total " << m_model->getEndFrame() << std::endl;
+            DEBUG << "SpectrogramLayer::fillTimerTimedOut: extent for " << model << ": " << fill << ", last " << lastFill << ", total " << m_model->getEndFrame() << endl;
 #endif
 
             if (fill >= lastFill) {
                 if (fill >= m_model->getEndFrame() && lastFill > 0) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT

     size_t fftSize = getFFTSize(v);
 
     if (m_fftModels.find(v) != m_fftModels.end()) {
         if (m_fftModels[v].first == 0) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-            std::cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found null model" << std::endl;
+            DEBUG << "SpectrogramLayer::getFFTModel(" << v << "): Found null model" << endl;
 #endif
             return 0;
         }
         if (m_fftModels[v].first->getHeight() != fftSize / 2 + 1) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-            std::cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found a model with the wrong height (" << m_fftModels[v].first->getHeight() << ", wanted " << (fftSize / 2 + 1) << ")" << std::endl;
+            DEBUG << "SpectrogramLayer::getFFTModel(" << v << "): Found a model with the wrong height (" << m_fftModels[v].first->getHeight() << ", wanted " << (fftSize / 2 + 1) << ")" << endl;
 #endif
             delete m_fftModels[v].first;
             m_fftModels.erase(v);
             delete m_peakCaches[v];
             m_peakCaches.erase(v);
         } else {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-            std::cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found a good model of height " << m_fftModels[v].first->getHeight() << std::endl;
+            DEBUG << "SpectrogramLayer::getFFTModel(" << v << "): Found a good model of height " << m_fftModels[v].first->getHeight() << endl;
 #endif
             return m_fftModels[v].first;
         }
     }
 

     }
 
     int s0 = int(std::min(s00, s10) + 0.0001);
     int s1 = int(std::max(s01, s11) + 0.0001);
 
-//    std::cerr << "SpectrogramLayer::updateViewMagnitudes: x0 = " << x0 << ", x1 = " << x1 << ", s00 = " << s00 << ", s11 = " << s11 << " s0 = " << s0 << ", s1 = " << s1 << std::endl;
+//    DEBUG << "SpectrogramLayer::updateViewMagnitudes: x0 = " << x0 << ", x1 = " << x1 << ", s00 = " << s00 << ", s11 = " << s11 << " s0 = " << s0 << ", s1 = " << s1 << endl;
 
     if (int(m_columnMags.size()) <= s1) {
         m_columnMags.resize(s1 + 1);
     }
 

             mag.sample(m_columnMags[s]);
         }
     }
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-    std::cerr << "SpectrogramLayer::updateViewMagnitudes returning from cols "
-              << s0 << " -> " << s1 << " inclusive" << std::endl;
+    DEBUG << "SpectrogramLayer::updateViewMagnitudes returning from cols "
+              << s0 << " -> " << s1 << " inclusive" << endl;
 #endif
 
     if (!mag.isSet()) return false;
     if (mag == m_viewMags[v]) return false;
     m_viewMags[v] = mag;

     // It's practically FORTRAN 77 in its clarity and linearity.
 
     Profiler profiler("SpectrogramLayer::paint", false);
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-    std::cerr << "SpectrogramLayer::paint(): m_model is " << m_model << ", zoom level is " << v->getZoomLevel() << ", m_updateTimer " << m_updateTimer << std::endl;
+    DEBUG << "SpectrogramLayer::paint(): m_model is " << m_model << ", zoom level is " << v->getZoomLevel() << ", m_updateTimer " << m_updateTimer << endl;
     
     std::cerr << "rect is " << rect.x() << "," << rect.y() << " " << rect.width() << "x" << rect.height() << std::endl;
 #endif
 
     long startFrame = v->getStartFrame();

     if (!m_model || !m_model->isOK() || !m_model->isReady()) {
 	return;
     }
 
     if (isLayerDormant(v)) {
-	std::cerr << "SpectrogramLayer::paint(): Layer is dormant, making it undormant again" << std::endl;
+	DEBUG << "SpectrogramLayer::paint(): Layer is dormant, making it undormant again" << endl;
     }
 
     // Need to do this even if !isLayerDormant, as that could mean v
     // is not in the dormancy map at all -- we need it to be present
     // and accountable for when determining whether we need the cache

     }
 */
     ImageCache &cache = m_imageCaches[v];
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-    std::cerr << "SpectrogramLayer::paint(): image cache valid area " << cache.
-
-validArea.x() << ", " << cache.validArea.y() << ", " << cache.validArea.width() << "x" << cache.validArea.height() << std::endl;
+    DEBUG << "SpectrogramLayer::paint(): image cache valid area " << cache.
+
+validArea.x() << ", " << cache.validArea.y() << ", " << cache.validArea.width() << "x" << cache.validArea.height() << endl;
 #endif
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     bool stillCacheing = (m_updateTimer != 0);
-    std::cerr << "SpectrogramLayer::paint(): Still cacheing = " << stillCacheing << std::endl;
+    DEBUG << "SpectrogramLayer::paint(): Still cacheing = " << stillCacheing << endl;
 #endif
 
     int zoomLevel = v->getZoomLevel();
 
     int x0 = 0;

 #endif
 
     bool runOutOfData = false;
 
     if (w == 0) {
-        std::cerr << "*** NOTE: w == 0" << std::endl;
+        DEBUG << "*** NOTE: w == 0" << endl;
     }
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     size_t pixels = 0;
 #endif

 
     Profiler profiler2("SpectrogramLayer::paint: draw image");
 
     if (recreateWholeImageCache) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "Recreating image cache: width = " << v->width()
-                  << ", height = " << h << std::endl;
+        DEBUG << "Recreating image cache: width = " << v->width()
+                  << ", height = " << h << endl;
 #endif
 	cache.image = QImage(v->width(), h, QImage::Format_ARGB32_Premultiplied);
     }
 
     if (w > 0) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "Painting " << w << "x" << h
+        DEBUG << "Painting " << w << "x" << h
                   << " from draw buffer at " << 0 << "," << 0
                   << " to " << w << "x" << h << " on cache at "
-                  << x0 << "," << 0 << std::endl;
+                  << x0 << "," << 0 << endl;
 #endif
 
         QPainter cachePainter(&cache.image);
 
         if (bufferBinResolution) {
             int scaledLeft = v->getXForFrame(leftBoundaryFrame);
             int scaledRight = v->getXForFrame(rightBoundaryFrame);
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-            cerr << "Rescaling image from " << bufwid
+            DEBUG << "Rescaling image from " << bufwid
                  << "x" << h << " to "
                  << scaledRight-scaledLeft << "x" << h << endl;
 #endif
             Preferences::SpectrogramXSmoothing xsmoothing = 
                 Preferences::getInstance()->getSpectrogramXSmoothing();
-//            cerr << "xsmoothing == " << xsmoothing << endl;
+//            DEBUG << "xsmoothing == " << xsmoothing << endl;
             QImage scaled = m_drawBuffer.scaled
                 (scaledRight - scaledLeft, h,
                  Qt::IgnoreAspectRatio,
                  ((xsmoothing == Preferences::SpectrogramXInterpolated) ?
                   Qt::SmoothTransformation : Qt::FastTransformation));
             int scaledLeftCrop = v->getXForFrame(leftCropFrame);
             int scaledRightCrop = v->getXForFrame(rightCropFrame);
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-            cerr << "Drawing image region of width " << scaledRightCrop - scaledLeftCrop << " to "
+            DEBUG << "Drawing image region of width " << scaledRightCrop - scaledLeftCrop << " to "
                  << scaledLeftCrop << " from " << scaledLeftCrop - scaledLeft << endl;
 #endif
             cachePainter.drawImage
                 (QRect(scaledLeftCrop, 0,
                        scaledRightCrop - scaledLeftCrop, h),

     }
 
     QRect pr = rect & cache.validArea;
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-    std::cerr << "Painting " << pr.width() << "x" << pr.height()
+    DEBUG << "Painting " << pr.width() << "x" << pr.height()
               << " from cache at " << pr.x() << "," << pr.y()
-              << " to window" << std::endl;
+              << " to window" << endl;
 #endif
 
     paint.drawImage(pr.x(), pr.y(), cache.image,
                     pr.x(), pr.y(), pr.width(), pr.height());
     //!!!

 
         if (!m_normalizeVisibleArea || !overallMagChanged) {
     
             if (cache.validArea.x() > 0) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-                std::cerr << "SpectrogramLayer::paint() updating left (0, "
-                          << cache.validArea.x() << ")" << std::endl;
+                DEBUG << "SpectrogramLayer::paint() updating left (0, "
+                          << cache.validArea.x() << ")" << endl;
 #endif
                 v->update(0, 0, cache.validArea.x(), h);
             }
             
             if (cache.validArea.x() + cache.validArea.width() <
                 cache.image.width()) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-                std::cerr << "SpectrogramLayer::paint() updating right ("
+                DEBUG << "SpectrogramLayer::paint() updating right ("
                           << cache.validArea.x() + cache.validArea.width()
                           << ", "
                           << cache.image.width() - (cache.validArea.x() +
                                                      cache.validArea.width())
-                          << ")" << std::endl;
+                          << ")" << endl;
 #endif
                 v->update(cache.validArea.x() + cache.validArea.width(),
                           0,
                           cache.image.width() - (cache.validArea.x() +
                                                   cache.validArea.width()),

     }
 
     illuminateLocalFeatures(v, paint);
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-    std::cerr << "SpectrogramLayer::paint() returning" << std::endl;
+    DEBUG << "SpectrogramLayer::paint() returning" << endl;
 #endif
 
     if (!m_synchronous) {
         m_lastPaintBlockWidth = paintBlockWidth;
         (void)gettimeofday(&tv, 0);

             MagnitudeRange mag;
 
             if (sx != psx) {
                 if (fft) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-                    cerr << "Retrieving column " << sx << " from fft directly" << endl;
+                    DEBUG << "Retrieving column " << sx << " from fft directly" << endl;
 #endif
                     if (m_colourScale == PhaseColourScale) {
                         fft->getPhasesAt(sx, autoarray, minbin, maxbin - minbin + 1);
                     } else if (m_normalizeColumns) {
                         fft->getNormalizedMagnitudesAt(sx, autoarray, minbin, maxbin - minbin + 1);
                     } else {
                         fft->getMagnitudesAt(sx, autoarray, minbin, maxbin - minbin + 1);
                     }
                 } else {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-                    cerr << "Retrieving column " << sx << " from peaks cache" << endl;
+                    DEBUG << "Retrieving column " << sx << " from peaks cache" << endl;
 #endif
                     c = sourceModel->getColumn(sx);
                     if (m_normalizeColumns) {
                         for (int y = 0; y < h; ++y) {
                             if (c[y] > columnMax) columnMax = c[y];

     if (m_updateTimer == 0) return 100;
     if (m_fftModels.find(v) == m_fftModels.end()) return 100;
 
     size_t completion = m_fftModels[v].first->getCompletion();
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-    std::cerr << "SpectrogramLayer::getCompletion: completion = " << completion << std::endl;
+    DEBUG << "SpectrogramLayer::getCompletion: completion = " << completion << endl;
 #endif
     return completion;
 }
 
 QString

 SpectrogramLayer::getDisplayExtents(float &min, float &max) const
 {
     min = getEffectiveMinFrequency();
     max = getEffectiveMaxFrequency();
 
-//    std::cerr << "SpectrogramLayer::getDisplayExtents: " << min << "->" << max << std::endl;
+//    DEBUG << "SpectrogramLayer::getDisplayExtents: " << min << "->" << max << endl;
     return true;
 }    
 
 bool
 SpectrogramLayer::setDisplayExtents(float min, float max)
 {
     if (!m_model) return false;
 
-//    std::cerr << "SpectrogramLayer::setDisplayExtents: " << min << "->" << max << std::endl;
+//    DEBUG << "SpectrogramLayer::setDisplayExtents: " << min << "->" << max << endl;
 
     if (min < 0) min = 0;
     if (max > m_model->getSampleRate()/2) max = m_model->getSampleRate()/2;
     
     size_t minf = lrintf(min);

     size_t initialMax = m_initialMaxFrequency;
     if (initialMax == 0) initialMax = sr / 2;
 
     defaultStep = mapper.getPositionForValue(initialMax) - minStep;
 
-//    std::cerr << "SpectrogramLayer::getVerticalZoomSteps: " << maxStep - minStep << " (" << maxStep <<"-" << minStep << "), default is " << defaultStep << " (from initial max freq " << initialMax << ")" << std::endl;
+//    DEBUG << "SpectrogramLayer::getVerticalZoomSteps: " << maxStep - minStep << " (" << maxStep <<"-" << minStep << "), default is " << defaultStep << " (from initial max freq " << initialMax << ")" << endl;
 
     return maxStep - minStep;
 }
 
 int

     float dmin, dmax;
     getDisplayExtents(dmin, dmax);
     
     SpectrogramRangeMapper mapper(m_model->getSampleRate(), m_fftSize);
     int n = mapper.getPositionForValue(dmax - dmin);
-//    std::cerr << "SpectrogramLayer::getCurrentVerticalZoomStep: " << n << std::endl;
+//    DEBUG << "SpectrogramLayer::getCurrentVerticalZoomStep: " << n << endl;
     return n;
 }
 
 void
 SpectrogramLayer::setVerticalZoomStep(int step)

     }
     if (newmax > mmax) {
         newmax = mmax;
     }
     
-//    std::cerr << "SpectrogramLayer::setVerticalZoomStep: " << step << ": " << newmin << " -> " << newmax << " (range " << newdist << ")" << std::endl;
+//    DEBUG << "SpectrogramLayer::setVerticalZoomStep: " << step << ": " << newmin << " -> " << newmax << " (range " << newdist << ")" << endl;
 
     setMinFrequency(lrintf(newmin));
     setMaxFrequency(lrintf(newmax));
 }
 

     if (r.startY > 0.0) y0 = getYForFrequency(v, r.startY);
     
     int y1 = y0;
     if (r.endY > 0.0) y1 = getYForFrequency(v, r.endY);
 
-//    std::cerr << "SpectrogramLayer::updateMeasureRectYCoords: start " << r.startY << " -> " << y0 << ", end " << r.endY << " -> " << y1 << std::endl;
+//    DEBUG << "SpectrogramLayer::updateMeasureRectYCoords: start " << r.startY << " -> " << y0 << ", end " << r.endY << " -> " << y1 << endl;
 
     r.pixrect = QRect(r.pixrect.x(), y0, r.pixrect.width(), y1 - y0);
 }
 
 void

         r.startY = getFrequencyForY(v, y);
         r.endY = r.startY;
     } else {
         r.endY = getFrequencyForY(v, y);
     }
-//    std::cerr << "SpectrogramLayer::setMeasureRectYCoord: start " << r.startY << " <- " << y << ", end " << r.endY << " <- " << y << std::endl;
+//    DEBUG << "SpectrogramLayer::setMeasureRectYCoord: start " << r.startY << " <- " << y << ", end " << r.endY << " <- " << y << endl;
 
 }
 
 void
 SpectrogramLayer::toXml(QTextStream &stream,

     float threshold = attributes.value("threshold").toFloat(&ok);
     if (ok) setThreshold(threshold);
 
     size_t minFrequency = attributes.value("minFrequency").toUInt(&ok);
     if (ok) {
-        std::cerr << "SpectrogramLayer::setProperties: setting min freq to " << minFrequency << std::endl;
+        DEBUG << "SpectrogramLayer::setProperties: setting min freq to " << minFrequency << endl;
         setMinFrequency(minFrequency);
     }
 
     size_t maxFrequency = attributes.value("maxFrequency").toUInt(&ok);
     if (ok) {
-        std::cerr << "SpectrogramLayer::setProperties: setting max freq to " << maxFrequency << std::endl;
+        DEBUG << "SpectrogramLayer::setProperties: setting max freq to " << maxFrequency << endl;
         setMaxFrequency(maxFrequency);
     }
 
     ColourScale colourScale = (ColourScale)
 	attributes.value("colourScale").toInt(&ok);