comparison layer/SpectrogramLayer.h @ 85:d31c4f5230d7

* Start factoring out the spectrogram's FFT cache into a separate set of
  classes that will permit a choice of disk or memory cache strategies

 #include <QMutex>
 #include <QWaitCondition>
 
 #include <fftw3.h>
 
-#include <stdint.h>
-
 class View;
 class QPainter;
 class QImage;
 class QPixmap;
 class QTimer;
+class FFTCacheBase;
 
 /**
  * SpectrogramLayer represents waveform data (obtained from a
  * DenseTimeValueModel) in spectrogram form.
  */

     QColor              m_crosshairColour;
     FrequencyScale      m_frequencyScale;
     BinDisplay          m_binDisplay;
     bool                m_normalizeColumns;
 
-    // We would like to cache magnitude in a way that can have gain
-    // applied afterwards and can determine whether something is a
-    // peak or not, and also cache phase rather than only
-    // phase-adjusted frequency so that we don't have to recalculate
-    // if switching between phase and magnitude displays.  At the same
-    // time, we don't want to waste too much memory.
-
-    // This implies probably 16 bits for a normalized magnitude (in
-    // dB?) and at most 16 bits for phase.
-
-    // Each column's magnitudes are expected to be stored normalized
-    // to [0,1] with respect to the column, so the normalization
-    // factor should be calculated before all values in a column, and
-    // set appropriately.
-
-    class Cache {
-    public:
-	Cache(); // of size zero, call resize() before using
-	~Cache();
-
-	size_t getWidth() const { return m_width; }
-	size_t getHeight() const { return m_height; }
-	
-	void resize(size_t width, size_t height);
-	void reset(); // zero-fill or 1-fill as appropriate without changing size
-	
-	float getMagnitudeAt(size_t x, size_t y) const {
-	    return getNormalizedMagnitudeAt(x, y) * m_factor[x];
-	}
-
-	float getNormalizedMagnitudeAt(size_t x, size_t y) const {
-	    return float(m_magnitude[x][y]) / 65535.0;
-	}
-
-	float getPhaseAt(size_t x, size_t y) const {
-	    int16_t i = (int16_t)m_phase[x][y];
-	    return (float(i) / 32767.0) * M_PI;
-	}
-
-	bool isLocalPeak(size_t x, size_t y) const {
-	    if (y > 0 && m_magnitude[x][y] < m_magnitude[x][y-1]) return false;
-	    if (y < m_height-1 && m_magnitude[x][y] < m_magnitude[x][y+1]) return false;
-	    return true;
-	}
-
-	bool isOverThreshold(size_t x, size_t y, float threshold) const {
-	    if (threshold == 0.0) return true;
-	    return getMagnitudeAt(x, y) > threshold;
-	}
-
-	void setNormalizationFactor(size_t x, float factor) {
-	    if (x < m_width) m_factor[x] = factor;
-	}
-
-	void setMagnitudeAt(size_t x, size_t y, float mag) {
-	    // norm factor must already be set
-	    setNormalizedMagnitudeAt(x, y, mag / m_factor[x]);
-	}
-
-	void setNormalizedMagnitudeAt(size_t x, size_t y, float norm) {
-	    if (x < m_width && y < m_height) {
-		m_magnitude[x][y] = uint16_t(norm * 65535.0);
-	    }
-	}
-
-	void setPhaseAt(size_t x, size_t y, float phase) {
-	    // phase in range -pi -> pi
-	    if (x < m_width && y < m_height) {
-		m_phase[x][y] = uint16_t(int16_t((phase * 32767) / M_PI));
-	    }
-	}
-
-	QColor getColour(unsigned char index) const {
-	    return m_colours[index];
-	}
-
-	void setColour(unsigned char index, QColor colour) {
-	    m_colours[index] = colour;
-	}
-
-    private:
-	size_t m_width;
-	size_t m_height;
-	uint16_t **m_magnitude;
-	uint16_t **m_phase;
-	float *m_factor;
-	QColor m_colours[256];
-
-	void resize(uint16_t **&, size_t, size_t);
-    };
-
     enum { NO_VALUE = 0 }; // colour index for unused pixels
 
-    Cache *m_cache;
+    FFTCacheBase *m_cache;
     bool m_cacheInvalid;
 
     class CacheFillThread : public QThread
     {
     public: