comparison layer/SpectrogramLayer.cpp @ 1086:163cb9b98104 spectrogram-minor-refactor

Simplify the oversampling/zero-padding logic. FFT model selection no longer depends on the view.

     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_initialThreshold(0.0),

     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 == "Zero Padding") return tr("Window");
+	name == "Window Increment") return tr("Window");
     if (name == "Colour" ||
 	name == "Threshold" ||
 	name == "Colour Rotation") return tr("Colour");
     if (name == "Normalization" ||
         name == "Gain" ||

 	*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;

 	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");

         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 (name == "Window Type") {
         setWindowType(Preferences::getInstance()->getWindowType());
         return;
     }
     if (name == "Spectrogram Y Smoothing") {
+        setWindowSize(m_windowSize);
         invalidateImageCaches();
         invalidateMagnitudes();
         emit layerParametersChanged();
     }
     if (name == "Spectrogram X Smoothing") {

 SpectrogramLayer::getChannel() const
 {
     return m_channel;
 }
 
+int
+SpectrogramLayer::getFFTOversampling() const
+{
+    if (m_binDisplay != AllBins) {
+        return 1;
+    }
+
+    Preferences::SpectrogramSmoothing smoothing = 
+        Preferences::getInstance()->getSpectrogramSmoothing();
+    
+    if (smoothing == Preferences::NoSpectrogramSmoothing ||
+        smoothing == Preferences::SpectrogramInterpolated) {
+        return 1;
+    }
+
+    return 4;
+}
+
 void
 SpectrogramLayer::setWindowSize(int ws)
 {
-    if (m_windowSize == ws) return;
+    int fftSize = ws * getFFTOversampling();
+
+    if (m_windowSize == ws && m_fftSize == fftSize) return;
 
     invalidateImageCaches();
     
     m_windowSize = ws;
-    m_fftSize = ws * (m_zeroPadLevel + 1);
+    m_fftSize = fftSize;
     
     invalidateFFTModels();
 
     emit layerParametersChanged();
 }

 
 int
 SpectrogramLayer::getWindowHopLevel() const
 {
     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)
 {

     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)
+    // Now map these on to ("proportions of") actual bins
 
     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;
 }
 
 double

 
     bool logarithmic = (m_frequencyScale == LogFrequencyScale);
 
     double q = v->getFrequencyForY(y, minf, maxf, logarithmic);
 
-    // Now map on to ("proportions of") actual bins, using raw FFT
-    // size (unsmoothed)
+    // Now map on to ("proportions of") actual bins
 
     q = (q * getFFTSize(v)) / sr;
 
     return q;
 }

 	    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(m_fftSize)/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);
-    q0i *= zp + 1;
-    q1i *= zp + 1;
 
     FFTModel *fft = getFFTModel(v);
 
     if (fft) {
 

 
     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);
+SpectrogramLayer::getFFTSize(const LayerGeometryProvider *) const
+{
+    //!!!
+    return m_fftSize;
 }
 	
 FFTModel *
 SpectrogramLayer::getFFTModel(const LayerGeometryProvider *v) const
 {

 
     // 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.
+    // If we are zero padding (i.e. oversampling) 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.
     
     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;

 //        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;
+    int over = getFFTOversampling();
+    minbin = minbin * over;
+    maxbin = (maxbin + 1) * over - 1;
 
     double minFreq = (double(minbin) * sr) / fftSize;
     double maxFreq = (double(maxbin) * sr) / fftSize;
 
     double displayMinFreq = minFreq;

 
     if (m_binDisplay != PeakFrequencies) {
 
         for (int y = 0; y < h; ++y) {
             double q0 = 0, q1 = 0;
-            if (!getSmoothedYBinRange(v, h-y-1, q0, q1)) {
+            if (!getYBinRange(v, h-y-1, q0, q1)) {
                 binfory[y] = -1;
             } else {
                 binfory[y] = q0;
             }
         }