svgui: layer/SpectrogramLayer.cpp comparison

comparison layer/SpectrogramLayer.cpp @ 1146:74f2706995b7 3.0-integration

Merge work on unified spectrogram and colour 3d plot caching renderer

author	Chris Cannam
date	Fri, 05 Aug 2016 15:05:02 +0100
parents	17f999cd0a22
children	1badacff7ab2

comparison

equal deleted inserted replaced

-:b4fd6c67fce5
+:74f2706995b7
 #include "base/Window.h"
 #include "base/Pitch.h"
 #include "base/Preferences.h"
 #include "base/RangeMapper.h"
 #include "base/LogRange.h"
+#include "base/ColumnOp.h"
 #include "widgets/CommandHistory.h"
+#include "data/model/Dense3DModelPeakCache.h"
 #include "ColourMapper.h"
-#include "ImageRegionFinder.h"
-#include "data/model/Dense3DModelPeakCache.h"
 #include "PianoScale.h"
+#include "PaintAssistant.h"
+#include "Colour3DPlotRenderer.h"
 #include <QPainter>
 #include <QImage>
 #include <QPixmap>
 #include <QRect>
 #ifndef __GNUC__
 #include <alloca.h>
 #endif
-#define DEBUG_SPECTROGRAM_REPAINT 1
+//#define DEBUG_SPECTROGRAM 1
+//#define DEBUG_SPECTROGRAM_REPAINT 1
 using namespace std;
 SpectrogramLayer::SpectrogramLayer(Configuration config) :
 m_model(0),
 m_channel(0),
 m_windowSize(1024),
 m_windowType(HanningWindow),
 m_windowHopLevel(2),
-m_zeroPadLevel(0),
-m_fftSize(1024),
 m_gain(1.0),
 m_initialGain(1.0),
-m_threshold(0.0),
+m_threshold(1.0e-8f),
-m_initialThreshold(0.0),
+m_initialThreshold(1.0e-8f),
 m_colourRotation(0),
 m_initialRotation(0),
 m_minFrequency(10),
 m_maxFrequency(8000),
 m_initialMaxFrequency(8000),
-m_colourScale(dBColourScale),
+m_colourScale(ColourScaleType::Log),
+m_colourScaleMultiple(1.0),
 m_colourMap(0),
-m_frequencyScale(LinearFrequencyScale),
+m_binScale(BinScale::Linear),
-m_binDisplay(AllBins),
+m_binDisplay(BinDisplay::AllBins),
-m_normalization(NoNormalization),
+m_normalization(ColumnNormalization::None),
+m_normalizeVisibleArea(false),
 m_lastEmittedZoomStep(-1),
 m_synchronous(false),
 m_haveDetailedScale(false),
 m_exiting(false),
-m_peakCacheDivisor(8),
+m_fftModel(0),
-m_sliceableModel(0)
+m_peakCache(0),
+m_peakCacheDivisor(8)
 {
 QString colourConfigName = "spectrogram-colour";
 int colourConfigDefault = int(ColourMapper::Green);
 if (config == FullRangeDb) {
 	setWindowSize(8192);
 	setWindowHopLevel(4);
 m_initialMaxFrequency = 1500;
 	setMaxFrequency(1500);
 setMinFrequency(40);
-	setColourScale(LinearColourScale);
+	setColourScale(ColourScaleType::Linear);
 setColourMap(ColourMapper::Sunset);
-setFrequencyScale(LogFrequencyScale);
+setBinScale(BinScale::Log);
 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);
+	setBinScale(BinScale::Log);
-	setColourScale(LinearColourScale);
+	setColourScale(ColourScaleType::Linear);
-	setBinDisplay(PeakFrequencies);
+	setBinDisplay(BinDisplay::PeakFrequencies);
-setNormalization(NormalizeColumns);
+setNormalization(ColumnNormalization::Max1);
 colourConfigName = "spectrogram-melodic-colour";
 colourConfigDefault = int(ColourMapper::Sunset);
 }
 QSettings settings;
 Preferences *prefs = Preferences::getInstance();
 connect(prefs, SIGNAL(propertyChanged(PropertyContainer::PropertyName)),
 this, SLOT(preferenceChanged(PropertyContainer::PropertyName)));
 setWindowType(prefs->getWindowType());
-initialisePalette();
 }
 SpectrogramLayer::~SpectrogramLayer()
 {
-invalidateFFTModels();
+invalidateRenderers();
+invalidateFFTModel();
+}
+pair<ColourScaleType, double>
+SpectrogramLayer::convertToColourScale(int value)
+{
+switch (value) {
+case 0: return { ColourScaleType::Linear, 1.0 };
+case 1: return { ColourScaleType::Meter, 1.0 };
+case 2: return { ColourScaleType::Log, 2.0 }; // dB^2 (i.e. log of power)
+case 3: return { ColourScaleType::Log, 1.0 }; // dB   (of magnitude)
+case 4: return { ColourScaleType::Phase, 1.0 };
+default: return { ColourScaleType::Linear, 1.0 };
+}
+}
+int
+SpectrogramLayer::convertFromColourScale(ColourScaleType scale, double multiple)
+{
+switch (scale) {
+case ColourScaleType::Linear: return 0;
+case ColourScaleType::Meter: return 1;
+case ColourScaleType::Log: return (multiple > 1.5 ? 2 : 3);
+case ColourScaleType::Phase: return 4;
+case ColourScaleType::PlusMinusOne:
+case ColourScaleType::Absolute:
+default: return 0;
+}
+}
+std::pair<ColumnNormalization, bool>
+SpectrogramLayer::convertToColumnNorm(int value)
+{
+switch (value) {
+default:
+case 0: return { ColumnNormalization::None, false };
+case 1: return { ColumnNormalization::Max1, false };
+case 2: return { ColumnNormalization::None, true }; // visible area
+case 3: return { ColumnNormalization::Hybrid, false };
+}
+}
+int
+SpectrogramLayer::convertFromColumnNorm(ColumnNormalization norm, bool visible)
+{
+if (visible) return 2;
+switch (norm) {
+case ColumnNormalization::None: return 0;
+case ColumnNormalization::Max1: return 1;
+case ColumnNormalization::Hybrid: return 3;
+case ColumnNormalization::Sum1:
+default: return 0;
+}
 }
 void
 SpectrogramLayer::setModel(const DenseTimeValueModel *model)
 {
 //    cerr << "SpectrogramLayer(" << this << "): setModel(" << model << ")" << endl;
 if (model == m_model) return;
 m_model = model;
-invalidateFFTModels();
+invalidateFFTModel();
 if (!m_model || !m_model->isOK()) return;
 connectSignals(m_model);
 list.push_back("Gain");
 list.push_back("Colour Rotation");
 //    list.push_back("Min Frequency");
 //    list.push_back("Max Frequency");
 list.push_back("Frequency Scale");
-////    list.push_back("Zero Padding");
 return list;
 }
 QString
 SpectrogramLayer::getPropertyLabel(const PropertyName &name) const
 if (name == "Gain") return tr("Gain");
 if (name == "Colour Rotation") return tr("Colour Rotation");
 if (name == "Min Frequency") return tr("Min Frequency");
 if (name == "Max Frequency") return tr("Max Frequency");
 if (name == "Frequency Scale") return tr("Frequency Scale");
-if (name == "Zero Padding") return tr("Smoothing");
 return "";
 }
 QString
 SpectrogramLayer::getPropertyIconName(const PropertyName &) const
 SpectrogramLayer::getPropertyType(const PropertyName &name) const
 {
 if (name == "Gain") return RangeProperty;
 if (name == "Colour Rotation") return RangeProperty;
 if (name == "Threshold") return RangeProperty;
-if (name == "Zero Padding") return ToggleProperty;
 return ValueProperty;
 }
 QString
 SpectrogramLayer::getPropertyGroupName(const PropertyName &name) const
 {
 if (name == "Bin Display" ||
 name == "Frequency Scale") return tr("Bins");
 if (name == "Window Size" ||
-	name == "Window Increment" ||
+	name == "Window Increment") return tr("Window");
-name == "Zero Padding") return tr("Window");
 if (name == "Colour" ||
 	name == "Threshold" ||
 	name == "Colour Rotation") return tr("Colour");
 if (name == "Normalization" ||
 name == "Gain" ||
 	if (val < *min) val = *min;
 	if (val > *max) val = *max;
 } else if (name == "Threshold") {
-	*min = -50;
+	*min = -81;
-	*max = 0;
+	*max = -1;
 *deflt = int(lrint(AudioLevel::multiplier_to_dB(m_initialThreshold)));
 	if (*deflt < *min) *deflt = *min;
 	if (*deflt > *max) *deflt = *max;
 	val = m_colourRotation;
 } else if (name == "Colour Scale") {
+// linear, meter, db^2, db, phase
 	*min = 0;
 	*max = 4;
-*deflt = int(dBColourScale);
+*deflt = 2;
-	val = (int)m_colourScale;
+	val = convertFromColourScale(m_colourScale, m_colourScaleMultiple);
 } else if (name == "Colour") {
 	*min = 0;
 	*max = ColourMapper::getColourMapCount() - 1;
 	*min = 0;
 	*max = 5;
 *deflt = 2;
 val = m_windowHopLevel;
-} else if (name == "Zero Padding") {
-	*min = 0;
-	*max = 1;
-*deflt = 0;
-val = m_zeroPadLevel > 0 ? 1 : 0;
 } else if (name == "Min Frequency") {
 	*min = 0;
 	*max = 9;
 } else if (name == "Frequency Scale") {
 	*min = 0;
 	*max = 1;
-*deflt = int(LinearFrequencyScale);
+*deflt = int(BinScale::Linear);
-	val = (int)m_frequencyScale;
+	val = (int)m_binScale;
 } else if (name == "Bin Display") {
 	*min = 0;
 	*max = 2;
-*deflt = int(AllBins);
+*deflt = int(BinDisplay::AllBins);
 	val = (int)m_binDisplay;
 } else if (name == "Normalization") {
 *min = 0;
 *max = 3;
-*deflt = int(NoNormalization);
+*deflt = 0;
-val = (int)m_normalization;
+val = convertFromColumnNorm(m_normalization, m_normalizeVisibleArea);
 } else {
 	val = Layer::getPropertyRangeAndValue(name, min, max, deflt);
 }
 	case 2: return tr("50 %");
 	case 3: return tr("75 %");
 	case 4: return tr("87.5 %");
 	case 5: return tr("93.75 %");
 	}
