comparison layer/SpectrogramLayer.cpp @ 382:06b5f110c5d2

* Speed up spectrogram painting by releasing mutex in FFTDataServer
while calculating data prior to writing it, and by adding whole-column
value query methods to FFT objects
* Add paint cache to Thumbwheel -- repaints of this widget were slowing
down the whole spectrogram repaint
* More uses of MutexLocker (named and with debug) and more profile
points
* Make startup much quicker some of the time, with OSC server in place

 }
 
 bool
 SpectrogramLayer::getYBinRange(View *v, int y, float &q0, float &q1) const
 {
+    Profiler profiler("SpectrogramLayer::getYBinRange");
+    
     int h = v->height();
     if (y < 0 || y >= h) return false;
 
     int sr = m_model->getSampleRate();
     float minf = getEffectiveMinFrequency();

                                        m_channel,
                                        m_windowType,
                                        m_windowSize,
                                        getWindowIncrement(),
                                        fftSize,
-                                       true,
+                                       true, // polar
                                        StorageAdviser::SpeedCritical,
                                        m_candidateFillStartFrame);
 
         if (!model->isOK()) {
             QMessageBox::critical

 
 //    std::cerr << "(giving actual minFreq " << minFreq << " and display minFreq " << displayMinFreq << ")" << std::endl;
 
     float ymag[h];
     float ydiv[h];
-    float yval[maxbin + 1]; //!!! cache this?
+
+    float yval[maxbin - minbin + 1];
+    float values[maxbin - minbin + 1];
 
     size_t increment = getWindowIncrement();
     
     bool logarithmic = (m_frequencyScale == LogFrequencyScale);
 
     for (size_t q = minbin; q <= maxbin; ++q) {
         float f0 = (float(q) * sr) / fftSize;
-        yval[q] = v->getYForFrequency(f0, displayMinFreq, displayMaxFreq,
-                                      logarithmic);
-//        std::cerr << "min: " << minFreq << ", max: " << maxFreq << ", yval[" << q << "]: " << yval[q] << std::endl;
+        yval[q - minbin] =
+            v->getYForFrequency(f0, displayMinFreq, displayMaxFreq,
+                                logarithmic);
     }
 
     MagnitudeRange overallMag = m_viewMags[v];
     bool overallMagChanged = false;
 

 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     size_t pixels = 0;
 #endif
 
+    Profiler outerprof("SpectrogramLayer::paint: all cols");
+    FFTModel::PeakSet peaks;
+
     for (int x = 0; x < w; ++x) {
+
+        Profiler innerprof("SpectrogramLayer::paint: 1 pixel column");
 
         if (runOutOfData) {
 #ifdef DEBUG_SPECTROGRAM_REPAINT
             std::cerr << "Run out of data -- dropping out of loop" << std::endl;
 #endif

             if (!fftSuspended) {
                 fft->suspendWrites();
                 fftSuspended = true;
             }
 
+            Profiler innerprof2("SpectrogramLayer::paint: 1 data column");
+
             MagnitudeRange mag;
 
-            FFTModel::PeakSet peaks;
-            if (m_binDisplay == PeakFrequencies &&
-                s < int(fft->getWidth()) - 1) {
-                peaks = fft->getPeakFrequencies(FFTModel::AllPeaks,
-                                                s,
-                                                minbin, maxbin - 1);
+            if (m_binDisplay == PeakFrequencies) {
+                if (s < int(fft->getWidth()) - 1) {
+                    peaks = fft->getPeakFrequencies(FFTModel::AllPeaks,
+                                                    s,
+                                                    minbin, maxbin - 1);
+                } else {
+                    peaks.clear();
+                }
             }
+                
+            if (m_colourScale == PhaseColourScale) {
+                fft->getPhasesAt(s, values, minbin, maxbin - minbin + 1);
+            } else if (m_normalizeColumns) {
+                fft->getNormalizedMagnitudesAt(s, values, minbin, maxbin - minbin + 1);
+            } else {
+                fft->getMagnitudesAt(s, values, minbin, maxbin - minbin + 1);
+            }
 
             for (size_t q = minbin; q < maxbin; ++q) {
 
-                float y0 = yval[q + 1];
-                float y1 = yval[q];
+                Profiler innerprof3("SpectrogramLayer::paint: 1 bin");
+
+                float y0 = yval[q + 1 - minbin];
+                float y1 = yval[q - minbin];
 
 		if (m_binDisplay == PeakBins) {
 		    if (!fft->isLocalPeak(s, q)) continue;
 		}
                 if (m_binDisplay == PeakFrequencies) {

                 if (m_threshold != 0.f &&
                     !fft->isOverThreshold(s, q, m_threshold * (m_fftSize/2))) {
                     continue;
                 }
 
-		float sprop = 1.0;
+		float sprop = 1.f;
 		if (s == s0i) sprop *= (s + 1) - s0;
 		if (s == s1i) sprop *= s1 - s;
  
 		if (m_binDisplay == PeakFrequencies) {
 		    y0 = y1 = v->getYForFrequency
 			(peaks[q], displayMinFreq, displayMaxFreq, logarithmic);
 		}
 		
-		int y0i = int(y0 + 0.001);
+		int y0i = int(y0 + 0.001f);
 		int y1i = int(y1);
 
-                float value;
+                float value = values[q - minbin];
+
+                if (m_colourScale != PhaseColourScale) {
+                    if (!m_normalizeColumns) {
+                        value /= (m_fftSize/2.f);
+                    }
+                    mag.sample(value);
+                    value *= m_gain;
+                }
+
+                float v2 = value;
+
+//!!!
                 
+                value = 0.f;
                 if (m_colourScale == PhaseColourScale) {
                     value = fft->getPhaseAt(s, q);
                 } else if (m_normalizeColumns) {
                     value = fft->getNormalizedMagnitudeAt(s, q);
                     mag.sample(value);

                     value = fft->getMagnitudeAt(s, q) / (m_fftSize/2);
                     mag.sample(value);
                     value *= m_gain;
                 }
 
+                if (value != v2) {
+                    std::cout << "old = " << value << " new = " << v2 << " at y = " << q << std::endl;
+                }
+
                 if (interpolate) {
                     
                     int ypi = y0i;
-                    if (q < maxbin - 1) ypi = int(yval[q + 2]);
+                    if (q < maxbin - 1) ypi = int(yval[q + 2 - minbin]);
 
                     for (int y = ypi; y <= y1i; ++y) {
                     
                         if (y < 0 || y >= h) continue;
                     
                         float yprop = sprop;
                         float iprop = yprop;
 
                         if (ypi < y0i && y <= y0i) {
 
-                            float half = float(y0i - ypi) / 2;
+                            float half = float(y0i - ypi) / 2.f;
                             float dist = y - (ypi + half);
 
                             if (dist >= 0) {
                                 iprop = (iprop * dist) / half;
                                 ymag[y] += iprop * value;
                             }
                         } else {
                             if (y1i > y0i) {
 
-                                float half = float(y1i - y0i) / 2;
+                                float half = float(y1i - y0i) / 2.f;
                                 float dist = y - (y0i + half);
                                 
                                 if (dist >= 0) {
                                     iprop = (iprop * (half - dist)) / half;
                                 }

                         for (int y = y0i; y <= y1i; ++y) {
 		    
                             if (y < 0 || y >= h) continue;
 
                             float yprop = sprop;
-                            if (y == y0i) yprop *= (y + 1) - y0;
+                            if (y == y0i) yprop *= (y + 1.f) - y0;
                             if (y == y1i) yprop *= y1 - y;
                             ymag[y] += yprop * value;
                             ydiv[y] += yprop;
                         }
                     }

 #endif
                 }
             }
 	}
 
+        Profiler drawbufferprof("SpectrogramLayer::paint: set buffer pixels");
+
 	for (int y = 0; y < h; ++y) {
 
 	    if (ydiv[y] > 0.0) {
 
 		unsigned char pixel = 0;

 #ifdef DEBUG_SPECTROGRAM_REPAINT
         std::cerr << "Overall mag unchanged at [" << m_viewMags[v].getMin() << "->" << m_viewMags[v].getMax() << "]" << std::endl;
 #endif
     }
 
-    Profiler profiler2("SpectrogramLayer::paint: draw image", true);
+    outerprof.end();
+
+    Profiler profiler2("SpectrogramLayer::paint: draw image");
 
     if (recreateWholePixmapCache) {
         std::cerr << "Recreating pixmap cache: width = " << v->width()
                   << ", height = " << h << std::endl;
 	cache.pixmap = QPixmap(v->width(), h);

 }
 
 void
 SpectrogramLayer::illuminateLocalFeatures(View *v, QPainter &paint) const
 {
+    Profiler profiler("SpectrogramLayer::illuminateLocalFeatures");
+
     QPoint localPos;
     if (!v->shouldIlluminateLocalFeatures(this, localPos) || !m_model) {
         return;
     }
 

 {
     if (!m_model || !m_model->isOK()) {
 	return;
     }
 
-    Profiler profiler("SpectrogramLayer::paintVerticalScale", true);
+    Profiler profiler("SpectrogramLayer::paintVerticalScale");
 
     //!!! cache this?
 
     int h = rect.height(), w = rect.width();