comparison data/fft/FFTDataServer.cpp @ 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

                                      fftSize,
                                      polar);
 
     FFTDataServer *server = 0;
     
-    MutexLocker locker(&m_serverMapMutex, "FFTDataServer::m_serverMapMutex[getInstance]");
+    MutexLocker locker(&m_serverMapMutex, "FFTDataServer::getInstance::m_serverMapMutex");
 
     if ((server = findServer(n))) {
         return server;
     }
 

     // multiple of the smaller (e.g. even though in principle you can
     // draw the results at increment 256 from those at increment 768
     // or 1536, the model doesn't support this).
 
     {
-        MutexLocker locker(&m_serverMapMutex, "FFTDataServer::m_serverMapMutex[getFuzzyInstance]");
+        MutexLocker locker(&m_serverMapMutex, "FFTDataServer::getFuzzyInstance::m_serverMapMutex");
 
         ServerMap::iterator best = m_servers.end();
         int bestdist = -1;
     
         for (ServerMap::iterator i = m_servers.begin(); i != m_servers.end(); ++i) {

 
 void
 FFTDataServer::claimInstance(FFTDataServer *server, bool needLock)
 {
     MutexLocker locker(needLock ? &m_serverMapMutex : 0,
-                       "FFTDataServer::m_serverMapMutex[claimInstance]");
+                       "FFTDataServer::claimInstance::m_serverMapMutex");
 
 #ifdef DEBUG_FFT_SERVER
     std::cerr << "FFTDataServer::claimInstance(" << server << ")" << std::endl;
 #endif
 

 
 void
 FFTDataServer::releaseInstance(FFTDataServer *server, bool needLock)
 {    
     MutexLocker locker(needLock ? &m_serverMapMutex : 0,
-                       "FFTDataServer::m_serverMapMutex[releaseInstance]");
+                       "FFTDataServer::releaseInstance::m_serverMapMutex");
 
 #ifdef DEBUG_FFT_SERVER
     std::cerr << "FFTDataServer::releaseInstance(" << server << ")" << std::endl;
 #endif
 

 
 void
 FFTDataServer::modelAboutToBeDeleted(Model *model)
 {
     MutexLocker locker(&m_serverMapMutex,
-                       "FFTDataServer::m_serverMapMutex[modelAboutToBeDeleted]");
+                       "FFTDataServer::modelAboutToBeDeleted::m_serverMapMutex");
 
 #ifdef DEBUG_FFT_SERVER
     std::cerr << "FFTDataServer::modelAboutToBeDeleted(" << model << ")"
               << std::endl;
 #endif

         m_fillThread->wait();
         delete m_fillThread;
     }
 
     MutexLocker locker(&m_writeMutex,
-                       "FFTDataServer::m_writeMutex[~FFTDataServer]");
+                       "FFTDataServer::~FFTDataServer::m_writeMutex");
 
     for (CacheVector::iterator i = m_caches.begin(); i != m_caches.end(); ++i) {
 
         if (*i) {
             delete *i;

     std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): suspend" << std::endl;
 #endif
     Profiler profiler("FFTDataServer::suspend", false);
 
     MutexLocker locker(&m_writeMutex,
-                       "FFTDataServer::m_writeMutex[suspend]");
+                       "FFTDataServer::suspend::m_writeMutex");
     m_suspended = true;
     for (CacheVector::iterator i = m_caches.begin(); i != m_caches.end(); ++i) {
         if (*i) (*i)->suspend();
     }
 }

 #ifdef DEBUG_FFT_SERVER
     std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "])::getCacheAux" << std::endl;
 #endif
 
     MutexLocker locker(&m_writeMutex,
-                       "FFTDataServer::m_writeMutex[getCacheAux]");
+                       "FFTDataServer::getCacheAux::m_writeMutex");
 
     if (m_lastUsedCache == -1) {
         m_fillThread->start();
     }
 

     size_t col;
     FFTCache *cache = getCache(x, col);
     if (!cache) return 0;
 
     if (!cache->haveSetColumnAt(col)) {
+        Profiler profiler("FFTDataServer::getMagnitudeAt: filling");
 #ifdef DEBUG_FFT_SERVER
         std::cerr << "FFTDataServer::getMagnitudeAt: calling fillColumn(" 
                   << x << ")" << std::endl;
 #endif
-        fillColumn(x);
+        // hold mutex so that write thread doesn't mess with class
+        // member data in fillColumn
+        MutexLocker locker(&m_writeMutex,
+                           "FFTDataServer::getMagnitudeAt: m_writeMutex");
+        fillColumn(x, true);
     }
     return cache->getMagnitudeAt(col, y);