-}
-if (name == "Zero Padding") {
-if (value == 0) return tr("None");
-return QString("%1x").arg(value + 1);
 }
 if (name == "Min Frequency") {
 	switch (value) {
 	default:
 	case 0: return tr("No min");
 {
 if (name == "Gain") {
 return new LinearRangeMapper(-50, 50, -25, 25, tr("dB"));
 }
 if (name == "Threshold") {
-return new LinearRangeMapper(-50, 0, -50, 0, tr("dB"));
+return new LinearRangeMapper(-81, -1, -81, -1, tr("dB"));
 }
 return 0;
 }
 void
 SpectrogramLayer::setProperty(const PropertyName &name, int value)
 {
 if (name == "Gain") {
 	setGain(float(pow(10, float(value)/20.0)));
 } else if (name == "Threshold") {
-	if (value == -50) setThreshold(0.0);
+	if (value == -81) setThreshold(0.0);
 	else setThreshold(float(AudioLevel::dB_to_multiplier(value)));
 } else if (name == "Colour Rotation") {
 	setColourRotation(value);
 } else if (name == "Colour") {
 setColourMap(value);
 } else if (name == "Window Size") {
 	setWindowSize(32 << value);
 } else if (name == "Window Increment") {
 setWindowHopLevel(value);
-} else if (name == "Zero Padding") {
-setZeroPadLevel(value > 0.1 ? 3 : 0);
 } else if (name == "Min Frequency") {
 	switch (value) {
 	default:
 	case 0: setMinFrequency(0); break;
 	case 1: setMinFrequency(10); break;
 if (vs != m_lastEmittedZoomStep) {
 emit verticalZoomChanged();
 m_lastEmittedZoomStep = vs;
 }
 } else if (name == "Colour Scale") {
+setColourScaleMultiple(1.0);
 	switch (value) {
 	default:
-	case 0: setColourScale(LinearColourScale); break;
+	case 0: setColourScale(ColourScaleType::Linear); break;
-	case 1: setColourScale(MeterColourScale); break;
+	case 1: setColourScale(ColourScaleType::Meter); break;
-	case 2: setColourScale(dBSquaredColourScale); break;
+	case 2:
-	case 3: setColourScale(dBColourScale); break;
+setColourScale(ColourScaleType::Log);
-	case 4: setColourScale(PhaseColourScale); break;
+setColourScaleMultiple(2.0);
+break;
+	case 3: setColourScale(ColourScaleType::Log); break;
+	case 4: setColourScale(ColourScaleType::Phase); break;
 	}
 } else if (name == "Frequency Scale") {
 	switch (value) {
 	default:
-	case 0: setFrequencyScale(LinearFrequencyScale); break;
+	case 0: setBinScale(BinScale::Linear); break;
-	case 1: setFrequencyScale(LogFrequencyScale); break;
+	case 1: setBinScale(BinScale::Log); break;
 	}
 } else if (name == "Bin Display") {
 	switch (value) {
 	default:
-	case 0: setBinDisplay(AllBins); break;
+	case 0: setBinDisplay(BinDisplay::AllBins); break;
-	case 1: setBinDisplay(PeakBins); break;
+	case 1: setBinDisplay(BinDisplay::PeakBins); break;
-	case 2: setBinDisplay(PeakFrequencies); break;
+	case 2: setBinDisplay(BinDisplay::PeakFrequencies); break;
 	}
 } else if (name == "Normalization") {
-switch (value) {
+auto n = convertToColumnNorm(value);
-default:
+setNormalization(n.first);
-case 0: setNormalization(NoNormalization); break;
+setNormalizeVisibleArea(n.second);
-case 1: setNormalization(NormalizeColumns); break;
+}
-case 2: setNormalization(NormalizeVisibleArea); break;
+}
-case 3: setNormalization(NormalizeHybrid); break;
-}
+void
-}
+SpectrogramLayer::invalidateRenderers()
-}
-void
-SpectrogramLayer::invalidateImageCaches()
 {
 #ifdef DEBUG_SPECTROGRAM
-cerr << "SpectrogramLayer::invalidateImageCaches called" << endl;
+cerr << "SpectrogramLayer::invalidateRenderers called" << endl;
 #endif
-for (ViewImageCache::iterator i = m_imageCaches.begin();
-i != m_imageCaches.end(); ++i) {
+for (ViewRendererMap::iterator i = m_renderers.begin();
-i->second.invalidate();
+i != m_renderers.end(); ++i) {
-}
+delete i->second;
+}
+m_renderers.clear();
 }
 void
 SpectrogramLayer::preferenceChanged(PropertyContainer::PropertyName name)
 {
 if (name == "Window Type") {
 setWindowType(Preferences::getInstance()->getWindowType());
 return;
 }
 if (name == "Spectrogram Y Smoothing") {
-invalidateImageCaches();
+setWindowSize(m_windowSize);
+invalidateRenderers();
 invalidateMagnitudes();
 emit layerParametersChanged();
 }
 if (name == "Spectrogram X Smoothing") {
-invalidateImageCaches();
+invalidateRenderers();
 invalidateMagnitudes();
 emit layerParametersChanged();
 }
 if (name == "Tuning Frequency") {
 emit layerParametersChanged();
 void
 SpectrogramLayer::setChannel(int ch)
 {
 if (m_channel == ch) return;
-invalidateImageCaches();
+invalidateRenderers();
 m_channel = ch;
-invalidateFFTModels();
+invalidateFFTModel();
 emit layerParametersChanged();
 }
 int
 SpectrogramLayer::getChannel() const
 {
 return m_channel;
 }
+int
+SpectrogramLayer::getFFTOversampling() const
+{
+if (m_binDisplay != BinDisplay::AllBins) {
+return 1;
+}
+Preferences::SpectrogramSmoothing smoothing =
+Preferences::getInstance()->getSpectrogramSmoothing();
+if (smoothing == Preferences::NoSpectrogramSmoothing ||
+smoothing == Preferences::SpectrogramInterpolated) {
+return 1;
+}
+return 4;
+}
+int
+SpectrogramLayer::getFFTSize() const
+{
+return m_windowSize * getFFTOversampling();
+}
 void
 SpectrogramLayer::setWindowSize(int ws)
 {
 if (m_windowSize == ws) return;
-invalidateImageCaches();
+invalidateRenderers();
 m_windowSize = ws;
-m_fftSize = ws * (m_zeroPadLevel + 1);
+invalidateFFTModel();
-invalidateFFTModels();
 emit layerParametersChanged();
 }
 int
 void
 SpectrogramLayer::setWindowHopLevel(int v)
 {
 if (m_windowHopLevel == v) return;
-invalidateImageCaches();
+invalidateRenderers();
 m_windowHopLevel = v;
-invalidateFFTModels();
+invalidateFFTModel();
 emit layerParametersChanged();
 //    fillCache();
 }
 {
 return m_windowHopLevel;
 }
 void
-SpectrogramLayer::setZeroPadLevel(int v)
-{
-if (m_zeroPadLevel == v) return;
-invalidateImageCaches();
-m_zeroPadLevel = v;
-m_fftSize = m_windowSize * (v + 1);
-invalidateFFTModels();
-emit layerParametersChanged();
-}
-int
-SpectrogramLayer::getZeroPadLevel() const
-{
-return m_zeroPadLevel;
-}
-void
 SpectrogramLayer::setWindowType(WindowType w)
 {
 if (m_windowType == w) return;
-invalidateImageCaches();
+invalidateRenderers();
 m_windowType = w;
-invalidateFFTModels();
+invalidateFFTModel();
 emit layerParametersChanged();
 }
 WindowType
 //    SVDEBUG << "SpectrogramLayer::setGain(" << gain << ") (my gain is now "
 //	      << m_gain << ")" << endl;
 if (m_gain == gain) return;
-invalidateImageCaches();
+invalidateRenderers();
 m_gain = gain;
 emit layerParametersChanged();
 }
 void
 SpectrogramLayer::setThreshold(float threshold)
 {
 if (m_threshold == threshold) return;
-invalidateImageCaches();
+invalidateRenderers();
 m_threshold = threshold;
 emit layerParametersChanged();
 }
 {
 if (m_minFrequency == mf) return;
 //    SVDEBUG << "SpectrogramLayer::setMinFrequency: " << mf << endl;
-invalidateImageCaches();
+invalidateRenderers();
 invalidateMagnitudes();
 m_minFrequency = mf;
 emit layerParametersChanged();
 {
 if (m_maxFrequency == mf) return;
 //    SVDEBUG << "SpectrogramLayer::setMaxFrequency: " << mf << endl;
-invalidateImageCaches();
+invalidateRenderers();
 invalidateMagnitudes();
 m_maxFrequency = mf;
 emit layerParametersChanged();
 }
 void
 SpectrogramLayer::setColourRotation(int r)
 {
-invalidateImageCaches();
 if (r < 0) r = 0;
 if (r > 256) r = 256;
 int distance = r - m_colourRotation;
 if (distance != 0) {
-	rotatePalette(-distance);
 	m_colourRotation = r;
 }
+// Initially the idea with colour rotation was that we would just
+// rotate the palette of an already-generated cache. That's not
+// really practical now that cacheing is handled in a separate
+// class in which the main cache no longer has a palette.
+invalidateRenderers();
 emit layerParametersChanged();
 }
 void
-SpectrogramLayer::setColourScale(ColourScale colourScale)
+SpectrogramLayer::setColourScale(ColourScaleType colourScale)
 {
 if (m_colourScale == colourScale) return;
-invalidateImageCaches();
+invalidateRenderers();
 m_colourScale = colourScale;
 emit layerParametersChanged();
 }
-SpectrogramLayer::ColourScale
+ColourScaleType
 SpectrogramLayer::getColourScale() const
 {
 return m_colourScale;
 }
 void
+SpectrogramLayer::setColourScaleMultiple(double multiple)
+{
+if (m_colourScaleMultiple == multiple) return;
+invalidateRenderers();
+m_colourScaleMultiple = multiple;
+emit layerParametersChanged();
+}
+double
+SpectrogramLayer::getColourScaleMultiple() const
+{
+return m_colourScaleMultiple;
+}
+void
 SpectrogramLayer::setColourMap(int map)
 {
 if (m_colourMap == map) return;
-invalidateImageCaches();
+invalidateRenderers();
 m_colourMap = map;
-initialisePalette();
 emit layerParametersChanged();
 }
 int
 {
 return m_colourMap;
 }
 void
-SpectrogramLayer::setFrequencyScale(FrequencyScale frequencyScale)
+SpectrogramLayer::setBinScale(BinScale binScale)
 {
-if (m_frequencyScale == frequencyScale) return;
+if (m_binScale == binScale) return;
-invalidateImageCaches();
+invalidateRenderers();
-m_frequencyScale = frequencyScale;
+m_binScale = binScale;
 emit layerParametersChanged();
 }
-SpectrogramLayer::FrequencyScale
+BinScale
-SpectrogramLayer::getFrequencyScale() const
+SpectrogramLayer::getBinScale() const
 {
-return m_frequencyScale;
+return m_binScale;
 }
 void
 SpectrogramLayer::setBinDisplay(BinDisplay binDisplay)
 {
 if (m_binDisplay == binDisplay) return;
-invalidateImageCaches();
+invalidateRenderers();
 m_binDisplay = binDisplay;
 emit layerParametersChanged();
 }
-SpectrogramLayer::BinDisplay
+BinDisplay
 SpectrogramLayer::getBinDisplay() const
 {
 return m_binDisplay;
 }
 void
-SpectrogramLayer::setNormalization(Normalization n)
+SpectrogramLayer::setNormalization(ColumnNormalization n)
 {
 if (m_normalization == n) return;
-invalidateImageCaches();
+invalidateRenderers();
 invalidateMagnitudes();
 m_normalization = n;
 emit layerParametersChanged();
 }
-SpectrogramLayer::Normalization
+ColumnNormalization
 SpectrogramLayer::getNormalization() const
 {
 return m_normalization;
+}
+void
+SpectrogramLayer::setNormalizeVisibleArea(bool n)
+{
+if (m_normalizeVisibleArea == n) return;
+invalidateRenderers();
+invalidateMagnitudes();
+m_normalizeVisibleArea = n;
+emit layerParametersChanged();
+}
+bool
+SpectrogramLayer::getNormalizeVisibleArea() const
+{
+return m_normalizeVisibleArea;
 }
 void
 SpectrogramLayer::setLayerDormant(const LayerGeometryProvider *v, bool dormant)
 {
 return;
 }
 Layer::setLayerDormant(v, true);
-const View *view = v->getView();
+	invalidateRenderers();
-	invalidateImageCaches();
-m_imageCaches.erase(view->getId());
-if (m_fftModels.find(view->getId()) != m_fftModels.end()) {
-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 != m_sliceableModel) {
-emit sliceableModelReplaced(m_sliceableModel, i->second);
-replaced = true;
-break;
-}
-}
-if (!replaced) emit sliceableModelReplaced(m_sliceableModel, 0);
-}
-delete m_fftModels[view->getId()];
-m_fftModels.erase(view->getId());
-delete m_peakCaches[view->getId()];
-m_peakCaches.erase(view->getId());
-}
 } else {
 Layer::setLayerDormant(v, false);
 }
 {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
 cerr << "SpectrogramLayer::cacheInvalid()" << endl;
 #endif
-invalidateImageCaches();
+invalidateRenderers();
 invalidateMagnitudes();
 }
 void
 SpectrogramLayer::cacheInvalid(
 // 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();
+invalidateRenderers();
 invalidateMagnitudes();
 }
 bool
 SpectrogramLayer::hasLightBackground() const
 {
 return ColourMapper(m_colourMap, 1.f, 255.f).hasLightBackground();
 }
