comparison data/model/FFTModel.cpp @ 1038:cc27f35aa75c cxx11

Introducing the signed 64-bit frame index type, and fixing build failures from inclusion of -Wconversion with -Werror. Not finished yet.

     if (!isOK()) return false;
 
     int sampleRate = m_server->getModel()->getSampleRate();
 
     int fftSize = m_server->getFFTSize() >> m_yshift;
-    frequency = (float(y) * sampleRate) / fftSize;
+    frequency = float((double(y) * sampleRate) / fftSize);
 
     if (x+1 >= getWidth()) return false;
 
     // At frequency f, a phase shift of 2pi (one cycle) happens in 1/f sec.
     // At hopsize h and sample rate sr, one hop happens in h/sr sec.

     // We need to know what phase shift we expect from h/sr sec.
     // -> 2pi * ((h/sr) / (w/(b*sr)))
     //  = 2pi * ((h * b * sr) / (w * sr))
     //  = 2pi * (h * b) / w.
 
-    float oldPhase = getPhaseAt(x, y);
-    float newPhase = getPhaseAt(x+1, y);
+    double oldPhase = getPhaseAt(x, y);
+    double newPhase = getPhaseAt(x+1, y);
 
     int incr = getResolution();
 
-    float expectedPhase = oldPhase + (2.0 * M_PI * y * incr) / fftSize;
-
-    float phaseError = princargf(newPhase - expectedPhase);
+    double expectedPhase = oldPhase + (2.0 * M_PI * y * incr) / fftSize;
+
+    double phaseError = princarg(newPhase - expectedPhase);
 
 //    bool stable = (fabsf(phaseError) < (1.1f * (m_windowIncrement * M_PI) / m_fftSize));
 
     // The new frequency estimate based on the phase error resulting
     // from assuming the "native" frequency of this bin
 
     frequency =
-        (sampleRate * (expectedPhase + phaseError - oldPhase)) /
-        (2 * M_PI * incr);
+        float((sampleRate * (expectedPhase + phaseError - oldPhase)) /
+              (2 * M_PI * incr));
 
     return true;
 }
 
 FFTModel::PeakLocationSet

 
     Column values = getColumn(x);
 
     float mean = 0.f;
     for (int i = 0; i < values.size(); ++i) mean += values[i];
-    if (values.size() >0) mean /= values.size();
-
+    if (values.size() > 0) mean = mean / float(values.size());
+    
     // For peak picking we use a moving median window, picking the
     // highest value within each continuous region of values that
     // exceed the median.  For pitch adaptivity, we adjust the window
     // size to a roughly constant pitch range (about four tones).
 

 
         while ((int)window.size() > medianWinSize) {
             window.pop_front();
         }
 
-        int actualSize = window.size();
+        int actualSize = int(window.size());
 
         if (type == MajorPitchAdaptivePeaks) {
             if (ymax + halfWin < values.size()) binmax = ymax + halfWin;
             else binmax = values.size()-1;
         }
 
         std::deque<float> sorted(window);
         std::sort(sorted.begin(), sorted.end());
-        float median = sorted[int(sorted.size() * dist)];
+        float median = sorted[int(float(sorted.size()) * dist)];
 
         int centrebin = 0;
         if (bin > actualSize/2) centrebin = bin - actualSize/2;
         
         while (centrebin > prevcentre || bin == binmin) {

     percentile = 0.5;
     if (type == MajorPeaks) return 10;
     if (bin == 0) return 3;
 
     int fftSize = m_server->getFFTSize() >> m_yshift;
-    float binfreq = (float(sampleRate) * bin) / fftSize;
-    float hifreq = Pitch::getFrequencyForPitch(73, 0, binfreq);
-
-    int hibin = lrintf((hifreq * fftSize) / sampleRate);
+    double binfreq = (double(sampleRate) * bin) / fftSize;
+    double hifreq = Pitch::getFrequencyForPitch(73, 0, binfreq);
+
+    int hibin = int(lrint((hifreq * fftSize) / sampleRate));
     int medianWinSize = hibin - bin;
     if (medianWinSize < 3) medianWinSize = 3;
 
-    percentile = 0.5 + (binfreq / sampleRate);
+    percentile = 0.5f + float(binfreq / sampleRate);
 
     return medianWinSize;
 }
 
 FFTModel::PeakSet

     }
 
     int phaseIndex = 0;
     for (PeakLocationSet::iterator i = locations.begin();
          i != locations.end(); ++i) {
-        float oldPhase = phases[phaseIndex];
-        float newPhase = getPhaseAt(x+1, *i);
-        float expectedPhase = oldPhase + (2.0 * M_PI * *i * incr) / fftSize;
-        float phaseError = princargf(newPhase - expectedPhase);
-        float frequency =
+        double oldPhase = phases[phaseIndex];
+        double newPhase = getPhaseAt(x+1, *i);
+        double expectedPhase = oldPhase + (2.0 * M_PI * *i * incr) / fftSize;
+        double phaseError = princarg(newPhase - expectedPhase);
+        double frequency =
             (sampleRate * (expectedPhase + phaseError - oldPhase))
             / (2 * M_PI * incr);
 //        bool stable = (fabsf(phaseError) < (1.1f * (incr * M_PI) / fftSize));
 //        if (stable)
-        peaks[*i] = frequency;
+        peaks[*i] = float(frequency);
         ++phaseIndex;
     }
 
     return peaks;
 }