comparison layer/SpectrogramLayer.cpp @ 1087:6d990a24ac1b spectrogram-minor-refactor

One FFT size method, no member for it

     m_model(0),
     m_channel(0),
     m_windowSize(1024),
     m_windowType(HanningWindow),
     m_windowHopLevel(2),
-    m_fftSize(1024),
     m_gain(1.0),
     m_initialGain(1.0),
     m_threshold(0.0),
     m_initialThreshold(0.0),
     m_colourRotation(0),

     }
 
     return 4;
 }
 
+int
+SpectrogramLayer::getFFTSize() const
+{
+    return m_windowSize * getFFTOversampling();
+}
+
 void
 SpectrogramLayer::setWindowSize(int ws)
 {
-    int fftSize = ws * getFFTOversampling();
-
-    if (m_windowSize == ws && m_fftSize == fftSize) return;
+    if (m_windowSize == ws) return;
 
     invalidateImageCaches();
     
     m_windowSize = ws;
-    m_fftSize = fftSize;
     
     invalidateFFTModels();
 
     emit layerParametersChanged();
 }

 
 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);
-	if (maxbin > m_fftSize / 2) maxbin = m_fftSize / 2;
-	maxf = maxbin * sr / m_fftSize;
+	int maxbin = int((double(m_maxFrequency) * getFFTSize()) / sr + 0.1);
+	if (maxbin > getFFTSize() / 2) maxbin = getFFTSize() / 2;
+	maxf = maxbin * sr / getFFTSize();
     }
 
     return maxf;
 }
 

     q0 = v->getFrequencyForY(y, minf, maxf, logarithmic);
     q1 = v->getFrequencyForY(y - 1, minf, maxf, logarithmic);
 
     // Now map these on to ("proportions of") actual bins
 
-    q0 = (q0 * m_fftSize) / sr;
-    q1 = (q1 * m_fftSize) / sr;
+    q0 = (q0 * getFFTSize()) / sr;
+    q1 = (q1 * getFFTSize()) / sr;
 
     return true;
 }
 
 double

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

     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 == q1i) freqMax = (sr * (q+1)) / m_fftSize;
+	if (q == q0i) freqMin = (sr * q) / getFFTSize();
+	if (q == q1i) freqMax = (sr * (q+1)) / getFFTSize();
     }
     return true;
 }
 
 bool

 	    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))) {
+                (s, q, float(m_threshold * double(getFFTSize())/2.0))) {
                 continue;
             }
 
             double freq = binfreq;
 	    

 
                     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::getFFTSize(const LayerGeometryProvider *) const
-{
-    //!!!
-    return m_fftSize;
-}
 	
 FFTModel *
 SpectrogramLayer::getFFTModel(const LayerGeometryProvider *v) const
 {
     if (!m_model) return 0;
 
-    int fftSize = getFFTSize(v);
+    int fftSize = getFFTSize();
 
     const View *view = v->getView();
     
     if (m_fftModels.find(view->getId()) != m_fftModels.end()) {
         if (m_fftModels[view->getId()] == 0) {

     // 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);
+    int fftSize = getFFTSize();
 
     const View *view = v->getView();
     ScrollableImageCache &cache = getImageCacheReference(view);
 
 #ifdef DEBUG_SPECTROGRAM_REPAINT

     // 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;
+    int maxbin = 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;
+	maxbin = int((double(m_maxFrequency) * fftSize) / sr + 0.001);
+	if (maxbin > fftSize / 2) maxbin = fftSize / 2;
     }
 
     int minbin = 1;
     if (m_minFrequency > 0) {
-	minbin = int((double(m_minFrequency) * m_fftSize) / sr + 0.001);
+	minbin = int((double(m_minFrequency) * fftSize) / sr + 0.001);
 //        cerr << "m_minFrequency = " << m_minFrequency << " -> minbin = " << minbin << endl;
 	if (minbin < 1) minbin = 1;
 	if (minbin >= maxbin) minbin = maxbin - 1;
     }
 

     double maxFreq = (double(maxbin) * sr) / fftSize;
 
     double displayMinFreq = minFreq;
     double displayMaxFreq = maxFreq;
 
-    if (fftSize != m_fftSize) {
-        displayMinFreq = getEffectiveMinFrequency();
-        displayMaxFreq = getEffectiveMaxFrequency();
-    }
+//!!!    if (fftSize != getFFTSize()) {
+//        displayMinFreq = getEffectiveMinFrequency();
+//        displayMaxFreq = getEffectiveMaxFrequency();
+//    }
 
 //    cerr << "(giving actual minFreq " << minFreq << " and display minFreq " << displayMinFreq << ")" << endl;
 
     int increment = getWindowIncrement();
     

                                                sx,
                                                minbin,
                                                maxbin - minbin + 1);
 
                 if (m_colourScale != PhaseColourScale) {
-                    column = ColumnOp::fftScale(column, m_fftSize);
+                    column = ColumnOp::fftScale(column, getFFTSize());
                 }
 
                 recordColumnExtents(column,
                                     sx,
                                     overallMag,

                                                    minbin,
                                                    maxbin - minbin + 1);
                 }
 
                 if (m_colourScale != PhaseColourScale) {
-                    column = ColumnOp::fftScale(column, m_fftSize);
+                    column = ColumnOp::fftScale(column, getFFTSize());
                 }
 
                 recordColumnExtents(column,
                                     sx,
                                     overallMag,

                                   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);
     unit = "Hz";
     return true;

     int h = rect.height(), w = rect.width();
 
     int tickw = (m_frequencyScale == LogFrequencyScale ? 10 : 4);
     int pkw = (m_frequencyScale == LogFrequencyScale ? 10 : 0);
 
-    int bins = m_fftSize / 2;
+    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);
-	if (bins > m_fftSize / 2) bins = m_fftSize / 2;
+	bins = int((double(m_maxFrequency) * getFFTSize()) / sr + 0.1);
+	if (bins > getFFTSize() / 2) bins = getFFTSize() / 2;
     }
 
     int cw = 0;
 
     if (detailed) cw = getColourScaleWidth(paint);

 	    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) {
 		paint.drawLine(w - tickw, h - vy, w, h - vy);
 	    }

 {
     if (!m_model) return 0;
 
     sv_samplerate_t sr = m_model->getSampleRate();
 
-    SpectrogramRangeMapper mapper(sr, m_fftSize);
-
-//    int maxStep = mapper.getPositionForValue((double(sr) / m_fftSize) + 0.001);
+    SpectrogramRangeMapper mapper(sr, getFFTSize());
+
+//    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) {

 
 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
 {

         // 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));
+    }
+}
+