-void
-SpectrogramLayer::initialisePalette()
-{
-int formerRotation = m_colourRotation;
-if (m_colourMap == (int)ColourMapper::BlackOnWhite) {
-	m_palette.setColour(NO_VALUE, Qt::white);
-} else {
-	m_palette.setColour(NO_VALUE, Qt::black);
-}
-ColourMapper mapper(m_colourMap, 1.f, 255.f);
-for (int pixel = 1; pixel < 256; ++pixel) {
-m_palette.setColour((unsigned char)pixel, mapper.map(pixel));
-}
-m_crosshairColour = mapper.getContrastingColour();
-m_colourRotation = 0;
-rotatePalette(m_colourRotation - formerRotation);
-m_colourRotation = formerRotation;
-m_drawBuffer = QImage();
-}
-void
-SpectrogramLayer::rotatePalette(int distance)
-{
-QColor newPixels[256];
-newPixels[NO_VALUE] = m_palette.getColour(NO_VALUE);
-for (int pixel = 1; pixel < 256; ++pixel) {
-	int target = pixel + distance;
-	while (target < 1) target += 255;
-	while (target > 255) target -= 255;
-	newPixels[target] = m_palette.getColour((unsigned char)pixel);
-}
-for (int pixel = 0; pixel < 256; ++pixel) {
-	m_palette.setColour((unsigned char)pixel, newPixels[pixel]);
-}
-m_drawBuffer = QImage();
-}
-unsigned char
-SpectrogramLayer::getDisplayValue(LayerGeometryProvider *v, double input) const
-{
-int value;
-double min = 0.0;
-double max = 1.0;
-if (m_normalization == NormalizeVisibleArea) {
-min = m_viewMags[v->getId()].getMin();
-max = m_viewMags[v->getId()].getMax();
-} else if (m_normalization != NormalizeColumns) {
-if (m_colourScale == LinearColourScale //||
-//            m_colourScale == MeterColourScale) {
-) {
-max = 0.1;
-}
-}
-double thresh = -80.0;
-if (max == 0.0) max = 1.0;
-if (max == min) min = max - 0.0001;
-switch (m_colourScale) {
-default:
-case LinearColourScale:
-value = int(((input - min) / (max - min)) * 255.0) + 1;
-	break;
-case MeterColourScale:
-value = AudioLevel::multiplier_to_preview
-((input - min) / (max - min), 254) + 1;
-	break;
-case dBSquaredColourScale:
-input = ((input - min) * (input - min)) / ((max - min) * (max - min));
-if (input > 0.0) {
-input = 10.0 * log10(input);
-} else {
-input = thresh;
-}
-if (min > 0.0) {
-thresh = 10.0 * log10(min * min);
-if (thresh < -80.0) thresh = -80.0;
-}
-	input = (input - thresh) / (-thresh);
-	if (input < 0.0) input = 0.0;
-	if (input > 1.0) input = 1.0;
-	value = int(input * 255.0) + 1;
-	break;
-case dBColourScale:
-//!!! experiment with normalizing the visible area this way.
-//In any case, we need to have some indication of what the dB
-//scale is relative to.
-input = (input - min) / (max - min);
-if (input > 0.0) {
-input = 10.0 * log10(input);
-} else {
-input = thresh;
-}
-if (min > 0.0) {
-thresh = 10.0 * log10(min);
-if (thresh < -80.0) thresh = -80.0;
-}
-	input = (input - thresh) / (-thresh);
-	if (input < 0.0) input = 0.0;
-	if (input > 1.0) input = 1.0;
-	value = int(input * 255.0) + 1;
-	break;
-case PhaseColourScale:
-	value = int((input * 127.0 / M_PI) + 128);
-	break;
-}
-if (value > UCHAR_MAX) value = UCHAR_MAX;
-if (value < 0) value = 0;
-return (unsigned char)value;
-}
 double
 SpectrogramLayer::getEffectiveMinFrequency() const
 {
 sv_samplerate_t sr = m_model->getSampleRate();
-double minf = double(sr) / m_fftSize;
+double minf = double(sr) / getFFTSize();
 if (m_minFrequency > 0.0) {
-	int minbin = int((double(m_minFrequency) * m_fftSize) / sr + 0.01);
+	int minbin = int((double(m_minFrequency) * getFFTSize()) / sr + 0.01);
 	if (minbin < 1) minbin = 1;
-	minf = minbin * sr / m_fftSize;
+	minf = minbin * sr / getFFTSize();
 }
 return minf;
 }
 {
 sv_samplerate_t sr = m_model->getSampleRate();
 double maxf = double(sr) / 2;
 if (m_maxFrequency > 0.0) {
-	int maxbin = int((double(m_maxFrequency) * m_fftSize) / sr + 0.1);
+	int maxbin = int((double(m_maxFrequency) * getFFTSize()) / sr + 0.1);
-	if (maxbin > m_fftSize / 2) maxbin = m_fftSize / 2;
+	if (maxbin > getFFTSize() / 2) maxbin = getFFTSize() / 2;
-	maxf = maxbin * sr / m_fftSize;
+	maxf = maxbin * sr / getFFTSize();
 }
 return maxf;
 }
 bool
 SpectrogramLayer::getYBinRange(LayerGeometryProvider *v, int y, double &q0, double &q1) const
 {
 Profiler profiler("SpectrogramLayer::getYBinRange");
 int h = v->getPaintHeight();
 if (y < 0 || y >= h) return false;
+q0 = getBinForY(v, y);
+q1 = getBinForY(v, y-1);
+return true;
+}
+double
+SpectrogramLayer::getYForBin(const LayerGeometryProvider *v, double bin) const
+{
+double minf = getEffectiveMinFrequency();
+double maxf = getEffectiveMaxFrequency();
+bool logarithmic = (m_binScale == BinScale::Log);
+sv_samplerate_t sr = m_model->getSampleRate();
+double freq = (bin * sr) / getFFTSize();
+double y = v->getYForFrequency(freq, minf, maxf, logarithmic);
+return y;
+}
+double
+SpectrogramLayer::getBinForY(const LayerGeometryProvider *v, double y) const
+{
 sv_samplerate_t sr = m_model->getSampleRate();
 double minf = getEffectiveMinFrequency();
 double maxf = getEffectiveMaxFrequency();
-bool logarithmic = (m_frequencyScale == LogFrequencyScale);
+bool logarithmic = (m_binScale == BinScale::Log);
-q0 = v->getFrequencyForY(y, minf, maxf, logarithmic);
+double freq = v->getFrequencyForY(y, minf, maxf, logarithmic);
-q1 = v->getFrequencyForY(y - 1, minf, maxf, logarithmic);
+// Now map on to ("proportion of") actual bins
-// Now map these on to ("proportions of") actual bins, using raw
+double bin = (freq * getFFTSize()) / sr;
-// FFT size (unsmoothed)
+return bin;
-q0 = (q0 * m_fftSize) / sr;
+}
-q1 = (q1 * m_fftSize) / sr;
-return true;
-}
-bool
-SpectrogramLayer::getSmoothedYBinRange(LayerGeometryProvider *v, int y, double &q0, double &q1) const
-{
-Profiler profiler("SpectrogramLayer::getSmoothedYBinRange");
-int h = v->getPaintHeight();
-if (y < 0 || y >= h) return false;
-sv_samplerate_t sr = m_model->getSampleRate();
-double minf = getEffectiveMinFrequency();
-double maxf = getEffectiveMaxFrequency();
-bool logarithmic = (m_frequencyScale == LogFrequencyScale);
-q0 = v->getFrequencyForY(y, minf, maxf, logarithmic);
-q1 = v->getFrequencyForY(y - 1, minf, maxf, logarithmic);
-// Now map these on to ("proportions of") actual bins, using raw
-// FFT size (unsmoothed)
-q0 = (q0 * getFFTSize(v)) / sr;
-q1 = (q1 * getFFTSize(v)) / sr;
-return true;
-}
 bool
 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();
 int q1i = int(q1);
 sv_samplerate_t sr = m_model->getSampleRate();
 for (int q = q0i; q <= q1i; ++q) {
-	if (q == q0i) freqMin = (sr * q) / m_fftSize;
+	if (q == q0i) freqMin = (sr * q) / getFFTSize();
-	if (q == q1i) freqMax = (sr * (q+1)) / m_fftSize;
+	if (q == q1i) freqMax = (sr * (q+1)) / getFFTSize();
 }
 return true;
 }
 bool
 {
 if (!m_model || !m_model->isOK() || !m_model->isReady()) {
 	return false;
 }
-FFTModel *fft = getFFTModel(v);
+FFTModel *fft = getFFTModel();
 if (!fft) return false;
 double s0 = 0, s1 = 0;
 if (!getXBinRange(v, x, s0, s1)) return false;
 sv_samplerate_t sr = m_model->getSampleRate();
 bool haveAdj = false;
-bool peaksOnly = (m_binDisplay == PeakBins ||
+bool peaksOnly = (m_binDisplay == BinDisplay::PeakBins ||
-		      m_binDisplay == PeakFrequencies);
+		      m_binDisplay == BinDisplay::PeakFrequencies);
 for (int q = q0i; q <= q1i; ++q) {
 	for (int s = s0i; s <= s1i; ++s) {
 	    if (q == q0i) freqMin = binfreq;
 	    if (q == q1i) freqMax = binfreq;
 	    if (peaksOnly && !fft->isLocalPeak(s, q)) continue;
-	    if (!fft->isOverThreshold(s, q, float(m_threshold * double(m_fftSize)/2.0))) continue;
+	    if (!fft->isOverThreshold
+(s, q, float(m_threshold * double(getFFTSize())/2.0))) {
+continue;
+}
 double freq = binfreq;
 	    if (s < int(fft->getWidth()) - 1) {
 int s0i = int(s0 + 0.001);
 int s1i = int(s1);
 bool rv = false;
-int zp = getZeroPadLevel(v);
+FFTModel *fft = getFFTModel();
-q0i *= zp + 1;
-q1i *= zp + 1;
-FFTModel *fft = getFFTModel(v);
 if (fft) {
 int cw = fft->getWidth();
 int ch = fft->getHeight();
 value = fft->getPhaseAt(s, q);
 if (!have || value < phaseMin) { phaseMin = value; }
 if (!have || value > phaseMax) { phaseMax = value; }
-value = fft->getMagnitudeAt(s, q) / (m_fftSize/2.0);
+value = fft->getMagnitudeAt(s, q) / (getFFTSize()/2.0);
 if (!have || value < min) { min = value; }
 if (!have || value > max) { max = value; }
 have = true;
 }
 }
 }
 return rv;
 }
-int
-SpectrogramLayer::getZeroPadLevel(const LayerGeometryProvider *v) const
-{
-//!!! tidy all this stuff
-if (m_binDisplay != AllBins) return 0;
-Preferences::SpectrogramSmoothing smoothing =
-Preferences::getInstance()->getSpectrogramSmoothing();
-if (smoothing == Preferences::NoSpectrogramSmoothing ||
-smoothing == Preferences::SpectrogramInterpolated) return 0;
-if (m_frequencyScale == LogFrequencyScale) return 3;
-sv_samplerate_t sr = m_model->getSampleRate();
-int maxbin = m_fftSize / 2;
-if (m_maxFrequency > 0) {
-	maxbin = int((double(m_maxFrequency) * m_fftSize) / sr + 0.1);
-	if (maxbin > m_fftSize / 2) maxbin = m_fftSize / 2;
-}
-int minbin = 1;
-if (m_minFrequency > 0) {
-	minbin = int((double(m_minFrequency) * m_fftSize) / sr + 0.1);
-	if (minbin < 1) minbin = 1;
-	if (minbin >= maxbin) minbin = maxbin - 1;
-}
-double perPixel =
-double(v->getPaintHeight()) /
-double((maxbin - minbin) / (m_zeroPadLevel + 1));
-if (perPixel > 2.8) {
-return 3; // 4x oversampling
-} else if (perPixel > 1.5) {
-return 1; // 2x
-} else {
-return 0; // 1x
-}
-}
-int
-SpectrogramLayer::getFFTSize(const LayerGeometryProvider *v) const
-{
-return m_fftSize * (getZeroPadLevel(v) + 1);
-}
 FFTModel *
-SpectrogramLayer::getFFTModel(const LayerGeometryProvider *v) const
+SpectrogramLayer::getFFTModel() const
 {
 if (!m_model) return 0;
-int fftSize = getFFTSize(v);
+int fftSize = getFFTSize();
-const View *view = v->getView();
+//!!! it is now surely slower to do this on every getFFTModel()
+//!!! request than it would be to recreate the model immediately
-if (m_fftModels.find(view->getId()) != m_fftModels.end()) {
+//!!! when something changes instead of just invalidating it
-if (m_fftModels[view->getId()] == 0) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+if (m_fftModel &&
-cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found null model" << endl;
+m_fftModel->getHeight() == fftSize / 2 + 1 &&
-#endif
+m_fftModel->getWindowIncrement() == getWindowIncrement()) {
-return 0;
+return m_fftModel;
 }
-if (m_fftModels[view->getId()]->getHeight() != fftSize / 2 + 1) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+delete m_peakCache;
-cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found a model with the wrong height (" << m_fftModels[view->getId()]->getHeight() << ", wanted " << (fftSize / 2 + 1) << ")" << endl;
+m_peakCache = 0;
-#endif
-delete m_fftModels[view->getId()];
+delete m_fftModel;
-m_fftModels.erase(view->getId());
+m_fftModel = new FFTModel(m_model,
-delete m_peakCaches[view->getId()];
+m_channel,
-m_peakCaches.erase(view->getId());
+m_windowType,
-} else {
+m_windowSize,
-#ifdef DEBUG_SPECTROGRAM_REPAINT
+getWindowIncrement(),
-cerr << "SpectrogramLayer::getFFTModel(" << v << "): Found a good model of height " << m_fftModels[view->getId()]->getHeight() << endl;
+fftSize);
-#endif
-return m_fftModels[view->getId()];
+if (!m_fftModel->isOK()) {
-}
+QMessageBox::critical
-}
+(0, tr("FFT cache failed"),
+tr("Failed to create the FFT model for this spectrogram.\n"
-if (m_fftModels.find(view->getId()) == m_fftModels.end()) {
+"There may be insufficient memory or disc space to continue."));
+delete m_fftModel;
-FFTModel *model = new FFTModel(m_model,
+m_fftModel = 0;
-m_channel,
+return 0;
-m_windowType,
+}
-m_windowSize,
-getWindowIncrement(),
+((SpectrogramLayer *)this)->sliceableModelReplaced(0, m_fftModel);
-fftSize);
+return m_fftModel;
-if (!model->isOK()) {
-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[view->getId()] = 0;
-return 0;
-}
-if (!m_sliceableModel) {
-#ifdef DEBUG_SPECTROGRAM
-cerr << "SpectrogramLayer: emitting sliceableModelReplaced(0, " << model << ")" << endl;
-#endif
-((SpectrogramLayer *)this)->sliceableModelReplaced(0, model);
-m_sliceableModel = model;
-}
-m_fftModels[view->getId()] = model;
-}
-return m_fftModels[view->getId()];
 }
 Dense3DModelPeakCache *
