comparison layer/SpectrogramLayer.cpp @ 9:561be41ad083

* Tweaked up spectrogram and added a colourmap rotation option
* Fleshed out the SV file reader code -- now we just need to hook it up
  and watch it fall over

     m_channel(0),
     m_windowSize(1024),
     m_windowType(HanningWindow),
     m_windowOverlap(50),
     m_gain(1.0),
+    m_colourRotation(0),
     m_maxFrequency(8000),
     m_colourScale(dBColourScale),
     m_colourScheme(DefaultColours),
     m_frequencyScale(LinearFrequencyScale),
     m_cache(0),

     list.push_back(tr("Colour Scale"));
     list.push_back(tr("Window Type"));
     list.push_back(tr("Window Size"));
     list.push_back(tr("Window Overlap"));
     list.push_back(tr("Gain"));
+    list.push_back(tr("Colour Rotation"));
     list.push_back(tr("Max Frequency"));
     list.push_back(tr("Frequency Scale"));
     return list;
 }
 
 Layer::PropertyType
 SpectrogramLayer::getPropertyType(const PropertyName &name) const
 {
     if (name == tr("Gain")) return RangeProperty;
+    if (name == tr("Colour Rotation")) return RangeProperty;
     return ValueProperty;
 }
 
 QString
 SpectrogramLayer::getPropertyGroupName(const PropertyName &name) const
 {
     if (name == tr("Window Size") ||
 	name == tr("Window Overlap")) return tr("Window");
     if (name == tr("Gain") ||
+	name == tr("Colour Rotation") ||
 	name == tr("Colour Scale")) return tr("Scale");
     if (name == tr("Max Frequency") ||
 	name == tr("Frequency Scale")) return tr("Frequency");
     return QString();
 }

 	*max = 50;
 
 	deft = lrint(log10(m_gain) * 20.0);
 	if (deft < *min) deft = *min;
 	if (deft > *max) deft = *max;
