comparison layer/SliceLayer.cpp @ 811:c4ef666721bf

Merge from branch warnfix_no_size_t

 
 QString
 SliceLayer::getFeatureDescription(View *v, QPoint &p) const
 {
     int minbin, maxbin, range;
-    return getFeatureDescription(v, p, true, minbin, maxbin, range);
+    return getFeatureDescriptionAux(v, p, true, minbin, maxbin, range);
 }
 
 QString
-SliceLayer::getFeatureDescription(View *v, QPoint &p,
-                                  bool includeBinDescription,
-                                  int &minbin, int &maxbin, int &range) const
+SliceLayer::getFeatureDescriptionAux(View *v, QPoint &p,
+                                     bool includeBinDescription,
+                                     int &minbin, int &maxbin, int &range) const
 {
     minbin = 0;
     maxbin = 0;
     if (!m_sliceableModel) return "";
 

     if (minbin < 0) minbin = 0;
     if (maxbin < 0) maxbin = 0;
     
     int sampleRate = m_sliceableModel->getSampleRate();
 
-    size_t f0 = m_currentf0;
-    size_t f1 = m_currentf1;
+    int f0 = m_currentf0;
+    int f1 = m_currentf1;
 
     RealTime rt0 = RealTime::frame2RealTime(f0, sampleRate);
     RealTime rt1 = RealTime::frame2RealTime(f1, sampleRate);
     
     range = f1 - f0 + 1;

         
     case AbsoluteScale:
         value = fabsf(value);
         // and fall through
         
+    case LinearScale:
     default:
         norm = (value - m_threshold);
         if (norm < 0) norm = 0;
         y = yorigin - (float(h) * norm);
         break;

     }
 
     case MeterScale:
         value = AudioLevel::preview_to_multiplier(lrintf(y), h);
         break;
-    
+
+    case LinearScale:
+    case AbsoluteScale:
     default:
         value = y / h + m_threshold;
     }
 
     return value / m_gain;

     paint.setBrush(Qt::NoBrush);
 
     if (v->getViewManager() && v->getViewManager()->shouldShowScaleGuides()) {
         if (!m_scalePoints.empty()) {
             paint.setPen(QColor(240, 240, 240)); //!!! and dark background?
-            for (size_t i = 0; i < m_scalePoints.size(); ++i) {
+            for (int i = 0; i < (int)m_scalePoints.size(); ++i) {
                 paint.drawLine(0, m_scalePoints[i], rect.width(), m_scalePoints[i]);
             }
         }
     }
 

 
     if (h <= 0) return;
 
     QPainterPath path;
 
-    size_t mh = m_sliceableModel->getHeight();
+    int mh = m_sliceableModel->getHeight();
 
     int divisor = 0;
 
     m_values.clear();
-    for (size_t bin = 0; bin < mh; ++bin) {
+    for (int bin = 0; bin < mh; ++bin) {
         m_values.push_back(0.f);
     }
 
-    size_t f0 = v->getCentreFrame();
+    int f0 = v->getCentreFrame();
     int f0x = v->getXForFrame(f0);
     f0 = v->getFrameForX(f0x);
-    size_t f1 = v->getFrameForX(f0x + 1);
+    int f1 = v->getFrameForX(f0x + 1);
     if (f1 > f0) --f1;
 
 //    cerr << "centre frame " << v->getCentreFrame() << ", x " << f0x << ", f0 " << f0 << ", f1 " << f1 << endl;
 
-    size_t res = m_sliceableModel->getResolution();
-    size_t col0 = f0 / res;
-    size_t col1 = col0;
+    int res = m_sliceableModel->getResolution();
+    int col0 = f0 / res;
+    int col1 = col0;
     if (m_samplingMode != NearestSample) col1 = f1 / res;
     f0 = col0 * res;
     f1 = (col1 + 1) * res - 1;
 
 //    cerr << "resolution " << res << ", col0 " << col0 << ", col1 " << col1 << ", f0 " << f0 << ", f1 " << f1 << endl;

     m_currentf0 = f0;
     m_currentf1 = f1;
 
     BiasCurve curve;
     getBiasCurve(curve);
-    size_t cs = curve.size();
-
-    for (size_t col = col0; col <= col1; ++col) {
-        for (size_t bin = 0; bin < mh; ++bin) {
+    int cs = curve.size();
+
+    for (int col = col0; col <= col1; ++col) {
+        for (int bin = 0; bin < mh; ++bin) {
             float value = m_sliceableModel->getValueAt(col, bin);
             if (bin < cs) value *= curve[bin];
             if (m_samplingMode == SamplePeak) {
                 if (value > m_values[bin]) m_values[bin] = value;
             } else {

         }
         ++divisor;
     }
 
     float max = 0.f;
-    for (size_t bin = 0; bin < mh; ++bin) {
+    for (int bin = 0; bin < mh; ++bin) {
         if (m_samplingMode == SampleMean) m_values[bin] /= divisor;
         if (m_values[bin] > max) max = m_values[bin];
     }
     if (max != 0.f && m_normalize) {
-        for (size_t bin = 0; bin < mh; ++bin) {
+        for (int bin = 0; bin < mh; ++bin) {
             m_values[bin] /= max;
         }
     }
 
-    float py = 0;
     float nx = xorigin;
 
     ColourMapper mapper(m_colourMap, 0, 1);
 
-    for (size_t bin = 0; bin < mh; ++bin) {
+    for (int bin = 0; bin < mh; ++bin) {
 
         float x = nx;
         nx = xorigin + getXForBin(bin + 1, mh, w);
 
         float value = m_values[bin];

         } else if (m_plotStyle == PlotFilledBlocks) {
 
             paint.fillRect(QRectF(x, y, nx - x, yorigin - y), mapper.map(norm));
         }
 
-        py = y;
     }
 
     if (m_plotStyle != PlotFilledBlocks) {
         paint.drawPath(path);
     }