-SpectrogramLayer::getPeakCache(const LayerGeometryProvider *v) const
+SpectrogramLayer::getPeakCache() const
 {
-const View *view = v->getView();
+//!!! see comment in getFFTModel
-if (!m_peakCaches[view->getId()]) {
-FFTModel *f = getFFTModel(v);
+if (!m_peakCache) {
+FFTModel *f = getFFTModel();
 if (!f) return 0;
-m_peakCaches[view->getId()] =
+m_peakCache = new Dense3DModelPeakCache(f, m_peakCacheDivisor);
-new Dense3DModelPeakCache(f, m_peakCacheDivisor);
+}
-}
+return m_peakCache;
-return m_peakCaches[view->getId()];
 }
 const Model *
 SpectrogramLayer::getSliceableModel() const
 {
-if (m_sliceableModel) return m_sliceableModel;
+return m_fftModel;
-if (m_fftModels.empty()) return 0;
+}
-m_sliceableModel = m_fftModels.begin()->second;
-return m_sliceableModel;
+void
-}
+SpectrogramLayer::invalidateFFTModel()
-void
-SpectrogramLayer::invalidateFFTModels()
 {
 #ifdef DEBUG_SPECTROGRAM
-cerr << "SpectrogramLayer::invalidateFFTModels called" << endl;
+cerr << "SpectrogramLayer::invalidateFFTModel called" << endl;
 #endif
-for (ViewFFTMap::iterator i = m_fftModels.begin();
-i != m_fftModels.end(); ++i) {
+emit sliceableModelReplaced(m_fftModel, 0);
-delete i->second;
-}
+delete m_fftModel;
-for (PeakCacheMap::iterator i = m_peakCaches.begin();
+delete m_peakCache;
-i != m_peakCaches.end(); ++i) {
-delete i->second;
+m_fftModel = 0;
-}
+m_peakCache = 0;
-m_fftModels.clear();
-m_peakCaches.clear();
-if (m_sliceableModel) {
-cerr << "SpectrogramLayer: emitting sliceableModelReplaced(" << m_sliceableModel << ", 0)" << endl;
-emit sliceableModelReplaced(m_sliceableModel, 0);
-m_sliceableModel = 0;
-}
 }
 void
 SpectrogramLayer::invalidateMagnitudes()
 {
 #ifdef DEBUG_SPECTROGRAM
 cerr << "SpectrogramLayer::invalidateMagnitudes called" << endl;
 #endif
 m_viewMags.clear();
-for (vector<MagnitudeRange>::iterator i = m_columnMags.begin();
+}
-i != m_columnMags.end(); ++i) {
-*i = MagnitudeRange();
+void
-}
+SpectrogramLayer::setSynchronousPainting(bool synchronous)
-}
+{
+m_synchronous = synchronous;
-bool
+}
-SpectrogramLayer::updateViewMagnitudes(LayerGeometryProvider *v) const
-{
+Colour3DPlotRenderer *
-MagnitudeRange mag;
+SpectrogramLayer::getRenderer(LayerGeometryProvider *v) const
+{
-int x0 = 0, x1 = v->getPaintWidth();
+int viewId = v->getId();
-double s00 = 0, s01 = 0, s10 = 0, s11 = 0;
+if (m_renderers.find(viewId) == m_renderers.end()) {
-if (!getXBinRange(v, x0, s00, s01)) {
-s00 = s01 = double(m_model->getStartFrame()) / getWindowIncrement();
+Colour3DPlotRenderer::Sources sources;
-}
+sources.verticalBinLayer = this;
+sources.fft = getFFTModel();
-if (!getXBinRange(v, x1, s10, s11)) {
+sources.source = sources.fft;
-s10 = s11 = double(m_model->getEndFrame()) / getWindowIncrement();
+sources.peaks = getPeakCache();
-}
+ColourScale::Parameters cparams;
-int s0 = int(min(s00, s10) + 0.0001);
+cparams.colourMap = m_colourMap;
-int s1 = int(max(s01, s11) + 0.0001);
+cparams.scaleType = m_colourScale;
+cparams.multiple = m_colourScaleMultiple;
-//    SVDEBUG << "SpectrogramLayer::updateViewMagnitudes: x0 = " << x0 << ", x1 = " << x1 << ", s00 = " << s00 << ", s11 = " << s11 << " s0 = " << s0 << ", s1 = " << s1 << endl;
+if (m_colourScale != ColourScaleType::Phase) {
-if (int(m_columnMags.size()) <= s1) {
+cparams.gain = m_gain;
-m_columnMags.resize(s1 + 1);
+cparams.threshold = m_threshold;
-}
-for (int s = s0; s <= s1; ++s) {
-if (m_columnMags[s].isSet()) {
-mag.sample(m_columnMags[s]);
 }
-}
+float minValue = 0.0f;
+float maxValue = 1.0f;
+if (m_normalizeVisibleArea && m_viewMags[viewId].isSet()) {
+minValue = m_viewMags[viewId].getMin();
+maxValue = m_viewMags[viewId].getMax();
+} else if (m_colourScale == ColourScaleType::Linear &&
+m_normalization == ColumnNormalization::None) {
+maxValue = 0.1f;
+}
+if (maxValue <= minValue) {
+maxValue = minValue + 0.1f;
+}
+if (maxValue <= m_threshold) {
+maxValue = m_threshold + 0.1f;
+}
+cparams.minValue = minValue;
+cparams.maxValue = maxValue;
+m_lastRenderedMags[viewId] = MagnitudeRange(minValue, maxValue);
+Colour3DPlotRenderer::Parameters params;
+params.colourScale = ColourScale(cparams);
+params.normalization = m_normalization;
+params.binDisplay = m_binDisplay;
+params.binScale = m_binScale;
+params.alwaysOpaque = true;
+params.invertVertical = false;
+params.scaleFactor = 1.0;
+params.colourRotation = m_colourRotation;
+if (m_colourScale != ColourScaleType::Phase &&
+m_normalization != ColumnNormalization::Hybrid) {
+params.scaleFactor *= 2.f / float(getFFTSize());
+}
+Preferences::SpectrogramSmoothing smoothing =
+Preferences::getInstance()->getSpectrogramSmoothing();
+params.interpolate =
+(smoothing == Preferences::SpectrogramInterpolated ||
+smoothing == Preferences::SpectrogramZeroPaddedAndInterpolated);
+m_renderers[v->getId()] = new Colour3DPlotRenderer(sources, params);
+}
+return m_renderers[v->getId()];
+}
+void
+SpectrogramLayer::paintWithRenderer(LayerGeometryProvider *v, QPainter &paint, QRect rect) const
+{
+Colour3DPlotRenderer *renderer = getRenderer(v);
+Colour3DPlotRenderer::RenderResult result;
+MagnitudeRange magRange;
+int viewId = v->getId();
+bool continuingPaint = !renderer->geometryChanged(v);
+if (continuingPaint) {
+magRange = m_viewMags[viewId];
+}
+if (m_synchronous) {
+result = renderer->render(v, paint, rect);
+} else {
+result = renderer->renderTimeConstrained(v, paint, rect);
 #ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer::updateViewMagnitudes returning from cols "
+cerr << "rect width from this paint: " << result.rendered.width()
-<< s0 << " -> " << s1 << " inclusive" << endl;
+<< ", mag range in this paint: " << result.range.getMin() << " -> "
-cerr << "SpectrogramLayer::updateViewMagnitudes: for view id " << v->getId()
+<< result.range.getMax() << endl;
-<< ": min is " << mag.getMin() << ", max is " << mag.getMax() << endl;
 #endif
-if (!mag.isSet()) return false;
+QRect uncached = renderer->getLargestUncachedRect(v);
-if (mag == m_viewMags[v->getId()]) return false;
+if (uncached.width() > 0) {
-m_viewMags[v->getId()] = mag;
+v->updatePaintRect(uncached);
-return true;
+}
 }
-void
+magRange.sample(result.range);
-SpectrogramLayer::setSynchronousPainting(bool synchronous)
-{
+if (magRange.isSet()) {
-m_synchronous = synchronous;
+if (m_viewMags[viewId] != magRange) {
-}
+m_viewMags[viewId] = magRange;
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-ScrollableImageCache &
+cerr << "mag range in this view has changed: "
-SpectrogramLayer::getImageCacheReference(const LayerGeometryProvider *view) const
+<< magRange.getMin() << " -> " << magRange.getMax() << endl;
-{
+#endif
-if (m_imageCaches.find(view->getId()) == m_imageCaches.end()) {
+}
-m_imageCaches[view->getId()] = ScrollableImageCache(view);
+}
-}
-return m_imageCaches.at(view->getId());
+if (!continuingPaint && m_normalizeVisibleArea &&
+m_viewMags[viewId] != m_lastRenderedMags[viewId]) {
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "mag range has changed from last rendered range: re-rendering"
+<< endl;
+#endif
+delete m_renderers[viewId];
+m_renderers.erase(viewId);
+v->updatePaintRect(v->getPaintRect());
+}
 }
 void
 SpectrogramLayer::paint(LayerGeometryProvider *v, QPainter &paint, QRect rect) const
 {
 cerr << "SpectrogramLayer::paint() entering: m_model is " << m_model << ", zoom level is " << v->getZoomLevel() << endl;
 cerr << "SpectrogramLayer::paint(): rect is " << rect.x() << "," << rect.y() << " " << rect.width() << "x" << rect.height() << endl;
 #endif
-sv_frame_t startFrame = v->getStartFrame();
 if (!m_model || !m_model->isOK() || !m_model->isReady()) {
 	return;
 }
 if (isLayerDormant(v)) {
 	SVDEBUG << "SpectrogramLayer::paint(): Layer is dormant, making it undormant again" << endl;
 }
-// Need to do this even if !isLayerDormant, as that could mean v
+paintWithRenderer(v, paint, rect);
-// is not in the dormancy map at all -- we need it to be present
-// and accountable for when determining whether we need the cache
-// in the cache-fill thread above.
-//!!! no inter use cache-fill thread
-const_cast<SpectrogramLayer *>(this)->Layer::setLayerDormant(v, false);
-int fftSize = getFFTSize(v);
-const View *view = v->getView();
-ScrollableImageCache &cache = getImageCacheReference(view);
-#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() ||
-rect.x() > cache.getValidRight()) {
-cerr << "SpectrogramLayer: NOTE: requested rect is not contiguous with cache valid area" << endl;
-}
-#endif
-int zoomLevel = v->getZoomLevel();
-int x0 = v->getXForViewX(rect.x());
-int x1 = v->getXForViewX(rect.x() + rect.width());
-if (x0 < 0) x0 = 0;
-if (x1 > v->getPaintWidth()) x1 = v->getPaintWidth();
-if (updateViewMagnitudes(v)) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer: magnitude range changed to [" << m_viewMags[v->getId()].getMin() << "->" << m_viewMags[v->getId()].getMax() << "]" << endl;
-#endif
-if (m_normalization == NormalizeVisibleArea) {
-cache.invalidate();
-}
-}
-if (cache.getZoomLevel() != zoomLevel ||
-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 (v->getXForFrame(cache.getStartFrame()) ==
-v->getXForFrame(startFrame) &&
-cache.getValidLeft() <= x0 &&
-cache.getValidRight() >= x1) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer: image cache hit!" << endl;
-#endif
-paint.drawImage(rect, cache.getImage(), rect);
-illuminateLocalFeatures(v, paint);
-return;
-} else {
-// cache doesn't begin at the right frame or doesn't
-// contain the complete view, but might be scrollable or
-// partially usable
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer: scrolling the image cache if applicable" << endl;
-#endif
-cache.scrollTo(startFrame);
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer: after scrolling, cache valid from "
-<< cache.getValidLeft() << " width " << cache.getValidWidth()
-<< endl;
-#endif
-}
-}
-bool rightToLeft = false;
-if (!cache.isValid()) {
-if (!m_synchronous) {
-// When rendering the whole thing, start from somewhere near
-// the middle so that the region of interest appears first
-//!!! (perhaps we should have some cunning test to avoid
-//!!! doing this if past repaints have appeared fast
-//!!! enough to do the whole width in one shot)
-if (x0 == 0 && x1 == v->getPaintWidth()) {
-x0 = int(x1 * 0.3);
-}
-}
-} else {
-// When rendering only a part of the cache, we need to make
-// sure that the part we're rendering is adjacent to (or
-// 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
-// happen when just waving the pointer over a small part of
-// the view -- if we lose the partly-built cache every time
-// the user does that, we'll never finish building it.
-int left = x0;
-int width = x1 - x0;
-bool isLeftOfValidArea = false;
-cache.adjustToTouchValidArea(left, width, isLeftOfValidArea);
-x0 = left;
-x1 = x0 + width;
-// That call also told us whether we should be painting
-// sub-regions of our target region in right-to-left order in
-// order to ensure contiguity
-rightToLeft = isLeftOfValidArea;
-}
-// 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 repaintWidth = x1 - x0;
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer: x0 " << x0 << ", x1 " << x1
-<< ", repaintWidth " << repaintWidth << ", h " << h
-<< ", rightToLeft " << rightToLeft << endl;
-#endif
-sv_samplerate_t sr = m_model->getSampleRate();
-// Set minFreq and maxFreq to the frequency extents of the possibly
-// zero-padded visible bin range, and displayMinFreq and displayMaxFreq
-// to the actual scale frequency extents (presumably not zero padded).
-// If we are zero padding, we want to use the zero-padded
-// equivalents of the bins that we would be using if not zero
-// padded, to avoid spaces at the top and bottom of the display.
-// Note fftSize is the actual zero-padded fft size, m_fftSize the
-// nominal fft size.
-int maxbin = m_fftSize / 2;
-if (m_maxFrequency > 0) {
-	maxbin = int((double(m_maxFrequency) * m_fftSize) / sr + 0.001);
-	if (maxbin > m_fftSize / 2) maxbin = m_fftSize / 2;
-}
-int minbin = 1;
-if (m_minFrequency > 0) {
-	minbin = int((double(m_minFrequency) * m_fftSize) / sr + 0.001);
-//        cerr << "m_minFrequency = " << m_minFrequency << " -> minbin = " << minbin << endl;
-	if (minbin < 1) minbin = 1;
-	if (minbin >= maxbin) minbin = maxbin - 1;
-}
-int zpl = getZeroPadLevel(v) + 1;
-minbin = minbin * zpl;
-maxbin = (maxbin + 1) * zpl - 1;
-double minFreq = (double(minbin) * sr) / fftSize;
-double maxFreq = (double(maxbin) * sr) / fftSize;
-double displayMinFreq = minFreq;
-double displayMaxFreq = maxFreq;
-if (fftSize != m_fftSize) {
-displayMinFreq = getEffectiveMinFrequency();
-displayMaxFreq = getEffectiveMaxFrequency();
-}
-//    cerr << "(giving actual minFreq " << minFreq << " and display minFreq " << displayMinFreq << ")" << endl;
-int increment = getWindowIncrement();
-bool logarithmic = (m_frequencyScale == LogFrequencyScale);
-MagnitudeRange overallMag = m_viewMags[v->getId()];
-bool overallMagChanged = false;
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer: " << ((double(v->getFrameForX(1) - v->getFrameForX(0))) / increment) << " bin(s) per pixel" << endl;
-#endif
-if (repaintWidth == 0) {
-SVDEBUG << "*** NOTE: repaintWidth == 0" << endl;
-}
-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
-// time-bin resolution (if a time-bin spans more than one pixel).
-// We need to ensure that it starts and ends at points where a
-// time-bin boundary occurs at an exact pixel boundary, and with a
-// certain amount of overlap across existing pixels so that we can
-// scale and draw from it without smoothing errors at the edges.
-// 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 bufferIsBinResolution = false;
-if (increment > zoomLevel) bufferIsBinResolution = true;
-sv_frame_t leftBoundaryFrame = -1, leftCropFrame = -1;
-sv_frame_t rightBoundaryFrame = -1, rightCropFrame = -1;
-int bufwid;
-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;
-}
-}
-}
-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 + 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;
-#endif
-bufwid = int((rightBoundaryFrame - leftBoundaryFrame) / increment);
-} else {
-bufwid = repaintWidth;
-}
-vector<int> binforx(bufwid);
-vector<double> binfory(h);
-bool usePeaksCache = false;
-if (bufferIsBinResolution) {
-for (int x = 0; x < bufwid; ++x) {
-binforx[x] = int(leftBoundaryFrame / increment) + x;
-}
-m_drawBuffer = QImage(bufwid, h, QImage::Format_Indexed8);
-} else {
-for (int x = 0; x < bufwid; ++x) {
-double s0 = 0, s1 = 0;
-if (getXBinRange(v, x + x0, s0, s1)) {
-binforx[x] = int(s0 + 0.0001);
-} else {
-binforx[x] = -1; //???
-}
-}
-if (m_drawBuffer.width() < bufwid || m_drawBuffer.height() != h) {
-m_drawBuffer = QImage(bufwid, h, QImage::Format_Indexed8);
-}
-usePeaksCache = (increment * m_peakCacheDivisor) < zoomLevel;
-if (m_colourScale == PhaseColourScale) usePeaksCache = false;
-}
-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;
-}
-}
-attainedBufwid =
-paintDrawBuffer(v, bufwid, h, binforx, binfory,
-usePeaksCache,
-overallMag, overallMagChanged,
-rightToLeft,
-softTimeLimit);
-} else {
-attainedBufwid =
-paintDrawBufferPeakFrequencies(v, bufwid, h, binforx,
-minbin, maxbin,
-displayMinFreq, displayMaxFreq,
-logarithmic,
-overallMag, overallMagChanged,
-rightToLeft,
-softTimeLimit);
-}
-int failedToRepaint = bufwid - attainedBufwid;
-int paintedLeft = x0;
-int paintedWidth = x1 - x0;
-if (failedToRepaint > 0) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer::paint(): Failed to repaint " << failedToRepaint << " of " << bufwid
-<< " columns in time (so managed to repaint " << bufwid - failedToRepaint << ")" << endl;
-#endif
-if (rightToLeft) {
-paintedLeft += failedToRepaint;
-}
-paintedWidth -= failedToRepaint;
-if (paintedWidth < 0) {
-paintedWidth = 0;
-}
-} else if (failedToRepaint < 0) {
-cerr << "WARNING: failedToRepaint < 0 (= " << failedToRepaint << ")"
-<< endl;
-failedToRepaint = 0;
-}
-if (overallMagChanged) {
-m_viewMags[v->getId()] = overallMag;
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer: Overall mag is now [" << m_viewMags[v->getId()].getMin() << "->" << m_viewMags[v->getId()].getMax() << "] - will be updating" << endl;
-#endif
-}
-outerprof.end();
-Profiler profiler2("SpectrogramLayer::paint: draw image");
-if (paintedWidth > 0) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer: Copying " << paintedWidth << "x" << h
-<< " from draw buffer at " << paintedLeft - x0 << "," << 0
-<< " to " << paintedWidth << "x" << h << " on cache at "
-<< x0 << "," << 0 << endl;
-#endif
-if (bufferIsBinResolution) {
-int scaledLeft = v->getXForFrame(leftBoundaryFrame);
-int scaledRight = v->getXForFrame(rightBoundaryFrame);
-#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();
-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
-cerr << "SpectrogramLayer: Drawing image region of width " << scaledRightCrop - scaledLeftCrop << " to "
-<< scaledLeftCrop << " from " << scaledLeftCrop - scaledLeft << endl;
-#endif
-int targetLeft = scaledLeftCrop;
-if (targetLeft < 0) {
-targetLeft = 0;
-}
-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 {
-cache.drawImage(paintedLeft, paintedWidth,
-m_drawBuffer,
-paintedLeft - x0, paintedWidth);
-}
-}
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer: Cache valid area now from " << cache.getValidLeft()
-<< " width " << cache.getValidWidth() << ", height "
-<< cache.getSize().height() << endl;
-#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.getImage(),
-pr.x(), pr.y(), pr.width(), pr.height());
-if (!m_synchronous) {
-if ((m_normalization != NormalizeVisibleArea) || !overallMagChanged) {
-QRect areaLeft(0, 0, cache.getValidLeft(), h);
-QRect areaRight(cache.getValidRight(), 0,
-cache.getSize().width() - cache.getValidRight(), h);
-bool haveSpaceLeft = (areaLeft.width() > 0);
-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 (updateLeft) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer::paint() updating left ("
-<< areaLeft.x() << ", "
-<< areaLeft.width() << ")" << endl;
-#endif
-v->updatePaintRect(areaLeft);
-}
-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.invalidate();
-v->updatePaintRect(v->getPaintRect());
-}
-}
 illuminateLocalFeatures(v, paint);
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-cerr << "SpectrogramLayer::paint() returning" << endl;
-#endif
-}
-int
-SpectrogramLayer::paintDrawBufferPeakFrequencies(LayerGeometryProvider *v,
-int w,
-int h,
-const vector<int> &binforx,
-int minbin,
-int maxbin,
-double displayMinFreq,
-double displayMaxFreq,
-bool logarithmic,
-MagnitudeRange &overallMag,
-bool &overallMagChanged,
-bool rightToLeft,
-double softTimeLimit) const
-{
-Profiler profiler("SpectrogramLayer::paintDrawBufferPeakFrequencies");
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-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 0;
-FFTModel::PeakSet peakfreqs;
-int psx = -1;
-#ifdef __GNUC__
-float values[maxbin - minbin + 1];
-#else
-float *values = (float *)alloca((maxbin - minbin + 1) * sizeof(float));
-#endif
-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;
-if (x+1 < w) sx1 = binforx[x+1];
-if (sx0 < 0) sx0 = sx1 - 1;
-if (sx0 < 0) continue;
-if (sx1 <= sx0) sx1 = sx0 + 1;
-for (int sx = sx0; sx < sx1; ++sx) {
-if (sx < 0 || sx >= int(fft->getWidth())) continue;
-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_normalization == NormalizeColumns) {
-fft->getNormalizedMagnitudesAt(sx, values, minbin, maxbin - minbin + 1);
-} else if (m_normalization == NormalizeHybrid) {
-float max = fft->getNormalizedMagnitudesAt
-(sx, values, minbin, maxbin - minbin + 1);
-float scale = log10f(max + 1.f);
-for (int i = minbin; i <= maxbin; ++i) {
-values[i - minbin] *= scale;
-}
-} else {
-fft->getMagnitudesAt(sx, values, minbin, maxbin - minbin + 1);
-}
-psx = sx;
-}
-for (FFTModel::PeakSet::const_iterator pi = peakfreqs.begin();
-pi != peakfreqs.end(); ++pi) {
-int bin = pi->first;
-double freq = pi->second;
-if (bin < minbin) continue;
-if (bin > maxbin) break;
-double value = values[bin - minbin];
-if (m_colourScale != PhaseColourScale) {
-if (m_normalization != NormalizeColumns) {
-value /= (m_fftSize/2.0);
-}
-mag.sample(float(value));
-value *= m_gain;
-}
-double y = v->getYForFrequency
-(freq, displayMinFreq, displayMaxFreq, logarithmic);
-int iy = int(y + 0.5);
-if (iy < 0 || iy >= h) continue;
-m_drawBuffer.setPixel(x, iy, getDisplayValue(v, value));
-}
-if (mag.isSet()) {
-if (sx >= int(m_columnMags.size())) {
-#ifdef DEBUG_SPECTROGRAM
-cerr << "INTERNAL ERROR: " << sx << " >= "
-<< m_columnMags.size()
-<< " at SpectrogramLayer.cpp::paintDrawBuffer"
-<< endl;
-#endif
-} else {
-m_columnMags[sx].sample(mag);
-if (overallMag.sample(mag)) overallMagChanged = true;
-}
-}
-}
-if (haveTimeLimits) {
-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::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,
-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 << "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 << "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 = m_peakCacheDivisor;
-minbin = 0;
-maxbin = sourceModel->getHeight();
-} else {
-sourceModel = fft = getFFTModel(v);
-}
-if (!sourceModel) return 0;
-bool interpolate = false;
-Preferences::SpectrogramSmoothing smoothing =
-Preferences::getInstance()->getSpectrogramSmoothing();
-if (smoothing == Preferences::SpectrogramInterpolated ||
-smoothing == Preferences::SpectrogramZeroPaddedAndInterpolated) {
-if (m_binDisplay != PeakBins &&
-m_binDisplay != PeakFrequencies) {
-interpolate = true;
-}
-}
-int psx = -1;
-#ifdef __GNUC__
-float autoarray[maxbin - minbin + 1];
-float peaks[h];
-#else
-float *autoarray = (float *)alloca((maxbin - minbin + 1) * sizeof(float));
-float *peaks = (float *)alloca(h * sizeof(float));
-#endif
-const float *values = autoarray;
-DenseThreeDimensionalModel::Column c;
-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) {
-// x is the on-canvas pixel coord; sx (later) will be the
-// source column index
-++columnCount;
-if (binforx[x] < 0) continue;
-float columnMax = 0.f;
-int sx0 = binforx[x] / divisor;
-int sx1 = sx0;
-if (x+1 < w) sx1 = binforx[x+1] / divisor;
-if (sx0 < 0) sx0 = sx1 - 1;
-if (sx0 < 0) continue;
-if (sx1 <= sx0) sx1 = sx0 + 1;
-for (int y = 0; y < h; ++y) peaks[y] = 0.f;
-for (int sx = sx0; sx < sx1; ++sx) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-//            cerr << "sx = " << sx << endl;
-#endif
-if (sx < 0 || sx >= int(sourceModel->getWidth())) continue;
-MagnitudeRange mag;
-if (sx != psx) {
-if (fft) {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-//                    cerr << "Retrieving column " << sx << " from fft directly" << endl;
-#endif
-if (m_colourScale == PhaseColourScale) {
-fft->getPhasesAt(sx, autoarray, minbin, maxbin - minbin + 1);
-} else if (m_normalization == NormalizeColumns) {
-fft->getNormalizedMagnitudesAt(sx, autoarray, minbin, maxbin - minbin + 1);
-} else if (m_normalization == NormalizeHybrid) {
-float max = fft->getNormalizedMagnitudesAt
-(sx, autoarray, minbin, maxbin - minbin + 1);
-float scale = log10f(max + 1.f);
-for (int i = minbin; i <= maxbin; ++i) {
-autoarray[i - minbin] *= scale;
-}
-} else {
-fft->getMagnitudesAt(sx, autoarray, minbin, maxbin - minbin + 1);
-}
-} else {
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-//                    cerr << "Retrieving column " << sx << " from peaks cache" << endl;
-#endif
-c = sourceModel->getColumn(sx);
-if (m_normalization == NormalizeColumns ||
-m_normalization == NormalizeHybrid) {
-for (int y = 0; y < h; ++y) {
-if (c[y] > columnMax) columnMax = c[y];
-}
-}
-values = c.data() + minbin;
-}
-psx = sx;
-}
-for (int y = 0; y < h; ++y) {
-double sy0 = binfory[y];
-double sy1 = sy0 + 1;
-if (y+1 < h) sy1 = binfory[y+1];
-double value = 0.0;
-if (interpolate && fabs(sy1 - sy0) < 1.0) {
-double centre = (sy0 + sy1) / 2;
-double dist = (centre - 0.5) - rint(centre - 0.5);
-int bin = int(centre);
-int other = (dist < 0 ? (bin-1) : (bin+1));
-if (bin < minbin) bin = minbin;
-if (bin > maxbin) bin = maxbin;
-if (other < minbin || other > maxbin) other = bin;
-double prop = 1.0 - fabs(dist);
-double v0 = values[bin - minbin];
-double v1 = values[other - minbin];
-if (m_binDisplay == PeakBins) {
-if (bin == minbin || bin == maxbin ||
-v0 < values[bin-minbin-1] ||
-v0 < values[bin-minbin+1]) v0 = 0.0;
-if (other == minbin || other == maxbin ||
-v1 < values[other-minbin-1] ||
-v1 < values[other-minbin+1]) v1 = 0.0;
-}
-if (v0 == 0.0 && v1 == 0.0) continue;
-value = prop * v0 + (1.0 - prop) * v1;
-if (m_colourScale != PhaseColourScale) {
-if (m_normalization != NormalizeColumns &&
-m_normalization != NormalizeHybrid) {
-value /= (m_fftSize/2.0);
-}
-mag.sample(float(value));
-value *= m_gain;
-}
-peaks[y] = float(value);
-} else {
-int by0 = int(sy0 + 0.0001);
-int by1 = int(sy1 + 0.0001);
-if (by1 < by0 + 1) by1 = by0 + 1;
-for (int bin = by0; bin < by1; ++bin) {
-value = values[bin - minbin];
-if (m_binDisplay == PeakBins) {
-if (bin == minbin || bin == maxbin ||
-value < values[bin-minbin-1] ||
-value < values[bin-minbin+1]) continue;
-}
-if (m_colourScale != PhaseColourScale) {
-if (m_normalization != NormalizeColumns &&
-m_normalization != NormalizeHybrid) {
-value /= (m_fftSize/2.0);
-}
-mag.sample(float(value));
-value *= m_gain;
-}
-if (value > peaks[y]) {
-peaks[y] = float(value); //!!! not right for phase!
-}
-}
-}
-}
-if (mag.isSet()) {
-if (sx >= int(m_columnMags.size())) {
-#ifdef DEBUG_SPECTROGRAM
-cerr << "INTERNAL ERROR: " << sx << " >= "
-<< m_columnMags.size()
-<< " at SpectrogramLayer.cpp::paintDrawBuffer"
-<< endl;
-#endif
-} else {
-m_columnMags[sx].sample(mag);
-if (overallMag.sample(mag)) overallMagChanged = true;
-}
-}
-}
-// at this point we have updated m_columnMags and overallMag
-// -- used elsewhere for calculating the overall view range
-// for NormalizeVisibleArea mode -- and calculated "peaks"
-// (the possibly scaled and interpolated value array from
-// which we actually draw the column) and "columnMax" (maximum
-// value used for normalisation)
-for (int y = 0; y < h; ++y) {
-double peak = peaks[y];
-if (m_colourScale != PhaseColourScale &&
-(m_normalization == NormalizeColumns ||
-m_normalization == NormalizeHybrid) &&
-columnMax > 0.f) {
-peak /= columnMax;
-if (m_normalization == NormalizeHybrid) {
-peak *= log10(columnMax + 1.f);
-}
-}
-unsigned char peakpix = getDisplayValue(v, peak);
-m_drawBuffer.setPixel(x, h-y-1, peakpix);
-}
-if (haveTimeLimits) {
-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(LayerGeometryProvider *v, QPainter &paint) const
 {
 QPoint localPos;
 if (!v->shouldIlluminateLocalFeatures(this, localPos) || !m_model) {
 return;
 }
-//    cerr << "SpectrogramLayer: illuminateLocalFeatures("
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-//              << localPos.x() << "," << localPos.y() << ")" << endl;
+cerr << "SpectrogramLayer: illuminateLocalFeatures("
+<< localPos.x() << "," << localPos.y() << ")" << endl;
+#endif
 double s0, s1;
 double f0, f1;
 if (getXBinRange(v, localPos.x(), s0, s1) &&
 int x1 = v->getXForFrame((s1i + 1) * getWindowIncrement());
 int y1 = int(getYForFrequency(v, f1));
 int y0 = int(getYForFrequency(v, f0));
-//        cerr << "SpectrogramLayer: illuminate "
+#ifdef DEBUG_SPECTROGRAM_REPAINT
-//                  << x0 << "," << y1 << " -> " << x1 << "," << y0 << endl;
+cerr << "SpectrogramLayer: illuminate "
+<< x0 << "," << y1 << " -> " << x1 << "," << y0 << endl;
+#endif
 paint.setPen(v->getForeground());
 //!!! should we be using paintCrosshairs for this?
 SpectrogramLayer::getYForFrequency(const LayerGeometryProvider *v, double frequency) const
 {
 return v->getYForFrequency(frequency,
 			       getEffectiveMinFrequency(),
 			       getEffectiveMaxFrequency(),
-			       m_frequencyScale == LogFrequencyScale);
+			       m_binScale == BinScale::Log);
 }
 double
 SpectrogramLayer::getFrequencyForY(const LayerGeometryProvider *v, int y) const
 {
 return v->getFrequencyForY(y,
 			       getEffectiveMinFrequency(),
 			       getEffectiveMaxFrequency(),
-			       m_frequencyScale == LogFrequencyScale);
+			       m_binScale == BinScale::Log);
 }
 int
-SpectrogramLayer::getCompletion(LayerGeometryProvider *v) const
+SpectrogramLayer::getCompletion(LayerGeometryProvider *) const
 {
-const View *view = v->getView();
+if (!m_fftModel) return 100;
+int completion = m_fftModel->getCompletion();
-if (m_fftModels.find(view->getId()) == m_fftModels.end()) return 100;
-int completion = m_fftModels[view->getId()]->getCompletion();
 #ifdef DEBUG_SPECTROGRAM_REPAINT
 cerr << "SpectrogramLayer::getCompletion: completion = " << completion << endl;
 #endif
 return completion;
 }
 QString
-SpectrogramLayer::getError(LayerGeometryProvider *v) const
+SpectrogramLayer::getError(LayerGeometryProvider *) const
 {
-const View *view = v->getView();
+if (!m_fftModel) return "";
-if (m_fftModels.find(view->getId()) == m_fftModels.end()) return "";
+return m_fftModel->getError();
-return m_fftModels[view->getId()]->getError();
 }
 bool
 SpectrogramLayer::getValueExtents(double &min, double &max,
 bool &logarithmic, QString &unit) const
 {
 if (!m_model) return false;
 sv_samplerate_t sr = m_model->getSampleRate();
-min = double(sr) / m_fftSize;
+min = double(sr) / getFFTSize();
 max = double(sr) / 2;
-logarithmic = (m_frequencyScale == LogFrequencyScale);
+logarithmic = (m_binScale == BinScale::Log);
 unit = "Hz";
 return true;
 }
 bool
 int minf = int(lrint(min));
 int maxf = int(lrint(max));
 if (m_minFrequency == minf && m_maxFrequency == maxf) return true;
-invalidateImageCaches();
+invalidateRenderers();
 invalidateMagnitudes();
 m_minFrequency = minf;
 m_maxFrequency = maxf;
 }
 void
 SpectrogramLayer::measureDoubleClick(LayerGeometryProvider *v, QMouseEvent *e)
 {
-const View *view = v->getView();
+const Colour3DPlotRenderer *renderer = getRenderer(v);
-ScrollableImageCache &cache = getImageCacheReference(view);
+if (!renderer) return;
-cerr << "cache width: " << cache.getSize().width() << ", height: "
+QRect rect = renderer->findSimilarRegionExtents(e->pos());
-<< cache.getSize().height() << endl;
-QImage image = cache.getImage();
-ImageRegionFinder finder;
-QRect rect = finder.findRegionExtents(&image, e->pos());
 if (rect.isValid()) {
 MeasureRect mr;
 setMeasureRectFromPixrect(v, mr, rect);
 CommandHistory::getInstance()->addCommand
 (new AddMeasurementRectCommand(this, mr));
 paint.drawLine(0, cursorPos.y(), cursorPos.x() - 1, cursorPos.y());
 paint.drawLine(cursorPos.x(), 0, cursorPos.x(), v->getPaintHeight());
 double fundamental = getFrequencyForY(v, cursorPos.y());
-v->drawVisibleText(paint,
+PaintAssistant::drawVisibleText(v, paint,
 sw + 2,
 cursorPos.y() - 2,
 QString("%1 Hz").arg(fundamental),
-View::OutlinedText);
+PaintAssistant::OutlinedText);
 if (Pitch::isFrequencyInMidiRange(fundamental)) {
 QString pitchLabel = Pitch::getPitchLabelForFrequency(fundamental);
-v->drawVisibleText(paint,
+PaintAssistant::drawVisibleText(v, paint,
 sw + 2,
 cursorPos.y() + paint.fontMetrics().ascent() + 2,
 pitchLabel,
-View::OutlinedText);
+PaintAssistant::OutlinedText);
 }
 sv_frame_t frame = v->getFrameForX(cursorPos.x());
 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,
+PaintAssistant::drawVisibleText(v, paint,
 cursorPos.x() - paint.fontMetrics().width(frameLabel) - 2,
 v->getPaintHeight() - 2,
 frameLabel,
-View::OutlinedText);
+PaintAssistant::OutlinedText);
-v->drawVisibleText(paint,
+PaintAssistant::drawVisibleText(v, paint,
 cursorPos.x() + 2,
 v->getPaintHeight() - 2,
 rtLabel,
-View::OutlinedText);
+PaintAssistant::OutlinedText);
 int harmonic = 2;
 while (harmonic < 100) {
 	haveValues = true;
 }
 QString adjFreqText = "", adjPitchText = "";
-if (m_binDisplay == PeakFrequencies) {
+if (m_binDisplay == BinDisplay::PeakFrequencies) {
 	if (!getAdjustedYBinSourceRange(v, x, y, freqMin, freqMax,
 					adjFreqMin, adjFreqMax)) {
 	    return "";
 	}
 					  m_model->getSampleRate() / 2));
 int fw = paint.fontMetrics().width(tr("43Hz"));
 if (tw < fw) tw = fw;
-int tickw = (m_frequencyScale == LogFrequencyScale ? 10 : 4);
+int tickw = (m_binScale == BinScale::Log ? 10 : 4);
 return cw + tickw + tw + 13;
 }
 void
