comparison LocalCandidatePYIN.cpp @ 141:72bda34e0e64 fixedlag

Merge from branch vamp-fft-revision

     m_threshDistr(2.0f),
     m_outputUnvoiced(0.0f),
     m_preciseTime(0.0f),
     m_pitchProb(0),
     m_timestamp(0),
-    m_nCandidate(13)
+    m_nCandidate(13),
+    m_yinUtil(0)
 {
 }
 
 LocalCandidatePYIN::~LocalCandidatePYIN()
 {
+    delete m_yinUtil;
 }
 
 string
 LocalCandidatePYIN::getIdentifier() const
 {

 {
     return ""; // no programs
 }
 
 void
-LocalCandidatePYIN::selectProgram(string name)
+LocalCandidatePYIN::selectProgram(string)
 {
 }
 
 LocalCandidatePYIN::OutputList
 LocalCandidatePYIN::getOutputDescriptors() const

           << std::endl;
 */
     m_channels = channels;
     m_stepSize = stepSize;
     m_blockSize = blockSize;
+
+    m_yinUtil = new YinUtil(m_blockSize/2);
     
     reset();
 
     return true;
 }

     double *dInputBuffers = new double[m_blockSize];
     for (size_t i = 0; i < m_blockSize; ++i) dInputBuffers[i] = inputBuffers[0][i];
     
     size_t yinBufferSize = m_blockSize/2;
     double* yinBuffer = new double[yinBufferSize];
-    if (!m_preciseTime) YinUtil::fastDifference(dInputBuffers, yinBuffer, yinBufferSize);
-    else YinUtil::slowDifference(dInputBuffers, yinBuffer, yinBufferSize);    
+    if (!m_preciseTime) m_yinUtil->fastDifference(dInputBuffers, yinBuffer);
+    else m_yinUtil->slowDifference(dInputBuffers, yinBuffer);    
     
     delete [] dInputBuffers;
 
-    YinUtil::cumulativeDifference(yinBuffer, yinBufferSize);
+    m_yinUtil->cumulativeDifference(yinBuffer);
     
     float minFrequency = 60;
     float maxFrequency = 900;
-    vector<double> peakProbability = YinUtil::yinProb(yinBuffer, 
-                                                      m_threshDistr, 
-                                                      yinBufferSize, 
-                                                      m_inputSampleRate/maxFrequency, 
-                                                      m_inputSampleRate/minFrequency);
+    vector<double> peakProbability = m_yinUtil->yinProb(yinBuffer, 
+                                                        m_threshDistr, 
+                                                        m_inputSampleRate/maxFrequency, 
+                                                        m_inputSampleRate/minFrequency);
 
     vector<pair<double, double> > tempPitchProb;
     for (size_t iBuf = 0; iBuf < yinBufferSize; ++iBuf)
     {
         if (peakProbability[iBuf] > 0)
         {
             double currentF0 = 
                 m_inputSampleRate * (1.0 /
-                YinUtil::parabolicInterpolation(yinBuffer, iBuf, yinBufferSize));
+                m_yinUtil->parabolicInterpolation(yinBuffer, iBuf));
             double tempPitch = 12 * std::log(currentF0/440)/std::log(2.) + 69;
             tempPitchProb.push_back(pair<double, double>(tempPitch, peakProbability[iBuf]));
         }
     }
     m_pitchProb.push_back(tempPitchProb);

         vector<float> mpOut;
 
         for (size_t iFrame = 0; iFrame < rawPitchPath.size(); ++iFrame)
         {
             float freq = hmm.nearestFreq(rawPitchPath[iFrame], 
-                                                m_pitchProb[iFrame]);
+                                         m_pitchProb[iFrame]);
             mpOut.push_back(freq); // for note processing below
         }
 
-        float prevFreq = 0;
-        for (size_t iFrame = 0; iFrame < nFrame; ++iFrame)
+        for (size_t iFrame = 0; iFrame < rawPitchPath.size(); ++iFrame)
         {
             if (mpOut[iFrame] > 0) {
 
                 pitchTracks[iCandidate][iFrame] = mpOut[iFrame];
                 freqSum[iCandidate] += mpOut[iFrame];
                 freqNumber[iCandidate]++;
-                prevFreq = mpOut[iFrame];
-
             }
         }
         freqMean[iCandidate] = freqSum[iCandidate]*1.0/freqNumber[iCandidate];
     }