comparison layer/SpectrogramLayer.cpp @ 86:93a7efc75fb7

* Switch spectrogram layer over to using the new rudimentary disk-backed
  FFT cache

 #include "base/Profiler.h"
 #include "base/AudioLevel.h"
 #include "base/Window.h"
 #include "base/Pitch.h"
 #include "base/FFTCache.h"
+#include "base/FFTFileCache.h"
 
 #include <QPainter>
 #include <QImage>
 #include <QPixmap>
 #include <QRect>

     m_colourScheme(DefaultColours),
     m_frequencyScale(LinearFrequencyScale),
     m_binDisplay(AllBins),
     m_normalizeColumns(false),
     m_cache(0),
+    m_writeCache(0),
     m_cacheInvalid(true),
     m_pixmapCache(0),
     m_pixmapCacheInvalid(true),
     m_fillThread(0),
     m_updateTimer(0),

     m_exiting = true;
     m_condition.wakeAll();
     if (m_fillThread) m_fillThread->wait();
     delete m_fillThread;
     
+    delete m_writeCache;
     delete m_cache;
 }
 
 void
 SpectrogramLayer::setModel(const DenseTimeValueModel *model)

     if (m_cacheInvalid || !m_cache) return;
 
     int formerRotation = m_colourRotation;
 
     if (m_colourScheme == BlackOnWhite) {
-	m_cache->setColour(NO_VALUE, Qt::white);
+	m_colourMap.setColour(NO_VALUE, Qt::white);
     } else {
-	m_cache->setColour(NO_VALUE, Qt::black);
+	m_colourMap.setColour(NO_VALUE, Qt::black);
     }
 
     for (int pixel = 1; pixel < 256; ++pixel) {
 
 	QColor colour;

 	    colour = QColor::fromHsv(pixel, 255, 255);
             m_crosshairColour = Qt::white;
 	    break;
 	}
 