-SpectrogramLayer::paintVerticalScale(LayerGeometryProvider *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;
 }
 Profiler profiler("SpectrogramLayer::paintVerticalScale");
 //!!! cache this?
 int h = rect.height(), w = rect.width();
+int textHeight = paint.fontMetrics().height();
-int tickw = (m_frequencyScale == LogFrequencyScale ? 10 : 4);
-int pkw = (m_frequencyScale == LogFrequencyScale ? 10 : 0);
+if (detailed && (h > textHeight * 3 + 10)) {
+paintDetailedScale(v, paint, rect);
-int bins = m_fftSize / 2;
+}
+m_haveDetailedScale = detailed;
+int tickw = (m_binScale == BinScale::Log ? 10 : 4);
+int pkw = (m_binScale == BinScale::Log ? 10 : 0);
+int bins = getFFTSize() / 2;
 sv_samplerate_t sr = m_model->getSampleRate();
 if (m_maxFrequency > 0) {
-	bins = int((double(m_maxFrequency) * m_fftSize) / sr + 0.1);
+	bins = int((double(m_maxFrequency) * getFFTSize()) / sr + 0.1);
-	if (bins > m_fftSize / 2) bins = m_fftSize / 2;
+	if (bins > getFFTSize() / 2) bins = getFFTSize() / 2;
 }
 int cw = 0;
 if (detailed) cw = getColourScaleWidth(paint);
