comparison layer/SpectrogramLayer.cpp @ 248:28c8e8e3c537

* Fix many compile warnings, remove some debug output

 void
 SpectrogramLayer::setMinFrequency(size_t mf)
 {
     if (m_minFrequency == mf) return;
 
-    std::cerr << "SpectrogramLayer::setMinFrequency: " << mf << std::endl;
+//    std::cerr << "SpectrogramLayer::setMinFrequency: " << mf << std::endl;
 
     invalidatePixmapCaches();
     invalidateMagnitudes();
     
     m_minFrequency = mf;

 void
 SpectrogramLayer::setMaxFrequency(size_t mf)
 {
     if (m_maxFrequency == mf) return;
 
-    std::cerr << "SpectrogramLayer::setMaxFrequency: " << mf << std::endl;
+//    std::cerr << "SpectrogramLayer::setMaxFrequency: " << mf << std::endl;
 
     invalidatePixmapCaches();
     invalidateMagnitudes();
     
     m_maxFrequency = mf;

 #endif
 
     for (ViewFFTMap::iterator i = m_fftModels.begin();
          i != m_fftModels.end(); ++i) {
 
-        const View *v = i->first;
         const FFTModel *model = i->second.first;
         size_t lastFill = i->second.second;
 
         if (model) {
 

             m_fftModels[v] = FFTFillPair(0, 0);
             return 0;
         }
 
         if (!m_sliceableModel) {
+#ifdef DEBUG_SPECTROGRAM
             std::cerr << "SpectrogramLayer: emitting sliceableModelReplaced(0, " << model << ")" << std::endl;
+#endif
             ((SpectrogramLayer *)this)->sliceableModelReplaced(0, model);
             m_sliceableModel = model;
         }
 
         m_fftModels[v] = FFTFillPair(model, 0);

     int s0 = int(std::min(s00, s10) + 0.0001);
     int s1 = int(std::max(s01, s11) + 0.0001);
 
 //    std::cerr << "SpectrogramLayer::updateViewMagnitudes: x0 = " << x0 << ", x1 = " << x1 << ", s00 = " << s00 << ", s11 = " << s11 << " s0 = " << s0 << ", s1 = " << s1 << std::endl;
 
-    if (m_columnMags.size() <= s1) {
+    if (int(m_columnMags.size()) <= s1) {
         m_columnMags.resize(s1 + 1);
     }
 
     for (int s = s0; s <= s1; ++s) {
         if (m_columnMags[s].isSet()) {

 
 #ifdef DEBUG_SPECTROGRAM_REPAINT
     std::cerr << "SpectrogramLayer::paint(): pixmap cache valid area " << cache.validArea.x() << ", " << cache.validArea.y() << ", " << cache.validArea.width() << "x" << cache.validArea.height() << std::endl;
 #endif
 
+#ifdef DEBUG_SPECTROGRAM_REPAINT
     bool stillCacheing = (m_updateTimer != 0);
-
-#ifdef DEBUG_SPECTROGRAM_REPAINT
     std::cerr << "SpectrogramLayer::paint(): Still cacheing = " << stillCacheing << std::endl;
 #endif
 
     int zoomLevel = v->getZoomLevel();
 

 	}
 
 	int s0i = int(s0 + 0.001);
 	int s1i = int(s1);
 
-	if (s1i >= fft->getWidth()) {
-	    if (s0i >= fft->getWidth()) {
+	if (s1i >= int(fft->getWidth())) {
+	    if (s0i >= int(fft->getWidth())) {
 		continue;
 	    } else {
 		s1i = s0i;
 	    }
 	}

                 }
 	    }
 
             if (mag.isSet()) {
 
-                if (s >= m_columnMags.size()) {
+                if (s >= int(m_columnMags.size())) {
                     std::cerr << "INTERNAL ERROR: " << s << " >= "
                               << m_columnMags.size() << " at SpectrogramLayer.cpp:2087" << std::endl;
                 }
 
                 m_columnMags[s].sample(mag);

         int s1i = int(s1);
         
         int x0 = v->getXForFrame(s0i * getWindowIncrement());
         int x1 = v->getXForFrame((s1i + 1) * getWindowIncrement());
 
-        int y1 = getYForFrequency(v, f1);
-        int y0 = getYForFrequency(v, f0);
+        int y1 = int(getYForFrequency(v, f1));
+        int y0 = int(getYForFrequency(v, f0));
         
 //        std::cerr << "SpectrogramLayer: illuminate "
 //                  << x0 << "," << y1 << " -> " << x1 << "," << y0 << std::endl;
         
         paint.setPen(Qt::white);

 bool
 SpectrogramLayer::getDisplayExtents(float &min, float &max) const
 {
     min = getEffectiveMinFrequency();
     max = getEffectiveMaxFrequency();
-    std::cerr << "SpectrogramLayer::getDisplayExtents: " << min << "->" << max << std::endl;
+//    std::cerr << "SpectrogramLayer::getDisplayExtents: " << min << "->" << max << std::endl;
     return true;
 }    
 
 bool
 SpectrogramLayer::setDisplayExtents(float min, float max)

 
     return true;
 }
 
 bool
-SpectrogramLayer::snapToFeatureFrame(View *v, int &frame,
+SpectrogramLayer::snapToFeatureFrame(View *, int &frame,
 				     size_t &resolution,
 				     SnapType snap) const
 {
     resolution = getWindowIncrement();
     int left = (frame / resolution) * resolution;

     
     return true;
 } 
 
 bool
-SpectrogramLayer::getCrosshairExtents(View *v, QPainter &paint,
+SpectrogramLayer::getCrosshairExtents(View *v, QPainter &,
                                       QPoint cursorPos,
                                       std::vector<QRect> &extents) const
 {
     QRect vertical(cursorPos.x() - 12, 0, 12, v->height());
     extents.push_back(vertical);

                 len = 10;
             }
         }
 
         paint.drawLine(cursorPos.x() - len,
-                       hy,
+                       int(hy),
                        cursorPos.x(),
-                       hy);
+                       int(hy));
 
         ++harmonic;
     }
 
     paint.restore();

 
     return cw;
 }
 
 int
-SpectrogramLayer::getVerticalScaleWidth(View *v, QPainter &paint) const
+SpectrogramLayer::getVerticalScaleWidth(View *, QPainter &paint) const
 {
     if (!m_model || !m_model->isOK()) return 0;
 
     int cw = getColourScaleWidth(paint);
 

 
     if (m_frequencyScale == LogFrequencyScale) {
 
 	paint.drawLine(w - pkw - 1, 0, w - pkw - 1, h);
 
-	int sr = m_model->getSampleRate();
 	float minf = getEffectiveMinFrequency();
 	float maxf = getEffectiveMaxFrequency();
 
 	int py = h, ppy = h;
 	paint.setBrush(paint.pen().color());

 }
 
 class SpectrogramRangeMapper : public RangeMapper
 {
 public:
-    SpectrogramRangeMapper(int sr, int fftsize) :
+    SpectrogramRangeMapper(int sr, int /* fftsize */) :
         m_dist(float(sr) / 2),
         m_s2(sqrtf(sqrtf(2))) { }
     ~SpectrogramRangeMapper() { }
     
     virtual int getPositionForValue(float value) const {
 
         float dist = m_dist;
     
         int n = 0;
-        int discard = 0;
 
         while (dist > (value + 0.00001) && dist > 0.1f) {
             dist /= m_s2;
             ++n;
         }

     int maxStep = mapper.getPositionForValue(0);
     int minStep = mapper.getPositionForValue(float(sr) / 2);
     
     defaultStep = mapper.getPositionForValue(m_initialMaxFrequency) - minStep;
 
-    std::cerr << "SpectrogramLayer::getVerticalZoomSteps: " << maxStep - minStep << " (" << maxStep <<"-" << minStep << "), default is " << defaultStep << " (from initial max freq " << m_initialMaxFrequency << ")" << std::endl;
+//    std::cerr << "SpectrogramLayer::getVerticalZoomSteps: " << maxStep - minStep << " (" << maxStep <<"-" << minStep << "), default is " << defaultStep << " (from initial max freq " << m_initialMaxFrequency << ")" << std::endl;
 
     return maxStep - minStep;
 }
 
 int

     float dmin, dmax;
     getDisplayExtents(dmin, dmax);
     
     SpectrogramRangeMapper mapper(m_model->getSampleRate(), m_fftSize);
     int n = mapper.getPositionForValue(dmax - dmin);
-    std::cerr << "SpectrogramLayer::getCurrentVerticalZoomStep: " << n << std::endl;
+//    std::cerr << "SpectrogramLayer::getCurrentVerticalZoomStep: " << n << std::endl;
     return n;
 }
 
 void
 SpectrogramLayer::setVerticalZoomStep(int step)

     }
     if (newmax > mmax) {
         newmax = mmax;
     }
     
-    std::cerr << "SpectrogramLayer::setVerticalZoomStep: " << step << ": " << newmin << " -> " << newmax << " (range " << ddist << ")" << std::endl;
+//    std::cerr << "SpectrogramLayer::setVerticalZoomStep: " << step << ": " << newmin << " -> " << newmax << " (range " << ddist << ")" << std::endl;
 
     setMinFrequency(int(newmin));
     setMaxFrequency(int(newmax));
 }