svgui: layer/SpectrogramLayer.cpp comparison

comparison layer/SpectrogramLayer.cpp @ 1045:f535f6e5dbb0 alignment-simple

Merge in from SV 3.0-integration branches

author	Chris Cannam
date	Wed, 02 Mar 2016 17:25:27 +0000
parents	4e5c1c326794
children	5e5873c24142

comparison

equal deleted inserted replaced

-:f2c63ec85901
+:f535f6e5dbb0
 #include <QPainter>
 #include <QImage>
 #include <QPixmap>
 #include <QRect>
-#include <QTimer>
 #include <QApplication>
 #include <QMessageBox>
 #include <QMouseEvent>
 #include <QTextStream>
+#include <QSettings>
 #include <iostream>
 #include <cassert>
 #include <cmath>
 #ifndef __GNUC__
 #include <alloca.h>
 #endif
-//#define DEBUG_SPECTROGRAM_REPAINT 1
+#define DEBUG_SPECTROGRAM_REPAINT 1
-using std::vector;
+using namespace std;
 SpectrogramLayer::SpectrogramLayer(Configuration config) :
 m_model(0),
 m_channel(0),
 m_windowSize(1024),
 m_initialMaxFrequency(8000),
 m_colourScale(dBColourScale),
 m_colourMap(0),
 m_frequencyScale(LinearFrequencyScale),
 m_binDisplay(AllBins),
-m_normalizeColumns(false),
+m_normalization(NoNormalization),
-m_normalizeVisibleArea(false),
-m_normalizeHybrid(false),
 m_lastEmittedZoomStep(-1),
 m_synchronous(false),
 m_haveDetailedScale(false),
-m_lastPaintBlockWidth(0),
-m_updateTimer(0),
-m_candidateFillStartFrame(0),
 m_exiting(false),
 m_sliceableModel(0)
 {
+QString colourConfigName = "spectrogram-colour";
+int colourConfigDefault = int(ColourMapper::Green);
 if (config == FullRangeDb) {
 m_initialMaxFrequency = 0;
 setMaxFrequency(0);
 } else if (config == MelodicRange) {
 	setWindowSize(8192);
 	setMaxFrequency(1500);
 setMinFrequency(40);
 	setColourScale(LinearColourScale);
 setColourMap(ColourMapper::Sunset);
 setFrequencyScale(LogFrequencyScale);
+colourConfigName = "spectrogram-melodic-colour";
+colourConfigDefault = int(ColourMapper::Sunset);
 //        setGain(20);
 } else if (config == MelodicPeaks) {
 	setWindowSize(4096);
 	setWindowHopLevel(5);
 m_initialMaxFrequency = 2000;
 	setMaxFrequency(2000);
 	setMinFrequency(40);
 	setFrequencyScale(LogFrequencyScale);
 	setColourScale(LinearColourScale);
 	setBinDisplay(PeakFrequencies);
-	setNormalizeColumns(true);
+setNormalization(NormalizeColumns);
-}
+colourConfigName = "spectrogram-melodic-colour";
+colourConfigDefault = int(ColourMapper::Sunset);
+}
+QSettings settings;
+settings.beginGroup("Preferences");
+setColourMap(settings.value(colourConfigName, colourConfigDefault).toInt());
+settings.endGroup();
 Preferences *prefs = Preferences::getInstance();
 connect(prefs, SIGNAL(propertyChanged(PropertyContainer::PropertyName)),
 this, SLOT(preferenceChanged(PropertyContainer::PropertyName)));
 setWindowType(prefs->getWindowType());
 initialisePalette();
 }
 SpectrogramLayer::~SpectrogramLayer()
 {
-delete m_updateTimer;
-m_updateTimer = 0;
 invalidateFFTModels();
 }
 void
 SpectrogramLayer::setModel(const DenseTimeValueModel *model)
 PropertyList list;
 list.push_back("Colour");
 list.push_back("Colour Scale");
 list.push_back("Window Size");
 list.push_back("Window Increment");
-list.push_back("Normalize Columns");
+list.push_back("Normalization");
-list.push_back("Normalize Visible Area");
 list.push_back("Bin Display");
 list.push_back("Threshold");
 list.push_back("Gain");
 list.push_back("Colour Rotation");
 //    list.push_back("Min Frequency");
 {
 if (name == "Colour") return tr("Colour");
 if (name == "Colour Scale") return tr("Colour Scale");
 if (name == "Window Size") return tr("Window Size");
 if (name == "Window Increment") return tr("Window Overlap");
-if (name == "Normalize Columns") return tr("Normalize Columns");
+if (name == "Normalization") return tr("Normalization");
-if (name == "Normalize Visible Area") return tr("Normalize Visible Area");
 if (name == "Bin Display") return tr("Bin Display");
 if (name == "Threshold") return tr("Threshold");
 if (name == "Gain") return tr("Gain");
 if (name == "Colour Rotation") return tr("Colour Rotation");
 if (name == "Min Frequency") return tr("Min Frequency");
 if (name == "Zero Padding") return tr("Smoothing");
 return "";
 }
 QString
-SpectrogramLayer::getPropertyIconName(const PropertyName &name) const
+SpectrogramLayer::getPropertyIconName(const PropertyName &) const
 {
-if (name == "Normalize Columns") return "normalise-columns";
-if (name == "Normalize Visible Area") return "normalise";
 return "";
 }
 Layer::PropertyType
 SpectrogramLayer::getPropertyType(const PropertyName &name) const
 {
 if (name == "Gain") return RangeProperty;
 if (name == "Colour Rotation") return RangeProperty;
-if (name == "Normalize Columns") return ToggleProperty;
-if (name == "Normalize Visible Area") return ToggleProperty;
 if (name == "Threshold") return RangeProperty;
 if (name == "Zero Padding") return ToggleProperty;
 return ValueProperty;
 }
 	name == "Window Increment" ||
 name == "Zero Padding") return tr("Window");
 if (name == "Colour" ||
 	name == "Threshold" ||
 	name == "Colour Rotation") return tr("Colour");
-if (name == "Normalize Columns" ||
+if (name == "Normalization" ||
-name == "Normalize Visible Area" ||
 name == "Gain" ||
 	name == "Colour Scale") return tr("Scale");
 return QString();
 }
 	*min = 0;
 	*max = 2;
 *deflt = int(AllBins);
 	val = (int)m_binDisplay;
-} else if (name == "Normalize Columns") {
+} else if (name == "Normalization") {
-*deflt = 0;
+*min = 0;
-	val = (m_normalizeColumns ? 1 : 0);
+*max = 3;
+*deflt = int(NoNormalization);
-} else if (name == "Normalize Visible Area") {
+val = (int)m_normalization;
-*deflt = 0;
-	val = (m_normalizeVisibleArea ? 1 : 0);
 } else {
 	val = Layer::getPropertyRangeAndValue(name, min, max, deflt);
 }
 	case 1: return tr("Meter");
 	case 2: return tr("dBV^2");
 	case 3: return tr("dBV");
 	case 4: return tr("Phase");
 	}
+}
+if (name == "Normalization") {
+return ""; // icon only
 }
 if (name == "Window Size") {
 	return QString("%1").arg(32 << value);
 }
 if (name == "Window Increment") {
 	case 1: return tr("Peak Bins");
 	case 2: return tr("Frequencies");
 	}
 }
 return tr("<unknown>");
+}
+QString
+SpectrogramLayer::getPropertyValueIconName(const PropertyName &name,
+int value) const
+{
+if (name == "Normalization") {
+switch(value) {
+default:
+case 0: return "normalise-none";
+case 1: return "normalise-columns";
+case 2: return "normalise";
+case 3: return "normalise-hybrid";
+}
+}
+return "";
 }
 RangeMapper *
 SpectrogramLayer::getNewPropertyRangeMapper(const PropertyName &name) const
 {
 	default:
 	case 0: setBinDisplay(AllBins); break;
 	case 1: setBinDisplay(PeakBins); break;
 	case 2: setBinDisplay(PeakFrequencies); break;
 	}
-} else if (name == "Normalize Columns") {
+} else if (name == "Normalization") {
-	setNormalizeColumns(value ? true : false);
+switch (value) {
-} else if (name == "Normalize Visible Area") {
+default:
-	setNormalizeVisibleArea(value ? true : false);
+case 0: setNormalization(NoNormalization); break;
+case 1: setNormalization(NormalizeColumns); break;
+case 2: setNormalization(NormalizeVisibleArea); break;
+case 3: setNormalization(NormalizeHybrid); break;
+}
 }
 }
 void
 SpectrogramLayer::invalidateImageCaches()
 {
+#ifdef DEBUG_SPECTROGRAM
+cerr << "SpectrogramLayer::invalidateImageCaches called" << endl;
+#endif
 for (ViewImageCache::iterator i = m_imageCaches.begin();
 i != m_imageCaches.end(); ++i) {
-i->second.validArea = QRect();
+i->second.invalidate();
-}
-}
-void
-SpectrogramLayer::invalidateImageCaches(sv_frame_t startFrame, sv_frame_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
-SVDEBUG << "SpectrogramLayer::invalidateImageCaches("
-<< startFrame << ", " << endFrame << "): view range is "
-<< v->getStartFrame() << ", " << v->getEndFrame()
-<< endl;
-cerr << "Valid area was: " << i->second.validArea.x() << ", "
-<< i->second.validArea.y() << " "
-<< i->second.validArea.width() << "x"
-<< i->second.validArea.height() << endl;
-#endif
-if (int(startFrame) > v->getStartFrame()) {
-if (startFrame >= v->getEndFrame()) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "Modified start frame is off right of view" << endl;
-#endif
-return;
-}
-int x = v->getXForFrame(startFrame);
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "clipping from 0 to " << x-1 << endl;
-#endif
-if (x > 1) {
-i->second.validArea &=
-QRect(0, 0, x-1, v->height());
-} else {
-i->second.validArea = QRect();
-}
-} else {
-if (int(endFrame) < v->getStartFrame()) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "Modified end frame is off left of view" << endl;
-#endif
-return;
-}
-int x = v->getXForFrame(endFrame);
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "clipping from " << x+1 << " to " << v->width()
-<< endl;
-#endif
-if (x < v->width()) {
-i->second.validArea &=
-QRect(x+1, 0, v->width()-(x+1), v->height());
-} else {
-i->second.validArea = QRect();
-}
-}
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "Valid area is now: " << i->second.validArea.x() << ", "
-<< i->second.validArea.y() << " "
-<< i->second.validArea.width() << "x"
-<< i->second.validArea.height() << endl;
-#endif
 }
 }
 void
 SpectrogramLayer::preferenceChanged(PropertyContainer::PropertyName name)
 {
 return m_binDisplay;
 }
 void
-SpectrogramLayer::setNormalizeColumns(bool n)
+SpectrogramLayer::setNormalization(Normalization n)
 {
-if (m_normalizeColumns == n) return;
+if (m_normalization == n) return;
 invalidateImageCaches();
 invalidateMagnitudes();
-m_normalizeColumns = n;
+m_normalization = n;
 emit layerParametersChanged();
 }
