comparison layer/SpectrogramLayer.cpp @ 1022:2bd5eb6a6c6b colourschemes

Tidy a bit

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

 
     for (int q = q0i; q <= q1i; ++q) {
 
 	for (int s = s0i; s <= s1i; ++s) {
 
-            if (!fft->isColumnAvailable(s)) continue;
-
 	    double binfreq = (double(sr) * q) / m_windowSize;
 	    if (q == q0i) freqMin = binfreq;
 	    if (q == q1i) freqMax = binfreq;
 
 	    if (peaksOnly && !fft->isLocalPeak(s, q)) continue;

 
         for (int q = q0i; q <= q1i; ++q) {
             for (int s = s0i; s <= s1i; ++s) {
                 if (s >= 0 && q >= 0 && s < cw && q < ch) {
 
-                    if (!fft->isColumnAvailable(s)) continue;
-                    
                     double value;
 
                     value = fft->getPhaseAt(s, q);
                     if (!have || value < phaseMin) { phaseMin = value; }
                     if (!have || value > phaseMax) { phaseMax = value; }

     // in the cache-fill thread above.
     //!!! no inter use cache-fill thread
     const_cast<SpectrogramLayer *>(this)->Layer::setLayerDormant(v, false);
 
     int fftSize = getFFTSize(v);
-/*
-    FFTModel *fft = getFFTModel(v);
-    if (!fft) {
-	cerr << "ERROR: SpectrogramLayer::paint(): No FFT model, returning" << endl;
-	return;
-    }
-*/
 
     const View *view = v->getView();
     
     ImageCache &cache = m_imageCaches[view];
 

 
     bool recreateWholeImageCache = true;
 
     x0 = rect.left();
     x1 = rect.right() + 1;
-/*
-    double xPixelRatio = double(fft->getResolution()) / double(zoomLevel);
-    cerr << "xPixelRatio = " << xPixelRatio << endl;
-    if (xPixelRatio < 1.f) xPixelRatio = 1.f;
-*/
+
+    if (updateViewMagnitudes(v)) {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+        cerr << "SpectrogramLayer: magnitude range changed to [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << endl;
+#endif
+        if (m_normalization == NormalizeVisibleArea) {
+            cache.validArea = QRect();
+        }
+    }
+
     if (cache.validArea.width() > 0) {
 
         int cw = cache.image.width();
         int ch = cache.image.height();
         
 	if (int(cache.zoomLevel) == zoomLevel &&
 	    cw == v->getPaintWidth() &&
 	    ch == v->getPaintHeight()) {
 
+            // cache size and zoom level exactly match the view
+            
 	    if (v->getXForFrame(cache.startFrame) ==
 		v->getXForFrame(startFrame) &&
                 cache.validArea.x() <= x0 &&
                 cache.validArea.x() + cache.validArea.width() >= x1) {
-	    
+
+                // and cache begins at the right frame, so use it whole
+                
 #ifdef DEBUG_SPECTROGRAM_REPAINT
 		cerr << "SpectrogramLayer: image cache good" << endl;
 #endif
 
 		paint.drawImage(rect, cache.image, rect);
-                //!!!
-//                paint.drawImage(v->rect(), cache.image,
-//                                QRect(QPoint(0, 0), cache.image.size()));
 
                 illuminateLocalFeatures(v, paint);
 		return;
 
 	    } else {
 
+                // cache doesn't begin at the right frame or doesn't
+                // contain the complete view, but might be scrollable
+                // or partially usable
+                
 #ifdef DEBUG_SPECTROGRAM_REPAINT
 		cerr << "SpectrogramLayer: image cache partially OK" << endl;
 #endif
 
 		recreateWholeImageCache = false;

 #endif
 
 		if (dx != 0 &&
                     dx > -cw &&
                     dx <  cw) {
+
+                    // cache is scrollable, scroll it
                     
                     int dxp = dx;
                     if (dxp < 0) dxp = -dxp;
                     size_t copy = (cw - dxp) * sizeof(QRgb);
                     for (int y = 0; y < ch; ++y) {

                         } else {
                             memmove(line + dxp, line, copy);
                         }
                     }
 
+                    // and calculate its new valid area
+                    
                     int px = cache.validArea.x();
                     int pw = cache.validArea.width();
 
 		    if (dx < 0) {
 			x0 = cw + dx;

                     cerr << "valid area now "
                               << px << "," << cache.validArea.y()
                               << " " << pw << "x" << cache.validArea.height()
                               << endl;
 #endif
-/*
-		    paint.drawImage(rect & cache.validArea,
-                                     cache.image,
-                                     rect & cache.validArea);
-*/
+
                 } else if (dx != 0) {
 
-                    // we scrolled too far to be of use
+                    // we've moved too far from the cached area for it
+                    // to be of use
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
                     cerr << "dx == " << dx << ": scrolled too far for cache to be useful" << endl;
 #endif
 

                 cerr << "(cache height " << ch
                           << " != " << v->getPaintHeight();
             }
 #endif
             cache.validArea = QRect();
-//            recreateWholeImageCache = true;
 	}
-    }
-
-    if (updateViewMagnitudes(v)) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-        cerr << "SpectrogramLayer: magnitude range changed to [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << endl;
-#endif
-        if (m_normalization == NormalizeVisibleArea) {
-            cache.validArea = QRect();
-            recreateWholeImageCache = true;
-        }
-    } else {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-        cerr << "No change in magnitude range [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << endl;
-#endif
     }
 
     if (recreateWholeImageCache) {
         x0 = 0;
         x1 = v->getPaintWidth();

         (void)gettimeofday(&tv, 0);
         m_lastPaintTime = RealTime::fromTimeval(tv) - mainPaintStart;
     }
 }
 
-bool
+void
 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 false;
+    if (!fft) return;
 
     FFTModel::PeakSet peakfreqs;
 
     int psx = -1;
 

         if (sx1 <= sx0) sx1 = sx0 + 1;
 
         for (int sx = sx0; sx < sx1; ++sx) {
 
             if (sx < 0 || sx >= int(fft->getWidth())) continue;
-
-            if (!m_synchronous) {
-                if (!fft->isColumnAvailable(sx)) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-                    cerr << "Met unavailable column at col " << sx << endl;
-#endif
-                    return false;
-                }
-            }
 
             MagnitudeRange mag;
 
             if (sx != psx) {
                 peakfreqs = fft->getPeakFrequencies(FFTModel::AllPeaks, sx,

                     if (overallMag.sample(mag)) overallMagChanged = true;
                 }
             }
         }
     }
-
-    return true;
-}
-
-bool
+}
+
+void
 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 false;
+    if (!sourceModel) return;
 
     bool interpolate = false;
     Preferences::SpectrogramSmoothing smoothing = 
         Preferences::getInstance()->getSpectrogramSmoothing();
     if (smoothing == Preferences::SpectrogramInterpolated ||

 #ifdef DEBUG_SPECTROGRAM_REPAINT
 //            cerr << "sx = " << sx << endl;
 #endif
 
             if (sx < 0 || sx >= int(sourceModel->getWidth())) continue;
-
-            if (!m_synchronous) {
-                if (!sourceModel->isColumnAvailable(sx)) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-                    cerr << "Met unavailable column at col " << sx << endl;
-#endif
-                    return false;
-                }
-            }
 
             MagnitudeRange mag;
 
             if (sx != psx) {
                 if (fft) {

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