+
+    } else if (name == tr("Colour Rotation")) {
+
+	*min = 0;
+	*max = 256;
+
+	deft = m_colourRotation;
 
     } else if (name == tr("Colour Scale")) {
 
 	*min = 0;
 	*max = 3;

     return deft;
 }
 
 QString
 SpectrogramLayer::getPropertyValueLabel(const PropertyName &name,
-				    int value) const
+					int value) const
 {
     if (name == tr("Colour")) {
 	switch (value) {
 	default:
 	case 0: return tr("Default");

 void
 SpectrogramLayer::setProperty(const PropertyName &name, int value)
 {
     if (name == tr("Gain")) {
 	setGain(pow(10, float(value)/20.0));
+    } else if (name == tr("Colour Rotation")) {
+	setColourRotation(value);
     } else if (name == tr("Colour")) {
 	if (m_view) m_view->setLightBackground(value == 2);
 	switch (value) {
 	default:
 	case 0:	setColourScheme(DefaultColours); break;

     m_mutex.lock();
     m_cacheInvalid = true;
     m_pixmapCacheInvalid = true;
     
     m_channel = ch;
+
+    m_mutex.unlock();
+
     emit layerParametersChanged();
-    
-    m_mutex.unlock();
+
     fillCache();
-
 }
 
 int
 SpectrogramLayer::getChannel() const
 {

     m_mutex.lock();
     m_cacheInvalid = true;
     m_pixmapCacheInvalid = true;
     
     m_windowSize = ws;
+    
+    m_mutex.unlock();
+
     emit layerParametersChanged();
-    
-    m_mutex.unlock();
+
     fillCache();
-
 }
 
 size_t
 SpectrogramLayer::getWindowSize() const
 {

     m_mutex.lock();
     m_cacheInvalid = true;
     m_pixmapCacheInvalid = true;
     
     m_windowOverlap = wi;
+    
+    m_mutex.unlock();
+
     emit layerParametersChanged();
-    
-    m_mutex.unlock();
+
     fillCache();
 }
 
 size_t
 SpectrogramLayer::getWindowOverlap() const

     m_mutex.lock();
     m_cacheInvalid = true;
     m_pixmapCacheInvalid = true;
     
     m_windowType = w;
+    
+    m_mutex.unlock();
+
     emit layerParametersChanged();
-    
-    m_mutex.unlock();
+
     fillCache();
 }
 
 WindowType
 SpectrogramLayer::getWindowType() const

     m_mutex.lock();
     m_cacheInvalid = true;
     m_pixmapCacheInvalid = true;
     
     m_gain = gain;
+    
+    m_mutex.unlock();
+
     emit layerParametersChanged();
-    
-    m_mutex.unlock();
+
     fillCache();
 }
 
 float
 SpectrogramLayer::getGain() const

     m_mutex.lock();
     // don't need to invalidate main cache here
     m_pixmapCacheInvalid = true;
     
     m_maxFrequency = mf;
+    
+    m_mutex.unlock();
+
     emit layerParametersChanged();
-    
-    m_mutex.unlock();
 }
 
 size_t
 SpectrogramLayer::getMaxFrequency() const
 {
     return m_maxFrequency;
+}
+
+void
+SpectrogramLayer::setColourRotation(int r)
+{
+    m_mutex.lock();
+    // don't need to invalidate main cache here
+    m_pixmapCacheInvalid = true;
+
+    if (r < 0) r = 0;
+    if (r > 256) r = 256;
+    int distance = r - m_colourRotation;
+
+    if (distance != 0) {
+	rotateCacheColourmap(-distance);
+	m_colourRotation = r;
+    }
+    
+    m_mutex.unlock();
+
+    emit layerParametersChanged();
 }
 
 void
 SpectrogramLayer::setColourScale(ColourScale colourScale)
 {

     m_mutex.lock();
     m_cacheInvalid = true;
     m_pixmapCacheInvalid = true;
     
     m_colourScale = colourScale;
-    emit layerParametersChanged();
     
     m_mutex.unlock();
     fillCache();
+
+    emit layerParametersChanged();
 }
 
 SpectrogramLayer::ColourScale
 SpectrogramLayer::getColourScale() const
 {

 
     m_mutex.lock();
     // don't need to invalidate main cache here
     m_pixmapCacheInvalid = true;
     
+    int formerColourRotation = m_colourRotation;
+
     m_colourScheme = scheme;
     setCacheColourmap();
+
+    int distance = formerColourRotation - m_colourRotation;
+
+    if (distance != 0) {
+	rotateCacheColourmap(-distance);
+	m_colourRotation = formerColourRotation;
+    }
+
+    m_mutex.unlock();
+
     emit layerParametersChanged();
-    
-    m_mutex.unlock();
 }
 
 SpectrogramLayer::ColourScheme
 SpectrogramLayer::getColourScheme() const
 {

     m_mutex.lock();
     // don't need to invalidate main cache here
     m_pixmapCacheInvalid = true;
     
     m_frequencyScale = frequencyScale;
+    
+    m_mutex.unlock();
+
     emit layerParametersChanged();
-    
-    m_mutex.unlock();
 }
 
 SpectrogramLayer::FrequencyScale
 SpectrogramLayer::getFrequencyScale() const
 {

 	}
 
 	m_cache->setColor
 	    (pixel, qRgb(colour.red(), colour.green(), colour.blue()));
     }
+
+    m_colourRotation = 0;
+}
+
+void
+SpectrogramLayer::rotateCacheColourmap(int distance)
+{
+    QRgb newPixels[256];
+
+    newPixels[0] = m_cache->color(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);
+    }
+
+    for (int pixel = 0; pixel < 256; ++pixel) {
+	m_cache->setColor(pixel, newPixels[pixel]);
+    }
 }
 
 bool
 SpectrogramLayer::fillCacheColumn(int column, double *input,
 				  fftw_complex *output,
 				  fftw_plan plan, 
+				  size_t windowSize,
+				  size_t increment,
 				  const Window<double> &windower,
 				  bool lock) const
 {
-    size_t increment = m_windowSize - m_windowSize * m_windowOverlap / 100;
     int startFrame = increment * column;
-    int endFrame = startFrame + m_windowSize;
-
-    startFrame -= int(m_windowSize - increment) / 2;
-    endFrame   -= int(m_windowSize - increment) / 2;
+    int endFrame = startFrame + windowSize;
+
+    startFrame -= int(windowSize - increment) / 2;
+    endFrame   -= int(windowSize - increment) / 2;
     size_t pfx = 0;
 
     if (startFrame < 0) {
 	pfx = size_t(-startFrame);
 	for (size_t i = 0; i < pfx; ++i) {

 	}
     }
 
     size_t got = m_model->getValues(m_channel, startFrame + pfx,
 				    endFrame, input + pfx);
-    while (got + pfx < m_windowSize) {
+    while (got + pfx < windowSize) {
 	input[got + pfx] = 0.0;
 	++got;
     }
 
     if (m_gain != 1.0) {
-	for (size_t i = 0; i < m_windowSize; ++i) {
+	for (size_t i = 0; i < windowSize; ++i) {
 	    input[i] *= m_gain;
 	}
     }
 
     windower.cut(input);

     fftw_execute(plan);
 
     if (lock) m_mutex.lock();
     bool interrupted = false;
 
-    for (size_t i = 0; i < m_windowSize / 2; ++i) {
+    for (size_t i = 0; i < windowSize / 2; ++i) {
 
 	int value = 0;
 
 	if (m_colourScale == PhaseColourScale) {
 

 
 	} else {
 
 	    double mag = sqrt(output[i][0] * output[i][0] +
 			      output[i][1] * output[i][1]);
-	    mag /= m_windowSize / 2;
+	    mag /= windowSize / 2;
 
 	    switch (m_colourScale) {
 		
 	    default:
 	    case LinearColourScale:

 
 	    std::cerr << "SpectrogramLayer::CacheFillThread::run: model is ready" << std::endl;
 
 	    size_t start = m_layer.m_model->getStartFrame();
 	    size_t end = m_layer.m_model->getEndFrame();
+
+	    WindowType windowType = m_layer.m_windowType;
 	    size_t windowSize = m_layer.m_windowSize;
 	    size_t windowIncrement = m_layer.getWindowIncrement();
 
 	    size_t visibleStart = start;
 	    size_t visibleEnd = end;

 		}
 		visibleEnd = m_layer.m_view->getEndFrame();
 	    }
 
 	    delete m_layer.m_cache;
-	    m_layer.m_cache = new QImage((end - start) / windowIncrement + 1,
-					windowSize / 2,
-					QImage::Format_Indexed8);
+	    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.setCacheColourmap();
     
 	    m_layer.m_cache->fill(0);
 	    m_layer.m_mutex.unlock();

 		fftw_malloc(windowSize * sizeof(fftw_complex));
 
 	    fftw_plan plan = fftw_plan_dft_r2c_1d(windowSize, input,
 						  output, FFTW_ESTIMATE);
 
-	    Window<double> windower(m_layer.m_windowType, m_layer.m_windowSize);
+	    Window<double> windower(windowType, windowSize);
 
 	    if (!plan) {
 		std::cerr << "WARNING: fftw_plan_dft_r2c_1d(" << windowSize << ") failed!" << std::endl;
 		fftw_free(input);
 		fftw_free(output);

 		m_layer.m_mutex.lock();
 
 		for (size_t f = visibleStart; f < visibleEnd; f += windowIncrement) {
 	    
 		    m_layer.fillCacheColumn(int((f - start) / windowIncrement),
-					    input, output, plan, windower, false);
+					    input, output, plan,
+					    windowSize, windowIncrement,
+					    windower, false);
 
 		    m_layer.m_mutex.unlock();
 		    m_layer.m_mutex.lock();
 
 		    if (m_layer.m_cacheInvalid || m_layer.m_exiting) {

 	    if (!interrupted && doVisibleFirst) {
 		
 		for (size_t f = visibleEnd; f < end; f += windowIncrement) {
 	    
 		    if (!m_layer.fillCacheColumn(int((f - start) / windowIncrement),
-						 input, output, plan, windower, true)) {
+						 input, output, plan,
+						 windowSize, windowIncrement,
+						 windower, true)) {
 			interrupted = true;
 			m_fillExtent = 0;
 			break;
 		    }
 

 		size_t baseCompletion = m_fillCompletion;
 
 		for (size_t f = start; f < remainingEnd; f += windowIncrement) {
 
 		    if (!m_layer.fillCacheColumn(int((f - start) / windowIncrement),
-						 input, output, plan, windower, true)) {
+						 input, output, plan,
+						 windowSize, windowIncrement,
+						 windower, true)) {
 			interrupted = true;
 			m_fillExtent = 0;
 			break;
 		    }
 		    

 		    }
 		}
 	    }
 		    
 	    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));
+/*
+		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 high = m_cache->color(pixNum > 254 ? 255 : pixNum + 1);
+		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));
 	    }
 	}