-bool
+SpectrogramLayer::Normalization
-SpectrogramLayer::getNormalizeColumns() const
+SpectrogramLayer::getNormalization() const
 {
-return m_normalizeColumns;
+return m_normalization;
 }
 void
-SpectrogramLayer::setNormalizeHybrid(bool n)
+SpectrogramLayer::setLayerDormant(const LayerGeometryProvider *v, bool dormant)
-{
-if (m_normalizeHybrid == n) return;
-invalidateImageCaches();
-invalidateMagnitudes();
-m_normalizeHybrid = n;
-emit layerParametersChanged();
-}
-bool
-SpectrogramLayer::getNormalizeHybrid() const
-{
-return m_normalizeHybrid;
-}
-void
-SpectrogramLayer::setNormalizeVisibleArea(bool n)
-{
-SVDEBUG << "SpectrogramLayer::setNormalizeVisibleArea(" << n
-<< ") (from " << m_normalizeVisibleArea << ")" << endl;
-if (m_normalizeVisibleArea == n) return;
-invalidateImageCaches();
-invalidateMagnitudes();
-m_normalizeVisibleArea = n;
-emit layerParametersChanged();
-}
-bool
-SpectrogramLayer::getNormalizeVisibleArea() const
-{
-return m_normalizeVisibleArea;
-}
-void
-SpectrogramLayer::setLayerDormant(const View *v, bool dormant)
 {
 if (dormant) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "SpectrogramLayer::setLayerDormant(" << dormant << ")"
+cerr << "SpectrogramLayer::setLayerDormant(" << dormant << ")"
 << endl;
 #endif
 if (isLayerDormant(v)) {
 return;
 }
 Layer::setLayerDormant(v, true);
+const View *view = v->getView();
 	invalidateImageCaches();
-m_imageCaches.erase(v);
+m_imageCaches.erase(view->getId());
-if (m_fftModels.find(v) != m_fftModels.end()) {
+if (m_fftModels.find(view->getId()) != m_fftModels.end()) {
-if (m_sliceableModel == m_fftModels[v].first) {
+if (m_sliceableModel == m_fftModels[view->getId()]) {
 bool replaced = false;
 for (ViewFFTMap::iterator i = m_fftModels.begin();
 i != m_fftModels.end(); ++i) {
-if (i->second.first != m_sliceableModel) {
+if (i->second != m_sliceableModel) {
-emit sliceableModelReplaced(m_sliceableModel, i->second.first);
+emit sliceableModelReplaced(m_sliceableModel, i->second);
 replaced = true;
 break;
 }
 }
 if (!replaced) emit sliceableModelReplaced(m_sliceableModel, 0);
 }
-delete m_fftModels[v].first;
+delete m_fftModels[view->getId()];
-m_fftModels.erase(v);
+m_fftModels.erase(view->getId());
-delete m_peakCaches[v];
+delete m_peakCaches[view->getId()];
-m_peakCaches.erase(v);
+m_peakCaches.erase(view->getId());
 }
 } else {
 Layer::setLayerDormant(v, false);
 void
 SpectrogramLayer::cacheInvalid()
 {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "SpectrogramLayer::cacheInvalid()" << endl;
+cerr << "SpectrogramLayer::cacheInvalid()" << endl;
 #endif
 invalidateImageCaches();
 invalidateMagnitudes();
 }
 void
-SpectrogramLayer::cacheInvalid(sv_frame_t from, sv_frame_t to)
+SpectrogramLayer::cacheInvalid(
-{
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+sv_frame_t from, sv_frame_t to
-SVDEBUG << "SpectrogramLayer::cacheInvalid(" << from << ", " << to << ")" << endl;
+#else
-#endif
+sv_frame_t     , sv_frame_t
+#endif
-invalidateImageCaches(from, to);
+)
+{
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "SpectrogramLayer::cacheInvalid(" << from << ", " << to << ")" << endl;
+#endif
+// We used to call invalidateMagnitudes(from, to) to invalidate
+// only those caches whose views contained some of the (from, to)
+// range. That's the right thing to do; it has been lost in
+// pulling out the image cache code, but it might not matter very
+// much, since the underlying models for spectrogram layers don't
+// change very often. Let's see.
+invalidateImageCaches();
 invalidateMagnitudes();
-}
-void
-SpectrogramLayer::fillTimerTimedOut()
-{
-if (!m_model) return;
-bool allDone = true;
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "SpectrogramLayer::fillTimerTimedOut: have " << m_fftModels.size() << " FFT models associated with views" << endl;
-#endif
-for (ViewFFTMap::iterator i = m_fftModels.begin();
-i != m_fftModels.end(); ++i) {
-const FFTModel *model = i->second.first;
-sv_frame_t lastFill = i->second.second;
-if (model) {
-sv_frame_t fill = model->getFillExtent();
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "SpectrogramLayer::fillTimerTimedOut: extent for " << model << ": " << fill << ", last " << lastFill << ", total " << m_model->getEndFrame() << endl;
-#endif
-if (fill >= lastFill) {
-if (fill >= m_model->getEndFrame() && lastFill > 0) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "complete!" << endl;
-#endif
-invalidateImageCaches();
-i->second.second = -1;
-emit modelChanged();
-} else if (fill > lastFill) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer: emitting modelChanged("
-<< lastFill << "," << fill << ")" << endl;
-#endif
-invalidateImageCaches(lastFill, fill);
-i->second.second = fill;
-emit modelChangedWithin(lastFill, fill);
-}
-} else {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer: going backwards, emitting modelChanged("
-<< m_model->getStartFrame() << "," << m_model->getEndFrame() << ")" << endl;
-#endif
-invalidateImageCaches();
-i->second.second = fill;
-emit modelChangedWithin(m_model->getStartFrame(), m_model->getEndFrame());
-}
-if (i->second.second >= 0) {
-allDone = false;
-}
-}
-}
-if (allDone) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer: all complete!" << endl;
-#endif
-delete m_updateTimer;
-m_updateTimer = 0;
-}
 }
 bool
 SpectrogramLayer::hasLightBackground() const
 {
 m_drawBuffer = QImage();
 }
 unsigned char
-SpectrogramLayer::getDisplayValue(View *v, double input) const
+SpectrogramLayer::getDisplayValue(LayerGeometryProvider *v, double input) const
 {
 int value;
 double min = 0.0;
 double max = 1.0;
-if (m_normalizeVisibleArea) {
+if (m_normalization == NormalizeVisibleArea) {
-min = m_viewMags[v].getMin();
+min = m_viewMags[v->getId()].getMin();
-max = m_viewMags[v].getMax();
+max = m_viewMags[v->getId()].getMax();
-} else if (!m_normalizeColumns) {
+} else if (m_normalization != NormalizeColumns) {
 if (m_colourScale == LinearColourScale //||
 //            m_colourScale == MeterColourScale) {
 ) {
 max = 0.1;
 }
 return maxf;
 }
 bool
-SpectrogramLayer::getYBinRange(View *v, int y, double &q0, double &q1) const
+SpectrogramLayer::getYBinRange(LayerGeometryProvider *v, int y, double &q0, double &q1) const
 {
 Profiler profiler("SpectrogramLayer::getYBinRange");
-int h = v->height();
+int h = v->getPaintHeight();
 if (y < 0 || y >= h) return false;
 sv_samplerate_t sr = m_model->getSampleRate();
 double minf = getEffectiveMinFrequency();
 double maxf = getEffectiveMaxFrequency();
 return true;
 }
 bool
-SpectrogramLayer::getSmoothedYBinRange(View *v, int y, double &q0, double &q1) const
+SpectrogramLayer::getSmoothedYBinRange(LayerGeometryProvider *v, int y, double &q0, double &q1) const
 {
 Profiler profiler("SpectrogramLayer::getSmoothedYBinRange");
-int h = v->height();
+int h = v->getPaintHeight();
 if (y < 0 || y >= h) return false;
 sv_samplerate_t sr = m_model->getSampleRate();
 double minf = getEffectiveMinFrequency();
 double maxf = getEffectiveMaxFrequency();
 return true;
 }
 bool
-SpectrogramLayer::getXBinRange(View *v, int x, double &s0, double &s1) const
+SpectrogramLayer::getXBinRange(LayerGeometryProvider *v, int x, double &s0, double &s1) const
 {
 sv_frame_t modelStart = m_model->getStartFrame();
 sv_frame_t modelEnd = m_model->getEndFrame();
 // Each pixel column covers an exact range of sample frames:
 return true;
 }
 bool
-SpectrogramLayer::getXBinSourceRange(View *v, int x, RealTime &min, RealTime &max) const
+SpectrogramLayer::getXBinSourceRange(LayerGeometryProvider *v, int x, RealTime &min, RealTime &max) const
 {
 double s0 = 0, s1 = 0;
 if (!getXBinRange(v, x, s0, s1)) return false;
 int s0i = int(s0 + 0.001);
 max = RealTime::frame2RealTime(w1, m_model->getSampleRate());
 return true;
 }
 bool
-SpectrogramLayer::getYBinSourceRange(View *v, int y, double &freqMin, double &freqMax)
+SpectrogramLayer::getYBinSourceRange(LayerGeometryProvider *v, int y, double &freqMin, double &freqMax)
 const
 {
 double q0 = 0, q1 = 0;
 if (!getYBinRange(v, y, q0, q1)) return false;
 }
 return true;
 }
 bool
-SpectrogramLayer::getAdjustedYBinSourceRange(View *v, int x, int y,
+SpectrogramLayer::getAdjustedYBinSourceRange(LayerGeometryProvider *v, int x, int y,
 					     double &freqMin, double &freqMax,
 					     double &adjFreqMin, double &adjFreqMax)
 const
 {
 if (!m_model || !m_model->isOK() || !m_model->isReady()) {
 		      m_binDisplay == PeakFrequencies);
 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;
 return haveAdj;
 }
 bool
-SpectrogramLayer::getXYBinSourceRange(View *v, int x, int y,
+SpectrogramLayer::getXYBinSourceRange(LayerGeometryProvider *v, int x, int y,
 				      double &min, double &max,
 				      double &phaseMin, double &phaseMax) const
 {
 if (!m_model || !m_model->isOK() || !m_model->isReady()) {
 	return false;
 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; }
 return rv;
 }
 int
-SpectrogramLayer::getZeroPadLevel(const View *v) const
+SpectrogramLayer::getZeroPadLevel(const LayerGeometryProvider *v) const
 {
 //!!! tidy all this stuff
 if (m_binDisplay != AllBins) return 0;
 	if (minbin < 1) minbin = 1;
 	if (minbin >= maxbin) minbin = maxbin - 1;
 }
 double perPixel =
-double(v->height()) /
+double(v->getPaintHeight()) /
 double((maxbin - minbin) / (m_zeroPadLevel + 1));
 if (perPixel > 2.8) {
 return 3; // 4x oversampling
 } else if (perPixel > 1.5) {
 return 0; // 1x
 }
 }
 int
-SpectrogramLayer::getFFTSize(const View *v) const
+SpectrogramLayer::getFFTSize(const LayerGeometryProvider *v) const
 {
 return m_fftSize * (getZeroPadLevel(v) + 1);
 }
 FFTModel *
-SpectrogramLayer::getFFTModel(const View *v) const
+SpectrogramLayer::getFFTModel(const LayerGeometryProvider *v) const
 {
 if (!m_model) return 0;
 int fftSize = getFFTSize(v);
-if (m_fftModels.find(v) != m_fftModels.end()) {
+const View *view = v->getView();
-if (m_fftModels[v].first == 0) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+if (m_fftModels.find(view->getId()) != m_fftModels.end()) {
-SVDEBUG << "SpectrogramLayer::getFFTModel(" << v << "): Found null model" << endl;
+if (m_fftModels[view->getId()] == 0) {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found null model" << endl;
 #endif
 return 0;
 }
-if (m_fftModels[v].first->getHeight() != fftSize / 2 + 1) {
+if (m_fftModels[view->getId()]->getHeight() != fftSize / 2 + 1) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "SpectrogramLayer::getFFTModel(" << v << "): Found a model with the wrong height (" << m_fftModels[v].first->getHeight() << ", wanted " << (fftSize / 2 + 1) << ")" << endl;
+cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found a model with the wrong height (" << m_fftModels[view->getId()]->getHeight() << ", wanted " << (fftSize / 2 + 1) << ")" << endl;
 #endif
-delete m_fftModels[v].first;
+delete m_fftModels[view->getId()];
-m_fftModels.erase(v);
+m_fftModels.erase(view->getId());
-delete m_peakCaches[v];
+delete m_peakCaches[view->getId()];
-m_peakCaches.erase(v);
+m_peakCaches.erase(view->getId());
 } else {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "SpectrogramLayer::getFFTModel(" << v << "): Found a good model of height " << m_fftModels[v].first->getHeight() << endl;
+cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found a good model of height " << m_fftModels[view->getId()]->getHeight() << endl;
 #endif
-return m_fftModels[v].first;
+return m_fftModels[view->getId()];
 }
 }
-if (m_fftModels.find(v) == m_fftModels.end()) {
+if (m_fftModels.find(view->getId()) == m_fftModels.end()) {
 FFTModel *model = new FFTModel(m_model,
 m_channel,
 m_windowType,
 m_windowSize,
 QMessageBox::critical
 (0, tr("FFT cache failed"),
 tr("Failed to create the FFT model for this spectrogram.\n"
 "There may be insufficient memory or disc space to continue."));
 delete model;
-m_fftModels[v] = FFTFillPair(0, 0);
+m_fftModels[view->getId()] = 0;
 return 0;
 }
 if (!m_sliceableModel) {
 #ifdef DEBUG_SPECTROGRAM
 #endif
 ((SpectrogramLayer *)this)->sliceableModelReplaced(0, model);
 m_sliceableModel = model;
 }
-m_fftModels[v] = FFTFillPair(model, 0);
+m_fftModels[view->getId()] = model;
+}
-delete m_updateTimer;
-m_updateTimer = new QTimer((SpectrogramLayer *)this);
+return m_fftModels[view->getId()];
-connect(m_updateTimer, SIGNAL(timeout()),
-this, SLOT(fillTimerTimedOut()));
-m_updateTimer->start(200);
-}
-return m_fftModels[v].first;
 }
 Dense3DModelPeakCache *
-SpectrogramLayer::getPeakCache(const View *v) const
+SpectrogramLayer::getPeakCache(const LayerGeometryProvider *v) const
 {
-if (!m_peakCaches[v]) {
+const View *view = v->getView();
+if (!m_peakCaches[view->getId()]) {
 FFTModel *f = getFFTModel(v);
 if (!f) return 0;
-m_peakCaches[v] = new Dense3DModelPeakCache(f, 8);
+m_peakCaches[view->getId()] = new Dense3DModelPeakCache(f, 8);
 }
-return m_peakCaches[v];
+return m_peakCaches[view->getId()];
 }
 const Model *
 SpectrogramLayer::getSliceableModel() const
 {
 if (m_sliceableModel) return m_sliceableModel;
 if (m_fftModels.empty()) return 0;
-m_sliceableModel = m_fftModels.begin()->second.first;
+m_sliceableModel = m_fftModels.begin()->second;
 return m_sliceableModel;
 }
 void
 SpectrogramLayer::invalidateFFTModels()
 {
+#ifdef DEBUG_SPECTROGRAM
+cerr << "SpectrogramLayer::invalidateFFTModels called" << endl;
+#endif
 for (ViewFFTMap::iterator i = m_fftModels.begin();
 i != m_fftModels.end(); ++i) {
-delete i->second.first;
+delete i->second;
 }
 for (PeakCacheMap::iterator i = m_peakCaches.begin();
 i != m_peakCaches.end(); ++i) {
 delete i->second;
 }
 }
 void
 SpectrogramLayer::invalidateMagnitudes()
 {
+#ifdef DEBUG_SPECTROGRAM
+cerr << "SpectrogramLayer::invalidateMagnitudes called" << endl;
+#endif
 m_viewMags.clear();
-for (std::vector<MagnitudeRange>::iterator i = m_columnMags.begin();
+for (vector<MagnitudeRange>::iterator i = m_columnMags.begin();
 i != m_columnMags.end(); ++i) {
 *i = MagnitudeRange();
 }
 }
 bool
-SpectrogramLayer::updateViewMagnitudes(View *v) const
+SpectrogramLayer::updateViewMagnitudes(LayerGeometryProvider *v) const
 {
 MagnitudeRange mag;
-int x0 = 0, x1 = v->width();
+int x0 = 0, x1 = v->getPaintWidth();
 double s00 = 0, s01 = 0, s10 = 0, s11 = 0;
 if (!getXBinRange(v, x0, s00, s01)) {
 s00 = s01 = double(m_model->getStartFrame()) / getWindowIncrement();
 }
 if (!getXBinRange(v, x1, s10, s11)) {
 s10 = s11 = double(m_model->getEndFrame()) / getWindowIncrement();
 }
-int s0 = int(std::min(s00, s10) + 0.0001);
+int s0 = int(min(s00, s10) + 0.0001);
-int s1 = int(std::max(s01, s11) + 0.0001);
+int s1 = int(max(s01, s11) + 0.0001);
 //    SVDEBUG << "SpectrogramLayer::updateViewMagnitudes: x0 = " << x0 << ", x1 = " << x1 << ", s00 = " << s00 << ", s11 = " << s11 << " s0 = " << s0 << ", s1 = " << s1 << endl;
 if (int(m_columnMags.size()) <= s1) {
 m_columnMags.resize(s1 + 1);
 mag.sample(m_columnMags[s]);
 }
 }
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "SpectrogramLayer::updateViewMagnitudes returning from cols "
+cerr << "SpectrogramLayer::updateViewMagnitudes returning from cols "
 << s0 << " -> " << s1 << " inclusive" << endl;
+cerr << "SpectrogramLayer::updateViewMagnitudes: for view id " << v->getId()
+<< ": min is " << mag.getMin() << ", max is " << mag.getMax() << endl;
 #endif
 if (!mag.isSet()) return false;
-if (mag == m_viewMags[v]) return false;
+if (mag == m_viewMags[v->getId()]) return false;
-m_viewMags[v] = mag;
+m_viewMags[v->getId()] = mag;
 return true;
 }
 void
 SpectrogramLayer::setSynchronousPainting(bool synchronous)
 {
 m_synchronous = synchronous;
 }
+ScrollableImageCache &
+SpectrogramLayer::getImageCacheReference(const LayerGeometryProvider *view) const
+{
+if (m_imageCaches.find(view->getId()) == m_imageCaches.end()) {
+m_imageCaches[view->getId()] = ScrollableImageCache(view);
+}
+return m_imageCaches.at(view->getId());
+}
 void
-SpectrogramLayer::paint(View *v, QPainter &paint, QRect rect) const
+SpectrogramLayer::paint(LayerGeometryProvider *v, QPainter &paint, QRect rect) const
 {
-// What a lovely, old-fashioned function this is.
-// It's practically FORTRAN 77 in its clarity and linearity.
 Profiler profiler("SpectrogramLayer::paint", false);
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "SpectrogramLayer::paint(): m_model is " << m_model << ", zoom level is " << v->getZoomLevel() << ", m_updateTimer " << m_updateTimer << endl;
+cerr << "SpectrogramLayer::paint() entering: m_model is " << m_model << ", zoom level is " << v->getZoomLevel() << endl;
-cerr << "rect is " << rect.x() << "," << rect.y() << " " << rect.width() << "x" << rect.height() << endl;
+cerr << "SpectrogramLayer::paint(): rect is " << rect.x() << "," << rect.y() << " " << rect.width() << "x" << rect.height() << endl;
 #endif
 sv_frame_t startFrame = v->getStartFrame();
-if (startFrame < 0) m_candidateFillStartFrame = 0;
-else m_candidateFillStartFrame = startFrame;
 if (!m_model || !m_model->isOK() || !m_model->isReady()) {
 	return;
 }
 // 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);
+const View *view = v->getView();
-if (!fft) {
+ScrollableImageCache &cache = getImageCacheReference(view);
-	cerr << "ERROR: SpectrogramLayer::paint(): No FFT model, returning" << endl;
-	return;
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-}
+cerr << "SpectrogramLayer::paint(): image cache valid area from " << cache.getValidLeft() << " width " << cache.getValidWidth() << ", height " << cache.getSize().height() << endl;
-*/
+if (rect.x() + rect.width() + 1 < cache.getValidLeft() ||
-ImageCache &cache = m_imageCaches[v];
+rect.x() > cache.getValidRight()) {
+cerr << "SpectrogramLayer: NOTE: requested rect is not contiguous with cache valid area" << endl;
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+}
-SVDEBUG << "SpectrogramLayer::paint(): image cache valid area " << cache.
-validArea.x() << ", " << cache.validArea.y() << ", " << cache.validArea.width() << "x" << cache.validArea.height() << endl;
-#endif
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-bool stillCacheing = (m_updateTimer != 0);
-SVDEBUG << "SpectrogramLayer::paint(): Still cacheing = " << stillCacheing << endl;
 #endif
 int zoomLevel = v->getZoomLevel();
-int x0 = 0;
+int x0 = v->getXForViewX(rect.x());
-int x1 = v->width();
+int x1 = v->getXForViewX(rect.x() + rect.width());
+if (x0 < 0) x0 = 0;
-bool recreateWholeImageCache = true;
+if (x1 > v->getPaintWidth()) x1 = v->getPaintWidth();
-x0 = rect.left();
+if (updateViewMagnitudes(v)) {
-x1 = rect.right() + 1;
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-/*
+cerr << "SpectrogramLayer: magnitude range changed to [" << m_viewMags[v->getId()].getMin() << "->" << m_viewMags[v->getId()].getMax() << "]" << endl;
-double xPixelRatio = double(fft->getResolution()) / double(zoomLevel);
+#endif
-cerr << "xPixelRatio = " << xPixelRatio << endl;
+if (m_normalization == NormalizeVisibleArea) {
-if (xPixelRatio < 1.f) xPixelRatio = 1.f;
+cache.invalidate();
-*/
+}
-if (cache.validArea.width() > 0) {
+}
-int cw = cache.image.width();
+if (cache.getZoomLevel() != zoomLevel ||
-int ch = cache.image.height();
+cache.getSize() != v->getPaintSize()) {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "SpectrogramLayer: resizing image cache from "
+<< cache.getSize().width() << "x" << cache.getSize().height()
+<< " to "
+<< v->getPaintSize().width() << "x" << v->getPaintSize().height()
+<< " and updating zoom level from " << cache.getZoomLevel()
+<< " to " << zoomLevel
+<< endl;
+#endif
+cache.resize(v->getPaintSize());
+cache.setZoomLevel(zoomLevel);
+cache.setStartFrame(startFrame);
+}
+if (cache.isValid()) {
-	if (int(cache.zoomLevel) == zoomLevel &&
+if (v->getXForFrame(cache.getStartFrame()) ==
-	    cw == v->width() &&
+v->getXForFrame(startFrame) &&
-	    ch == v->height()) {
+cache.getValidLeft() <= x0 &&
+cache.getValidRight() >= x1) {
-	    if (v->getXForFrame(cache.startFrame) ==
-		v->getXForFrame(startFrame) &&
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-cache.validArea.x() <= x0 &&
+cerr << "SpectrogramLayer: image cache hit!" << endl;
-cache.validArea.x() + cache.validArea.width() >= x1) {
+#endif
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+paint.drawImage(rect, cache.getImage(), rect);
-		cerr << "SpectrogramLayer: image cache good" << endl;
-#endif
+illuminateLocalFeatures(v, paint);
+return;
-		paint.drawImage(rect, cache.image, rect);
-//!!!
+} else {
-//                paint.drawImage(v->rect(), cache.image,
-//                                QRect(QPoint(0, 0), cache.image.size()));
+// cache doesn't begin at the right frame or doesn't
+// contain the complete view, but might be scrollable or
-illuminateLocalFeatures(v, paint);
+// partially usable
-		return;
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-	    } else {
+cerr << "SpectrogramLayer: scrolling the image cache if applicable" << endl;
+#endif
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-		cerr << "SpectrogramLayer: image cache partially OK" << endl;
+cache.scrollTo(startFrame);
-#endif
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-		recreateWholeImageCache = false;
+cerr << "SpectrogramLayer: after scrolling, cache valid from "
+<< cache.getValidLeft() << " width " << cache.getValidWidth()
-		int dx = v->getXForFrame(cache.startFrame) -
+<< endl;
-		         v->getXForFrame(startFrame);
+#endif
+}
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+}
-		cerr << "SpectrogramLayer: dx = " << dx << " (image cache " << cw << "x" << ch << ")" << endl;
-#endif
+bool rightToLeft = false;
-		if (dx != 0 &&
+if (!cache.isValid()) {
-dx > -cw &&
+if (!m_synchronous) {
-dx <  cw) {
+// When rendering the whole thing, start from somewhere near
+// the middle so that the region of interest appears first
-int dxp = dx;
-if (dxp < 0) dxp = -dxp;
+//!!! (perhaps we should have some cunning test to avoid
-size_t copy = (cw - dxp) * sizeof(QRgb);
+//!!! doing this if past repaints have appeared fast
-for (int y = 0; y < ch; ++y) {
+//!!! enough to do the whole width in one shot)
-QRgb *line = (QRgb *)cache.image.scanLine(y);
+if (x0 == 0 && x1 == v->getPaintWidth()) {
-if (dx < 0) {
+x0 = int(x1 * 0.3);
-memmove(line, line + dxp, copy);
-} else {
-memmove(line + dxp, line, copy);
-}
-}
-int px = cache.validArea.x();
-int pw = cache.validArea.width();
-		    if (dx < 0) {
-			x0 = cw + dx;
-			x1 = cw;
-px += dx;
-if (px < 0) {
-pw += px;
-px = 0;
-if (pw < 0) pw = 0;
-}
-		    } else {
-			x0 = 0;
-			x1 = dx;
-px += dx;
-if (px + pw > cw) {
-pw = int(cw) - px;
-if (pw < 0) pw = 0;
-}
-		    }
-cache.validArea =
-QRect(px, cache.validArea.y(),
-pw, cache.validArea.height());
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-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
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "dx == " << dx << ": scrolled too far for cache to be useful" << endl;
-#endif
-cache.validArea = QRect();
-recreateWholeImageCache = true;
-}
-	    }
-	} else {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-	    cerr << "SpectrogramLayer: image cache useless" << endl;
-if (int(cache.zoomLevel) != zoomLevel) {
-cerr << "(cache zoomLevel " << cache.zoomLevel
-<< " != " << zoomLevel << ")" << endl;
 }
-if (cw != v->width()) {
-cerr << "(cache width " << cw
-<< " != " << v->width();
-}
-if (ch != v->height()) {
-cerr << "(cache height " << ch
-<< " != " << v->height();
-}
-#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_normalizeVisibleArea) {
-cache.validArea = QRect();
-recreateWholeImageCache = true;
 }
 } else {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+// When rendering only a part of the cache, we need to make
-cerr << "No change in magnitude range [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << endl;
+// sure that the part we're rendering is adjacent to (or
-#endif
+// overlapping) a valid area of cache, if we have one. The
-}
+// alternative is to ditch the valid area of cache and render
+// only the requested area, but that's risky because this can
-if (recreateWholeImageCache) {
+// happen when just waving the pointer over a small part of
-x0 = 0;
+// the view -- if we lose the partly-built cache every time
-x1 = v->width();
+// the user does that, we'll never finish building it.
-}
+int left = x0;
+int width = x1 - x0;
-struct timeval tv;
+bool isLeftOfValidArea = false;
-(void)gettimeofday(&tv, 0);
+cache.adjustToTouchValidArea(left, width, isLeftOfValidArea);
-RealTime mainPaintStart = RealTime::fromTimeval(tv);
+x0 = left;
+x1 = x0 + width;
-int paintBlockWidth = m_lastPaintBlockWidth;
+// That call also told us whether we should be painting
-if (m_synchronous) {
+// sub-regions of our target region in right-to-left order in
-if (paintBlockWidth < x1 - x0) {
+// order to ensure contiguity
-// always paint full width
+rightToLeft = isLeftOfValidArea;
-paintBlockWidth = x1 - x0;
+}
-}
-} else {
-if (paintBlockWidth == 0) {
-paintBlockWidth = (300000 / zoomLevel);
-} else {
-RealTime lastTime = m_lastPaintTime;
-while (lastTime > RealTime::fromMilliseconds(200) &&
-paintBlockWidth > 50) {
-paintBlockWidth /= 2;
-lastTime = lastTime / 2;
-}
-while (lastTime < RealTime::fromMilliseconds(90) &&
-paintBlockWidth < 1500) {
-paintBlockWidth *= 2;
-lastTime = lastTime * 2;
-}
-}
-if (paintBlockWidth < 20) paintBlockWidth = 20;
-}
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "[" << this << "]: last paint width: " << m_lastPaintBlockWidth << ", last paint time: " << m_lastPaintTime << ", new paint width: " << paintBlockWidth << endl;
-#endif
 // We always paint the full height when refreshing the cache.
 // Smaller heights can be used when painting direct from cache
 // (further up in this function), but we want to ensure the cache
 // is coherent without having to worry about vertical matching of
 // required and valid areas as well as horizontal.
+int h = v->getPaintHeight();
-int h = v->height();
+int repaintWidth = x1 - x0;
-if (cache.validArea.width() > 0) {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-// If part of the cache is known to be valid, select a strip
+cerr << "SpectrogramLayer: x0 " << x0 << ", x1 " << x1
-// immediately to left or right of the valid part
+<< ", repaintWidth " << repaintWidth << ", h " << h
+<< ", rightToLeft " << rightToLeft << endl;
-//!!! this really needs to be coordinated with the selection
-//!!! of m_drawBuffer boundaries in the bufferBinResolution
-//!!! case below
-int vx0 = 0, vx1 = 0;
-vx0 = cache.validArea.x();
-vx1 = cache.validArea.x() + cache.validArea.width();
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "x0 " << x0 << ", x1 " << x1 << ", vx0 " << vx0 << ", vx1 " << vx1 << ", paintBlockWidth " << paintBlockWidth << endl;
-#endif
-if (x0 < vx0) {
-if (x0 + paintBlockWidth < vx0) {
-x0 = vx0 - paintBlockWidth;
-}
-x1 = vx0;
-} else if (x0 >= vx1) {
-x0 = vx1;
-if (x1 > x0 + paintBlockWidth) {
-x1 = x0 + paintBlockWidth;
-}
-} else {
-// x0 is within the valid area
-if (x1 > vx1) {
-x0 = vx1;
-if (x0 + paintBlockWidth < x1) {
-x1 = x0 + paintBlockWidth;
-}
-} else {
-x1 = x0; // it's all valid, paint nothing
-}
-}
-cache.validArea = QRect
-(std::min(vx0, x0), cache.validArea.y(),
-std::max(vx1 - std::min(vx0, x0),
-x1 - std::min(vx0, x0)),
-cache.validArea.height());
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "Valid area becomes " << cache.validArea.x()
-<< ", " << cache.validArea.y() << ", "
-<< cache.validArea.width() << "x"
-<< cache.validArea.height() << endl;
-#endif
-} else {
-if (x1 > x0 + paintBlockWidth) {
-int sfx = x1;
-if (startFrame < 0) sfx = v->getXForFrame(0);
-if (sfx >= x0 && sfx + paintBlockWidth <= x1) {
-x0 = sfx;
-x1 = x0 + paintBlockWidth;
-} else {
-int mid = (x1 + x0) / 2;
-x0 = mid - paintBlockWidth/2;
-x1 = x0 + paintBlockWidth;
-}
-}
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "Valid area becomes " << x0 << ", 0, " << (x1-x0)
-<< "x" << h << endl;
-#endif
-cache.validArea = QRect(x0, 0, x1 - x0, h);
-}
-/*
-if (xPixelRatio != 1.f) {
-x0 = int((int(x0 / xPixelRatio) - 4) * xPixelRatio + 0.0001);
-x1 = int((int(x1 / xPixelRatio) + 4) * xPixelRatio + 0.0001);
-}
-*/
-int w = x1 - x0;
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "x0 " << x0 << ", x1 " << x1 << ", w " << w << ", h " << h << endl;
 #endif
 sv_samplerate_t sr = m_model->getSampleRate();
 // Set minFreq and maxFreq to the frequency extents of the possibly
 //    cerr << "(giving actual minFreq " << minFreq << " and display minFreq " << displayMinFreq << ")" << endl;
 int increment = getWindowIncrement();
 bool logarithmic = (m_frequencyScale == LogFrequencyScale);
-/*
-double yforbin[maxbin - minbin + 1];
+MagnitudeRange overallMag = m_viewMags[v->getId()];
-for (int q = minbin; q <= maxbin; ++q) {
-double f0 = (double(q) * sr) / fftSize;
-yforbin[q - minbin] =
-v->getYForFrequency(f0, displayMinFreq, displayMaxFreq,
-logarithmic);
-}
-*/
-MagnitudeRange overallMag = m_viewMags[v];
 bool overallMagChanged = false;
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << ((double(v->getFrameForX(1) - v->getFrameForX(0))) / increment) << " bin(s) per pixel" << endl;
+cerr << "SpectrogramLayer: " << ((double(v->getFrameForX(1) - v->getFrameForX(0))) / increment) << " bin(s) per pixel" << endl;
 #endif
-if (w == 0) {
+if (repaintWidth == 0) {
-SVDEBUG << "*** NOTE: w == 0" << endl;
+SVDEBUG << "*** NOTE: repaintWidth == 0" << endl;
 }
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-int pixels = 0;
-#endif
 Profiler outerprof("SpectrogramLayer::paint: all cols");
 // The draw buffer contains a fragment at either our pixel
 // resolution (if there is more than one time-bin per pixel) or
 // If (getFrameForX(x) / increment) * increment ==
 // getFrameForX(x), then x is a time-bin boundary.  We want two
 // such boundaries at either side of the draw buffer -- one which
 // we draw up to, and one which we subsequently crop at.
-bool bufferBinResolution = false;
+bool bufferIsBinResolution = false;
-if (increment > zoomLevel) bufferBinResolution = true;
+if (increment > zoomLevel) bufferIsBinResolution = true;
 sv_frame_t leftBoundaryFrame = -1, leftCropFrame = -1;
 sv_frame_t rightBoundaryFrame = -1, rightCropFrame = -1;
 int bufwid;
-if (bufferBinResolution) {
+if (bufferIsBinResolution) {
 for (int x = x0; ; --x) {
 sv_frame_t f = v->getFrameForX(x);
 if ((f / increment) * increment == f) {
 if (leftCropFrame == -1) leftCropFrame = f;
-else if (x < x0 - 2) { leftBoundaryFrame = f; break; }
+else if (x < x0 - 2) {
+leftBoundaryFrame = f;
+break;
+}
 }
 }
-for (int x = x0 + w; ; ++x) {
+for (int x = x0 + repaintWidth; ; ++x) {
 sv_frame_t f = v->getFrameForX(x);
 if ((f / increment) * increment == f) {
 if (rightCropFrame == -1) rightCropFrame = f;
-else if (x > x0 + w + 2) { rightBoundaryFrame = f; break; }
+else if (x > x0 + repaintWidth + 2) {
+rightBoundaryFrame = f;
+break;
+}
 }
 }
 #ifdef DEBUG_SPECTROGRAM_REPAINT
 cerr << "Left: crop: " << leftCropFrame << " (bin " << leftCropFrame/increment << "); boundary: " << leftBoundaryFrame << " (bin " << leftBoundaryFrame/increment << ")" << endl;
 cerr << "Right: crop: " << rightCropFrame << " (bin " << rightCropFrame/increment << "); boundary: " << rightBoundaryFrame << " (bin " << rightBoundaryFrame/increment << ")" << endl;
 bufwid = int((rightBoundaryFrame - leftBoundaryFrame) / increment);
 } else {
-bufwid = w;
+bufwid = repaintWidth;
 }
 vector<int> binforx(bufwid);
 vector<double> binfory(h);
 bool usePeaksCache = false;
-if (bufferBinResolution) {
+if (bufferIsBinResolution) {
 for (int x = 0; x < bufwid; ++x) {
 binforx[x] = int(leftBoundaryFrame / increment) + x;
-//            cerr << "binforx[" << x << "] = " << binforx[x] << endl;
 }
 m_drawBuffer = QImage(bufwid, h, QImage::Format_Indexed8);
 } else {
 for (int x = 0; x < bufwid; ++x) {
 double s0 = 0, s1 = 0;
 binforx[x] = int(s0 + 0.0001);
 } else {
 binforx[x] = -1; //???
 }
 }
-if (m_drawBuffer.width() < bufwid || m_drawBuffer.height() < h) {
+if (m_drawBuffer.width() < bufwid || m_drawBuffer.height() != h) {
 m_drawBuffer = QImage(bufwid, h, QImage::Format_Indexed8);
 }
 usePeaksCache = (increment * 8) < zoomLevel;
 if (m_colourScale == PhaseColourScale) usePeaksCache = false;
 }
-// No longer exists in Qt5:    m_drawBuffer.setNumColors(256);
 for (int pixel = 0; pixel < 256; ++pixel) {
 m_drawBuffer.setColor((unsigned char)pixel,
 m_palette.getColour((unsigned char)pixel).rgb());
 }
 m_drawBuffer.fill(0);
+int attainedBufwid = bufwid;
+double softTimeLimit;
+if (m_synchronous) {
+// must paint the whole thing for synchronous mode, so give
+// "no timeout"
+softTimeLimit = 0.0;
+} else if (bufferIsBinResolution) {
+// calculating boundaries later will be too fiddly for partial
+// paints, and painting should be fast anyway when this is the
+// case because it means we're well zoomed in
+softTimeLimit = 0.0;
+} else {
+// neither limitation applies, so use a short soft limit
+if (m_binDisplay == PeakFrequencies) {
+softTimeLimit = 0.15;
+} else {
+softTimeLimit = 0.1;
+}
+}
 if (m_binDisplay != PeakFrequencies) {
 for (int y = 0; y < h; ++y) {
 double q0 = 0, q1 = 0;
 if (!getSmoothedYBinRange(v, h-y-1, q0, q1)) {
 binfory[y] = -1;
 } else {
 binfory[y] = q0;
-//                cerr << "binfory[" << y << "] = " << binfory[y] << endl;
 }
 }
-paintDrawBuffer(v, bufwid, h, binforx, binfory, usePeaksCache,
+attainedBufwid =
-overallMag, overallMagChanged);
+paintDrawBuffer(v, bufwid, h, binforx, binfory,
+usePeaksCache,
+overallMag, overallMagChanged,
+rightToLeft,
+softTimeLimit);
 } else {
-paintDrawBufferPeakFrequencies(v, bufwid, h, binforx,
+attainedBufwid =
-minbin, maxbin,
+paintDrawBufferPeakFrequencies(v, bufwid, h, binforx,
-displayMinFreq, displayMaxFreq,
+minbin, maxbin,
-logarithmic,
+displayMinFreq, displayMaxFreq,
-overallMag, overallMagChanged);
+logarithmic,
-}
+overallMag, overallMagChanged,
+rightToLeft,
-/*
+softTimeLimit);
-for (int x = 0; x < w / xPixelRatio; ++x) {
+}
-Profiler innerprof("SpectrogramLayer::paint: 1 pixel column");
+int failedToRepaint = bufwid - attainedBufwid;
-runOutOfData = !paintColumnValues(v, fft, x0, x,
+int paintedLeft = x0;
-minbin, maxbin,
+int paintedWidth = x1 - x0;
-displayMinFreq, displayMaxFreq,
-xPixelRatio,
+if (failedToRepaint > 0) {
-h, yforbin);
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-if (runOutOfData) {
+cerr << "SpectrogramLayer::paint(): Failed to repaint " << failedToRepaint << " of " << bufwid
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+<< " columns in time (so managed to repaint " << bufwid - failedToRepaint << ")" << endl;
-cerr << "Run out of data -- dropping out of loop" << endl;
+#endif
-#endif
-break;
+if (rightToLeft) {
-}
+paintedLeft += failedToRepaint;
 }
-*/
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+paintedWidth -= failedToRepaint;
-//    cerr << pixels << " pixels drawn" << endl;
-#endif
+if (paintedWidth < 0) {
+paintedWidth = 0;
+}
+} else if (failedToRepaint < 0) {
+cerr << "WARNING: failedToRepaint < 0 (= " << failedToRepaint << ")"
+<< endl;
+failedToRepaint = 0;
+}
 if (overallMagChanged) {
-m_viewMags[v] = overallMag;
+m_viewMags[v->getId()] = overallMag;
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "Overall mag is now [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "] - will be updating" << endl;
+cerr << "SpectrogramLayer: Overall mag is now [" << m_viewMags[v->getId()].getMin() << "->" << m_viewMags[v->getId()].getMax() << "] - will be updating" << endl;
-#endif
-} else {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "Overall mag unchanged at [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << endl;
 #endif
 }
 outerprof.end();
 Profiler profiler2("SpectrogramLayer::paint: draw image");
-if (recreateWholeImageCache) {
+if (paintedWidth > 0) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "Recreating image cache: width = " << v->width()
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-<< ", height = " << h << endl;
+cerr << "SpectrogramLayer: Copying " << paintedWidth << "x" << h
-#endif
+<< " from draw buffer at " << paintedLeft - x0 << "," << 0
-	cache.image = QImage(v->width(), h, QImage::Format_ARGB32_Premultiplied);
+<< " to " << paintedWidth << "x" << h << " on cache at "
-}
-if (w > 0) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "Painting " << w << "x" << h
-<< " from draw buffer at " << 0 << "," << 0
-<< " to " << w << "x" << h << " on cache at "
 << x0 << "," << 0 << endl;
 #endif
-QPainter cachePainter(&cache.image);
+if (bufferIsBinResolution) {
-if (bufferBinResolution) {
 int scaledLeft = v->getXForFrame(leftBoundaryFrame);
 int scaledRight = v->getXForFrame(rightBoundaryFrame);
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "Rescaling image from " << bufwid
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "SpectrogramLayer: Rescaling image from " << bufwid
 << "x" << h << " to "
 << scaledRight-scaledLeft << "x" << h << endl;
 #endif
 Preferences::SpectrogramXSmoothing xsmoothing =
 Preferences::getInstance()->getSpectrogramXSmoothing();
-//            SVDEBUG << "xsmoothing == " << xsmoothing << endl;
 QImage scaled = m_drawBuffer.scaled
 (scaledRight - scaledLeft, h,
 Qt::IgnoreAspectRatio,
 ((xsmoothing == Preferences::SpectrogramXInterpolated) ?
 Qt::SmoothTransformation : Qt::FastTransformation));
 int scaledLeftCrop = v->getXForFrame(leftCropFrame);
 int scaledRightCrop = v->getXForFrame(rightCropFrame);
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "Drawing image region of width " << scaledRightCrop - scaledLeftCrop << " to "
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "SpectrogramLayer: Drawing image region of width " << scaledRightCrop - scaledLeftCrop << " to "
 << scaledLeftCrop << " from " << scaledLeftCrop - scaledLeft << endl;
 #endif
-cachePainter.drawImage
-(QRect(scaledLeftCrop, 0,
+int targetLeft = scaledLeftCrop;
-scaledRightCrop - scaledLeftCrop, h),
+if (targetLeft < 0) {
-scaled,
+targetLeft = 0;
-QRect(scaledLeftCrop - scaledLeft, 0,
+}
-scaledRightCrop - scaledLeftCrop, h));
+int targetWidth = scaledRightCrop - targetLeft;
+if (targetLeft + targetWidth > cache.getSize().width()) {
+targetWidth = cache.getSize().width() - targetLeft;
+}
+int sourceLeft = targetLeft - scaledLeft;
+if (sourceLeft < 0) {
+sourceLeft = 0;
+}
+int sourceWidth = targetWidth;
+if (targetWidth > 0) {
+cache.drawImage
+(targetLeft,
+targetWidth,
+scaled,
+sourceLeft,
+sourceWidth);
+}
 } else {
-cachePainter.drawImage(QRect(x0, 0, w, h),
-m_drawBuffer,
+cache.drawImage(paintedLeft, paintedWidth,
-QRect(0, 0, w, h));
+m_drawBuffer,
-}
+paintedLeft - x0, paintedWidth);
+}
-cachePainter.end();
+}
-}
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-QRect pr = rect & cache.validArea;
+cerr << "SpectrogramLayer: Cache valid area now from " << cache.getValidLeft()
+<< " width " << cache.getValidWidth() << ", height "
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+<< cache.getSize().height() << endl;
-SVDEBUG << "Painting " << pr.width() << "x" << pr.height()
+#endif
+QRect pr = rect & cache.getValidArea();
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "SpectrogramLayer: Copying " << pr.width() << "x" << pr.height()
 << " from cache at " << pr.x() << "," << pr.y()
 << " to window" << endl;
 #endif
-paint.drawImage(pr.x(), pr.y(), cache.image,
+paint.drawImage(pr.x(), pr.y(), cache.getImage(),
 pr.x(), pr.y(), pr.width(), pr.height());
-//!!!
-//    paint.drawImage(v->rect(), cache.image,
-//                    QRect(QPoint(0, 0), cache.image.size()));
-cache.startFrame = startFrame;
-cache.zoomLevel = zoomLevel;
 if (!m_synchronous) {
-if (!m_normalizeVisibleArea || !overallMagChanged) {
+if ((m_normalization != NormalizeVisibleArea) || !overallMagChanged) {
-if (cache.validArea.x() > 0) {
+QRect areaLeft(0, 0, cache.getValidLeft(), h);
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+QRect areaRight(cache.getValidRight(), 0,
-SVDEBUG << "SpectrogramLayer::paint() updating left (0, "
+cache.getSize().width() - cache.getValidRight(), h);
-<< cache.validArea.x() << ")" << endl;
-#endif
+bool haveSpaceLeft = (areaLeft.width() > 0);
-v->update(0, 0, cache.validArea.x(), h);
+bool haveSpaceRight = (areaRight.width() > 0);
+bool updateLeft = haveSpaceLeft;
+bool updateRight = haveSpaceRight;
+if (updateLeft && updateRight) {
+if (rightToLeft) {
+// we just did something adjoining the cache on
+// its left side, so now do something on its right
+updateLeft = false;
+} else {
+updateRight = false;
+}
 }
-if (cache.validArea.x() + cache.validArea.width() <
+if (updateLeft) {
-cache.image.width()) {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "SpectrogramLayer::paint() updating left ("
-SVDEBUG << "SpectrogramLayer::paint() updating right ("
+<< areaLeft.x() << ", "
-<< cache.validArea.x() + cache.validArea.width()
+<< areaLeft.width() << ")" << endl;
-<< ", "
+#endif
-<< cache.image.width() - (cache.validArea.x() +
+v->updatePaintRect(areaLeft);
-cache.validArea.width())
-<< ")" << endl;
-#endif
-v->update(cache.validArea.x() + cache.validArea.width(),
-0,
-cache.image.width() - (cache.validArea.x() +
-cache.validArea.width()),
-h);
 }
+if (updateRight) {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "SpectrogramLayer::paint() updating right ("
+<< areaRight.x() << ", "
+<< areaRight.width() << ")" << endl;
+#endif
+v->updatePaintRect(areaRight);
+}
 } else {
 // overallMagChanged
 cerr << "\noverallMagChanged - updating all\n" << endl;
-cache.validArea = QRect();
+cache.invalidate();
-v->update();
+v->updatePaintRect(v->getPaintRect());
 }
 }
 illuminateLocalFeatures(v, paint);
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "SpectrogramLayer::paint() returning" << endl;
+cerr << "SpectrogramLayer::paint() returning" << endl;
 #endif
+}
-if (!m_synchronous) {
-m_lastPaintBlockWidth = paintBlockWidth;
+int
-(void)gettimeofday(&tv, 0);
+SpectrogramLayer::paintDrawBufferPeakFrequencies(LayerGeometryProvider *v,
-m_lastPaintTime = RealTime::fromTimeval(tv) - mainPaintStart;
-}
-}
-bool
-SpectrogramLayer::paintDrawBufferPeakFrequencies(View *v,
 int w,
 int h,
 const vector<int> &binforx,
 int minbin,
 int maxbin,
 double displayMinFreq,
 double displayMaxFreq,
 bool logarithmic,
 MagnitudeRange &overallMag,
-bool &overallMagChanged) const
+bool &overallMagChanged,
+bool rightToLeft,
+double softTimeLimit) const
 {
 Profiler profiler("SpectrogramLayer::paintDrawBufferPeakFrequencies");
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "minbin " << minbin << ", maxbin " << maxbin << "; w " << w << ", h " << h << endl;
+cerr << "SpectrogramLayer::paintDrawBufferPeakFrequencies: minbin " << minbin << ", maxbin " << maxbin << "; w " << w << ", h " << h << endl;
 #endif
 if (minbin < 0) minbin = 0;
 if (maxbin < 0) maxbin = minbin+1;
 FFTModel *fft = getFFTModel(v);
-if (!fft) return false;
+if (!fft) return 0;
 FFTModel::PeakSet peakfreqs;
 int psx = -1;
 float values[maxbin - minbin + 1];
 #else
 float *values = (float *)alloca((maxbin - minbin + 1) * sizeof(float));
 #endif
-for (int x = 0; x < w; ++x) {
+int minColumns = 4;
+bool haveTimeLimits = (softTimeLimit > 0.0);
+double hardTimeLimit = softTimeLimit * 2.0;
+bool overridingSoftLimit = false;
+auto startTime = chrono::steady_clock::now();
+int start = 0;
+int finish = w;
+int step = 1;
+if (rightToLeft) {
+start = w-1;
+finish = -1;
+step = -1;
+}
+int columnCount = 0;
+for (int x = start; x != finish; x += step) {
+++columnCount;
 if (binforx[x] < 0) continue;
 int sx0 = binforx[x];
 int sx1 = sx0;
 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,
 minbin, maxbin - 1);
 if (m_colourScale == PhaseColourScale) {
 fft->getPhasesAt(sx, values, minbin, maxbin - minbin + 1);
-} else if (m_normalizeColumns) {
+} else if (m_normalization == NormalizeColumns) {
 fft->getNormalizedMagnitudesAt(sx, values, minbin, maxbin - minbin + 1);
-} else if (m_normalizeHybrid) {
+} else if (m_normalization == NormalizeHybrid) {
-fft->getNormalizedMagnitudesAt(sx, values, minbin, maxbin - minbin + 1);
+float max = fft->getNormalizedMagnitudesAt(sx, values, minbin, maxbin - minbin + 1);
-double max = fft->getMaximumMagnitudeAt(sx);
 if (max > 0.f) {
 for (int i = minbin; i <= maxbin; ++i) {
-values[i - minbin] = float(values[i - minbin] * log10(max));
+values[i - minbin] = float(values[i - minbin] *
+log10f(max));
 }
 }
 } else {
 fft->getMagnitudesAt(sx, values, minbin, maxbin - minbin + 1);
 }
 if (bin > maxbin) break;
 double value = values[bin - minbin];
 if (m_colourScale != PhaseColourScale) {
-if (!m_normalizeColumns && !m_normalizeHybrid) {
+if (m_normalization != NormalizeColumns) {
 value /= (m_fftSize/2.0);
 }
 mag.sample(float(value));
 value *= m_gain;
 }
 m_columnMags[sx].sample(mag);
 if (overallMag.sample(mag)) overallMagChanged = true;
 }
 }
 }
-}
+if (haveTimeLimits) {
-return true;
+if (columnCount >= minColumns) {
-}
+auto t = chrono::steady_clock::now();
+double diff = chrono::duration<double>(t - startTime).count();
-bool
+if (diff > hardTimeLimit) {
-SpectrogramLayer::paintDrawBuffer(View *v,
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "SpectrogramLayer::paintDrawBufferPeakFrequencies: hard limit " << hardTimeLimit << " sec exceeded after "
+<< columnCount << " columns with time " << diff << endl;
+#endif
+return columnCount;
+} else if (diff > softTimeLimit && !overridingSoftLimit) {
+// If we're more than half way through by the time
+// we reach the soft limit, ignore it (though
+// still respect the hard limit, above). Otherwise
+// respect the soft limit and return now.
+if (columnCount > w/2) {
+overridingSoftLimit = true;
+} else {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "SpectrogramLayer::paintDrawBufferPeakFrequencies: soft limit " << softTimeLimit << " sec exceeded after "
+<< columnCount << " columns with time " << diff << endl;
+#endif
+return columnCount;
+}
+}
+}
+}
+}
+return columnCount;
+}
+int
+SpectrogramLayer::paintDrawBuffer(LayerGeometryProvider *v,
 int w,
 int h,
 const vector<int> &binforx,
 const vector<double> &binfory,
 bool usePeaksCache,
 MagnitudeRange &overallMag,
-bool &overallMagChanged) const
+bool &overallMagChanged,
+bool rightToLeft,
+double softTimeLimit) const
 {
 Profiler profiler("SpectrogramLayer::paintDrawBuffer");
 int minbin = int(binfory[0] + 0.0001);
 int maxbin = int(binfory[h-1]);
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "minbin " << minbin << ", maxbin " << maxbin << "; w " << w << ", h " << h << endl;
+cerr << "SpectrogramLayer::paintDrawBuffer: minbin " << minbin << ", maxbin " << maxbin << "; w " << w << ", h " << h << endl;
 #endif
 if (minbin < 0) minbin = 0;
 if (maxbin < 0) maxbin = minbin+1;
 DenseThreeDimensionalModel *sourceModel = 0;
 FFTModel *fft = 0;
 int divisor = 1;
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "Note: bin display = " << m_binDisplay << ", w = " << w << ", binforx[" << w-1 << "] = " << binforx[w-1] << ", binforx[0] = " << binforx[0] << endl;
+cerr << "SpectrogramLayer::paintDrawBuffer: Note: bin display = " << m_binDisplay << ", w = " << w << ", binforx[" << w-1 << "] = " << binforx[w-1] << ", binforx[0] = " << binforx[0] << endl;
 #endif
 if (usePeaksCache) { //!!!
 sourceModel = getPeakCache(v);
 divisor = 8;//!!!
 minbin = 0;
 maxbin = sourceModel->getHeight();
 } else {
 sourceModel = fft = getFFTModel(v);
 }
-if (!sourceModel) return false;
+if (!sourceModel) return 0;
 bool interpolate = false;
 Preferences::SpectrogramSmoothing smoothing =
 Preferences::getInstance()->getSpectrogramSmoothing();
 if (smoothing == Preferences::SpectrogramInterpolated ||
 #endif
 const float *values = autoarray;
 DenseThreeDimensionalModel::Column c;
-for (int x = 0; x < w; ++x) {
+int minColumns = 4;
+bool haveTimeLimits = (softTimeLimit > 0.0);
+double hardTimeLimit = softTimeLimit * 2.0;
+bool overridingSoftLimit = false;
+auto startTime = chrono::steady_clock::now();
+int start = 0;
+int finish = w;
+int step = 1;
+if (rightToLeft) {
+start = w-1;
+finish = -1;
+step = -1;
+}
+int columnCount = 0;
+for (int x = start; x != finish; x += step) {
+++columnCount;
 if (binforx[x] < 0) continue;
 //        float columnGain = m_gain;
 float columnMax = 0.f;
 //            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) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "Retrieving column " << sx << " from fft directly" << endl;
+//                    cerr << "Retrieving column " << sx << " from fft directly" << endl;
 #endif
 if (m_colourScale == PhaseColourScale) {
 fft->getPhasesAt(sx, autoarray, minbin, maxbin - minbin + 1);
-} else if (m_normalizeColumns) {
+} else if (m_normalization == NormalizeColumns) {
 fft->getNormalizedMagnitudesAt(sx, autoarray, minbin, maxbin - minbin + 1);
-} else if (m_normalizeHybrid) {
+} else if (m_normalization == NormalizeHybrid) {
-fft->getNormalizedMagnitudesAt(sx, autoarray, minbin, maxbin - minbin + 1);
+float max = fft->getNormalizedMagnitudesAt(sx, autoarray, minbin, maxbin - minbin + 1);
-double max = fft->getMaximumMagnitudeAt(sx);
+float scale = log10f(max + 1.f);
+//                        cout << "sx = " << sx << ", max = " << max << ", log10(max) = " << log10(max) << ", scale = " << scale << endl;
 for (int i = minbin; i <= maxbin; ++i) {
-if (max > 0.0) {
+autoarray[i - minbin] *= scale;
-autoarray[i - minbin] = float(autoarray[i - minbin] * log10(max));
-}
 }
 } else {
 fft->getMagnitudesAt(sx, autoarray, minbin, maxbin - minbin + 1);
 }
 } else {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-SVDEBUG << "Retrieving column " << sx << " from peaks cache" << endl;
+//                    cerr << "Retrieving column " << sx << " from peaks cache" << endl;
 #endif
 c = sourceModel->getColumn(sx);
-if (m_normalizeColumns || m_normalizeHybrid) {
+if (m_normalization == NormalizeColumns ||
+m_normalization == NormalizeHybrid) {
 for (int y = 0; y < h; ++y) {
 if (c[y] > columnMax) columnMax = c[y];
 }
 }
-values = c.constData() + minbin;
+values = c.data() + minbin;
 }
 psx = sx;
 }
 for (int y = 0; y < h; ++y) {
 }
 if (v0 == 0.0 && v1 == 0.0) continue;
 value = prop * v0 + (1.0 - prop) * v1;
 if (m_colourScale != PhaseColourScale) {
-if (!m_normalizeColumns) {
+if (m_normalization != NormalizeColumns &&
+m_normalization != NormalizeHybrid) {
 value /= (m_fftSize/2.0);
 }
 mag.sample(float(value));
 value *= m_gain;
 }
 value < values[bin-minbin-1] ||
 value < values[bin-minbin+1]) continue;
 }
 if (m_colourScale != PhaseColourScale) {
-if (!m_normalizeColumns) {
+if (m_normalization != NormalizeColumns &&
+m_normalization != NormalizeHybrid) {
 value /= (m_fftSize/2.0);
 }
 mag.sample(float(value));
 value *= m_gain;
 }
 for (int y = 0; y < h; ++y) {
 double peak = peaks[y];
 if (m_colourScale != PhaseColourScale &&
-(m_normalizeColumns || m_normalizeHybrid) &&
+(m_normalization == NormalizeColumns ||
+m_normalization == NormalizeHybrid) &&
 columnMax > 0.f) {
 peak /= columnMax;
-if (m_normalizeHybrid) {
+if (m_normalization == NormalizeHybrid) {
-peak *= log10(columnMax);
+peak *= log10(columnMax + 1.f);
 }
 }
 unsigned char peakpix = getDisplayValue(v, peak);
 m_drawBuffer.setPixel(x, h-y-1, peakpix);
 }
-}
+if (haveTimeLimits) {
-return true;
+if (columnCount >= minColumns) {
+auto t = chrono::steady_clock::now();
+double diff = chrono::duration<double>(t - startTime).count();
+if (diff > hardTimeLimit) {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "SpectrogramLayer::paintDrawBuffer: hard limit " << hardTimeLimit << " sec exceeded after "
+<< columnCount << " columns with time " << diff << endl;
+#endif
+return columnCount;
+} else if (diff > softTimeLimit && !overridingSoftLimit) {
+// If we're more than half way through by the time
+// we reach the soft limit, ignore it (though
+// still respect the hard limit, above). Otherwise
+// respect the soft limit and return now.
+if (columnCount > w/2) {
+overridingSoftLimit = true;
+} else {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "SpectrogramLayer::paintDrawBuffer: soft limit " << softTimeLimit << " sec exceeded after "
+<< columnCount << " columns with time " << diff << endl;
+#endif
+return columnCount;
+}
+}
+}
+}
+}
+return columnCount;
 }
 void
-SpectrogramLayer::illuminateLocalFeatures(View *v, QPainter &paint) const
+SpectrogramLayer::illuminateLocalFeatures(LayerGeometryProvider *v, QPainter &paint) const
 {
 Profiler profiler("SpectrogramLayer::illuminateLocalFeatures");
 QPoint localPos;
 if (!v->shouldIlluminateLocalFeatures(this, localPos) || !m_model) {
 paint.drawRect(x0, y1, x1 - x0 + 1, y0 - y1 + 1);
 }
 }
 double
-SpectrogramLayer::getYForFrequency(const View *v, double frequency) const
+SpectrogramLayer::getYForFrequency(const LayerGeometryProvider *v, double frequency) const
 {
 return v->getYForFrequency(frequency,
 			       getEffectiveMinFrequency(),
 			       getEffectiveMaxFrequency(),
 			       m_frequencyScale == LogFrequencyScale);
 }
 double
-SpectrogramLayer::getFrequencyForY(const View *v, int y) const
+SpectrogramLayer::getFrequencyForY(const LayerGeometryProvider *v, int y) const
 {
 return v->getFrequencyForY(y,
 			       getEffectiveMinFrequency(),
 			       getEffectiveMaxFrequency(),
 			       m_frequencyScale == LogFrequencyScale);
 }
 int
-SpectrogramLayer::getCompletion(View *v) const
+SpectrogramLayer::getCompletion(LayerGeometryProvider *v) const
 {
-if (m_updateTimer == 0) return 100;
+const View *view = v->getView();
-if (m_fftModels.find(v) == m_fftModels.end()) return 100;
+if (m_fftModels.find(view->getId()) == m_fftModels.end()) return 100;
-int completion = m_fftModels[v].first->getCompletion();
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+int completion = m_fftModels[view->getId()]->getCompletion();
-SVDEBUG << "SpectrogramLayer::getCompletion: completion = " << completion << endl;
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "SpectrogramLayer::getCompletion: completion = " << completion << endl;
 #endif
 return completion;
 }
 QString
-SpectrogramLayer::getError(View *v) const
+SpectrogramLayer::getError(LayerGeometryProvider *v) const
 {
-if (m_fftModels.find(v) == m_fftModels.end()) return "";
+const View *view = v->getView();
-return m_fftModels[v].first->getError();
+if (m_fftModels.find(view->getId()) == m_fftModels.end()) return "";
+return m_fftModels[view->getId()]->getError();
 }
 bool
 SpectrogramLayer::getValueExtents(double &min, double &max,
 bool &logarithmic, QString &unit) const
 return true;
 }
 bool
-SpectrogramLayer::getYScaleValue(const View *v, int y,
+SpectrogramLayer::getYScaleValue(const LayerGeometryProvider *v, int y,
 double &value, QString &unit) const
 {
 value = getFrequencyForY(v, y);
 unit = "Hz";
 return true;
 }
 bool
-SpectrogramLayer::snapToFeatureFrame(View *,
+SpectrogramLayer::snapToFeatureFrame(LayerGeometryProvider *,
 sv_frame_t &frame,
 				     int &resolution,
 				     SnapType snap) const
 {
 resolution = getWindowIncrement();
 return true;
 }
 void
-SpectrogramLayer::measureDoubleClick(View *v, QMouseEvent *e)
+SpectrogramLayer::measureDoubleClick(LayerGeometryProvider *v, QMouseEvent *e)
 {
-ImageCache &cache = m_imageCaches[v];
+const View *view = v->getView();
+ScrollableImageCache &cache = getImageCacheReference(view);
-cerr << "cache width: " << cache.image.width() << ", height: "
-<< cache.image.height() << endl;
+cerr << "cache width: " << cache.getSize().width() << ", height: "
+<< cache.getSize().height() << endl;
-QImage image = cache.image;
+QImage image = cache.getImage();
 ImageRegionFinder finder;
 QRect rect = finder.findRegionExtents(&image, e->pos());
 if (rect.isValid()) {
 MeasureRect mr;
 (new AddMeasurementRectCommand(this, mr));
 }
 }
 bool
-SpectrogramLayer::getCrosshairExtents(View *v, QPainter &paint,
+SpectrogramLayer::getCrosshairExtents(LayerGeometryProvider *v, QPainter &paint,
 QPoint cursorPos,
-std::vector<QRect> &extents) const
+vector<QRect> &extents) const
 {
-QRect vertical(cursorPos.x() - 12, 0, 12, v->height());
+QRect vertical(cursorPos.x() - 12, 0, 12, v->getPaintHeight());
 extents.push_back(vertical);
 QRect horizontal(0, cursorPos.y(), cursorPos.x(), 1);
 extents.push_back(horizontal);
 paint.fontMetrics().width("C#10+50c") + 2,
 paint.fontMetrics().height());
 extents.push_back(pitch);
 QRect rt(cursorPos.x(),
-v->height() - paint.fontMetrics().height() - 2,
+v->getPaintHeight() - paint.fontMetrics().height() - 2,
 paint.fontMetrics().width("1234.567 s"),
 paint.fontMetrics().height());
 extents.push_back(rt);
 int w(paint.fontMetrics().width("1234567890") + 2);
 QRect frame(cursorPos.x() - w - 2,
-v->height() - paint.fontMetrics().height() - 2,
+v->getPaintHeight() - paint.fontMetrics().height() - 2,
 w,
 paint.fontMetrics().height());
 extents.push_back(frame);
 return true;
 }
 void
-SpectrogramLayer::paintCrosshairs(View *v, QPainter &paint,
+SpectrogramLayer::paintCrosshairs(LayerGeometryProvider *v, QPainter &paint,
 QPoint cursorPos) const
 {
 paint.save();
 int sw = getVerticalScaleWidth(v, m_haveDetailedScale, paint);
 paint.setFont(fn);
 }
 paint.setPen(m_crosshairColour);
 paint.drawLine(0, cursorPos.y(), cursorPos.x() - 1, cursorPos.y());
-paint.drawLine(cursorPos.x(), 0, cursorPos.x(), v->height());
+paint.drawLine(cursorPos.x(), 0, cursorPos.x(), v->getPaintHeight());
 double fundamental = getFrequencyForY(v, cursorPos.y());
 v->drawVisibleText(paint,
 sw + 2,
 RealTime rt = RealTime::frame2RealTime(frame, m_model->getSampleRate());
 QString rtLabel = QString("%1 s").arg(rt.toText(true).c_str());
 QString frameLabel = QString("%1").arg(frame);
 v->drawVisibleText(paint,
 cursorPos.x() - paint.fontMetrics().width(frameLabel) - 2,
-v->height() - 2,
+v->getPaintHeight() - 2,
 frameLabel,
 View::OutlinedText);
 v->drawVisibleText(paint,
 cursorPos.x() + 2,
-v->height() - 2,
+v->getPaintHeight() - 2,
 rtLabel,
 View::OutlinedText);
 int harmonic = 2;
 while (harmonic < 100) {
 int hy = int(lrint(getYForFrequency(v, fundamental * harmonic)));
-if (hy < 0 || hy > v->height()) break;
+if (hy < 0 || hy > v->getPaintHeight()) break;
 int len = 7;
 if (harmonic % 2 == 0) {
 if (harmonic % 4 == 0) {
 paint.restore();
 }
 QString
-SpectrogramLayer::getFeatureDescription(View *v, QPoint &pos) const
+SpectrogramLayer::getFeatureDescription(LayerGeometryProvider *v, QPoint &pos) const
 {
 int x = pos.x();
 int y = pos.y();
 if (!m_model || !m_model->isOK()) return "";
 return cw;
 }
 int
-SpectrogramLayer::getVerticalScaleWidth(View *, bool detailed, QPainter &paint) const
+SpectrogramLayer::getVerticalScaleWidth(LayerGeometryProvider *, bool detailed, QPainter &paint) const
 {
 if (!m_model || !m_model->isOK()) return 0;
 int cw = 0;
 if (detailed) cw = getColourScaleWidth(paint);
 return cw + tickw + tw + 13;
 }
 void
-SpectrogramLayer::paintVerticalScale(View *v, bool detailed, QPainter &paint, QRect rect) const
+SpectrogramLayer::paintVerticalScale(LayerGeometryProvider *v, bool detailed, QPainter &paint, QRect rect) const
 {
 if (!m_model || !m_model->isOK()) {
 	return;
 }
 	int ch = h - textHeight * (topLines + 1) - 8;
 //	paint.drawRect(4, textHeight + 4, cw - 1, ch + 1);
 	paint.drawRect(4 + cw - cbw, textHeight * topLines + 4, cbw - 1, ch + 1);
 	QString top, bottom;
-double min = m_viewMags[v].getMin();
+double min = m_viewMags[v->getId()].getMin();
-double max = m_viewMags[v].getMax();
+double max = m_viewMags[v->getId()].getMax();
 double dBmin = AudioLevel::multiplier_to_dB(min);
 double dBmax = AudioLevel::multiplier_to_dB(max);
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "paintVerticalScale: for view id " << v->getId()
+<< ": min = " << min << ", max = " << max
+<< ", dBmin = " << dBmin << ", dBmax = " << dBmax << endl;
+#endif
 if (dBmax < -60.f) dBmax = -60.f;
 else top = QString("%1").arg(lrint(dBmax));
 if (dBmin < dBmax - 60.f) dBmin = dBmax - 60.f;
 bottom = QString("%1").arg(lrint(dBmin));
 paint.drawLine(cw + 7, 0, cw + 7, h);
 int bin = -1;
-for (int y = 0; y < v->height(); ++y) {
+for (int y = 0; y < v->getPaintHeight(); ++y) {
 	double q0, q1;
-	if (!getYBinRange(v, v->height() - y, q0, q1)) continue;
+	if (!getYBinRange(v, v->getPaintHeight() - y, q0, q1)) continue;
 	int vy;
 	if (int(q0) > bin) {
 	    vy = y;
 	QString text = QString("%1").arg(freq);
 	if (bin == 1) text = tr("%1Hz").arg(freq); // bin 0 is DC
 	paint.drawLine(cw + 7, h - vy, w - pkw - 1, h - vy);
 	if (h - vy - textHeight >= -2) {
-	    int tx = w - 3 - paint.fontMetrics().width(text) - std::max(tickw, pkw);
+	    int tx = w - 3 - paint.fontMetrics().width(text) - max(tickw, pkw);
 	    paint.drawText(tx, h - vy + toff, text);
 	}
 	py = vy;
 }
 if (!m_model) return 0;
 return new SpectrogramRangeMapper(m_model->getSampleRate(), m_fftSize);
 }
 void
-SpectrogramLayer::updateMeasureRectYCoords(View *v, const MeasureRect &r) const
+SpectrogramLayer::updateMeasureRectYCoords(LayerGeometryProvider *v, const MeasureRect &r) const
 {
 int y0 = 0;
 if (r.startY > 0.0) y0 = int(getYForFrequency(v, r.startY));
 int y1 = y0;
 r.pixrect = QRect(r.pixrect.x(), y0, r.pixrect.width(), y1 - y0);
 }
 void
-SpectrogramLayer::setMeasureRectYCoord(View *v, MeasureRect &r, bool start, int y) const
+SpectrogramLayer::setMeasureRectYCoord(LayerGeometryProvider *v, MeasureRect &r, bool start, int y) const
 {
 if (start) {
 r.startY = getFrequencyForY(v, y);
 r.endY = r.startY;
 } else {
 	.arg(m_colourMap)
 	.arg(m_colourRotation)
 	.arg(m_frequencyScale)
 	.arg(m_binDisplay);
-s += QString("normalizeColumns=\"%1\" "
+// New-style normalization attributes, allowing for more types of
-"normalizeVisibleArea=\"%2\" "
+// normalization in future: write out the column normalization
-"normalizeHybrid=\"%3\" ")
+// type separately, and then whether we are normalizing visible
-	.arg(m_normalizeColumns ? "true" : "false")
+// area as well afterwards
-.arg(m_normalizeVisibleArea ? "true" : "false")
-.arg(m_normalizeHybrid ? "true" : "false");
+s += QString("columnNormalization=\"%1\" ")
+.arg(m_normalization == NormalizeColumns ? "peak" :
+m_normalization == NormalizeHybrid ? "hybrid" : "none");
+// Old-style normalization attribute. We *don't* write out
+// normalizeHybrid here because the only release that would accept
+// it (Tony v1.0) has a totally different scale factor for
+// it. We'll just have to accept that session files from Tony
+// v2.0+ will look odd in Tony v1.0
+s += QString("normalizeColumns=\"%1\" ")
+	.arg(m_normalization == NormalizeColumns ? "true" : "false");
+// And this applies to both old- and new-style attributes
+s += QString("normalizeVisibleArea=\"%1\" ")
+.arg(m_normalization == NormalizeVisibleArea ? "true" : "false");
 Layer::toXml(stream, indent, extraAttributes + " " + s);
 }
 void
 SpectrogramLayer::setProperties(const QXmlAttributes &attributes)
 BinDisplay binDisplay = (BinDisplay)
 	attributes.value("binDisplay").toInt(&ok);
 if (ok) setBinDisplay(binDisplay);
-bool normalizeColumns =
+bool haveNewStyleNormalization = false;
-	(attributes.value("normalizeColumns").trimmed() == "true");
-setNormalizeColumns(normalizeColumns);
+QString columnNormalization = attributes.value("columnNormalization");
+if (columnNormalization != "") {
+haveNewStyleNormalization = true;
+if (columnNormalization == "peak") {
+setNormalization(NormalizeColumns);
+} else if (columnNormalization == "hybrid") {
+setNormalization(NormalizeHybrid);
+} else if (columnNormalization == "none") {
+// do nothing
+} else {
+cerr << "NOTE: Unknown or unsupported columnNormalization attribute \""
+<< columnNormalization << "\"" << endl;
+}
+}
+if (!haveNewStyleNormalization) {
+bool normalizeColumns =
+(attributes.value("normalizeColumns").trimmed() == "true");
+if (normalizeColumns) {
+setNormalization(NormalizeColumns);
+}
+bool normalizeHybrid =
+(attributes.value("normalizeHybrid").trimmed() == "true");
+if (normalizeHybrid) {
+setNormalization(NormalizeHybrid);
+}
+}
 bool normalizeVisibleArea =
 	(attributes.value("normalizeVisibleArea").trimmed() == "true");
-setNormalizeVisibleArea(normalizeVisibleArea);
+if (normalizeVisibleArea) {
+setNormalization(NormalizeVisibleArea);
-bool normalizeHybrid =
+}
-	(attributes.value("normalizeHybrid").trimmed() == "true");
-setNormalizeHybrid(normalizeHybrid);
+if (!haveNewStyleNormalization && m_normalization == NormalizeHybrid) {
-}
+// Tony v1.0 is (and hopefully will remain!) the only released
+// SV-a-like to use old-style attributes when saving sessions
+// that ask for hybrid normalization. It saves them with the
+// wrong gain factor, so hack in a fix for that here -- this
+// gives us backward but not forward compatibility.
+setGain(m_gain / float(m_fftSize / 2));
+}
+}

Mercurial > hg > svgui

comparison layer/SpectrogramLayer.cpp @ 1045:f535f6e5dbb0 alignment-simple