comparison layer/SpectrogramLayer.cpp @ 478:0990b95140e3

* incremental commit

 	setNormalizeVisibleArea(value ? true : false);
     }
 }
 
 void
-SpectrogramLayer::invalidatePixmapCaches()
-{
-    for (ViewPixmapCache::iterator i = m_pixmapCaches.begin();
-         i != m_pixmapCaches.end(); ++i) {
+SpectrogramLayer::invalidateImageCaches()
+{
+    for (ViewImageCache::iterator i = m_imageCaches.begin();
+         i != m_imageCaches.end(); ++i) {
         i->second.validArea = QRect();
     }
 }
 
 void
-SpectrogramLayer::invalidatePixmapCaches(size_t startFrame, size_t endFrame)
-{
-    for (ViewPixmapCache::iterator i = m_pixmapCaches.begin();
-         i != m_pixmapCaches.end(); ++i) {
+SpectrogramLayer::invalidateImageCaches(size_t startFrame, size_t endFrame)
+{
+    for (ViewImageCache::iterator i = m_imageCaches.begin();
+         i != m_imageCaches.end(); ++i) {
 
         //!!! when are views removed from the map? on setLayerDormant?
         const View *v = i->first;
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "SpectrogramLayer::invalidatePixmapCaches(" 
+        std::cerr << "SpectrogramLayer::invalidateImageCaches(" 
                   << startFrame << ", " << endFrame << "): view range is "
                   << v->getStartFrame() << ", " << v->getEndFrame()
                   << std::endl;
 
         std::cerr << "Valid area was: " << i->second.validArea.x() << ", "

     if (name == "Window Type") {
         setWindowType(Preferences::getInstance()->getWindowType());
         return;
     }
     if (name == "Spectrogram Smoothing") {
-        invalidatePixmapCaches();
+        invalidateImageCaches();
         invalidateMagnitudes();
         emit layerParametersChanged();
     }
     if (name == "Tuning Frequency") {
         emit layerParametersChanged();

 void
 SpectrogramLayer::setChannel(int ch)
 {
     if (m_channel == ch) return;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     m_channel = ch;
     invalidateFFTModels();
 
     emit layerParametersChanged();
 }

 void
 SpectrogramLayer::setWindowSize(size_t ws)
 {
     if (m_windowSize == ws) return;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     
     m_windowSize = ws;
     m_fftSize = ws * (m_zeroPadLevel + 1);
     
     invalidateFFTModels();

 void
 SpectrogramLayer::setWindowHopLevel(size_t v)
 {
     if (m_windowHopLevel == v) return;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     
     m_windowHopLevel = v;
     
     invalidateFFTModels();
 

 void
 SpectrogramLayer::setZeroPadLevel(size_t v)
 {
     if (m_zeroPadLevel == v) return;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     
     m_zeroPadLevel = v;
     m_fftSize = m_windowSize * (v + 1);
 
     invalidateFFTModels();

 void
 SpectrogramLayer::setWindowType(WindowType w)
 {
     if (m_windowType == w) return;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     
     m_windowType = w;
 
     invalidateFFTModels();
 

 //    std::cerr << "SpectrogramLayer::setGain(" << gain << ") (my gain is now "
 //	      << m_gain << ")" << std::endl;
 
     if (m_gain == gain) return;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     
     m_gain = gain;
     
     emit layerParametersChanged();
 }

 void
 SpectrogramLayer::setThreshold(float threshold)
 {
     if (m_threshold == threshold) return;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     
     m_threshold = threshold;
 
     emit layerParametersChanged();
 }

 {
     if (m_minFrequency == mf) return;
 
 //    std::cerr << "SpectrogramLayer::setMinFrequency: " << mf << std::endl;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     invalidateMagnitudes();
     
     m_minFrequency = mf;
 
     emit layerParametersChanged();

 {
     if (m_maxFrequency == mf) return;
 
 //    std::cerr << "SpectrogramLayer::setMaxFrequency: " << mf << std::endl;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     invalidateMagnitudes();
     
     m_maxFrequency = mf;
     
     emit layerParametersChanged();

 }
 
 void
 SpectrogramLayer::setColourRotation(int r)
 {
-    invalidatePixmapCaches();
+    invalidateImageCaches();
 
     if (r < 0) r = 0;
     if (r > 256) r = 256;
     int distance = r - m_colourRotation;
 

 void
 SpectrogramLayer::setColourScale(ColourScale colourScale)
 {
     if (m_colourScale == colourScale) return;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     
     m_colourScale = colourScale;
     
     emit layerParametersChanged();
 }

 void
 SpectrogramLayer::setColourMap(int map)
 {
     if (m_colourMap == map) return;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     
     m_colourMap = map;
     initialisePalette();
 
     emit layerParametersChanged();

 void
 SpectrogramLayer::setFrequencyScale(FrequencyScale frequencyScale)
 {
     if (m_frequencyScale == frequencyScale) return;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     m_frequencyScale = frequencyScale;
 
     emit layerParametersChanged();
 }
 

 void
 SpectrogramLayer::setBinDisplay(BinDisplay binDisplay)
 {
     if (m_binDisplay == binDisplay) return;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     m_binDisplay = binDisplay;
 
     emit layerParametersChanged();
 }
 

 void
 SpectrogramLayer::setNormalizeColumns(bool n)
 {
     if (m_normalizeColumns == n) return;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     invalidateMagnitudes();
     m_normalizeColumns = n;
 
     emit layerParametersChanged();
 }

     std::cerr << "SpectrogramLayer::setNormalizeVisibleArea(" << n
               << ") (from " << m_normalizeVisibleArea << ")" << std::endl;
 
     if (m_normalizeVisibleArea == n) return;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     invalidateMagnitudes();
     m_normalizeVisibleArea = n;
 
     emit layerParametersChanged();
 }

             return;
         }
 
         Layer::setLayerDormant(v, true);
 
-	invalidatePixmapCaches();
-        m_pixmapCaches.erase(v);
+	invalidateImageCaches();
+        m_imageCaches.erase(v);
 
         if (m_fftModels.find(v) != m_fftModels.end()) {
 
             if (m_sliceableModel == m_fftModels[v].first) {
                 bool replaced = false;

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

             if (fill >= lastFill) {
                 if (fill >= m_model->getEndFrame() && lastFill > 0) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
                     std::cerr << "complete!" << std::endl;
 #endif
-                    invalidatePixmapCaches();
+                    invalidateImageCaches();
                     i->second.second = -1;
                     emit modelChanged();
 
                 } else if (fill > lastFill) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
                     std::cerr << "SpectrogramLayer: emitting modelChanged("
                               << lastFill << "," << fill << ")" << std::endl;
 #endif
-                    invalidatePixmapCaches(lastFill, fill);
+                    invalidateImageCaches(lastFill, fill);
                     i->second.second = fill;
                     emit modelChanged(lastFill, fill);
                 }
             } else {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
                 std::cerr << "SpectrogramLayer: going backwards, emitting modelChanged("
                           << m_model->getStartFrame() << "," << m_model->getEndFrame() << ")" << std::endl;
 #endif
-                invalidatePixmapCaches();
+                invalidateImageCaches();
                 i->second.second = fill;
                 emit modelChanged(m_model->getStartFrame(), m_model->getEndFrame());
             }
 
             if (i->second.second >= 0) {

     m_crosshairColour = mapper.getContrastingColour();
 
     m_colourRotation = 0;
     rotatePalette(m_colourRotation - formerRotation);
     m_colourRotation = formerRotation;
+
+    m_drawBuffer = QImage();
 }
 
 void
 SpectrogramLayer::rotatePalette(int distance)
 {

     }
 
     for (int pixel = 0; pixel < 256; ++pixel) {
 	m_palette.setColour(pixel, newPixels[pixel]);
     }
+
+    m_drawBuffer = QImage();
 }
 
 unsigned char
 SpectrogramLayer::getDisplayValue(View *v, float input) const
 {

     if (!fft) {
 	std::cerr << "ERROR: SpectrogramLayer::paint(): No FFT model, returning" << std::endl;
 	return;
     }
 
-    PixmapCache &cache = m_pixmapCaches[v];
-
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-    std::cerr << "SpectrogramLayer::paint(): pixmap cache valid area " << 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;
 #endif
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT

     int zoomLevel = v->getZoomLevel();
 
     int x0 = 0;
     int x1 = v->width();
 
-    bool recreateWholePixmapCache = true;
+    bool recreateWholeImageCache = true;
 
     x0 = rect.left();
     x1 = rect.right() + 1;
 
     if (cache.validArea.width() > 0) {
 
 	if (int(cache.zoomLevel) == zoomLevel &&
-	    cache.pixmap.width() == v->width() &&
-	    cache.pixmap.height() == v->height()) {
+	    cache.image.width() == v->width() &&
+	    cache.image.height() == v->height()) {
 
 	    if (v->getXForFrame(cache.startFrame) ==
 		v->getXForFrame(startFrame) &&
                 cache.validArea.x() <= x0 &&
                 cache.validArea.x() + cache.validArea.width() >= x1) {
 	    
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-		std::cerr << "SpectrogramLayer: pixmap cache good" << std::endl;
-#endif
-
-		paint.drawPixmap(rect, cache.pixmap, rect);
+		std::cerr << "SpectrogramLayer: image cache good" << std::endl;
+#endif
+
+		paint.drawImage(rect, cache.image, rect);
                 illuminateLocalFeatures(v, paint);
 		return;
 
 	    } else {
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-		std::cerr << "SpectrogramLayer: pixmap cache partially OK" << std::endl;
-#endif
-
-		recreateWholePixmapCache = false;
+		std::cerr << "SpectrogramLayer: image cache partially OK" << std::endl;
+#endif
+
+		recreateWholeImageCache = false;
 
 		int dx = v->getXForFrame(cache.startFrame) -
 		         v->getXForFrame(startFrame);
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-		std::cerr << "SpectrogramLayer: dx = " << dx << " (pixmap cache " << cache.pixmap.width() << "x" << cache.pixmap.height() << ")" << std::endl;
+		std::cerr << "SpectrogramLayer: dx = " << dx << " (image cache " << cache.image.width() << "x" << cache.image.height() << ")" << std::endl;
 #endif
 
 		if (dx != 0 &&
-                    dx > -cache.pixmap.width() &&
-                    dx <  cache.pixmap.width()) {
-
-                    QPixmap tmp = cache.pixmap;
-                    QPainter cachePainter(&cache.pixmap);
+                    dx > -cache.image.width() &&
+                    dx <  cache.image.width()) {
+
+                    QImage tmp = cache.image;
+                    QPainter cachePainter(&cache.image);
                     if (dx < 0) {
-                        cachePainter.drawPixmap
+                        cachePainter.drawImage
                             (QRect(0, 0,
-                                   cache.pixmap.width() + dx,
-                                   cache.pixmap.height()),
+                                   cache.image.width() + dx,
+                                   cache.image.height()),
                              tmp,
                              QRect(-dx, 0,
-                                   cache.pixmap.width() + dx,
-                                   cache.pixmap.height()));
+                                   cache.image.width() + dx,
+                                   cache.image.height()));
                     } else {
-                        cachePainter.drawPixmap
+                        cachePainter.drawImage
                             (QRect(dx, 0,
-                                   cache.pixmap.width() - dx,
-                                   cache.pixmap.height()),
+                                   cache.image.width() - dx,
+                                   cache.image.height()),
                              tmp,
                              QRect(0, 0,
-                                   cache.pixmap.width() - dx,
-                                   cache.pixmap.height()));
+                                   cache.image.width() - dx,
+                                   cache.image.height()));
                     }
 
                     int px = cache.validArea.x();
                     int pw = cache.validArea.width();
 
 		    if (dx < 0) {
-			x0 = cache.pixmap.width() + dx;
-			x1 = cache.pixmap.width();
+			x0 = cache.image.width() + dx;
+			x1 = cache.image.width();
                         px += dx;
                         if (px < 0) {
                             pw += px;
                             px = 0;
                             if (pw < 0) pw = 0;
                         }
 		    } else {
 			x0 = 0;
 			x1 = dx;
                         px += dx;
-                        if (px + pw > cache.pixmap.width()) {
-                            pw = int(cache.pixmap.width()) - px;
+                        if (px + pw > cache.image.width()) {
+                            pw = int(cache.image.width()) - px;
                             if (pw < 0) pw = 0;
                         }
 		    }
                     
                     cache.validArea =

                               << px << "," << cache.validArea.y()
                               << " " << pw << "x" << cache.validArea.height()
                               << std::endl;
 #endif
 
-		    paint.drawPixmap(rect & cache.validArea,
-                                     cache.pixmap,
+		    paint.drawImage(rect & cache.validArea,
+                                     cache.image,
                                      rect & cache.validArea);
 
                 } else if (dx != 0) {
 
                     // we scrolled too far to be of use

 #ifdef DEBUG_SPECTROGRAM_REPAINT
                     std::cerr << "dx == " << dx << ": scrolled too far for cache to be useful" << std::endl;
 #endif
 
                     cache.validArea = QRect();
-                    recreateWholePixmapCache = true;
+                    recreateWholeImageCache = true;
                 }
 	    }
 	} else {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-	    std::cerr << "SpectrogramLayer: pixmap cache useless" << std::endl;
+	    std::cerr << "SpectrogramLayer: image cache useless" << std::endl;
             if (int(cache.zoomLevel) != zoomLevel) {
                 std::cerr << "(cache zoomLevel " << cache.zoomLevel
                           << " != " << zoomLevel << ")" << std::endl;
             }
-            if (cache.pixmap.width() != v->width()) {
-                std::cerr << "(cache width " << cache.pixmap.width()
+            if (cache.image.width() != v->width()) {
+                std::cerr << "(cache width " << cache.image.width()
                           << " != " << v->width();
             }
-            if (cache.pixmap.height() != v->height()) {
-                std::cerr << "(cache height " << cache.pixmap.height()
+            if (cache.image.height() != v->height()) {
+                std::cerr << "(cache height " << cache.image.height()
                           << " != " << v->height();
             }
 #endif
             cache.validArea = QRect();
-//            recreateWholePixmapCache = true;
+//            recreateWholeImageCache = true;
 	}
     }
 
     if (updateViewMagnitudes(v)) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
         std::cerr << "SpectrogramLayer: magnitude range changed to [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << std::endl;
 #endif
         if (m_normalizeVisibleArea) {
             cache.validArea = QRect();
-            recreateWholePixmapCache = true;
+            recreateWholeImageCache = true;
         }
     } else {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
         std::cerr << "No change in magnitude range [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << std::endl;
 #endif
     }
 
-    if (recreateWholePixmapCache) {
+    if (recreateWholeImageCache) {
         x0 = 0;
         x1 = v->width();
     }
 
     struct timeval tv;

 #ifdef DEBUG_SPECTROGRAM_REPAINT
     std::cerr << "x0 " << x0 << ", x1 " << x1 << ", w " << w << ", h " << h << std::endl;
 #endif
 
     if (m_drawBuffer.width() < w || m_drawBuffer.height() < h) {
-        m_drawBuffer = QImage(w, h, QImage::Format_RGB32);
-    }
-
-    m_drawBuffer.fill(m_palette.getColour(0).rgb());
+        m_drawBuffer = QImage(w, h, QImage::Format_Indexed8);
+        m_drawBuffer.setNumColors(256);
+        for (int pixel = 0; pixel < 256; ++pixel) {
+            m_drawBuffer.setColor(pixel, m_palette.getColour(pixel).rgb());
+        }
+    }
+
+//    m_drawBuffer.fill(m_palette.getColour(0).rgb());
+    m_drawBuffer.fill(0);
 
     int sr = m_model->getSampleRate();
 
     // Set minFreq and maxFreq to the frequency extents of the possibly
     // zero-padded visible bin range, and displayMinFreq and displayMaxFreq

     }
 
 //    std::cerr << "(giving actual minFreq " << minFreq << " and display minFreq " << displayMinFreq << ")" << std::endl;
 
     float yforbin[maxbin - minbin + 1];
-    float yval[h];
 
     size_t increment = getWindowIncrement();
     
     bool logarithmic = (m_frequencyScale == LogFrequencyScale);
 

 
     for (int x = 0; x < w; ++x) {
 
         Profiler innerprof("SpectrogramLayer::paint: 1 pixel column");
 
-        runOutOfData = !getColumnValues(v, fft, x0, x,
-                                        minbin, maxbin,
-                                        displayMinFreq, displayMaxFreq,
-                                        h, yforbin, yval);
+        runOutOfData = !paintColumnValues(v, fft, x0, x,
+                                          minbin, maxbin,
+                                          displayMinFreq, displayMaxFreq,
+                                          h, yforbin);
 
         if (runOutOfData) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
             std::cerr << "Run out of data -- dropping out of loop" << std::endl;
 #endif
             break;
         }
-
-        Profiler drawbufferprof("SpectrogramLayer::paint: set buffer pixels");
-
-	for (int y = 0; y < h; ++y) {
-
-            unsigned char pixel = 0;
-
-            pixel = getDisplayValue(v, yval[y]);
-
-            assert(x <= m_drawBuffer.width());
-            QColor c = m_palette.getColour(pixel);
-            m_drawBuffer.setPixel(x, y,
-                                  qRgb(c.red(), c.green(), c.blue()));
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-            ++pixels;
-#endif
-	}
     }
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     std::cerr << pixels << " pixels drawn" << std::endl;
 #endif

 
     outerprof.end();
 
     Profiler profiler2("SpectrogramLayer::paint: draw image");
 
-    if (recreateWholePixmapCache) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-        std::cerr << "Recreating pixmap cache: width = " << v->width()
+    if (recreateWholeImageCache) {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+        std::cerr << "Recreating image cache: width = " << v->width()
                   << ", height = " << h << std::endl;
 #endif
-	cache.pixmap = QPixmap(v->width(), h);
+	cache.image = QImage(v->width(), h, QImage::Format_RGB32);
     }
 
     if (w > 0) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
         std::cerr << "Painting " << w << "x" << h
                   << " from draw buffer at " << 0 << "," << 0
                   << " to cache at " << x0 << "," << 0 << std::endl;
 #endif
 
-        QPainter cachePainter(&cache.pixmap);
+        QPainter cachePainter(&cache.image);
         cachePainter.drawImage(x0, 0, m_drawBuffer, 0, 0, w, h);
         cachePainter.end();
     }
 
     QRect pr = rect & cache.validArea;

     std::cerr << "Painting " << pr.width() << "x" << pr.height()
               << " from cache at " << pr.x() << "," << pr.y()
               << " to window" << std::endl;
 #endif
 
-    paint.drawPixmap(pr.x(), pr.y(), cache.pixmap,
+    paint.drawImage(pr.x(), pr.y(), cache.image,
                      pr.x(), pr.y(), pr.width(), pr.height());
 
     cache.startFrame = startFrame;
     cache.zoomLevel = zoomLevel;
 

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

 //!!!    if (fftSuspended) fft->resume();
 }
 
 
 bool
-SpectrogramLayer::getColumnValues(View *v, 
+SpectrogramLayer::paintColumnValues(View *v, 
                                   FFTModel *fft,
                                   int x0,
                                   int x,
                                   int minbin,
                                   int maxbin,
                                   float displayMinFreq,
                                   float displayMaxFreq,
                                   const int h,
-                                  const float *yforbin,
-                                  float *yval) const
+                                  const float *yforbin) const
 {
     float ymag[h];
     float ydiv[h];
     float values[maxbin - minbin + 1];
 

     if (!getXBinRange(v, x0 + x, s0, s1)) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
         std::cerr << "Out of range at " << x0 + x << std::endl;
 #endif
         assert(x <= m_drawBuffer.width());
-        return false;
+        return true;
     }
 
     int s0i = int(s0 + 0.001);
     int s1i = int(s1);
 
     if (s1i >= int(fft->getWidth())) {
         if (s0i >= int(fft->getWidth())) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
             std::cerr << "Column " << s0i << " out of range" << std::endl;
 #endif
-            return false;
+            return true;
         } else {
             s1i = s0i;
         }
     }
 

         }
     }
 
     for (int y = 0; y < h; ++y) {
 
+        float value = 0.f;
+
         if (ydiv[y] > 0.0) {
-            yval[y] = ymag[y] / ydiv[y];
-        } else {
-            yval[y] = 0;
-        }
+            value = ymag[y] / ydiv[y];
+        }
+        
+        unsigned char pixel = getDisplayValue(v, value);
+        m_drawBuffer.setPixel(x, y, pixel);
     }
 
     return true;
 }
 

     size_t minf = lrintf(min);
     size_t maxf = lrintf(max);
 
     if (m_minFrequency == minf && m_maxFrequency == maxf) return true;
 
-    invalidatePixmapCaches();
+    invalidateImageCaches();
     invalidateMagnitudes();
 
     m_minFrequency = minf;
     m_maxFrequency = maxf;
     

 } 
 
 void
 SpectrogramLayer::measureDoubleClick(View *v, QMouseEvent *e)
 {
-    PixmapCache &cache = m_pixmapCaches[v];
-
-    std::cerr << "cache width: " << cache.pixmap.width() << ", height: "
-              << cache.pixmap.height() << std::endl;
-
-    QImage image = cache.pixmap.toImage();
+    ImageCache &cache = m_imageCaches[v];
+
+    std::cerr << "cache width: " << cache.image.width() << ", height: "
+              << cache.image.height() << std::endl;
+
+    QImage image = cache.image;
 
     ImageRegionFinder finder;
     QRect rect = finder.findRegionExtents(&image, e->pos());
     if (rect.isValid()) {
         MeasureRect mr;