comparison layer/SpectrogramLayer.cpp @ 31:fc802f7b112e

* Change SpectrogramLayer to use its own cache type instead of a QImage
* Some gcc-4.0 compile fixes

 void
 SpectrogramLayer::setModel(const DenseTimeValueModel *model)
 {
     m_mutex.lock();
     m_model = model;
+    delete m_cache;
+    m_cache = 0;
     m_mutex.unlock();
 
     if (!m_model || !m_model->isOK()) return;
 
     connect(m_model, SIGNAL(modelChanged()), this, SIGNAL(modelChanged()));

 {
     if (m_cacheInvalid || !m_cache) return;
 
     int formerRotation = m_colourRotation;
 
-    m_cache->setNumColors(256);
-    
-    m_cache->setColor(0, qRgb(255, 255, 255));
+//    m_cache->setNumColors(256);
+    
+//    m_cache->setColour(0, qRgb(255, 255, 255));
+    m_cache->setColour(0, Qt::white);
 
     for (int pixel = 1; pixel < 256; ++pixel) {
 
 	QColor colour;
 	int hue, px;

 	case RedOnBlack:
 	    colour = QColor::fromHsv(10, pixel, pixel);
 	    break;
 	}
 
-	m_cache->setColor
-	    (pixel, qRgb(colour.red(), colour.green(), colour.blue()));
+//	m_cache->setColor
+//	    (pixel, qRgb(colour.red(), colour.green(), colour.blue()));
+	m_cache->setColour(pixel, colour);
     }
 
     m_colourRotation = 0;
     rotateCacheColourmap(m_colourRotation - formerRotation);
     m_colourRotation = formerRotation;

 void
 SpectrogramLayer::rotateCacheColourmap(int distance)
 {
     if (!m_cache) return;
 
-    QRgb newPixels[256];
-
-    newPixels[0] = m_cache->color(0);
+    QColor newPixels[256];
+
+    newPixels[0] = m_cache->getColour(0);
 
     for (int pixel = 1; pixel < 256; ++pixel) {
 	int target = pixel + distance;
 	while (target < 1) target += 255;
 	while (target > 255) target -= 255;
-	newPixels[target] = m_cache->color(pixel);
+	newPixels[target] = m_cache->getColour(pixel);
     }
 
     for (int pixel = 0; pixel < 256; ++pixel) {
-	m_cache->setColor(pixel, newPixels[pixel]);
+	m_cache->setColour(pixel, newPixels[pixel]);
     }
 }
 
 bool
 SpectrogramLayer::fillCacheColumn(int column, double *input,

 	if (m_cacheInvalid || m_exiting) {
 	    interrupted = true;
 	    break;
 	}
 
-	if (column < m_cache->width() && (int)i < m_cache->height()) {
-	    m_cache->setPixel(column, i, value + 1); // 0 is "unset"
-	}
+	m_cache->setValueAt(column, i, value + 1);
     }
 
     if (lock) m_mutex.unlock();
     return !interrupted;
+}
+
+SpectrogramLayer::Cache::Cache(size_t width, size_t height) :
+    m_width(width),
+    m_height(height)
+{
+    m_values = new unsigned char[m_width * m_height];
+    MUNLOCK(m_values, m_width * m_height * sizeof(unsigned char));
+}
+
+SpectrogramLayer::Cache::~Cache()
+{
+    delete[] m_values;
+}
+
+size_t
+SpectrogramLayer::Cache::getWidth() const
+{
+    return m_width;
+}
+
+size_t
+SpectrogramLayer::Cache::getHeight() const
+{
+    return m_height;
+}
+
+unsigned char
+SpectrogramLayer::Cache::getValueAt(size_t x, size_t y) const
+{
+    if (x >= m_width || y >= m_height) return 0;
+    return m_values[y * m_width + x];
+}
+
+void
+SpectrogramLayer::Cache::setValueAt(size_t x, size_t y, unsigned char value)
+{
+    if (x >= m_width || y >= m_height) return;
+    m_values[y * m_width + x] = value;
+}
+
+QColor
+SpectrogramLayer::Cache::getColour(unsigned char index) const
+{
+    return m_colours[index];
+}
+
+void
+SpectrogramLayer::Cache::setColour(unsigned char index, QColor colour)
+{
+    m_colours[index] = colour;
+}
+
+void
+SpectrogramLayer::Cache::fill(unsigned char value)
+{
+    for (size_t i = 0; i < m_width * m_height; ++i) {
+	m_values[i] = value;
+    }
 }
 
 void
 SpectrogramLayer::CacheFillThread::run()
 {

 	    }
 
 	    delete m_layer.m_cache;
 	    size_t width = (end - start) / windowIncrement + 1;
 	    size_t height = windowSize / 2;
