comparison layer/SpectrogramLayer.cpp @ 35:10ba9276a315

* Add TextModel and TextLayer types
* Make View refresh work better when editing a model (previously edits might
  not be refreshed if their visible changed area extended beyond the strict
  frame range that was being modified in the model)
* Add phase-adjusted instantaneous frequency display to spectrogram layer
  (still a work in progress)
* Pull maths aliases out into a separate header in dsp/maths so MathUtilities
  can be included without introducing them

 #include "base/View.h"
 #include "base/Profiler.h"
 #include "base/AudioLevel.h"
 #include "base/Window.h"
 #include "base/Pitch.h"
+
+#include "dsp/maths/MathUtilities.h"
 
 #include <QPainter>
 #include <QImage>
 #include <QPixmap>
 #include <QRect>

     m_colourRotation(0),
     m_maxFrequency(8000),
     m_colourScale(dBColourScale),
     m_colourScheme(DefaultColours),
     m_frequencyScale(LinearFrequencyScale),
+    m_frequencyAdjustment(RawFrequency),
     m_cache(0),
+    m_phaseAdjustCache(0),
     m_cacheInvalid(true),
     m_pixmapCache(0),
     m_pixmapCacheInvalid(true),
     m_fillThread(0),
     m_updateTimer(0),

     m_condition.wakeAll();
     if (m_fillThread) m_fillThread->wait();
     delete m_fillThread;
     
     delete m_cache;
