/ - Diff - Cepstral Pitch Tracker - Sound Software .ac.uk

Revision 30:2554aab152a5

+    }
     bool
     CepstrumPitchTracker::Hypothesis::isWithinTolerance(Estimate s)
     CepstrumPitchTracker::Hypothesis::isWithinTolerance(Estimate s) const
+    {
         if (m_pending.empty()) {
             return true;
-...
+    }
     bool
     CepstrumPitchTracker::Hypothesis::isOutOfDateFor(Estimate s)
     CepstrumPitchTracker::Hypothesis::isOutOfDateFor(Estimate s) const
+    {
         if (m_pending.empty()) return false;
-...
+    }
     bool
     CepstrumPitchTracker::Hypothesis::isSatisfied()
     CepstrumPitchTracker::Hypothesis::isSatisfied() const
+    {
         if (m_pending.empty()) return false;
-...
         if (meanConfidence > 0.0) {
             lengthRequired = int(2.0 / meanConfidence + 0.5);
+        }
         std::cerr << "meanConfidence = " << meanConfidence << ", lengthRequired = " << lengthRequired << ", length = " << m_pending.size() << std::endl;
         return (m_pending.size() > lengthRequired);
+    }
-...
+    }
     CepstrumPitchTracker::Hypothesis::State
     CepstrumPitchTracker::Hypothesis::getState()
     CepstrumPitchTracker::Hypothesis::getState() const
+    {
         return m_state;
+    }
     CepstrumPitchTracker::Hypothesis::Estimates
     CepstrumPitchTracker::Hypothesis::getAcceptedEstimates()
     CepstrumPitchTracker::Hypothesis::getAcceptedEstimates() const
+    {
         if (m_state == Satisfied || m_state == Expired) {
             return m_pending;
-...
+    }
     double
     CepstrumPitchTracker::Hypothesis::getMeanFrequency()
     CepstrumPitchTracker::Hypothesis::getMeanFrequency() const
+    {
         double acc = 0.0;
         for (int i = 0; i < m_pending.size(); ++i) {
-...
+    }
     CepstrumPitchTracker::Hypothesis::Note
     CepstrumPitchTracker::Hypothesis::getAveragedNote()
     CepstrumPitchTracker::Hypothesis::getAveragedNote() const
+    {
         Note n;
-...
         n.time = m_pending.begin()->time;
         Estimates::iterator i = m_pending.end();
         Estimates::const_iterator i = m_pending.end();
         --i;
         n.duration = i->time - n.time;
-...
         return n;
+    }
     void
     CepstrumPitchTracker::Hypothesis::addFeatures(FeatureSet &fs)
+    {
         for (int i = 0; i < m_pending.size(); ++i) {
     	Feature f;
     	f.hasTimestamp = true;
     	f.timestamp = m_pending[i].time;
     	f.values.push_back(m_pending[i].freq);
     	fs[0].push_back(f);
+        }
         Feature nf;
         nf.hasTimestamp = true;
         nf.hasDuration = true;
         Note n = getAveragedNote();
         nf.timestamp = n.time;
         nf.duration = n.duration;
         nf.values.push_back(n.freq);
         fs[1].push_back(nf);
+    }
     CepstrumPitchTracker::CepstrumPitchTracker(float inputSampleRate) :
         Plugin(inputSampleRate),
         m_channels(0),
-...
+    }
     void
     CepstrumPitchTracker::addFeaturesFrom(Hypothesis h, FeatureSet &fs)
+    {
         Hypothesis::Estimates es = h.getAcceptedEstimates();
         for (int i = 0; i < es.size(); ++i) {
     	Feature f;
     	f.hasTimestamp = true;
     	f.timestamp = es[i].time;
     	f.values.push_back(es[i].freq);
     	fs[0].push_back(f);
+        }
         Feature nf;
         nf.hasTimestamp = true;
         nf.hasDuration = true;
         Hypothesis::Note n = h.getAveragedNote();
         nf.timestamp = n.time;
         nf.duration = n.duration;
         nf.values.push_back(n.freq);
         fs[1].push_back(nf);
+    }
     void
     CepstrumPitchTracker::filter(const double *cep, double *data)
+    {
         for (int i = 0; i < m_bins; ++i) {
-...
+            }
             if (m_good.getState() == Hypothesis::Expired) {
                 m_good.addFeatures(fs);
                 addFeaturesFrom(m_good, fs);
+            }
             if (m_good.getState() == Hypothesis::Expired ||
-...
+    {
         FeatureSet fs;
         if (m_good.getState() == Hypothesis::Satisfied) {
             m_good.addFeatures(fs);
             addFeaturesFrom(m_good, fs);
+        }
         return fs;
+    }

             bool accept(Estimate);
             State getState();
             Estimates getAcceptedEstimates();
             Note getAveragedNote();
             void addFeatures(FeatureSet &fs);
             State getState() const;
             Estimates getAcceptedEstimates() const;
             Note getAveragedNote() const;
         private:
             bool isWithinTolerance(Estimate);
             bool isOutOfDateFor(Estimate);
             bool isSatisfied();
             double getMeanFrequency();
             bool isWithinTolerance(Estimate) const;
             bool isOutOfDateFor(Estimate) const;
             bool isSatisfied() const;
             double getMeanFrequency() const;
             State m_state;
             Estimates m_pending;
-...
         Hypotheses m_possible;
         Hypothesis m_good;
         void addFeaturesFrom(Hypothesis h, FeatureSet &fs);
         void filter(const double *in, double *out);
         double cubicInterpolate(const double[4], double);
         double findInterpolatedPeak(const double *in, int maxbin);

Also available in: Unified diff