-int cbw = paint.fontMetrics().width("dB");
 int py = -1;
-int textHeight = paint.fontMetrics().height();
 int toff = -textHeight + paint.fontMetrics().ascent() + 2;
-if (detailed && (h > textHeight * 3 + 10)) {
-int topLines = 2;
-if (m_colourScale == PhaseColourScale) topLines = 1;
-	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->getId()].getMin();
-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));
-//!!! & phase etc
-if (m_colourScale != PhaseColourScale) {
-paint.drawText((cw + 6 - paint.fontMetrics().width("dBFS")) / 2,
-2 + textHeight + toff, "dBFS");
-}
-//	paint.drawText((cw + 6 - paint.fontMetrics().width(top)) / 2,
-	paint.drawText(3 + cw - cbw - paint.fontMetrics().width(top),
-		       2 + textHeight * topLines + toff + textHeight/2, top);
-	paint.drawText(3 + cw - cbw - paint.fontMetrics().width(bottom),
-		       h + toff - 3 - textHeight/2, bottom);
-	paint.save();
-	paint.setBrush(Qt::NoBrush);
-int lasty = 0;
-int lastdb = 0;
-	for (int i = 0; i < ch; ++i) {
-double dBval = dBmin + (((dBmax - dBmin) * i) / (ch - 1));
-int idb = int(dBval);
-double value = AudioLevel::dB_to_multiplier(dBval);
-int colour = getDisplayValue(v, value * m_gain);
-	    paint.setPen(m_palette.getColour((unsigned char)colour));
-int y = textHeight * topLines + 4 + ch - i;
-paint.drawLine(5 + cw - cbw, y, cw + 2, y);
-if (i == 0) {
-lasty = y;
-lastdb = idb;
-} else if (i < ch - paint.fontMetrics().ascent() &&
-idb != lastdb &&
-((abs(y - lasty) > textHeight &&
-idb % 10 == 0) ||
-(abs(y - lasty) > paint.fontMetrics().ascent() &&
-idb % 5 == 0))) {
-paint.setPen(v->getBackground());
-QString text = QString("%1").arg(idb);
-paint.drawText(3 + cw - cbw - paint.fontMetrics().width(text),
-y + toff + textHeight/2, text);
-paint.setPen(v->getForeground());
-paint.drawLine(5 + cw - cbw, y, 8 + cw - cbw, y);
-lasty = y;
-lastdb = idb;
-}
-	}
-	paint.restore();
-}
 paint.drawLine(cw + 7, 0, cw + 7, h);
 int bin = -1;
 	    bin = int(q0);
 	} else {
 	    continue;
 	}
