comparison layer/SpectrogramLayer.h @ 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.

 #include "base/Window.h"
 #include "base/RealTime.h"
 #include "base/Thread.h"
 #include "model/PowerOfSqrtTwoZoomConstraint.h"
 #include "model/DenseTimeValueModel.h"
-#include "fileio/FFTDataServer.h"
+
+#include "fileio/FFTFuzzyAdapter.h"
 
 #include <QMutex>
 #include <QWaitCondition>
 #include <QImage>
 #include <QPixmap>

 class View;
 class QPainter;
 class QImage;
 class QPixmap;
 class QTimer;
+class FFTFuzzyAdapter;
+
 
 /**
  * SpectrogramLayer represents waveform data (obtained from a
  * DenseTimeValueModel) in spectrogram form.
  */

         QColor m_colours[256];
     };
 
     ColourMap m_colourMap;
 
-    FFTDataServer *m_fftServer;
-    void getFFTServer();
-
     struct PixmapCache
     {
         QPixmap pixmap;
         QRect validArea;
         long startFrame;

     void invalidatePixmapCaches();
     void invalidatePixmapCaches(size_t startFrame, size_t endFrame);
     mutable ViewPixmapCache m_pixmapCaches;
     mutable QImage m_drawBuffer;
 
-    QTimer *m_updateTimer;
+    mutable QTimer *m_updateTimer;
 
     mutable size_t m_candidateFillStartFrame;
-    size_t m_lastFillExtent;
+    mutable size_t m_lastFillExtent;
     bool m_exiting;
 
     void setColourmap();
     void rotateColourmap(int distance);
 

         if (m_windowHopLevel == 0) return m_windowSize;
         else if (m_windowHopLevel == 1) return (m_windowSize * 3) / 4;
         else return m_windowSize / (1 << (m_windowHopLevel - 1));
     }
 
-    size_t getFFTWidth() const {
-        return m_fftServer->getWidth(getWindowIncrement(), m_fftSize);
-    }
-    size_t getFFTHeight() const {
-        return m_fftServer->getHeight(getWindowIncrement(), m_fftSize);
-    }
-    float getFFTMagnitudeAt(size_t x, size_t y) const {
-        return m_fftServer->getMagnitudeAt(getWindowIncrement(), m_fftSize,
-                                              x, y);
-    }
-    float getFFTNormalizedMagnitudeAt(size_t x, size_t y) const {
-        return m_fftServer->getNormalizedMagnitudeAt(getWindowIncrement(), m_fftSize,
-                                                     x, y);
-    }
-    float getFFTPhaseAt(size_t x, size_t y) const {
-        return m_fftServer->getPhaseAt(getWindowIncrement(), m_fftSize,
-                                       x, y);
-    }
-    void getFFTValuesAt(size_t x, size_t y, float &real, float &imag) const {
-        m_fftServer->getValuesAt(getWindowIncrement(), m_fftSize,
-                                 x, y, real, imag);
-    }
-    bool isFFTLocalPeak(size_t x, size_t y) const {
-        return m_fftServer->isLocalPeak(getWindowIncrement(), m_fftSize,
-                                        x, y);
-    }
-    bool isFFTOverThreshold(size_t x, size_t y, float threshold) const {
-        return m_fftServer->isOverThreshold(getWindowIncrement(), m_fftSize,
-                                            x, y, threshold);
-    }
-    bool isFFTColumnReady(size_t x) const {
-        return m_fftServer->isColumnReady(getWindowIncrement(), m_fftSize, x);
-    }
+    size_t getZeroPadLevel(const View *v) const;
+    size_t getFFTSize(const View *v) const;
+    FFTFuzzyAdapter *getFFTAdapter(const View *v) const;
+    void invalidateFFTAdapters();
+    typedef std::map<const View *, FFTFuzzyAdapter *> ViewFFTMap;
+    mutable ViewFFTMap m_fftAdapters;
 };
 
 #endif