-	    m_layer.m_cache = new QImage(width, height,
-					 QImage::Format_Indexed8);
-
-	    // If we're using JACK in mlock mode, this will be locked
-	    // and we ought to unlock to avoid memory exhaustion.
-	    // Shame it doesn't appear to be possible to allocate
-	    // unlocked in the first place.
-	    //!!! hm, I don't think this is working.
-	    MUNLOCK((void *)m_layer.m_cache, width * height);
-    
+	    m_layer.m_cache = new Cache(width, height);
+
 	    m_layer.setCacheColourmap();
 
 	    m_layer.m_cache->fill(0);
 	    m_layer.m_mutex.unlock();
 

     int s1i = int(s1);
 
     if (m_mutex.tryLock()) {
 	if (m_cache && !m_cacheInvalid) {
 
-	    int cw = m_cache->width();
-	    int ch = m_cache->height();
+	    int cw = m_cache->getWidth();
+	    int ch = m_cache->getHeight();
 
 	    int min = -1, max = -1;
 
 	    for (int q = q0i; q <= q1i; ++q) {
 		for (int s = s0i; s <= s1i; ++s) {
 		    if (s >= 0 && q >= 0 && s < cw && q < ch) {
-			int value = m_cache->scanLine(q)[s];
+			int value = int(m_cache->getValueAt(s, q));
 			if (min == -1 || value < min) min = value;
 			if (max == -1 || value > max) max = value;
 		    }	
 		}
 	    }

 	if (m_cacheInvalid) {
 	    m_mutex.unlock();
 	    break;
 	}
 
-	int cw = m_cache->width();
-	int ch = m_cache->height();
+	int cw = m_cache->getWidth();
+	int ch = m_cache->getHeight();
 
 	float q0 = 0, q1 = 0;
 
 	if (!getYBinRange(y0 + y, q0, q1)) {
 	    for (int x = 0; x < w; ++x) {

 		    float qprop = sprop;
 		    if (q == q0i) qprop *= (q + 1) - q0;
 		    if (q == q1i) qprop *= q1 - q;
 
 		    if (s >= 0 && q >= 0 && s < cw && q < ch) {
-			total += qprop * m_cache->scanLine(q)[s];
+			total += qprop * m_cache->getValueAt(s, q);
 			divisor += qprop;
 		    }
 		}
 	    }
 		    
 	    if (divisor > 0.0) {
-/*
 		int pixel = int(total / divisor);
 		if (pixel > 255) pixel = 255;
 		if (pixel < 1) pixel = 1;
 		assert(x <= scaled.width());
-		scaled.setPixel(x, y, m_cache->color(pixel));
-*/
+		QColor c = m_cache->getColour(pixel);
+		scaled.setPixel(x, y,
+				qRgb(c.red(), c.green(), c.blue()));
+/*
 		float pixel = total / divisor;
 		float lq = pixel - int(pixel);
 		float hq = int(pixel) + 1 - pixel;
 		int pixNum = int(pixel);
 		QRgb low = m_cache->color(pixNum > 255 ? 255 : pixNum);

 		QRgb mixed = qRgb
 		    (qRed(low) * lq + qRed(high) * hq + 0.01,
 		     qGreen(low) * lq + qGreen(high) * hq + 0.01,
 		     qBlue(low) * lq + qBlue(high) * hq + 0.01);
 		scaled.setPixel(x, y, mixed);
-
+*/
 	    } else {
 		assert(x <= scaled.width());
 		scaled.setPixel(x, y, qRgb(0, 0, 0));
 	    }
 	}