+    delete m_phaseAdjustCache;
 }
 
 void
 SpectrogramLayer::setModel(const DenseTimeValueModel *model)
 {
     std::cerr << "SpectrogramLayer(" << this << "): setModel(" << model << ")" << std::endl;
 
     m_mutex.lock();
+    m_cacheInvalid = true;
     m_model = model;
     delete m_cache; //!!! hang on, this isn't safe to do here is it? 
 		    // we need some sort of guard against the fill
 		    // thread trying to read the defunct model too.
 		    // should we use a scavenger?
     m_cache = 0;
+    delete m_phaseAdjustCache; //!!! likewise
+    m_phaseAdjustCache = 0;
     m_mutex.unlock();
 
     if (!m_model || !m_model->isOK()) return;
 
     connect(m_model, SIGNAL(modelChanged()), this, SIGNAL(modelChanged()));

     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"));
+    list.push_back(tr("Frequency Adjustment"));
     return list;
 }
 
 Layer::PropertyType
 SpectrogramLayer::getPropertyType(const PropertyName &name) const

 
 QString
 SpectrogramLayer::getPropertyGroupName(const PropertyName &name) const
 {
     if (name == tr("Window Size") ||
+	name == tr("Window Type") ||
 	name == tr("Window Overlap")) return tr("Window");
+    if (name == tr("Colour") ||
+	name == tr("Colour Rotation")) return tr("Colour");
     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");
+	name == tr("Frequency Scale") ||
+	name == tr("Frequency Adjustment")) return tr("Frequency");
     return QString();
 }
 
 int
 SpectrogramLayer::getPropertyRangeAndValue(const PropertyName &name,

 
 	*min = 0;
 	*max = 1;
 	deft = (int)m_frequencyScale;
 
+    } else if (name == tr("Frequency Adjustment")) {
+
+	*min = 0;
+	*max = 2;
+	deft = (int)m_frequencyAdjustment;
+
     } else {
 	deft = Layer::getPropertyRangeAndValue(name, min, max);
     }
 
     return deft;

 	}
     }
     if (name == tr("Window Type")) {
 	switch ((WindowType)value) {
 	default:
-	case RectangularWindow: return tr("Rectangular");
+	case RectangularWindow: return tr("Rectangle");
 	case BartlettWindow: return tr("Bartlett");
 	case HammingWindow: return tr("Hamming");
 	case HanningWindow: return tr("Hanning");
 	case BlackmanWindow: return tr("Blackman");
 	case GaussianWindow: return tr("Gaussian");

 	return QString("%1").arg(32 << value);
     }
     if (name == tr("Window Overlap")) {
 	switch (value) {
 	default:
-	case 0: return tr("None");
-	case 1: return tr("25 %");
-	case 2: return tr("50 %");
-	case 3: return tr("75 %");
-	case 4: return tr("90 %");
+	case 0: return tr("0%");
+	case 1: return tr("25%");
+	case 2: return tr("50%");
+	case 3: return tr("75%");
+	case 4: return tr("90%");
 	}
     }
     if (name == tr("Max Frequency")) {
 	switch (value) {
 	default:

     if (name == tr("Frequency Scale")) {
 	switch (value) {
 	default:
 	case 0: return tr("Linear");
 	case 1: return tr("Log");
+	}
+    }
+    if (name == tr("Frequency Adjustment")) {
+	switch (value) {
+	default:
+	case 0: return tr("Bins");
+	case 1: return tr("Pitches");
+	case 2: return tr("Peaks");
 	}
     }
     return tr("<unknown>");
 }
 

 	switch (value) {
 	default:
 	case 0: setFrequencyScale(LinearFrequencyScale); break;
 	case 1: setFrequencyScale(LogFrequencyScale); break;
 	}
+    } else if (name == tr("Frequency Adjustment")) {
+	switch (value) {
+	default:
+	case 0: setFrequencyAdjustment(RawFrequency); break;
+	case 1: setFrequencyAdjustment(PhaseAdjustedFrequency); break;
+	case 2: setFrequencyAdjustment(PhaseAdjustedPeaks); break;
+	}
     }
 }
 
 void
 SpectrogramLayer::setChannel(int ch)

 SpectrogramLayer::setFrequencyScale(FrequencyScale frequencyScale)
 {
     if (m_frequencyScale == frequencyScale) return;
 
     m_mutex.lock();
+
     // don't need to invalidate main cache here
     m_pixmapCacheInvalid = true;
     
     m_frequencyScale = frequencyScale;
     

 
 SpectrogramLayer::FrequencyScale
 SpectrogramLayer::getFrequencyScale() const
 {
     return m_frequencyScale;
+}
+
+void
+SpectrogramLayer::setFrequencyAdjustment(FrequencyAdjustment frequencyAdjustment)
+{
+    if (m_frequencyAdjustment == frequencyAdjustment) return;
+
+    m_mutex.lock();
+
+    m_cacheInvalid = true;
+    m_pixmapCacheInvalid = true;
+    
+    m_frequencyAdjustment = frequencyAdjustment;
+    
+    m_mutex.unlock();
+
+    fillCache();
+
+    emit layerParametersChanged();
+}
+
+SpectrogramLayer::FrequencyAdjustment
+SpectrogramLayer::getFrequencyAdjustment() const
+{
+    return m_frequencyAdjustment;
 }
 
 void
 SpectrogramLayer::setLayerDormant(bool dormant)
 {

 {
     if (m_cacheInvalid || !m_cache) return;
 
     int formerRotation = m_colourRotation;
 
-//    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;

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

 				  fftw_complex *output,
 				  fftw_plan plan, 
 				  size_t windowSize,
 				  size_t increment,
 				  const Window<double> &windower,
-				  bool lock) const
-{
+				  bool resetStoredPhase) const
+{
+    static std::vector<double> storedPhase;
+
+    bool phaseAdjust =
+	(m_frequencyAdjustment == PhaseAdjustedFrequency ||
+	 m_frequencyAdjustment == PhaseAdjustedPeaks);
+    bool haveStoredPhase = true;
+    size_t sampleRate = 0;
+
+    static int counter = 0;
+
+    if (phaseAdjust) {
+	if (resetStoredPhase || (storedPhase.size() != windowSize / 2)) {
+	    haveStoredPhase = false;
+	    storedPhase.clear();
+	    for (size_t i = 0; i < windowSize / 2; ++i) {
+		storedPhase.push_back(0.0);
+	    }
+	    counter = 0;
+	}
+	++counter;
+	sampleRate = m_model->getSampleRate();
+    }
+
     int startFrame = increment * column;
     int endFrame = startFrame + windowSize;
 
     startFrame -= int(windowSize - increment) / 2;
     endFrame   -= int(windowSize - increment) / 2;

 	}
     }
 
     windower.cut(input);
 
+    for (size_t i = 0; i < windowSize/2; ++i) {
+	double temp = input[i];
+	input[i] = input[i + windowSize/2];
+	input[i + windowSize/2] = temp;
+    }
+    
     fftw_execute(plan);
 
-//    if (lock) m_mutex.lock();
     bool interrupted = false;
 
+    double prevMag = 0.0;
+
     for (size_t i = 0; i < windowSize / 2; ++i) {
 
 	int value = 0;
+	double phase = 0.0;
+
+	    double mag = sqrt(output[i][0] * output[i][0] +
+			      output[i][1] * output[i][1]);
+	    mag /= windowSize / 2;
+
+	if (phaseAdjust || (m_colourScale == PhaseColourScale)) {
+
+//	    phase = atan2(-output[i][1], output[i][0]);
+//	    phase = atan2(output[i][1], output[i][0]);
+	    phase = atan2(output[i][0], output[i][1]);
+//	    phase = MathUtilities::princarg(phase);
+	}	    
+
+	if (phaseAdjust && m_phaseAdjustCache && haveStoredPhase) {
+
+	    bool peak = true;
+	    if (m_frequencyAdjustment == PhaseAdjustedPeaks) {
+		if (mag < prevMag) peak = false;
+		else {
+		    double nextMag = 0.0;
+		    if (i < windowSize / 2 - 1) {
+			nextMag = sqrt(output[i+1][0] * output[i+1][0] +
+				       output[i+1][1] * output[i+1][1]);
+			nextMag /= windowSize / 2;
+		    }
+		    if (mag < nextMag) peak = false;
+		}
+		prevMag = mag;
+	    }
+
+	    if (!peak) {
+		if (m_cacheInvalid || m_exiting) {
+		    interrupted = true;
+		    break;
+		}
+		m_phaseAdjustCache->setValueAt(column, i, SCHAR_MIN);
+	    } else {
+
+//	    if (i > 45 && i < 55 && counter == 10)  {
+	    
+	    double freq = (double(i) * sampleRate) / m_windowSize;
+//	    std::cout << "\nbin = " << i << " initial estimate freq = " << freq
+//		      << " mag = " << mag << std::endl;
+
+	    double prevPhase = storedPhase[i];
+
+	    double expectedPhase =
+		prevPhase + (2 * M_PI * i * increment) / m_windowSize;
+
+	    double phaseError = MathUtilities::princarg(phase - expectedPhase);
+	    
+//	    if (fabs(phaseError) > (1.2 * (increment * M_PI) / m_windowSize)) {
+//		std::cout << "error > " << (1.2 * (increment * M_PI) / m_windowSize) << std::endl;
+//	    }// else {
+
+//	    std::cout << "prevPhase = " << prevPhase << ", phase = " << phase
+//		      << ", expected = " << MathUtilities::princarg(expectedPhase) << ", error = "
+//		      << phaseError << std::endl;
+
+	    double newFreq =
+		(sampleRate *
+		 (expectedPhase + phaseError - prevPhase)) /
+		//(prevPhase - (expectedPhase + phaseError))) /
+		(2 * M_PI * increment);
+
+//	    std::cout << freq << " (" << Pitch::getPitchLabelForFrequency(freq).toStdString() <<  ") -> " << newFreq << " (" << Pitch::getPitchLabelForFrequency(newFreq).toStdString() << ")" << std::endl;
+//	    }
+//}
+
+	    double binRange = (double(i + 1) * sampleRate) / windowSize - freq;
+	    
+	    int offset = lrint(((newFreq - freq) / binRange) * 10);//!!!
+
+	    if (m_cacheInvalid || m_exiting) {
+		interrupted = true;
+		break;
+	    }
+	    if (offset > SCHAR_MIN && offset <= SCHAR_MAX) {
+		signed char coff = offset;
+		m_phaseAdjustCache->setValueAt(column, i, (unsigned char)coff);
+	    } else {
+		m_phaseAdjustCache->setValueAt(column, i, 0);
+	    }
+	    }
+	    storedPhase[i] = phase;
+	}
 
 	if (m_colourScale == PhaseColourScale) {
 
-	    double phase = atan2(-output[i][1], output[i][0]);
+	    phase = MathUtilities::princarg(phase);
 	    value = int((phase * 128 / M_PI) + 128);
 
 	} else {
 
 	    double mag = sqrt(output[i][0] * output[i][0] +

 	}
 
 	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];
+    // use malloc rather than new[], because we want to be able to use realloc
+    m_values = (unsigned char *)
+	malloc(m_width * m_height * sizeof(unsigned char));
+    if (!m_values) throw std::bad_alloc();
     MUNLOCK(m_values, m_width * m_height * sizeof(unsigned char));
 }
 
 SpectrogramLayer::Cache::~Cache()
 {
-    delete[] m_values;
-}
+    if (m_values) free(m_values);
+}
+
+void
+SpectrogramLayer::Cache::resize(size_t width, size_t height)
+{
+    m_values = (unsigned char *)
+	realloc(m_values, m_width * m_height * sizeof(unsigned char));
+    if (!m_values) throw std::bad_alloc();
+    MUNLOCK(m_values, m_width * m_height * sizeof(unsigned char));
+}    
 
 size_t
 SpectrogramLayer::Cache::getWidth() const
 {
     return m_width;

 
 	if (m_layer.m_dormant) {
 
 	    if (m_layer.m_cacheInvalid) {
 		delete m_layer.m_cache;
+		delete m_layer.m_phaseAdjustCache;
 		m_layer.m_cache = 0;
+		m_layer.m_phaseAdjustCache = 0;
 	    }
 
 	} else if (m_layer.m_model && m_layer.m_cacheInvalid) {
 
 //	    std::cerr << "SpectrogramLayer::CacheFillThread::run: something to do" << std::endl;

 			windowIncrement;
 		}
 		visibleEnd = m_layer.m_view->getEndFrame();
 	    }
 
