comparison data/fft/FFTMemoryCache.h @ 408:115f60df1e4d

* 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

 #define _FFT_MEMORY_CACHE_H_
 
 #include "FFTCache.h"
 
 #include "base/ResizeableBitset.h"
+#include "base/Profiler.h"
 
 /**
  * In-memory FFT cache.  For this we want to cache magnitude with
  * enough resolution to have gain applied afterwards and determine
  * whether something is a peak or not, and also cache phase rather

  */
 
 class FFTMemoryCache : public FFTCache
 {
 public:
-    enum StorageType {
-        Compact, // 16 bits normalized polar
-        Rectangular, // floating point real+imag
-        Polar // floating point mag+phase
-    };
-
     FFTMemoryCache(StorageType storageType); // of size zero, call resize() before using
     virtual ~FFTMemoryCache();
 	
     virtual size_t getWidth() const { return m_width; }
     virtual size_t getHeight() const { return m_height; }

     virtual void resize(size_t width, size_t height);
     virtual void reset(); // zero-fill or 1-fill as appropriate without changing size
     
     virtual float getMagnitudeAt(size_t x, size_t y) const {
         if (m_storageType == Rectangular) {
+            Profiler profiler("FFTMemoryCache::getMagnitudeAt: cart to polar");
             return sqrt(m_freal[x][y] * m_freal[x][y] +
                         m_fimag[x][y] * m_fimag[x][y]);
         } else {
             return getNormalizedMagnitudeAt(x, y) * m_factor[x];
         }

         return m_factor[x];
     }
     
     virtual float getPhaseAt(size_t x, size_t y) const {
         if (m_storageType == Rectangular) {
+            Profiler profiler("FFTMemoryCache::getValuesAt: cart to polar");
             return atan2f(m_fimag[x][y], m_freal[x][y]);
         } else if (m_storageType == Polar) {
             return m_fphase[x][y];
         } else {
             int16_t i = (int16_t)m_phase[x][y];

     virtual void getValuesAt(size_t x, size_t y, float &real, float &imag) const {
         if (m_storageType == Rectangular) {
             real = m_freal[x][y];
             imag = m_fimag[x][y];
         } else {
+            Profiler profiler("FFTMemoryCache::getValuesAt: polar to cart");
             float mag = getMagnitudeAt(x, y);
             float phase = getPhaseAt(x, y);
             real = mag * cosf(phase);
             imag = mag * sinf(phase);
         }

 
     virtual void setColumnAt(size_t x, float *reals, float *imags);
 
     static size_t getCacheSize(size_t width, size_t height, StorageType type);
 
+    virtual StorageType getStorageType() { return m_storageType; }
     virtual Type getType() { return MemoryCache; }
 
 private:
     size_t m_width;
     size_t m_height;