comparison data/fft/FFTDataServer.cpp @ 843:e802e550a1f2

Drop std:: from cout, cerr, endl -- pull these in through Debug.h

 
             return;
         }
     }
     
-    std::cerr << "ERROR: FFTDataServer::claimInstance: instance "
-              << server << " unknown!" << std::endl;
+    cerr << "ERROR: FFTDataServer::claimInstance: instance "
+              << server << " unknown!" << endl;
 }
 
 void
 FFTDataServer::releaseInstance(FFTDataServer *server)
 {

     //    destroyed, so that we can delete all of its fft server instances
 
     for (ServerMap::iterator i = m_servers.begin(); i != m_servers.end(); ++i) {
         if (i->second.first == server) {
             if (i->second.second == 0) {
-                std::cerr << "ERROR: FFTDataServer::releaseInstance("
-                          << server << "): instance not allocated" << std::endl;
+                cerr << "ERROR: FFTDataServer::releaseInstance("
+                          << server << "): instance not allocated" << endl;
             } else if (--i->second.second == 0) {
 /*!!!
                 if (server->m_lastUsedCache == -1) { // never used
 #ifdef DEBUG_FFT_SERVER
                     SVDEBUG << "FFTDataServer::releaseInstance: instance "

 #endif
                     bool found = false;
                     for (ServerQueue::iterator j = m_releasedServers.begin();
                          j != m_releasedServers.end(); ++j) {
                         if (*j == server) {
-                            std::cerr << "ERROR: FFTDataServer::releaseInstance("
+                            cerr << "ERROR: FFTDataServer::releaseInstance("
                                       << server << "): server is already in "
-                                      << "released servers list" << std::endl;
+                                      << "released servers list" << endl;
                             found = true;
                         }
                     }
                     if (!found) m_releasedServers.push_back(server);
                     server->suspend();

             }
             return;
         }
     }
 
-    std::cerr << "ERROR: FFTDataServer::releaseInstance(" << server << "): "
-              << "instance not found" << std::endl;
+    cerr << "ERROR: FFTDataServer::releaseInstance(" << server << "): "
+              << "instance not found" << endl;
 }
 
 void
 FFTDataServer::purgeLimbo(int maxSize)
 {

         for (ServerMap::iterator i = m_servers.begin(); i != m_servers.end(); ++i) {
 
             if (i->second.first == server) {
                 found = true;
                 if (i->second.second > 0) {
-                    std::cerr << "ERROR: FFTDataServer::purgeLimbo: Server "
+                    cerr << "ERROR: FFTDataServer::purgeLimbo: Server "
                               << server << " is in released queue, but still has non-zero refcount "
-                              << i->second.second << std::endl;
+                              << i->second.second << endl;
                     // ... so don't delete it
                     break;
                 }
 #ifdef DEBUG_FFT_SERVER
                 SVDEBUG << "FFTDataServer::purgeLimbo: looks OK, erasing it"

                 break;
             }
         }
 
         if (!found) {
-            std::cerr << "ERROR: FFTDataServer::purgeLimbo: Server "
+            cerr << "ERROR: FFTDataServer::purgeLimbo: Server "
                       << server << " is in released queue, but not in server map!"
-                      << std::endl;
+                      << endl;
             delete server;
         }
 
         m_releasedServers.pop_front();
     }

             SVDEBUG << "FFTDataServer::modelAboutToBeDeleted: server is "
                       << server << endl;
 #endif
 
             if (i->second.second > 0) {
-                std::cerr << "WARNING: FFTDataServer::modelAboutToBeDeleted: Model " << model << " (\"" << model->objectName() << "\") is about to be deleted, but is still being referred to by FFT server " << server << " with non-zero refcount " << i->second.second << std::endl;
+                cerr << "WARNING: FFTDataServer::modelAboutToBeDeleted: Model " << model << " (\"" << model->objectName() << "\") is about to be deleted, but is still being referred to by FFT server " << server << " with non-zero refcount " << i->second.second << endl;
                 server->suspendWrites();
                 return;
             }
             for (ServerQueue::iterator j = m_releasedServers.begin();
                  j != m_releasedServers.end(); ++j) {

     m_exiting(false),
     m_suspended(true), //!!! or false?
     m_fillThread(0)
 {
 #ifdef DEBUG_FFT_SERVER
-    std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "])::FFTDataServer" << std::endl;
+    cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "])::FFTDataServer" << endl;
 #endif
 
     //!!! end is not correct until model finished reading -- what to do???
 
     size_t start = m_model->getStartFrame();

 
     m_width = (end - start) / m_windowIncrement + 1;
     m_height = m_fftSize / 2 + 1; // DC == 0, Nyquist == fftsize/2
 
 #ifdef DEBUG_FFT_SERVER 
-    std::cerr << "FFTDataServer(" << this << "): dimensions are "
-              << m_width << "x" << m_height << std::endl;
+    cerr << "FFTDataServer(" << this << "): dimensions are "
+              << m_width << "x" << m_height << endl;
 #endif
 
     size_t maxCacheSize = 20 * 1024 * 1024;
     size_t columnSize = m_height * sizeof(fftsample) * 2 + sizeof(fftsample);
     if (m_width * columnSize < maxCacheSize * 2) m_cacheWidth = m_width;
     else m_cacheWidth = maxCacheSize / columnSize;
     
 #ifdef DEBUG_FFT_SERVER
-    std::cerr << "FFTDataServer(" << this << "): cache width nominal "
+    cerr << "FFTDataServer(" << this << "): cache width nominal "
               << m_cacheWidth << ", actual ";
 #endif
     
     int bits = 0;
     while (m_cacheWidth > 1) { m_cacheWidth >>= 1; ++bits; }

     m_cacheWidth = 2;
     while (bits) { m_cacheWidth <<= 1; --bits; }
     m_cacheWidthMask = m_cacheWidth - 1;
 
 #ifdef DEBUG_FFT_SERVER
-    std::cerr << m_cacheWidth << " (power " << m_cacheWidthPower << ", mask "
-              << m_cacheWidthMask << ")" << std::endl;
+    cerr << m_cacheWidth << " (power " << m_cacheWidthPower << ", mask "
+              << m_cacheWidthMask << ")" << endl;
 #endif
 
     if (m_criteria == StorageAdviser::NoCriteria) {
 
         // assume "spectrogram" criteria for polar ffts, and "feature

                                      m_fftInput,
                                      m_fftOutput,
                                      FFTW_MEASURE);
 
     if (!m_fftPlan) {
-        std::cerr << "ERROR: fftf_plan_dft_r2c_1d(" << m_windowSize << ") failed!" << std::endl;
+        cerr << "ERROR: fftf_plan_dft_r2c_1d(" << m_windowSize << ") failed!" << endl;
         throw(0);
     }
 
     m_fillThread = new FillThread(*this, fillFromColumn);
 }
 
 FFTDataServer::~FFTDataServer()
 {
 #ifdef DEBUG_FFT_SERVER
-    std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "])::~FFTDataServer()" << std::endl;
+    cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "])::~FFTDataServer()" << endl;
 #endif
 
     m_suspended = false;
     m_exiting = true;
     m_condition.wakeAll();

 
 void
 FFTDataServer::deleteProcessingData()
 {
 #ifdef DEBUG_FFT_SERVER
-    std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): deleteProcessingData" << std::endl;
+    cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): deleteProcessingData" << endl;
 #endif
     if (m_fftInput) {
         fftf_destroy_plan(m_fftPlan);
         fftf_free(m_fftInput);
         fftf_free(m_fftOutput);

 
 void
 FFTDataServer::suspend()
 {
 #ifdef DEBUG_FFT_SERVER
-    std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): suspend" << std::endl;
+    cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): suspend" << endl;
 #endif
     Profiler profiler("FFTDataServer::suspend", false);
 
     QMutexLocker locker(&m_fftBuffersLock);
     m_suspended = true;

 
 void
 FFTDataServer::suspendWrites()
 {
 #ifdef DEBUG_FFT_SERVER
-    std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): suspendWrites" << std::endl;
+    cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): suspendWrites" << endl;
 #endif
     Profiler profiler("FFTDataServer::suspendWrites", false);
 
     m_suspended = true;
 }
 
 void
 FFTDataServer::resume()
 {
 #ifdef DEBUG_FFT_SERVER
-    std::cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): resume" << std::endl;
+    cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): resume" << endl;
 #endif
     Profiler profiler("FFTDataServer::resume", false);
 
     m_suspended = false;
     if (m_fillThread) {

 
         recommendation =
             StorageAdviser::recommend(m_criteria, minimumSize, maximumSize);
     }
 
-//    std::cerr << "Recommendation was: " << recommendation << std::endl;
+//    cerr << "Recommendation was: " << recommendation << endl;
 
     memoryCache = false;
 
     if ((recommendation & StorageAdviser::UseMemory) ||
         (recommendation & StorageAdviser::PreferMemory)) {

 
     compactCache = canCompact &&
         (recommendation & StorageAdviser::ConserveSpace);
 
 #ifdef DEBUG_FFT_SERVER
-    std::cerr << "FFTDataServer: memory cache = " << memoryCache << ", compact cache = " << compactCache << std::endl;
+    cerr << "FFTDataServer: memory cache = " << memoryCache << ", compact cache = " << compactCache << endl;
     
-    std::cerr << "Width " << w << " of " << m_width << ", height " << h << ", size " << w * h << std::endl;
+    cerr << "Width " << w << " of " << m_width << ", height " << h << ", size " << w * h << endl;
 #endif
 }
 
 bool
 FFTDataServer::makeCache(int c)

         } catch (std::bad_alloc) {
 
             delete cb->memoryCache;
             cb->memoryCache = 0;
             
-            std::cerr << "WARNING: Memory allocation failed when creating"
+            cerr << "WARNING: Memory allocation failed when creating"
                       << " FFT memory cache no. " << c << " of " << width 
                       << "x" << m_height << " (of total width " << m_width
-                      << "): falling back to disc cache" << std::endl;
+                      << "): falling back to disc cache" << endl;
 
             memoryCache = false;
         }
     }
 

         } catch (std::exception &e) {
 
             delete cb->fileCacheWriter;
             cb->fileCacheWriter = 0;
             
-            std::cerr << "ERROR: Failed to construct disc cache for FFT data: "
-                      << e.what() << std::endl;
+            cerr << "ERROR: Failed to construct disc cache for FFT data: "
+                      << e.what() << endl;
 
             throw;
         }
     }
 

     } catch (std::exception &e) {
 
         delete cb->fileCacheReader[me];
         cb->fileCacheReader.erase(me);
             
-        std::cerr << "ERROR: Failed to construct disc cache reader for FFT data: "
-                  << e.what() << std::endl;
+        cerr << "ERROR: Failed to construct disc cache reader for FFT data: "
+                  << e.what() << endl;
         return false;
     }
 
     // erase a reader that looks like it may no longer going to be
     // used by this thread for a while (leaving alone the current

 FFTDataServer::fillColumn(size_t x)
 {
     Profiler profiler("FFTDataServer::fillColumn", false);
 
     if (!m_model->isReady()) {
-        std::cerr << "WARNING: FFTDataServer::fillColumn(" 
-                  << x << "): model not yet ready" << std::endl;
+        cerr << "WARNING: FFTDataServer::fillColumn(" 
+                  << x << "): model not yet ready" << endl;
         return;
     }
 /*
     if (!m_fftInput) {
-        std::cerr << "WARNING: FFTDataServer::fillColumn(" << x << "): "
+        cerr << "WARNING: FFTDataServer::fillColumn(" << x << "): "
                   << "input has already been completed and discarded?"
-                  << std::endl;
+                  << endl;
         return;
     }
 */
     if (x >= m_width) {
-        std::cerr << "WARNING: FFTDataServer::fillColumn(" << x << "): "
+        cerr << "WARNING: FFTDataServer::fillColumn(" << x << "): "
                   << "x > width (" << x << " > " << m_width << ")"
-                  << std::endl;
+                  << endl;
         return;
     }
 
     size_t col;
 #ifdef DEBUG_FFT_SERVER_FILL
-    std::cout << "FFTDataServer::fillColumn(" << x << ")" << std::endl;
+    cout << "FFTDataServer::fillColumn(" << x << ")" << endl;
 #endif
     FFTCacheWriter *cache = getCacheWriter(x, col);
     if (!cache) return;
 
     int winsize = m_windowSize;

     if (cache->haveSetColumnAt(x & m_cacheWidthMask)) {
         return;
     }
 
     if (!m_fftInput) {
-        std::cerr << "WARNING: FFTDataServer::fillColumn(" << x << "): "
+        cerr << "WARNING: FFTDataServer::fillColumn(" << x << "): "
                   << "input has already been completed and discarded?"
-                  << std::endl;
+                  << endl;
         return;
     }
 
     for (int i = 0; i < off; ++i) {
         m_fftInput[i] = 0.0;

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

 
         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;
+            cerr << "FFTDataServer(" << this << " [" << (void *)QThread::currentThreadId() << "]): suspended, waiting..." << endl;
 #endif
             {
                 MutexLocker locker(&m_server.m_fftBuffersLock,
                                    "FFTDataServer::run::m_fftBuffersLock [2]");
                 if (m_server.m_suspended && !m_server.m_exiting) {