-	    delete m_layer.m_cache;
 	    size_t width = (end - start) / windowIncrement + 1;
 	    size_t height = windowSize / 2;
-	    m_layer.m_cache = new Cache(width, height);
+
+	    if (!m_layer.m_cache) {
+		m_layer.m_cache = new Cache(width, height);
+	    } else if (width != m_layer.m_cache->getWidth() ||
+		       height != m_layer.m_cache->getHeight()) {
+		m_layer.m_cache->resize(width, height);
+	    }
 
 	    m_layer.setCacheColourmap();
 	    m_layer.m_cache->fill(0);
+
+	    if (m_layer.m_frequencyAdjustment == PhaseAdjustedFrequency ||
+		m_layer.m_frequencyAdjustment == PhaseAdjustedPeaks) {
+		
+		if (!m_layer.m_phaseAdjustCache) {
+		    m_layer.m_phaseAdjustCache = new Cache(width, height);
+		} else if (width != m_layer.m_phaseAdjustCache->getWidth() ||
+			   height != m_layer.m_phaseAdjustCache->getHeight()) {
+		    m_layer.m_phaseAdjustCache->resize(width, height);
+		}
+
+		m_layer.m_phaseAdjustCache->fill(0);
+
+	    } else {
+		delete m_layer.m_phaseAdjustCache;
+		m_layer.m_phaseAdjustCache = 0;
+	    }
 
 	    // We don't need a lock when writing to or reading from
 	    // the pixels in the cache, because it's a fixed size
 	    // array.  We do need to ensure we have the width and