-	int freq = int((sr * bin) / m_fftSize);
+	int freq = int((sr * bin) / getFFTSize());
 	if (py >= 0 && (vy - py) < textHeight - 1) {
-	    if (m_frequencyScale == LinearFrequencyScale) {
+	    if (m_binScale == BinScale::Linear) {
 		paint.drawLine(w - tickw, h - vy, w, h - vy);
 	    }
 	    continue;
 	}
 	}
 	py = vy;
 }
-if (m_frequencyScale == LogFrequencyScale) {
+if (m_binScale == BinScale::Log) {
 // piano keyboard
 PianoScale().paintPianoVertical
 (v, paint, QRect(w - pkw - 1, 0, pkw, h),
 getEffectiveMinFrequency(), getEffectiveMaxFrequency());
 }
 m_haveDetailedScale = detailed;
+}
+void
+SpectrogramLayer::paintDetailedScale(LayerGeometryProvider *v,
+QPainter &paint, QRect rect) const
+{
+// The colour scale
+if (m_colourScale == ColourScaleType::Phase) {
+paintDetailedScalePhase(v, paint, rect);
+return;
+}
+int h = rect.height();
+int textHeight = paint.fontMetrics().height();
+int toff = -textHeight + paint.fontMetrics().ascent() + 2;
+int cw = getColourScaleWidth(paint);
+int cbw = paint.fontMetrics().width("dB");
+int topLines = 2;
+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->getId()].getMin();
+double max = m_viewMags[v->getId()].getMax();
+if (min < m_threshold) min = m_threshold;
+if (max <= min) max = min + 0.1;
+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));
+#ifdef DEBUG_SPECTROGRAM_REPAINT
+cerr << "adjusted dB range to min = " << dBmin << ", max = " << dBmax
+<< endl;
+#endif
+paint.drawText((cw + 6 - paint.fontMetrics().width("dBFS")) / 2,
+2 + textHeight + toff, "dBFS");
+paint.drawText(3 + cw - cbw - paint.fontMetrics().width(top),
+2 + textHeight * topLines + toff + textHeight/2, top);
+paint.drawText(3 + cw - cbw - paint.fontMetrics().width(bottom),
+h + toff - 3 - textHeight/2, bottom);
+paint.save();
+paint.setBrush(Qt::NoBrush);
+int lasty = 0;
+int lastdb = 0;
+for (int i = 0; i < ch; ++i) {
+double dBval = dBmin + (((dBmax - dBmin) * i) / (ch - 1));
+int idb = int(dBval);
+double value = AudioLevel::dB_to_multiplier(dBval);
+paint.setPen(getRenderer(v)->getColour(value));
+int y = textHeight * topLines + 4 + ch - i;
+paint.drawLine(5 + cw - cbw, y, cw + 2, y);
+if (i == 0) {
+lasty = y;
+lastdb = idb;
+} else if (i < ch - paint.fontMetrics().ascent() &&
+idb != lastdb &&
+((abs(y - lasty) > textHeight &&
+idb % 10 == 0) ||
+(abs(y - lasty) > paint.fontMetrics().ascent() &&
+idb % 5 == 0))) {
+paint.setPen(v->getForeground());
+QString text = QString("%1").arg(idb);
+paint.drawText(3 + cw - cbw - paint.fontMetrics().width(text),
+y + toff + textHeight/2, text);
+paint.drawLine(5 + cw - cbw, y, 8 + cw - cbw, y);
+lasty = y;
+lastdb = idb;
+}
+}
+paint.restore();
+}
+void
+SpectrogramLayer::paintDetailedScalePhase(LayerGeometryProvider *v,
+QPainter &paint, QRect rect) const
+{
+// The colour scale in phase mode
+int h = rect.height();
+int textHeight = paint.fontMetrics().height();
+int toff = -textHeight + paint.fontMetrics().ascent() + 2;
+int cw = getColourScaleWidth(paint);
+// Phase is not measured in dB of course, but this places the
+// scale at the same position as in the magnitude spectrogram
+int cbw = paint.fontMetrics().width("dB");
+int topLines = 1;
+int ch = h - textHeight * (topLines + 1) - 8;
+paint.drawRect(4 + cw - cbw, textHeight * topLines + 4, cbw - 1, ch + 1);
+QString top, bottom, middle;
+top = QString("%1").arg(QChar(0x3c0)); // pi
+bottom = "-" + top;
+middle = "0";
+double min = -M_PI;
+double max =  M_PI;
+paint.drawText(3 + cw - cbw - paint.fontMetrics().width(top),
+2 + textHeight * topLines + toff + textHeight/2, top);
+paint.drawText(3 + cw - cbw - paint.fontMetrics().width(middle),
+2 + textHeight * topLines + ch/2 + toff + textHeight/2, middle);
+paint.drawText(3 + cw - cbw - paint.fontMetrics().width(bottom),
+h + toff - 3 - textHeight/2, bottom);
+paint.save();
+paint.setBrush(Qt::NoBrush);
+for (int i = 0; i < ch; ++i) {
+double val = min + (((max - min) * i) / (ch - 1));
+paint.setPen(getRenderer(v)->getColour(val));
+int y = textHeight * topLines + 4 + ch - i;
+paint.drawLine(5 + cw - cbw, y, cw + 2, y);
+}
+paint.restore();
 }
 class SpectrogramRangeMapper : public RangeMapper
 {
 public:
 {
 if (!m_model) return 0;
 sv_samplerate_t sr = m_model->getSampleRate();
-SpectrogramRangeMapper mapper(sr, m_fftSize);
+SpectrogramRangeMapper mapper(sr, getFFTSize());
-//    int maxStep = mapper.getPositionForValue((double(sr) / m_fftSize) + 0.001);
+//    int maxStep = mapper.getPositionForValue((double(sr) / getFFTSize()) + 0.001);
 int maxStep = mapper.getPositionForValue(0);
 int minStep = mapper.getPositionForValue(double(sr) / 2);
 int initialMax = m_initialMaxFrequency;
 if (initialMax == 0) initialMax = int(sr / 2);
 if (!m_model) return 0;
 double dmin, dmax;
 getDisplayExtents(dmin, dmax);
-SpectrogramRangeMapper mapper(m_model->getSampleRate(), m_fftSize);
+SpectrogramRangeMapper mapper(m_model->getSampleRate(), getFFTSize());
 int n = mapper.getPositionForValue(dmax - dmin);
 //    SVDEBUG << "SpectrogramLayer::getCurrentVerticalZoomStep: " << n << endl;
 return n;
 }
 //    getDisplayExtents(dmin, dmax);
 //    cerr << "current range " << dmin << " -> " << dmax << ", range " << dmax-dmin << ", mid " << (dmax + dmin)/2 << endl;
 sv_samplerate_t sr = m_model->getSampleRate();
-SpectrogramRangeMapper mapper(sr, m_fftSize);
+SpectrogramRangeMapper mapper(sr, getFFTSize());
 double newdist = mapper.getValueForPosition(step);
 double newmin, newmax;
-if (m_frequencyScale == LogFrequencyScale) {
+if (m_binScale == BinScale::Log) {
 // need to pick newmin and newmax such that
 //
 // (log(newmin) + log(newmax)) / 2 == logmid
 // and
 RangeMapper *
 SpectrogramLayer::getNewVerticalZoomRangeMapper() const
 {
 if (!m_model) return 0;
-return new SpectrogramRangeMapper(m_model->getSampleRate(), m_fftSize);
+return new SpectrogramRangeMapper(m_model->getSampleRate(), getFFTSize());
 }
 void
 SpectrogramLayer::updateMeasureRectYCoords(LayerGeometryProvider *v, const MeasureRect &r) const
 {
 		 "colourRotation=\"%5\" "
 		 "frequencyScale=\"%6\" "
 		 "binDisplay=\"%7\" ")
 	.arg(m_minFrequency)
 	.arg(m_maxFrequency)
-	.arg(m_colourScale)
+	.arg(convertFromColourScale(m_colourScale, m_colourScaleMultiple))
 	.arg(m_colourMap)
 	.arg(m_colourRotation)
-	.arg(m_frequencyScale)
+	.arg(int(m_binScale))
-	.arg(m_binDisplay);
+	.arg(int(m_binDisplay));
 // New-style normalization attributes, allowing for more types of
 // normalization in future: write out the column normalization
 // type separately, and then whether we are normalizing visible
 // area as well afterwards
 s += QString("columnNormalization=\"%1\" ")
-.arg(m_normalization == NormalizeColumns ? "peak" :
+.arg(m_normalization == ColumnNormalization::Max1 ? "peak" :
-m_normalization == NormalizeHybrid ? "hybrid" : "none");
+m_normalization == ColumnNormalization::Hybrid ? "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");
+	.arg(m_normalization == ColumnNormalization::Max1 ? "true" : "false");
 // And this applies to both old- and new-style attributes
 s += QString("normalizeVisibleArea=\"%1\" ")
-.arg(m_normalization == NormalizeVisibleArea ? "true" : "false");
+.arg(m_normalizeVisibleArea ? "true" : "false");
 Layer::toXml(stream, indent, extraAttributes + " " + s);
 }
 void
 if (ok) {
 SVDEBUG << "SpectrogramLayer::setProperties: setting max freq to " << maxFrequency << endl;
 setMaxFrequency(maxFrequency);
 }
-ColourScale colourScale = (ColourScale)
+auto colourScale = convertToColourScale
-	attributes.value("colourScale").toInt(&ok);
+(attributes.value("colourScale").toInt(&ok));
-if (ok) setColourScale(colourScale);
+if (ok) {
+setColourScale(colourScale.first);
+setColourScaleMultiple(colourScale.second);
+}
 int colourMap = attributes.value("colourScheme").toInt(&ok);
 if (ok) setColourMap(colourMap);
 int colourRotation = attributes.value("colourRotation").toInt(&ok);
 if (ok) setColourRotation(colourRotation);
-FrequencyScale frequencyScale = (FrequencyScale)
+BinScale binScale = (BinScale)
 	attributes.value("frequencyScale").toInt(&ok);
-if (ok) setFrequencyScale(frequencyScale);
+if (ok) setBinScale(binScale);
 BinDisplay binDisplay = (BinDisplay)
 	attributes.value("binDisplay").toInt(&ok);
 if (ok) setBinDisplay(binDisplay);
 if (columnNormalization != "") {
 haveNewStyleNormalization = true;
 if (columnNormalization == "peak") {
-setNormalization(NormalizeColumns);
+setNormalization(ColumnNormalization::Max1);
 } else if (columnNormalization == "hybrid") {
-setNormalization(NormalizeHybrid);
+setNormalization(ColumnNormalization::Hybrid);
 } else if (columnNormalization == "none") {
-// do nothing
+setNormalization(ColumnNormalization::None);
 } else {
 cerr << "NOTE: Unknown or unsupported columnNormalization attribute \""
 << columnNormalization << "\"" << endl;
 }
 }
 if (!haveNewStyleNormalization) {
 bool normalizeColumns =
 (attributes.value("normalizeColumns").trimmed() == "true");
 if (normalizeColumns) {
-setNormalization(NormalizeColumns);
+setNormalization(ColumnNormalization::Max1);
 }
 bool normalizeHybrid =
 (attributes.value("normalizeHybrid").trimmed() == "true");
 if (normalizeHybrid) {
-setNormalization(NormalizeHybrid);
+setNormalization(ColumnNormalization::Hybrid);
 }
 }
 bool normalizeVisibleArea =
-	(attributes.value("normalizeVisibleArea").trimmed() == "true");
+(attributes.value("normalizeVisibleArea").trimmed() == "true");
-if (normalizeVisibleArea) {
+setNormalizeVisibleArea(normalizeVisibleArea);
-setNormalization(NormalizeVisibleArea);
-}
+if (!haveNewStyleNormalization && m_normalization == ColumnNormalization::Hybrid) {
-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));
+setGain(m_gain / float(getFFTSize() / 2));
 }
 }

Mercurial > hg > svgui

comparison layer/SpectrogramLayer.cpp @ 1146:74f2706995b7 3.0-integration