comparison data/fft/FFTDataServer.cpp @ 929:59e7fe1b1003 warnfix_no_size_t

Unsigned removals and warning fixes in data/

 
 FFTDataServer *
 FFTDataServer::getInstance(const DenseTimeValueModel *model,
                            int channel,
                            WindowType windowType,
-                           size_t windowSize,
-                           size_t windowIncrement,
-                           size_t fftSize,
+                           int windowSize,
+                           int windowIncrement,
+                           int fftSize,
                            bool polar,
                            StorageAdviser::Criteria criteria,
-                           size_t fillFromColumn)
+                           int fillFromColumn)
 {
     QString n = generateFileBasename(model,
                                      channel,
                                      windowType,
                                      windowSize,

 
 FFTDataServer *
 FFTDataServer::getFuzzyInstance(const DenseTimeValueModel *model,
                                 int channel,
                                 WindowType windowType,
-                                size_t windowSize,
-                                size_t windowIncrement,
-                                size_t fftSize,
+                                int windowSize,
+                                int windowIncrement,
+                                int fftSize,
                                 bool polar,
                                 StorageAdviser::Criteria criteria,
-                                size_t fillFromColumn)
+                                int fillFromColumn)
 {
     // Fuzzy matching:
     // 
     // -- if we're asked for polar and have non-polar, use it (and
     // vice versa).  This one is vital, and we do it for non-fuzzy as

 
 FFTDataServer::FFTDataServer(QString fileBaseName,
                              const DenseTimeValueModel *model,
                              int channel,
 			     WindowType windowType,
-			     size_t windowSize,
-			     size_t windowIncrement,
-			     size_t fftSize,
+			     int windowSize,
+			     int windowIncrement,
+			     int fftSize,
                              bool polar,
                              StorageAdviser::Criteria criteria,
-                             size_t fillFromColumn) :
+                             int fillFromColumn) :
     m_fileBaseName(fileBaseName),
     m_model(model),
     m_channel(channel),
     m_windower(windowType, windowSize),
     m_windowSize(windowSize),

     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();
-    size_t end = m_model->getEndFrame();
+    int start = m_model->getStartFrame();
+    int end = m_model->getEndFrame();
 
     m_width = (end - start) / m_windowIncrement + 1;
     m_height = m_fftSize / 2 + 1; // DC == 0, Nyquist == fftsize/2
 
 #ifdef DEBUG_FFT_SERVER 
     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);
+    int maxCacheSize = 20 * 1024 * 1024;
+    int 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
     cerr << "FFTDataServer(" << this << "): cache width nominal "

             m_criteria = StorageAdviser::Criteria
                 (StorageAdviser::PrecisionCritical);
         }
     }
 
-    for (size_t i = 0; i <= m_width / m_cacheWidth; ++i) {
+    for (int i = 0; i <= m_width / m_cacheWidth; ++i) {
         m_caches.push_back(0);
     }
 
     m_fftInput = (fftsample *)
         fftf_malloc(fftSize * sizeof(fftsample));

         }
     }
 }
 
 void