+}
+
+bool
+FFTDataServer::getMagnitudesAt(size_t x, float *values, size_t minbin, size_t count, size_t step)
+{
+    Profiler profiler("FFTDataServer::getMagnitudesAt", false);
+
+    if (x >= m_width) return false;
+
+    if (minbin >= m_height) minbin = m_height - 1;
+    if (count == 0) count = (m_height - minbin) / step;
+    else if (minbin + count * step > m_height) {
+        count = (m_height - minbin) / step;
+    }
+
+    size_t col;
+    FFTCache *cache = getCache(x, col);
+    if (!cache) return false;
+
+    if (!cache->haveSetColumnAt(col)) {
+        Profiler profiler("FFTDataServer::getMagnitudesAt: filling");
+        MutexLocker locker(&m_writeMutex,
+                           "FFTDataServer::getMagnitudesAt: m_writeMutex");
+        fillColumn(x, true);
+    }
+
+    for (size_t i = 0; i < count; ++i) {
+        values[i] = cache->getMagnitudeAt(col, i * step + minbin);
+    }
+
+    return true;
 }
 
 float
 FFTDataServer::getNormalizedMagnitudeAt(size_t x, size_t y)
 {

     size_t col;
     FFTCache *cache = getCache(x, col);
     if (!cache) return 0;
 
     if (!cache->haveSetColumnAt(col)) {
-        fillColumn(x);
+        Profiler profiler("FFTDataServer::getNormalizedMagnitudeAt: filling");
+        // hold mutex so that write thread doesn't mess with class
+        // member data in fillColumn
+        MutexLocker locker(&m_writeMutex,
+                           "FFTDataServer::getNormalizedMagnitudeAt: m_writeMutex");
+        fillColumn(x, true);
     }
     return cache->getNormalizedMagnitudeAt(col, y);
+}
+
+bool
+FFTDataServer::getNormalizedMagnitudesAt(size_t x, float *values, size_t minbin, size_t count, size_t step)
+{
+    Profiler profiler("FFTDataServer::getNormalizedMagnitudesAt", false);
+
+    if (x >= m_width) return false;
+
+    if (minbin >= m_height) minbin = m_height - 1;
+    if (count == 0) count = (m_height - minbin) / step;
+    else if (minbin + count * step > m_height) {
+        count = (m_height - minbin) / step;
+    }
+
+    size_t col;
+    FFTCache *cache = getCache(x, col);
+    if (!cache) return false;
+
+    if (!cache->haveSetColumnAt(col)) {
+        Profiler profiler("FFTDataServer::getNormalizedMagnitudesAt: filling");
+        MutexLocker locker(&m_writeMutex,
+                           "FFTDataServer::getNormalizedMagnitudesAt: m_writeMutex");
+        fillColumn(x, true);
+    }
+
+    for (size_t i = 0; i < count; ++i) {
+        values[i] = cache->getNormalizedMagnitudeAt(col, i * step + minbin);
+    }
+
+    return true;
 }
 
 float
 FFTDataServer::getMaximumMagnitudeAt(size_t x)
 {

     size_t col;
     FFTCache *cache = getCache(x, col);
     if (!cache) return 0;
 
     if (!cache->haveSetColumnAt(col)) {
-        fillColumn(x);
+        Profiler profiler("FFTDataServer::getMaximumMagnitudeAt: filling");
+        // hold mutex so that write thread doesn't mess with class
+        // member data in fillColumn
+        MutexLocker locker(&m_writeMutex,
+                           "FFTDataServer::getMaximumMagnitudeAt: m_writeMutex");
+        fillColumn(x, true);
     }
     return cache->getMaximumMagnitudeAt(col);
 }
 
 float

     size_t col;
     FFTCache *cache = getCache(x, col);
     if (!cache) return 0;
 
     if (!cache->haveSetColumnAt(col)) {
-        fillColumn(x);
+        Profiler profiler("FFTDataServer::getPhaseAt: filling");
+        // hold mutex so that write thread doesn't mess with class
+        // member data in fillColumn
+        MutexLocker locker(&m_writeMutex,
+                           "FFTDataServer::getPhaseAt: m_writeMutex");
+        fillColumn(x, true);
     }
     return cache->getPhaseAt(col, y);
