comparison data/fft/FFTDataServer.cpp @ 244:85bf384db35f

* Update to use new vamp-hostsdk instead of vamp-sdk
* Make spectrogram adapt its paint block size depending on how long it actually
  takes to draw
* Some thread debugging infrastructure

 #include "system/System.h"
 
 #include "base/StorageAdviser.h"
 #include "base/Exceptions.h"
 #include "base/Profiler.h"
+#include "base/Thread.h" // for debug mutex locker
 
 #include <QMessageBox>
 #include <QApplication>
-
 
 //#define DEBUG_FFT_SERVER 1
 //#define DEBUG_FFT_SERVER_FILL 1
 
 #ifdef DEBUG_FFT_SERVER_FILL
 #ifndef DEBUG_FFT_SERVER
 #define DEBUG_FFT_SERVER 1
 #endif
 #endif
+
 
 FFTDataServer::ServerMap FFTDataServer::m_servers;
 FFTDataServer::ServerQueue FFTDataServer::m_releasedServers;
 QMutex FFTDataServer::m_serverMapMutex;
 

                                      fftSize,
                                      polar);
 
     FFTDataServer *server = 0;
     
-    QMutexLocker locker(&m_serverMapMutex);
+    MutexLocker locker(&m_serverMapMutex, "FFTDataServer::m_serverMapMutex[getInstance]");
 
     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).
 
     {
-        QMutexLocker locker(&m_serverMapMutex);
+        MutexLocker locker(&m_serverMapMutex, "FFTDataServer::m_serverMapMutex[getFuzzyInstance]");
 
         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)
 {
-    QMutexLocker locker(needLock ? &m_serverMapMutex : 0);
+    MutexLocker locker(needLock ? &m_serverMapMutex : 0,
+                       "FFTDataServer::m_serverMapMutex[claimInstance]");
 
 #ifdef DEBUG_FFT_SERVER
     std::cerr << "FFTDataServer::claimInstance(" << server << ")" << std::endl;
 #endif
 

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

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

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

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

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

     std::cout << "FFTDataServer::fillColumn(" << x << ")" << std::endl;
 #endif
     FFTCache *cache = getCache(x, col);
     if (!cache) return;
 
-    QMutexLocker locker(&m_writeMutex);
+    MutexLocker locker(&m_writeMutex,
+                       "FFTDataServer::m_writeMutex[fillColumn]");
 
     if (cache->haveSetColumnAt(col)) return;
 
     int startFrame = m_windowIncrement * x;
     int endFrame = startFrame + m_windowSize;

 
             while (m_server.m_suspended) {
 #ifdef DEBUG_FFT_SERVER
                 std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): suspended, waiting..." << std::endl;
 #endif
-                m_server.m_writeMutex.lock();
-                m_server.m_condition.wait(&m_server.m_writeMutex, 10000);
-                m_server.m_writeMutex.unlock();
+                {
+                    MutexLocker locker(&m_server.m_writeMutex,
+                                       "FFTDataServer::m_writeMutex[run/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
                 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
-            m_server.m_writeMutex.lock();
-            m_server.m_condition.wait(&m_server.m_writeMutex, 10000);
-            m_server.m_writeMutex.unlock();
+            {
+                MutexLocker locker(&m_server.m_writeMutex,
+                                   "FFTDataServer::m_writeMutex[run/2]");
+                m_server.m_condition.wait(&m_server.m_writeMutex, 10000);
+            }
             if (m_server.m_exiting) return;
         }
 		    
         if (++counter == updateAt) {
             m_extent = f;