-FFTDataServer::getStorageAdvice(size_t w, size_t h,
+FFTDataServer::getStorageAdvice(int w, int h,
                                 bool &memoryCache, bool &compactCache)
 {
     int cells = w * h;
     int minimumSize = (cells / 1024) * sizeof(uint16_t); // kb
     int maximumSize = (cells / 1024) * sizeof(float); // kb

 
     CacheBlock *cb = new CacheBlock;
 
     QString name = QString("%1-%2").arg(m_fileBaseName).arg(c);
 
-    size_t width = m_cacheWidth;
+    int width = m_cacheWidth;
     if (c * m_cacheWidth + width > m_width) {
         width = m_width - c * m_cacheWidth;
     }
 
     bool memoryCache = false;

             
     return true;
 }
        
 float
-FFTDataServer::getMagnitudeAt(size_t x, size_t y)
+FFTDataServer::getMagnitudeAt(int x, int y)
 {
     Profiler profiler("FFTDataServer::getMagnitudeAt", false);
 
     if (x >= m_width || y >= m_height) return 0;
 
     float val = 0;
 
     try {
-        size_t col;
+        int col;
         FFTCacheReader *cache = getCacheReader(x, col);
         if (!cache) return 0;
 
         if (!cache->haveSetColumnAt(col)) {
             Profiler profiler("FFTDataServer::getMagnitudeAt: filling");

 
     return val;
 }
 
 bool
-FFTDataServer::getMagnitudesAt(size_t x, float *values, size_t minbin, size_t count, size_t step)
+FFTDataServer::getMagnitudesAt(int x, float *values, int minbin, int count, int step)
 {
     Profiler profiler("FFTDataServer::getMagnitudesAt", false);
 
     if (x >= m_width) return false;
 

     else if (minbin + count * step > m_height) {
         count = (m_height - minbin) / step;
     }
 
     try {
-        size_t col;
+        int col;
         FFTCacheReader *cache = getCacheReader(x, col);
         if (!cache) return false;
 
         if (!cache->haveSetColumnAt(col)) {
             Profiler profiler("FFTDataServer::getMagnitudesAt: filling");

 
     return true;
 }
 
 float
-FFTDataServer::getNormalizedMagnitudeAt(size_t x, size_t y)
+FFTDataServer::getNormalizedMagnitudeAt(int x, int y)
 {
     Profiler profiler("FFTDataServer::getNormalizedMagnitudeAt", false);
 
     if (x >= m_width || y >= m_height) return 0;
 
     float val = 0;
 
     try {
 
-        size_t col;
+        int col;
         FFTCacheReader *cache = getCacheReader(x, col);
         if (!cache) return 0;
 
         if (!cache->haveSetColumnAt(col)) {
             Profiler profiler("FFTDataServer::getNormalizedMagnitudeAt: filling");

 
     return val;
 }
 
 bool
-FFTDataServer::getNormalizedMagnitudesAt(size_t x, float *values, size_t minbin, size_t count, size_t step)
+FFTDataServer::getNormalizedMagnitudesAt(int x, float *values, int minbin, int count, int step)
 {
     Profiler profiler("FFTDataServer::getNormalizedMagnitudesAt", false);
 
     if (x >= m_width) return false;
 

         count = (m_height - minbin) / step;
     }
 
     try {
 
-        size_t col;
+        int col;
         FFTCacheReader *cache = getCacheReader(x, col);
         if (!cache) return false;
 
         if (!cache->haveSetColumnAt(col)) {
             Profiler profiler("FFTDataServer::getNormalizedMagnitudesAt: filling");
             fillColumn(x);
         }
         
-        for (size_t i = 0; i < count; ++i) {
+        for (int i = 0; i < count; ++i) {
             values[i] = cache->getNormalizedMagnitudeAt(col, i * step + minbin);
         }
         
     } catch (std::exception &e) {
         m_error = e.what();

 
     return true;
 }
 
 float
-FFTDataServer::getMaximumMagnitudeAt(size_t x)
+FFTDataServer::getMaximumMagnitudeAt(int x)
 {
     Profiler profiler("FFTDataServer::getMaximumMagnitudeAt", false);
 
     if (x >= m_width) return 0;
 
     float val = 0;
 
     try {
 
-        size_t col;
+        int col;
         FFTCacheReader *cache = getCacheReader(x, col);
         if (!cache) return 0;
 
         if (!cache->haveSetColumnAt(col)) {
             Profiler profiler("FFTDataServer::getMaximumMagnitudeAt: filling");

 
     return val;
 }
 
 float
-FFTDataServer::getPhaseAt(size_t x, size_t y)
+FFTDataServer::getPhaseAt(int x, int y)
 {
     Profiler profiler("FFTDataServer::getPhaseAt", false);
 
     if (x >= m_width || y >= m_height) return 0;
 
     float val = 0;
 
     try {
 
-        size_t col;
+        int col;
         FFTCacheReader *cache = getCacheReader(x, col);
         if (!cache) return 0;
 
         if (!cache->haveSetColumnAt(col)) {
             Profiler profiler("FFTDataServer::getPhaseAt: filling");

 
     return val;
 }
 
 bool
-FFTDataServer::getPhasesAt(size_t x, float *values, size_t minbin, size_t count, size_t step)
+FFTDataServer::getPhasesAt(int x, float *values, int minbin, int count, int step)
 {
     Profiler profiler("FFTDataServer::getPhasesAt", false);
 
     if (x >= m_width) return false;
 

         count = (m_height - minbin) / step;
     }
 
     try {
 
-        size_t col;
+        int col;
         FFTCacheReader *cache = getCacheReader(x, col);
         if (!cache) return false;
 
         if (!cache->haveSetColumnAt(col)) {
             Profiler profiler("FFTDataServer::getPhasesAt: filling");
             fillColumn(x);
         }
         
-        for (size_t i = 0; i < count; ++i) {
+        for (int i = 0; i < count; ++i) {
             values[i] = cache->getPhaseAt(col, i * step + minbin);
         }
 
     } catch (std::exception &e) {
         m_error = e.what();

 
     return true;
 }
 
 void
-FFTDataServer::getValuesAt(size_t x, size_t y, float &real, float &imaginary)
+FFTDataServer::getValuesAt(int x, int y, float &real, float &imaginary)
 {
     Profiler profiler("FFTDataServer::getValuesAt", false);
 
     if (x >= m_width || y >= m_height) {
         real = 0;

         return;
     }
 
     try {
 
-        size_t col;
+        int col;
         FFTCacheReader *cache = getCacheReader(x, col);
 
         if (!cache) {
             real = 0;
             imaginary = 0;

         m_error = e.what();
     }
 }
 
 bool
-FFTDataServer::getValuesAt(size_t x, float *reals, float *imaginaries, size_t minbin, size_t count, size_t step)
+FFTDataServer::getValuesAt(int x, float *reals, float *imaginaries, int minbin, int count, int step)
 {
     Profiler profiler("FFTDataServer::getValuesAt", false);
 
     if (x >= m_width) return false;
 

         count = (m_height - minbin) / step;
     }
 
     try {
 
-        size_t col;
+        int col;
         FFTCacheReader *cache = getCacheReader(x, col);
         if (!cache) return false;
 
         if (!cache->haveSetColumnAt(col)) {
             Profiler profiler("FFTDataServer::getValuesAt: filling");
             fillColumn(x);
         }
 
-        for (size_t i = 0; i < count; ++i) {
+        for (int i = 0; i < count; ++i) {
             cache->getValuesAt(col, i * step + minbin, reals[i], imaginaries[i]);
         }
 
     } catch (std::exception &e) {
         m_error = e.what();

 
     return true;
 }
 
 bool
-FFTDataServer::isColumnReady(size_t x)
+FFTDataServer::isColumnReady(int x)
 {
     Profiler profiler("FFTDataServer::isColumnReady", false);
 
     if (x >= m_width) return true;
 

         return false;
     }
 
     try {
 
-        size_t col;
+        int col;
         FFTCacheReader *cache = getCacheReader(x, col);
         if (!cache) return true;
 
         return cache->haveSetColumnAt(col);
 

         return false;
     }
 }    
 
 void
-FFTDataServer::fillColumn(size_t x)
+FFTDataServer::fillColumn(int x)
 {
     Profiler profiler("FFTDataServer::fillColumn", false);
 
     if (!m_model->isReady()) {
         cerr << "WARNING: FFTDataServer::fillColumn(" 

                   << "x > width (" << x << " > " << m_width << ")"
                   << endl;
         return;
     }
 
-    size_t col;
+    int col;
 #ifdef DEBUG_FFT_SERVER_FILL
     cout << "FFTDataServer::fillColumn(" << x << ")" << endl;
 #endif
     FFTCacheWriter *cache = getCacheWriter(x, col);
     if (!cache) return;

     if (m_error != "") return m_error;
     else if (m_fillThread) return m_fillThread->getError();
     else return "";
 }
 
-size_t
+int
 FFTDataServer::getFillCompletion() const 
 {
     if (m_fillThread) return m_fillThread->getCompletion();
     else return 100;
 }
 
-size_t
+int
 FFTDataServer::getFillExtent() const
 {
     if (m_fillThread) return m_fillThread->getExtent();
     else return m_model->getEndFrame();
 }

 
 QString
 FFTDataServer::generateFileBasename(const DenseTimeValueModel *model,
                                     int channel,
                                     WindowType windowType,
-                                    size_t windowSize,
-                                    size_t windowIncrement,
-                                    size_t fftSize,
+                                    int windowSize,
+                                    int windowIncrement,
+                                    int fftSize,
                                     bool polar)
 {
     char buffer[200];
 
     sprintf(buffer, "%u-%u-%u-%u-%u-%u%s",

 #endif
         sleep(1);
     }
     if (m_server.m_exiting) return;
 
-    size_t start = m_server.m_model->getStartFrame();
-    size_t end = m_server.m_model->getEndFrame();
-    size_t remainingEnd = end;
+    int start = m_server.m_model->getStartFrame();
+    int end = m_server.m_model->getEndFrame();
+    int remainingEnd = end;
 
     int counter = 0;
     int updateAt = 1;
     int maxUpdateAt = (end / m_server.m_windowIncrement) / 20;
     if (maxUpdateAt < 100) maxUpdateAt = 100;
 
     if (m_fillFrom > start) {
 
-        for (size_t f = m_fillFrom; f < end; f += m_server.m_windowIncrement) {
+        for (int f = m_fillFrom; f < end; f += m_server.m_windowIncrement) {
 	    
             try {
                 m_server.fillColumn(int((f - start) / m_server.m_windowIncrement));
             } catch (std::exception &e) {
                 std::cerr << "FFTDataServer::FillThread::run: exception: " << e.what() << std::endl;

                 if (m_server.m_exiting) return;
             }
 
             if (++counter == updateAt) {
                 m_extent = f;
-                m_completion = size_t(100 * fabsf(float(f - m_fillFrom) /
+                m_completion = int(100 * fabsf(float(f - m_fillFrom) /
                                                   float(end - start)));
                 counter = 0;
                 if (updateAt < maxUpdateAt) {
                     updateAt *= 2;
                     if (updateAt > maxUpdateAt) updateAt = maxUpdateAt;

         remainingEnd = m_fillFrom;
         if (remainingEnd > start) --remainingEnd;
         else remainingEnd = start;
     }
 
-    size_t baseCompletion = m_completion;
-
-    for (size_t f = start; f < remainingEnd; f += m_server.m_windowIncrement) {
+    int baseCompletion = m_completion;
+
+    for (int f = start; f < remainingEnd; f += m_server.m_windowIncrement) {
 
         try {
             m_server.fillColumn(int((f - start) / m_server.m_windowIncrement));
         } catch (std::exception &e) {
             std::cerr << "FFTDataServer::FillThread::run: exception: " << e.what() << std::endl;

         }
 		    
         if (++counter == updateAt) {
             m_extent = f;
             m_completion = baseCompletion +
-                size_t(100 * fabsf(float(f - start) /
+                int(100 * fabsf(float(f - start) /
                                    float(end - start)));
             counter = 0;
             if (updateAt < maxUpdateAt) {
                 updateAt *= 2;
                 if (updateAt > maxUpdateAt) updateAt = maxUpdateAt;