-	    // height of the cache and the FFT parameters fixed before
+	    // height of the cache and the FFT parameters known before
 	    // we unlock, in case they change in the model while we
 	    // aren't holding a lock.  It's safe for us to continue to
 	    // use the "old" values if that happens, because they will
 	    // continue to match the dimensions of the actual cache
 	    // (which we manage, not the model).

 		for (size_t f = visibleStart; f < visibleEnd; f += windowIncrement) {
 	    
 		    m_layer.fillCacheColumn(int((f - start) / windowIncrement),
 					    input, output, plan,
 					    windowSize, windowIncrement,
-					    windower, false);
+					    //!!! actually if we're doing phase adjustment we also want to fill the column preceding the visible area so that we have the right values for the first visible one (also applies below)
+					    windower, f == visibleStart);
 
 		    if (m_layer.m_cacheInvalid || m_layer.m_exiting) {
 			interrupted = true;
 			m_fillExtent = 0;
 			break;

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

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

 
 	float minf = float(sr) / m_windowSize;
 	
 	float maxlogf = log10f(maxf);
 	float minlogf = log10f(minf);
-
+ 
 	float logf0 = minlogf + ((maxlogf - minlogf) * (h - y - 1)) / h;
 	float logf1 = minlogf + ((maxlogf - minlogf) * (h - y)) / h;
 	
 	float f0 = pow(10.f, logf0);
 	float f1 = pow(10.f, logf1);

     int q1i = int(q1);
 
     int sr = m_model->getSampleRate();
 
     for (int q = q0i; q <= q1i; ++q) {
-	int binfreq = (sr * (q + 1)) / m_windowSize;
+	int binfreq = (sr * q) / m_windowSize;
 	if (q == q0i) freqMin = binfreq;
 	if (q == q1i) freqMax = binfreq;
     }
     return true;
+}
+
+bool
+SpectrogramLayer::getAdjustedYBinSourceRange(int x, int y,
+					     float &freqMin, float &freqMax,
+					     float &adjFreqMin, float &adjFreqMax)
+const
+{
+    float s0 = 0, s1 = 0;
+    if (!getXBinRange(x, s0, s1)) return false;
+
+    float q0 = 0, q1 = 0;
+    if (!getYBinRange(y, q0, q1)) return false;
+
+    int s0i = int(s0 + 0.001);
+    int s1i = int(s1);
+
+    int q0i = int(q0 + 0.001);
+    int q1i = int(q1);
+
+    int sr = m_model->getSampleRate();
+
+    bool haveAdj = false;
+
+    for (int q = q0i; q <= q1i; ++q) {
+
+	for (int s = s0i; s <= s1i; ++s) {
+
+	    float binfreq = (sr * q) / m_windowSize;
+	    if (q == q0i) freqMin = binfreq;
+	    if (q == q1i) freqMax = binfreq;
+	    
+	    if ((m_frequencyAdjustment == PhaseAdjustedFrequency ||
+		 m_frequencyAdjustment == PhaseAdjustedPeaks) &&
+		m_phaseAdjustCache) {
+
+		unsigned char cadj = m_phaseAdjustCache->getValueAt(s, q);
+		int adjust = int((signed char)cadj);
+		if (adjust == SCHAR_MIN &&
+		    m_frequencyAdjustment == PhaseAdjustedPeaks) {
+		    continue;
+		}
+		
+		float nextBinFreq = (sr * (q + 1)) / m_windowSize;
+		float fadjust = (adjust * (nextBinFreq - binfreq)) / 10.0;//!!!
+		float f = binfreq + fadjust;
+		if (!haveAdj || f < adjFreqMin) adjFreqMin = f;
+		if (!haveAdj || f > adjFreqMax) adjFreqMax = f;
+		haveAdj = true;
+	    }
+	}
+    }
+
+    if (!haveAdj) {
+	adjFreqMin = adjFreqMax = 0.0f;
+    }
+
+    return haveAdj;
 }
     
 bool
 SpectrogramLayer::getXYBinSourceRange(int x, int y, float &dbMin, float &dbMax) const
 {

     int h = y1 - y0;
 
 //    std::cerr << "x0 " << x0 << ", x1 " << x1 << ", w " << w << ", h " << h << std::endl;
 
     QImage scaled(w, h, QImage::Format_RGB32);
+    scaled.fill(0);
+
+    float ymag[h];
+    float ydiv[h];
+    
+    size_t bins = m_windowSize / 2;
+    int sr = m_model->getSampleRate();
+    
+    if (m_maxFrequency > 0) {
+	bins = int((double(m_maxFrequency) * m_windowSize) / sr + 0.1);
+	if (bins > m_windowSize / 2) bins = m_windowSize / 2;
+    }
+	
+    float maxFreq = (float(bins) * sr) / m_windowSize;
 
     m_mutex.unlock();
 
+    for (int x = 0; x < w; ++x) {
+
+	m_mutex.lock();
+	if (m_cacheInvalid) {
+	    m_mutex.unlock();
+	    break;
+	}
+
+	for (int y = 0; y < h; ++y) {
+	    ymag[y] = 0.0f;
+	    ydiv[y] = 0.0f;
+	}
+
+	float s0 = 0, s1 = 0;
+
+	if (!getXBinRange(x0 + x, s0, s1)) {
+	    assert(x <= scaled.width());
+	    for (int y = 0; y < h; ++y) {
+		scaled.setPixel(x, y, qRgb(0, 0, 0));
+	    }
+	    m_mutex.unlock();
+	    continue;
+	}
+
+	int s0i = int(s0 + 0.001);
+	int s1i = int(s1);
+
+	for (int q = 0; q < bins; ++q) {
+
+	    for (int s = s0i; s <= s1i; ++s) {
+
+		float sprop = 1.0;
+		if (s == s0i) sprop *= (s + 1) - s0;
+		if (s == s1i) sprop *= s1 - s;
+
+		float f0 = (float(q) * sr) / m_windowSize;
+		float f1 = (float(q + 1) * sr) / m_windowSize;
+ 
+		if ((m_frequencyAdjustment == PhaseAdjustedFrequency ||
+		     m_frequencyAdjustment == PhaseAdjustedPeaks) &&
+		    m_phaseAdjustCache) {
+
+		    unsigned char cadj = m_phaseAdjustCache->getValueAt(s, q);
+		    int adjust = int((signed char)cadj);
+
+		    if (adjust == SCHAR_MIN &&
+			m_frequencyAdjustment == PhaseAdjustedPeaks) {
+			continue;
+		    }
+
+		    float fadjust = (adjust * (f1 - f0)) / 10.0;//!!! was 100
+		    f0 = f1 = f0 + fadjust;
+		}
+	    
+		float y0 = h - (h * f1) / maxFreq;
+		float y1 = h - (h * f0) / maxFreq;
+
+		if (m_frequencyScale == LogFrequencyScale) {
+		    
+		    float maxf = m_maxFrequency;
+		    if (maxf == 0.0) maxf = float(sr) / 2;
+		    
+		    float minf = float(sr) / m_windowSize;
+		    
+		    float maxlogf = log10f(maxf);
+		    float minlogf = log10f(minf);
+		    
+		    y0 = h - (h * (log10f(f1) - minlogf)) / (maxlogf - minlogf);
+		    y1 = h - (h * (log10f(f0) - minlogf)) / (maxlogf - minlogf);
+		}
+
+		int y0i = int(y0 + 0.001);
+		int y1i = int(y1);
+
+		for (int y = y0i; y <= y1i; ++y) {
+		    
+		    if (y < 0 || y >= h) continue;
+
+		    float yprop = sprop;
+		    if (y == y0i) yprop *= (y + 1) - y0;
+		    if (y == y1i) yprop *= y1 - y;
+		    
+		    ymag[y] += yprop * m_cache->getValueAt(s, q);
+		    ydiv[y] += yprop;
+		}
+	    }
+	}
+
+	for (int y = 0; y < h; ++y) {
+
+	    int pixel = 1;
+
+	    if (ydiv[y] > 0.0) {
+		pixel = int(ymag[y] / ydiv[y]);
+		if (pixel > 255) pixel = 255;
+		if (pixel < 1) pixel = 1;
+	    }
+
+	    assert(x <= scaled.width());
+	    QColor c = m_cache->getColour(pixel);
+	    scaled.setPixel(x, y,
+			    qRgb(c.red(), c.green(), c.blue()));
+	}
+    
+
+	m_mutex.unlock();
+    }
+
+#ifdef NOT_DEFINED
     for (int y = 0; y < h; ++y) {
 
 	m_mutex.lock();
 	if (m_cacheInvalid) {
 	    m_mutex.unlock();

 	    }
 	}
 
 	m_mutex.unlock();
     }