+}
+
+bool
+FFTDataServer::getPhasesAt(size_t x, float *values, size_t minbin, size_t count, size_t step)
+{
+    Profiler profiler("FFTDataServer::getPhasesAt", false);
+
+    if (x >= m_width) return false;
+
+    if (minbin >= m_height) minbin = m_height - 1;
+    if (count == 0) count = (m_height - minbin) / step;
+    else if (minbin + count * step > m_height) {
+        count = (m_height - minbin) / step;
+    }
+
+    size_t col;
+    FFTCache *cache = getCache(x, col);
+    if (!cache) return false;
+
+    if (!cache->haveSetColumnAt(col)) {
+        Profiler profiler("FFTDataServer::getPhasesAt: filling");
+        MutexLocker locker(&m_writeMutex,
+                           "FFTDataServer::getPhasesAt: m_writeMutex");
+        fillColumn(x, true);
+    }
+
+    for (size_t i = 0; i < count; ++i) {
+        values[i] = cache->getPhaseAt(col, i * step + minbin);
+    }
+
+    return true;
 }
 
 void
 FFTDataServer::getValuesAt(size_t x, size_t y, float &real, float &imaginary)
 {

         imaginary = 0;
         return;
     }
 
     if (!cache->haveSetColumnAt(col)) {
+        Profiler profiler("FFTDataServer::getValuesAt: filling");
 #ifdef DEBUG_FFT_SERVER
         std::cerr << "FFTDataServer::getValuesAt(" << x << ", " << y << "): filling" << std::endl;
 #endif
-        fillColumn(x);
+        // hold mutex so that write thread doesn't mess with class
+        // member data in fillColumn
+        MutexLocker locker(&m_writeMutex,
+                           "FFTDataServer::getValuesAt: m_writeMutex");
+        fillColumn(x, true);
     }        
 
     cache->getValuesAt(col, y, real, imaginary);
 }
 

 
     return cache->haveSetColumnAt(col);
 }    
 
 void
