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

Revision 28:7927e7afbe07

     CepstrumPitchTracker::Hypothesis::Hypothesis()
+    {
         m_state = New;
         m_age = 0;
+    }
     CepstrumPitchTracker::Hypothesis::~Hypothesis()
-...
         return true;
+    }
     bool
     CepstrumPitchTracker::Hypothesis::isOutOfDateFor(Estimate s)
+    {
         if (m_pending.empty()) return false;
         return ((s.time - m_pending[m_pending.size()-1].time) >
                 RealTime::fromMilliseconds(40));
+    }
     bool
     CepstrumPitchTracker::Hypothesis::isSatisfied()
+    {
-...
         return (m_pending.size() > lengthRequired);
+    }
     void
     CepstrumPitchTracker::Hypothesis::advanceTime()
+    {
         ++m_age;
+    }
     bool
     CepstrumPitchTracker::Hypothesis::test(Estimate s)
     CepstrumPitchTracker::Hypothesis::accept(Estimate s)
+    {
         bool accept = false;
-...
             break;
         case Provisional:
             if (m_age > 3) {
             if (isOutOfDateFor(s)) {
                 m_state = Rejected;
             } else if (isWithinTolerance(s)) {
                 accept = true;
-...
             break;
         case Satisfied:
             if (m_age > 3) {
             if (isOutOfDateFor(s)) {
                 m_state = Expired;
             } else if (isWithinTolerance(s)) {
                 accept = true;
-...
         if (accept) {
             m_pending.push_back(s);
             m_age = 0;
             if (m_state == Provisional && isSatisfied()) {
                 m_state = Satisfied;
+            }
+        }
         return accept && (m_state == Satisfied);
         return accept;
+    }
     CepstrumPitchTracker::Hypothesis::State
-...
         e.time = timestamp;
         e.confidence = confidence;
         m_accepted.advanceTime();
     //    m_good.advanceTime();
         for (int i = 0; i < m_possible.size(); ++i) {
             m_possible[i].advanceTime();
     //        m_possible[i].advanceTime();
+        }
         if (!m_accepted.test(e)) {
         if (!m_good.accept(e)) {
             int candidate = -1;
             bool accepted = false;
             for (int i = 0; i < m_possible.size(); ++i) {
                 if (m_possible[i].test(e)) {
                     accepted = true;
                 if (m_possible[i].accept(e)) {
                     if (m_possible[i].getState() == Hypothesis::Satisfied) {
                         accepted = true;
                         candidate = i;
+                    }
                     break;
-...
             if (!accepted) {
                 Hypothesis h;
                 h.test(e); //!!! must succeed as h is new, so perhaps there should be a ctor for this
                 h.accept(e); //!!! must succeed as h is new, so perhaps there should be a ctor for this
                 m_possible.push_back(h);
+            }
             if (m_accepted.getState() == Hypothesis::Expired) {
                 m_accepted.addFeatures(fs);
             if (m_good.getState() == Hypothesis::Expired) {
                 m_good.addFeatures(fs);
+            }
             if (m_accepted.getState() == Hypothesis::Expired ||
                 m_accepted.getState() == Hypothesis::Rejected) {
             if (m_good.getState() == Hypothesis::Expired ||
                 m_good.getState() == Hypothesis::Rejected) {
                 if (candidate >= 0) {
                     m_accepted = m_possible[candidate];
                     m_good = m_possible[candidate];
                 } else {
                     m_accepted = Hypothesis();
                     m_good = Hypothesis();
+                }
+            }
-...
+            }
+        }
         std::cerr << "accepted length = " << m_accepted.getPendingLength()
                   << ", state = " << m_accepted.getState()
         std::cerr << "accepted length = " << m_good.getPendingLength()
                   << ", state = " << m_good.getState()
                   << ", hypothesis count = " << m_possible.size() << std::endl;
         delete[] data;
-...
     CepstrumPitchTracker::getRemainingFeatures()
+    {
         FeatureSet fs;
         if (m_accepted.getState() == Hypothesis::Satisfied) {
             m_accepted.addFeatures(fs);
         if (m_good.getState() == Hypothesis::Satisfied) {
             m_good.addFeatures(fs);
+        }
         return fs;
+    }

                 Expired
             };
             bool test(Estimate);
             void advanceTime();
             bool accept(Estimate);
             State getState();
-...
         private:
             bool isWithinTolerance(Estimate);
             bool isOutOfDateFor(Estimate);
             bool isSatisfied();
             double getMeanFrequency();
             State m_state;
             Estimates m_pending;
             int m_age;
         };
         typedef std::vector<Hypothesis> Hypotheses;
         Hypotheses m_possible;
         Hypothesis m_accepted;
         Hypothesis m_good;
         void filter(const double *in, double *out);
         double cubicInterpolate(const double[4], double);

Also available in: Unified diff