comparison layer/SpectrogramLayer.cpp @ 114:991de8783cf5

* Add fuzzy-adapter class to pick out subset data from FFT data server, instead
  of having separate methods in data server class.  Update spectrogram to use it.

* Give spectrogram layer one fft adapter per view, in case the views need
  different zero-padding levels.

* Reduce ridiculous memory consumption of MatrixFile for tall matrices.

  Still very much work in progress here.

     m_colourScale(dBColourScale),
     m_colourScheme(DefaultColours),
     m_frequencyScale(LinearFrequencyScale),
     m_binDisplay(AllBins),
     m_normalizeColumns(false),
-    m_fftServer(0),
     m_updateTimer(0),
     m_candidateFillStartFrame(0),
     m_lastFillExtent(0),
     m_exiting(false)
 {

 SpectrogramLayer::~SpectrogramLayer()
 {
     delete m_updateTimer;
     m_updateTimer = 0;
     
-    if (m_fftServer) {
-        FFTDataServer::releaseInstance(m_fftServer);
-        m_fftServer = 0;
-    }
+    invalidateFFTAdapters();
 }
 
 void
 SpectrogramLayer::setModel(const DenseTimeValueModel *model)
 {
 //    std::cerr << "SpectrogramLayer(" << this << "): setModel(" << model << ")" << std::endl;
 
     if (model == m_model) return;
 
     m_model = model;
-    getFFTServer();
+    invalidateFFTAdapters();
 
     if (!m_model || !m_model->isOK()) return;
 
     connect(m_model, SIGNAL(modelChanged()), this, SIGNAL(modelChanged()));
     connect(m_model, SIGNAL(modelChanged(size_t, size_t)),

     connect(m_model, SIGNAL(modelChanged(size_t, size_t)),
 	    this, SLOT(cacheInvalid(size_t, size_t)));
 
     emit modelReplaced();
 }
-
-void
-SpectrogramLayer::getFFTServer()
-{
-    if (m_fftServer) {
-        FFTDataServer::releaseInstance(m_fftServer);
-        m_fftServer = 0;
-    }
+/*!!!
+void
+SpectrogramLayer::invalidateFFTAdapters()
+{
+//    if (m_fftServer) {
+//        FFTDataServer::releaseInstance(m_fftServer);
+//        m_fftServer = 0;
+//    }
+
+    delete m_fftServer;
+    m_fftServer = 0;
 
     if (m_model) {
-        m_fftServer = FFTDataServer::getFuzzyInstance(m_model,
+//        m_fftServer = FFTDataServer::getFuzzyInstance(m_model,
+        m_fftServer = new FFTFuzzyAdapter(m_model,
                                                       m_channel,
                                                       m_windowType,
                                                       m_windowSize,
                                                       getWindowIncrement(),
                                                       m_fftSize,

         m_updateTimer = new QTimer(this);
         connect(m_updateTimer, SIGNAL(timeout()), this, SLOT(fillTimerTimedOut()));
         m_updateTimer->start(200);
     }
 }
-
+*/
 Layer::PropertyList
 SpectrogramLayer::getProperties() const
 {
     PropertyList list;
     list.push_back("Colour");

 {
     if (m_channel == ch) return;
 
     invalidatePixmapCaches();
     m_channel = ch;
-    getFFTServer();
+    invalidateFFTAdapters();
 
     emit layerParametersChanged();
 }
 
 int

     invalidatePixmapCaches();
     
     m_windowSize = ws;
     m_fftSize = ws * (m_zeroPadLevel + 1);
     
-    getFFTServer();
+    invalidateFFTAdapters();
 
     emit layerParametersChanged();
 }
 
 size_t

 
     invalidatePixmapCaches();
     
     m_windowHopLevel = v;
     
-    getFFTServer();
+    invalidateFFTAdapters();
 
     emit layerParametersChanged();
 
 //    fillCache();
 }

     invalidatePixmapCaches();
     
     m_zeroPadLevel = v;
     m_fftSize = m_windowSize * (v + 1);
 
-    getFFTServer();
+    invalidateFFTAdapters();
 
     emit layerParametersChanged();
 }
 
 size_t

 
     invalidatePixmapCaches();
     
     m_windowType = w;
 
-    getFFTServer();
+    invalidateFFTAdapters();
 
     emit layerParametersChanged();
 }
 
 WindowType

 
 	m_dormancy[v] = true;
 
 	invalidatePixmapCaches();
         m_pixmapCaches.erase(v);