-FFTDataServer::fillColumn(size_t x)
+FFTDataServer::fillColumn(size_t x, bool lockHeld)
 {
     Profiler profiler("FFTDataServer::fillColumn", false);
 
     if (!m_model->isReady()) {
         std::cerr << "WARNING: FFTDataServer::fillColumn(" 

     std::cout << "FFTDataServer::fillColumn(" << x << ")" << std::endl;
 #endif
     FFTCache *cache = getCache(x, col);
     if (!cache) return;
 
-    MutexLocker locker(&m_writeMutex,
-                       "FFTDataServer::m_writeMutex[fillColumn]");
-
-    if (cache->haveSetColumnAt(col)) return;
+    {
+        MutexLocker locker(lockHeld ? 0 : &m_writeMutex,
+                           "FFTDataServer::fillColumn::m_writeMutex [1]");
+
+        if (cache->haveSetColumnAt(col)) return;
+    }
+
+    int winsize = m_windowSize;
+    int fftsize = m_fftSize;
+    int hs = fftsize/2;
+
+    int pfx = 0;
+    int off = (fftsize - winsize) / 2;
 
     int startFrame = m_windowIncrement * x;
     int endFrame = startFrame + m_windowSize;
 
-    startFrame -= int(m_windowSize) / 2;
-    endFrame   -= int(m_windowSize) / 2;
-    size_t pfx = 0;
-
-    size_t off = (m_fftSize - m_windowSize) / 2;
-
-    for (size_t i = 0; i < off; ++i) {
+    startFrame -= winsize / 2;
+    endFrame   -= winsize / 2;
+
+    for (int i = 0; i < off; ++i) {
         m_fftInput[i] = 0.0;
-        m_fftInput[m_fftSize - i - 1] = 0.0;
+    }
+
+    for (int i = 0; i < off; ++i) {
+        m_fftInput[fftsize - i - 1] = 0.0;
     }
 
     if (startFrame < 0) {
-	pfx = size_t(-startFrame);
-	for (size_t i = 0; i < pfx; ++i) {
+	pfx = -startFrame;
+	for (int i = 0; i < pfx; ++i) {
 	    m_fftInput[off + i] = 0.0;
 	}
     }
 
 #ifdef DEBUG_FFT_SERVER_FILL

               << off + pfx << " in buffer of size " << m_fftSize
               << " with window size " << m_windowSize 
               << " from channel " << m_channel << std::endl;
 #endif
 
-    size_t count = 0;
+    int count = 0;
     if (endFrame > startFrame + pfx) count = endFrame - (startFrame + pfx);
 
-    size_t got = m_model->getData(m_channel, startFrame + pfx,
-                                  count, m_fftInput + off + pfx);
-
-    while (got + pfx < m_windowSize) {
+    int got = m_model->getData(m_channel, startFrame + pfx,
+                               count, m_fftInput + off + pfx);
+
+    while (got + pfx < winsize) {
 	m_fftInput[off + got + pfx] = 0.0;
 	++got;
     }
 
     if (m_channel == -1) {
 	int channels = m_model->getChannelCount();
 	if (channels > 1) {
-	    for (size_t i = 0; i < m_windowSize; ++i) {
+	    for (int i = 0; i < winsize; ++i) {
 		m_fftInput[off + i] /= channels;
 	    }
 	}
     }
 
     m_windower.cut(m_fftInput + off);
 
-    for (size_t i = 0; i < m_fftSize/2; ++i) {
+    for (int i = 0; i < hs; ++i) {
 	fftsample temp = m_fftInput[i];
-	m_fftInput[i] = m_fftInput[i + m_fftSize/2];
-	m_fftInput[i + m_fftSize/2] = temp;
+	m_fftInput[i] = m_fftInput[i + hs];
+	m_fftInput[i + hs] = temp;
     }
 
     fftf_execute(m_fftPlan);
 
-    fftsample factor = 0.0;
-
-    for (size_t i = 0; i <= m_fftSize/2; ++i) {
-
-        m_workbuffer[i] = m_fftOutput[i][0];
-        m_workbuffer[i + m_fftSize/2 + 1] = m_fftOutput[i][1];
-    }
-
-    cache->setColumnAt(col,
-                       m_workbuffer,
-                       m_workbuffer + m_fftSize/2+1);
+    // If our cache uses polar storage, it's more friendly for us to
+    // do the conversion before taking the write mutex
+
+    float factor = 0.f;
+
+    if (cache->getStorageType() == FFTCache::Compact ||
+        cache->getStorageType() == FFTCache::Polar) {
+
+        for (int i = 0; i <= hs; ++i) {
+            fftsample real = m_fftOutput[i][0];
+            fftsample imag = m_fftOutput[i][1];
+            float mag = sqrtf(real * real + imag * imag);
+            m_workbuffer[i] = mag;
+            m_workbuffer[i + hs + 1] = atan2f(imag, real);
+            if (mag > factor) factor = mag;
+        }
+
+    } else {
+
+        for (int i = 0; i <= hs; ++i) {
+            m_workbuffer[i] = m_fftOutput[i][0];
+            m_workbuffer[i + hs + 1] = m_fftOutput[i][1];
+        }
+    }
+
+    Profiler subprof("FFTDataServer::fillColumn: set to cache");
+
+    {
+        MutexLocker locker(lockHeld ? 0 : &m_writeMutex,
+                           "FFTDataServer::fillColumn: m_writeMutex [2]");
+
+        if (cache->getStorageType() == FFTCache::Compact ||
+            cache->getStorageType() == FFTCache::Polar) {
+            
+            cache->setColumnAt(col,
+                               m_workbuffer,
+                               m_workbuffer + hs + 1,
+                               factor);
+
+        } else {
+
+            cache->setColumnAt(col,
+                               m_workbuffer,
+                               m_workbuffer + hs + 1);
+        }
+    }
 
     if (m_suspended) {
 //        std::cerr << "FFTDataServer::fillColumn(" << x << "): calling resume" << std::endl;
 //        resume();
     }

 
     if (m_fillFrom > start) {
 
         for (size_t f = m_fillFrom; f < end; f += m_server.m_windowIncrement) {
 	    
-            m_server.fillColumn(int((f - start) / m_server.m_windowIncrement));
+            m_server.fillColumn(int((f - start) / m_server.m_windowIncrement),
+                                false);
 
             if (m_server.m_exiting) return;
 
             while (m_server.m_suspended) {
 #ifdef DEBUG_FFT_SERVER
                 std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): suspended, waiting..." << std::endl;
 #endif
                 {
                     MutexLocker locker(&m_server.m_writeMutex,
-                                       "FFTDataServer::m_writeMutex[run/1]");
+                                       "FFTDataServer::run::m_writeMutex [1]");
                     m_server.m_condition.wait(&m_server.m_writeMutex, 10000);
                 }
 #ifdef DEBUG_FFT_SERVER
                 std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): waited" << std::endl;
 #endif

 
     size_t baseCompletion = m_completion;
 
     for (size_t f = start; f < remainingEnd; f += m_server.m_windowIncrement) {
 
-        m_server.fillColumn(int((f - start) / m_server.m_windowIncrement));
+        m_server.fillColumn(int((f - start) / m_server.m_windowIncrement),
+                            false);
 
         if (m_server.m_exiting) return;
 
         while (m_server.m_suspended) {
 #ifdef DEBUG_FFT_SERVER
             std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): suspended, waiting..." << std::endl;
 #endif
             {
                 MutexLocker locker(&m_server.m_writeMutex,
-                                   "FFTDataServer::m_writeMutex[run/2]");
+                                   "FFTDataServer::run::m_writeMutex [2]");
                 m_server.m_condition.wait(&m_server.m_writeMutex, 10000);
             }
             if (m_server.m_exiting) return;
         }