-	m_cache->setColour(pixel, colour);
+	m_colourMap.setColour(pixel, colour);
     }
 
     m_colourRotation = 0;
     rotateCacheColourmap(m_colourRotation - formerRotation);
     m_colourRotation = formerRotation;

 {
     if (!m_cache) return;
 
     QColor newPixels[256];
 
-    newPixels[NO_VALUE] = m_cache->getColour(NO_VALUE);
+    newPixels[NO_VALUE] = m_colourMap.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_cache->getColour(pixel);
+	newPixels[target] = m_colourMap.getColour(pixel);
     }
 
     for (int pixel = 0; pixel < 256; ++pixel) {
-	m_cache->setColour(pixel, newPixels[pixel]);
+	m_colourMap.setColour(pixel, newPixels[pixel]);
     }
 }
 
 float
 SpectrogramLayer::calculateFrequency(size_t bin,

 SpectrogramLayer::fillCacheColumn(int column, double *input,
 				  fftw_complex *output,
 				  fftw_plan plan, 
 				  size_t windowSize,
 				  size_t increment,
+                                  float *workbuffer,
 				  const Window<double> &windower) const
 {
     //!!! we _do_ need a lock for these references to the model
     // though, don't we?
 

 	if (mag > factor) factor = mag;
 
 	double phase = atan2(output[i][1], output[i][0]);
 	phase = princarg(phase);
 
-	output[i][0] = mag;
-	m_cache->setPhaseAt(column, i, phase);
-    }
-
-    m_cache->setNormalizationFactor(column, factor);
-
-    for (size_t i = 0; i < windowSize/2; ++i) {
-	m_cache->setMagnitudeAt(column, i, output[i][0]);
-    }
+        workbuffer[i] = mag;
+        workbuffer[i + windowSize/2] = phase;
+    }
+
+    m_writeCache->setColumnAt(column, workbuffer,
+                              workbuffer + windowSize/2, factor);
 }
 
 unsigned char
 SpectrogramLayer::getDisplayValue(float input) const
 {

 	    visibleStart = (visibleStart / windowIncrement) * windowIncrement;
 
 	    size_t width = (end - start) / windowIncrement + 1;
 	    size_t height = windowSize / 2;
 
-	    if (!m_layer.m_cache) {
-		m_layer.m_cache = new FFTMemoryCache;
-	    }
-
-	    m_layer.m_cache->resize(width, height);
+//!!!	    if (!m_layer.m_cache) {
+//		m_layer.m_cache = new FFTMemoryCache;
+//	    }
+            if (!m_layer.m_writeCache) {
+                m_layer.m_writeCache = new FFTFileCache
+                    (QString("%1").arg(getObjectExportId(&m_layer)),
+                     MatrixFileCache::ReadWrite);
+            }
+	    m_layer.m_writeCache->resize(width, height);
+            if (m_layer.m_cache) delete m_layer.m_cache;
+            m_layer.m_cache = new FFTFileCache
+                (QString("%1").arg(getObjectExportId(&m_layer)),
+                 MatrixFileCache::ReadOnly);
+
 	    m_layer.setCacheColourmap();
-//!!!	    m_layer.m_cache->reset();
+//!!!	    m_layer.m_writeCache->reset();
 
 	    // We don't need a lock when writing to or reading from
 	    // the pixels in the cache.  We do need to ensure we have
 	    // the width and height of the cache and the FFT
 	    // parameters known before we unlock, in case they change

 		fftw_malloc(windowSize * sizeof(double));
 
 	    fftw_complex *output = (fftw_complex *)
 		fftw_malloc(windowSize * sizeof(fftw_complex));
 
+            float *workbuffer = (float *)
+                fftw_malloc(windowSize * sizeof(float));
+
 	    fftw_plan plan = fftw_plan_dft_r2c_1d(windowSize, input,
 						  output, FFTW_ESTIMATE);
 
 	    Window<double> windower(windowType, windowSize);
 

 		for (size_t f = visibleStart; f < end; f += windowIncrement) {
 	    
 		    m_layer.fillCacheColumn(int((f - start) / windowIncrement),
 					    input, output, plan,
 					    windowSize, windowIncrement,
-					    windower);
+                                            workbuffer, windower);
 
 		    if (m_layer.m_cacheInvalid || m_layer.m_exiting) {
 			interrupted = true;
 			m_fillExtent = 0;
 			break;

 		for (size_t f = start; f < remainingEnd; f += windowIncrement) {
 
 		    m_layer.fillCacheColumn(int((f - start) / windowIncrement),
 					    input, output, plan,
 					    windowSize, windowIncrement,
-					    windower);
+					    workbuffer, windower);
 
 		    if (m_layer.m_cacheInvalid || m_layer.m_exiting) {
 			interrupted = true;
 			m_fillExtent = 0;
 			break;

 	    }
 
 	    fftw_destroy_plan(plan);
 	    fftw_free(output);
 	    fftw_free(input);
+            fftw_free(workbuffer);
 
 	    if (!interrupted) {
 		m_fillExtent = end;
 		m_fillCompletion = 100;
 	    }

     int h = y1 - y0;
 
 //    std::cerr << "x0 " << x0 << ", x1 " << x1 << ", w " << w << ", h " << h << std::endl;
 
     QImage scaled(w, h, QImage::Format_RGB32);
-    scaled.fill(m_cache->getColour(0).rgb());
+    scaled.fill(m_colourMap.getColour(0).rgb());
 
     float ymag[h];
     float ydiv[h];
 
     int sr = m_model->getSampleRate();

 
 		float avg = ymag[y] / ydiv[y];
 		pixel = getDisplayValue(avg);
 
 		assert(x <= scaled.width());
-		QColor c = m_cache->getColour(pixel);
+		QColor c = m_colourMap.getColour(pixel);
 		scaled.setPixel(x, y,
 				qRgb(c.red(), c.green(), c.blue()));
 	    }
 	}
 

 
 	paint.save();
 	paint.setBrush(Qt::NoBrush);
 	for (int i = 0; i < ch; ++i) {
 	    int v = (i * 255) / ch + 1;
-	    paint.setPen(m_cache->getColour(v));
+	    paint.setPen(m_colourMap.getColour(v));
 	    paint.drawLine(5, 4 + textHeight + ch - i,
 			   cw + 2, 4 + textHeight + ch - i);
 	}
 	paint.restore();
     }