+
+        if (m_fftAdapters.find(v) != m_fftAdapters.end()) {
+            delete m_fftAdapters[v];
+            m_fftAdapters.erase(v);
+        }
 	
     } else {
 
 	m_dormancy[v] = false;
     }

 }
 
 void
 SpectrogramLayer::fillTimerTimedOut()
 {
+/*!!!
     if (m_fftServer && m_model) {
 
 	size_t fillExtent = m_fftServer->getFillExtent();
 #ifdef DEBUG_SPECTROGRAM_REPAINT
 	std::cerr << "SpectrogramLayer::fillTimerTimedOut: extent " << fillExtent << ", last " << m_lastFillExtent << ", total " << m_model->getEndFrame() << std::endl;

             invalidatePixmapCaches();
             emit modelChanged(m_model->getStartFrame(), m_model->getEndFrame());
 	    m_lastFillExtent = fillExtent;
 	}
     }
+*/
 }
 
 void
 SpectrogramLayer::setColourmap()
 {

 }
 
 void
 SpectrogramLayer::rotateColourmap(int distance)
 {
-    if (!m_fftServer) return;
-
     QColor newPixels[256];
 
     newPixels[NO_VALUE] = m_colourMap.getColour(NO_VALUE);
 
     for (int pixel = 1; pixel < 256; ++pixel) {

     float minf = getEffectiveMinFrequency();
     float maxf = getEffectiveMaxFrequency();
 
     bool logarithmic = (m_frequencyScale == LogFrequencyScale);
 
+    //!!! wrong for smoothing -- wrong fft size for fft adapter
+
     q0 = v->getFrequencyForY(y, minf, maxf, logarithmic);
     q1 = v->getFrequencyForY(y - 1, minf, maxf, logarithmic);
 
     // Now map these on to actual bins
 

 
     int q0i = int(q0 + 0.001);
     int q1i = int(q1);
 
     int sr = m_model->getSampleRate();
+
+    //!!! wrong for smoothing -- wrong fft size for fft adapter
 
     for (int q = q0i; q <= q1i; ++q) {
 	int binfreq = (sr * q) / m_fftSize;
 	if (q == q0i) freqMin = binfreq;
 	if (q == q1i) freqMax = binfreq;

 SpectrogramLayer::getAdjustedYBinSourceRange(View *v, int x, int y,
 					     float &freqMin, float &freqMax,
 					     float &adjFreqMin, float &adjFreqMax)
 const
 {
-    if (!m_fftServer) return false;
+    FFTFuzzyAdapter *fft = getFFTAdapter(v);
+    if (!fft) return false;
 
     float s0 = 0, s1 = 0;
     if (!getXBinRange(v, x, s0, s1)) return false;
 
     float q0 = 0, q1 = 0;

 
 	    float binfreq = (sr * q) / m_windowSize;
 	    if (q == q0i) freqMin = binfreq;
 	    if (q == q1i) freqMax = binfreq;
 
-	    if (peaksOnly && !isFFTLocalPeak(s, q)) continue;
-
-	    if (!isFFTOverThreshold(s, q, m_threshold)) continue;
+	    if (peaksOnly && !fft->isLocalPeak(s, q)) continue;
+
+	    if (!fft->isOverThreshold(s, q, m_threshold)) continue;
 
 	    float freq = binfreq;
 	    bool steady = false;
 	    
-	    if (s < int(getFFTWidth()) - 1) {
+	    if (s < int(fft->getWidth()) - 1) {
 
 		freq = calculateFrequency(q, 
 					  windowSize,
 					  windowIncrement,
 					  sr, 
-					  getFFTPhaseAt(s, q),
-					  getFFTPhaseAt(s+1, q),
+					  fft->getPhaseAt(s, q),
+					  fft->getPhaseAt(s+1, q),
 					  steady);
 	    
 		if (!haveAdj || freq < adjFreqMin) adjFreqMin = freq;
 		if (!haveAdj || freq > adjFreqMax) adjFreqMax = freq;
 

     int s0i = int(s0 + 0.001);
     int s1i = int(s1);
 
     bool rv = false;
 
-    if (m_fftServer) {
-
-        int cw = getFFTWidth();
-        int ch = getFFTHeight();
+    FFTFuzzyAdapter *fft = getFFTAdapter(v);
+
+    if (fft) {
+
+        int cw = fft->getWidth();
+        int ch = fft->getHeight();
 
         min = 0.0;
         max = 0.0;
         phaseMin = 0.0;
         phaseMax = 0.0;

             for (int s = s0i; s <= s1i; ++s) {
                 if (s >= 0 && q >= 0 && s < cw && q < ch) {
                     
                     float value;
 
-                    value = getFFTPhaseAt(s, q);
+                    value = fft->getPhaseAt(s, q);
                     if (!have || value < phaseMin) { phaseMin = value; }
                     if (!have || value > phaseMax) { phaseMax = value; }
 
-                    value = getFFTMagnitudeAt(s, q);
+                    value = fft->getMagnitudeAt(s, q);
                     if (!have || value < min) { min = value; }
                     if (!have || value > max) { max = value; }
                     
                     have = true;
                 }	

     }
 
     return rv;
 }
    
+size_t
+SpectrogramLayer::getZeroPadLevel(const View *v) const
+{
+    //!!! tidy all this stuff
+
+    if (m_binDisplay != AllBins) return 0;
+    if (m_frequencyScale == LogFrequencyScale) return 3;
+
+    int sr = m_model->getSampleRate();
+    
+    size_t bins = m_fftSize / 2;
+    if (m_maxFrequency > 0) {
+	bins = int((double(m_maxFrequency) * m_fftSize) / sr + 0.1);
+	if (bins > m_fftSize / 2) bins = m_fftSize / 2;
+    }
+
+    size_t minbin = 1;
+    if (m_minFrequency > 0) {
+	minbin = int((double(m_minFrequency) * m_fftSize) / sr + 0.1);
+	if (minbin < 1) minbin = 1;
+	if (minbin >= bins) minbin = bins - 1;
+    }
+
+    if (v->height() / 1.5 > (bins - minbin) / (m_zeroPadLevel + 1)) {
+        return 3;
+    } else {
+        return 0;
+    }
+}
+
+size_t
+SpectrogramLayer::getFFTSize(const View *v) const
+{
+    return m_fftSize * (getZeroPadLevel(v) + 1);
+}
+	
+FFTFuzzyAdapter *
+SpectrogramLayer::getFFTAdapter(const View *v) const
+{
+    if (!m_model) return 0;
+
+    size_t fftSize = getFFTSize(v);
+
+    if (m_fftAdapters.find(v) != m_fftAdapters.end()) {
+        if (m_fftAdapters[v]->getHeight() != fftSize / 2) {
+            delete m_fftAdapters[v];
+            m_fftAdapters.erase(v);
+        }
+    }
+
+    if (m_fftAdapters.find(v) == m_fftAdapters.end()) {
+        m_fftAdapters[v] = new FFTFuzzyAdapter(m_model,
+                                               m_channel,
+                                               m_windowType,
+                                               m_windowSize,
+                                               getWindowIncrement(),
+                                               getFFTSize(v),
+                                               true,
+                                               m_candidateFillStartFrame);
+        m_lastFillExtent = 0;
+        
+        delete m_updateTimer;
+        m_updateTimer = new QTimer((SpectrogramLayer *)this);
+        connect(m_updateTimer, SIGNAL(timeout()),
+                this, SLOT(fillTimerTimedOut()));
+        m_updateTimer->start(200);
+    }
+
+    return m_fftAdapters[v];
+}
+
+void
+SpectrogramLayer::invalidateFFTAdapters()
+{
+    for (ViewFFTMap::iterator i = m_fftAdapters.begin();
+         i != m_fftAdapters.end(); ++i) {
+        delete i->second;
+    }
+    
+    m_fftAdapters.clear();
+}
+
 void
 SpectrogramLayer::paint(View *v, QPainter &paint, QRect rect) const
 {
     if (m_colourScheme == BlackOnWhite) {
 	v->setLightBackground(true);

     // 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.
     m_dormancy[v] = false;
 
-    if (!m_fftServer) { // lock the mutex before checking this
-#ifdef DEBUG_SPECTROGRAM_REPAINT
-	std::cerr << "SpectrogramLayer::paint(): No FFT server, returning" << std::endl;
-#endif
+    size_t fftSize = getFFTSize(v);
+    FFTFuzzyAdapter *fft = getFFTAdapter(v);
+    if (!fft) {
+	std::cerr << "ERROR: SpectrogramLayer::paint(): No FFT adapter, returning" << std::endl;
 	return;
     }
 
     PixmapCache &cache = m_pixmapCaches[v];
 

 
     m_drawBuffer.fill(m_colourMap.getColour(0).rgb());
 
     int sr = m_model->getSampleRate();
     
-    size_t bins = m_fftSize / 2;
+    size_t bins = fftSize / 2;
     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) * fftSize) / sr + 0.1);
+	if (bins > fftSize / 2) bins = fftSize / 2;
     }
 
     size_t minbin = 1;
     if (m_minFrequency > 0) {
-	minbin = int((double(m_minFrequency) * m_fftSize) / sr + 0.1);
+	minbin = int((double(m_minFrequency) * fftSize) / sr + 0.1);
 	if (minbin < 1) minbin = 1;
 	if (minbin >= bins) minbin = bins - 1;
     }
 
-    //!!! quite wrong and won't work for layers that may be in more than one view
-    if (v->height() / 1.5 > (bins - minbin) / (m_zeroPadLevel + 1)) {
-        if (m_zeroPadLevel != 3) {
-            std::cerr << v->height()/1.5 << " > " << ((bins - minbin) / (m_zeroPadLevel + 1)) << ": switching to smoothed display" << std::endl;
-            ((SpectrogramLayer *)this)->setZeroPadLevel(3);
-            return;
-        }
-    } else {
-        if (m_zeroPadLevel != 0) {
-            ((SpectrogramLayer *)this)->setZeroPadLevel(0);
-            return;
-        }
-    }
-	
-    float minFreq = (float(minbin) * sr) / m_fftSize;
-    float maxFreq = (float(bins) * sr) / m_fftSize;
+    float minFreq = (float(minbin) * sr) / fftSize;
+    float maxFreq = (float(bins) * sr) / fftSize;
 
     float ymag[h];
     float ydiv[h];
     float yval[bins + 1];
 
     size_t increment = getWindowIncrement();
     
     bool logarithmic = (m_frequencyScale == LogFrequencyScale);
 
     for (size_t q = minbin; q <= bins; ++q) {
-        float f0 = (float(q) * sr) / m_fftSize;
+        float f0 = (float(q) * sr) / fftSize;
         yval[q] = v->getYForFrequency(f0, minFreq, maxFreq, logarithmic);
     }
 
     for (int x = 0; x < w; ++x) {
 

 	}
 
 	int s0i = int(s0 + 0.001);
 	int s1i = int(s1);
 
-	if (s1i >= getFFTWidth()) {
-	    if (s0i >= getFFTWidth()) {
+	if (s1i >= fft->getWidth()) {
+	    if (s0i >= fft->getWidth()) {
 		continue;
 	    } else {
 		s1i = s0i;
 	    }
 	}
 
         for (int s = s0i; s <= s1i; ++s) {
 
-            if (!isFFTColumnReady(s)) continue;
+            if (!fft->isColumnReady(s)) continue;
 
             for (size_t q = minbin; q < bins; ++q) {
 
                 float y0 = yval[q + 1];
                 float y1 = yval[q];
 
 		if (m_binDisplay == PeakBins ||
 		    m_binDisplay == PeakFrequencies) {
-		    if (!isFFTLocalPeak(s, q)) continue;
+		    if (!fft->isLocalPeak(s, q)) continue;
 		}
-		
-		if (!isFFTOverThreshold(s, q, m_threshold)) continue;
+
+                if (m_threshold != 0.f &&
+                    !fft->isOverThreshold(s, q, m_threshold)) {
+                    continue;
+                }
 
 		float sprop = 1.0;
 		if (s == s0i) sprop *= (s + 1) - s0;
 		if (s == s1i) sprop *= s1 - s;
  
 		if (m_binDisplay == PeakFrequencies &&
-		    s < int(getFFTWidth()) - 1) {
+		    s < int(fft->getWidth()) - 1) {
 
 		    bool steady = false;
                     float f = calculateFrequency(q,
 						 m_windowSize,
 						 increment,
 						 sr,
-						 getFFTPhaseAt(s, q),
-						 getFFTPhaseAt(s+1, q),
+						 fft->getPhaseAt(s, q),
+						 fft->getPhaseAt(s+1, q),
 						 steady);
 
 		    y0 = y1 = v->getYForFrequency
 			(f, minFreq, maxFreq, logarithmic);
 		}

 		int y1i = int(y1);
 
                 float value;
                 
                 if (m_colourScale == PhaseColourScale) {
-                    value = getFFTPhaseAt(s, q);
+                    value = fft->getPhaseAt(s, q);
                 } else if (m_normalizeColumns) {
-                    value = getFFTNormalizedMagnitudeAt(s, q) * m_gain;
+                    value = fft->getNormalizedMagnitudeAt(s, q) * m_gain;
                 } else {
-                    value = getFFTMagnitudeAt(s, q) * m_gain;
+                    value = fft->getMagnitudeAt(s, q) * m_gain;
                 }
 
 		for (int y = y0i; y <= y1i; ++y) {
 		    
 		    if (y < 0 || y >= h) continue;

 }
 
 int
 SpectrogramLayer::getCompletion() const
 {
+/*!!!
     if (m_updateTimer == 0 || !m_fftServer) return 100;
     size_t completion = m_fftServer->getFillCompletion();
 //    std::cerr << "SpectrogramLayer::getCompletion: completion = " << completion << std::endl;
     return completion;
+*/
+    return 100;
 }
 
 bool
 SpectrogramLayer::getValueExtents(float &min, float &max,
                                   bool &logarithmic, QString &unit) const

 
     int py = -1;
     int textHeight = paint.fontMetrics().height();
     int toff = -textHeight + paint.fontMetrics().ascent() + 2;
 
-    if (m_fftServer && h > textHeight * 2 + 10) {
+    if (h > textHeight * 2 + 10) {
 
 	int ch = h - textHeight * 2 - 8;
 	paint.drawRect(4, textHeight + 4, cw - 1, ch + 1);
 
 	QString top, bottom;