+#endif
 
     paint.drawImage(x0, y0, scaled);
 
     if (recreateWholePixmapCache) {
 	delete m_pixmapCache;

 
     if (!m_model || !m_model->isOK()) return "";
 
     float dbMin = 0, dbMax = 0;
     float freqMin = 0, freqMax = 0;
+    float adjFreqMin = 0, adjFreqMax = 0;
     QString pitchMin, pitchMax;
     RealTime rtMin, rtMax;
 
     bool haveDb = false;
 
     if (!getXBinSourceRange(x, rtMin, rtMax)) return "";
-    if (!getYBinSourceRange(y, freqMin, freqMax)) return "";
     if (getXYBinSourceRange(x, y, dbMin, dbMax)) haveDb = true;
+
+    QString adjFreqText = "", adjPitchText = "";
+
+    if ((m_frequencyAdjustment == PhaseAdjustedFrequency ||
+	 m_frequencyAdjustment == PhaseAdjustedPeaks) &&
+	m_phaseAdjustCache) {
+
+	if (!getAdjustedYBinSourceRange(x, y, freqMin, freqMax,
+					adjFreqMin, adjFreqMax)) return "";
+
+	if (adjFreqMin != adjFreqMax) {
+	    adjFreqText = tr("Adjusted Frequency:\t%1 - %2 Hz\n")
+		.arg(adjFreqMin).arg(adjFreqMax);
+	    adjPitchText = tr("Adjusted Pitch:\t%3 - %4\n")
+		.arg(Pitch::getPitchLabelForFrequency(adjFreqMin))
+		.arg(Pitch::getPitchLabelForFrequency(adjFreqMax));
+	} else {
+	    adjFreqText = tr("Adjusted Frequency:\t%1 Hz\n")
+		.arg(adjFreqMin);
+	    adjPitchText = tr("Adjusted Pitch:\t%2\n")
+		.arg(Pitch::getPitchLabelForFrequency(adjFreqMin));
+	}
+
+    } else {
+	
+	if (!getYBinSourceRange(y, freqMin, freqMax)) return "";
+    }
 
     //!!! want to actually do a one-off FFT to recalculate the dB value!
 
     QString text;
 

 	text += tr("Time:\t%1\n")
 	    .arg(rtMin.toText(true).c_str());
     }
 
     if (freqMin != freqMax) {
-	text += tr("Frequency:\t%1 - %2 Hz\nPitch:\t%3 - %4\n")
+	text += tr("Frequency:\t%1 - %2 Hz\n%3Pitch:\t%4 - %5\n%6")
 	    .arg(freqMin)
 	    .arg(freqMax)
+	    .arg(adjFreqText)
 	    .arg(Pitch::getPitchLabelForFrequency(freqMin))
-	    .arg(Pitch::getPitchLabelForFrequency(freqMax));
+	    .arg(Pitch::getPitchLabelForFrequency(freqMax))
+	    .arg(adjPitchText);
     } else {
-	text += tr("Frequency:\t%1 Hz\nPitch:\t%2\n")
+	text += tr("Frequency:\t%1 Hz\n%2Pitch:\t%3\n%4")
 	    .arg(freqMin)
-	    .arg(Pitch::getPitchLabelForFrequency(freqMin));
+	    .arg(adjFreqText)
+	    .arg(Pitch::getPitchLabelForFrequency(freqMin))
+	    .arg(adjPitchText);
     }	
 
     if (haveDb) {
 	if (lrintf(dbMin) != lrintf(dbMax)) {
 	    text += tr("dB:\t%1 - %2").arg(lrintf(dbMin)).arg(lrintf(dbMax));

     
     s += QString("channel=\"%1\" "
 		 "windowSize=\"%2\" "
 		 "windowType=\"%3\" "
 		 "windowOverlap=\"%4\" "
-		 "gain=\"%5\" "
-		 "maxFrequency=\"%6\" "
-		 "colourScale=\"%7\" "
-		 "colourScheme=\"%8\" "
-		 "frequencyScale=\"%9\"")
+		 "gain=\"%5\" ")
 	.arg(m_channel)
 	.arg(m_windowSize)
 	.arg(m_windowType)
 	.arg(m_windowOverlap)
-	.arg(m_gain)
+	.arg(m_gain);
+
+    s += QString("maxFrequency=\"%1\" "
+		 "colourScale=\"%2\" "
+		 "colourScheme=\"%3\" "
+		 "frequencyScale=\"%4\" "
+		 "frequencyAdjustment=\"%5\"")
 	.arg(m_maxFrequency)
 	.arg(m_colourScale)
 	.arg(m_colourScheme)
-	.arg(m_frequencyScale);
+	.arg(m_frequencyScale)
+	.arg(m_frequencyAdjustment);
 
     return Layer::toXmlString(indent, extraAttributes + " " + s);
 }
 
 void

     if (ok) setColourScheme(colourScheme);
 
     FrequencyScale frequencyScale = (FrequencyScale)
 	attributes.value("frequencyScale").toInt(&ok);
     if (ok) setFrequencyScale(frequencyScale);
+
+    FrequencyAdjustment frequencyAdjustment = (FrequencyAdjustment)
+	attributes.value("frequencyAdjustment").toInt(&ok);
+    if (ok) setFrequencyAdjustment(frequencyAdjustment);
 }
     
 
 #ifdef INCLUDE_MOCFILES
 #include "SpectrogramLayer.moc.cpp"