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

AgentFeeder.cpp
76	76	}
77	77
78	78	if (!swallowed) {
79		NoteHypothesis h;
	79	NoteHypothesis h(m_slack);
80	80	if (h.accept(e)) {
81	81	newCandidates.push_back(h);
82	82	}

     class AgentFeeder
+    {
     public:
         AgentFeeder() : m_haveCurrent(false) { }
         AgentFeeder(float slack) :
             m_slack(slack),
             m_current(slack),
             m_haveCurrent(false)
         { }
         void feed(NoteHypothesis::Estimate);
         void finish();
-...
         Hypotheses reap(Hypotheses);
     private:
         float m_slack;
         Hypotheses m_candidates;
         NoteHypothesis m_current;
         bool m_haveCurrent;

         m_fmin(50),
         m_fmax(900),
         m_vflen(1),
         m_slack(40),
         m_sensitivity(10),
         m_threshold(0.1),
         m_binFrom(0),
         m_binTo(0),
         m_bins(0),
-...
+    {
         // Increment this each time you release a version that behaves
         // differently from the previous one
         return 1;
         return 2;
+    }
     string
-...
     CepstralPitchTracker::getParameterDescriptors() const
+    {
         ParameterList list;
         ParameterDescriptor d;
         d.identifier = "sensitivity";
         d.name = "Sensitivity";
         d.description = "Sensitivity of the voicing detector";
         d.unit = "";
         d.minValue = 0;
         d.maxValue = 100;
         d.defaultValue = 10;
         d.isQuantized = true;
         d.quantizeStep = 1;
         list.push_back(d);
         d.identifier = "slack";
         d.name = "Slack";
         d.description = "Maximum permissible length of voicing gap for a continuous note";
         d.unit = "ms";
         d.minValue = 0;
         d.maxValue = 200;
         d.defaultValue = 40;
         d.isQuantized = true;
         d.quantizeStep = 1;
         list.push_back(d);
         d.identifier = "threshold";
         d.name = "Silence threshold";
         d.description = "Threshold for silence detection";
         d.unit = ""; //!!! todo: convert this threshold to a meaningful unit!
         d.minValue = 0;
         d.maxValue = 0.5;
         d.defaultValue = 0.1;
         d.isQuantized = false;
         list.push_back(d);
         return list;
+    }
     float
     CepstralPitchTracker::getParameter(string identifier) const
+    {
         if (identifier == "sensitivity") return m_sensitivity;
         else if (identifier == "slack") return m_slack;
         else if (identifier == "threshold") return m_threshold;
         return 0.f;
+    }
     void
     CepstralPitchTracker::setParameter(string identifier, float value)
+    {
         if (identifier == "sensitivity") m_sensitivity = value;
         else if (identifier == "slack") m_slack = value;
         else if (identifier == "threshold") m_threshold = value;
+    }
     CepstralPitchTracker::ProgramList
-...
         d.hasDuration = true;
         outputs.push_back(d);
         d.identifier = "raw";
         d.name = "Raw frequencies";
         d.description = "Raw peak frequencies from cepstrum, including unvoiced segments";
         d.unit = "Hz";
         d.hasFixedBinCount = true;
         d.binCount = 1;
         d.hasKnownExtents = true;
         d.minValue = m_fmin;
         d.maxValue = m_fmax;
         d.isQuantized = false;
         d.sampleType = OutputDescriptor::OneSamplePerStep;
         d.hasDuration = false;
         outputs.push_back(d);
         return outputs;
+    }
-...
     CepstralPitchTracker::reset()
+    {
         delete m_feeder;
         m_feeder = new AgentFeeder();
         m_feeder = new AgentFeeder(m_slack);
         m_nAccepted = 0;
+    }
-...
         double cimax = pi.findPeakLocation(data, m_bins, maxbin);
         double peakfreq = m_inputSampleRate / (cimax + m_binFrom);
         FeatureSet fs;
         Feature rawf;
         rawf.hasTimestamp = false;
         rawf.hasDuration = false;
         rawf.values.push_back(peakfreq);
         fs[2].push_back(rawf);
         double confidence = 0.0;
         double threshold = 0.1; // for magmean
         if (nextPeakVal != 0.0) {
             confidence = (maxval - nextPeakVal) * 10.0;
             if (magmean < threshold) confidence = 0.0;
             confidence = (maxval - nextPeakVal) * m_sensitivity;
             if (magmean < m_threshold) confidence = 0.0;
+        }
         delete[] data;
-...
         m_feeder->feed(e);
         FeatureSet fs;
         addNewFeatures(fs);
         return fs;
+    }

         float m_fmax;
         int m_vflen;
         float m_slack;
         float m_sensitivity;
         float m_threshold;
         int m_binFrom;
         int m_binTo;
         int m_bins; // count of "interesting" bins, those returned in m_cepOutput

     # DO NOT DELETE
     AgentFeeder.o: AgentFeeder.h NoteHypothesis.h
     CepstralPitchTracker.o: CepstralPitchTracker.h NoteHypothesis.h Cepstrum.h
     CepstralPitchTracker.o: MeanFilter.h PeakInterpolator.h
     libmain.o: CepstralPitchTracker.h NoteHypothesis.h
     CepstralPitchTracker.o: MeanFilter.h PeakInterpolator.h AgentFeeder.h
     NoteHypothesis.o: NoteHypothesis.h
     PeakInterpolator.o: PeakInterpolator.h
     libmain.o: CepstralPitchTracker.h NoteHypothesis.h
     test/TestAgentFeeder.o: AgentFeeder.h NoteHypothesis.h
     test/TestCepstrum.o: Cepstrum.h
     test/TestMeanFilter.o: MeanFilter.h
     test/TestNoteHypothesis.o: NoteHypothesis.h
     test/TestPeakInterpolator.o: PeakInterpolator.h
     AgentFeeder.o: NoteHypothesis.h
     CepstralPitchTracker.o: NoteHypothesis.h

NoteHypothesis.cpp
28	28
29	29	using Vamp::RealTime;
30	30
31		NoteHypothesis::NoteHypothesis()
	31	NoteHypothesis::NoteHypothesis(float slack) :
	32	m_state(New),
	33	m_slack(slack)
32	34	{
33		m_state = New;
34	35	}
35	36
36	37	NoteHypothesis::~NoteHypothesis()
...	...
65	66	{
66	67	if (m_pending.empty()) return false;
67	68	return ((s.time - m_pending[m_pending.size()-1].time) >
68		RealTime::fromMilliseconds(40));
	69	RealTime::fromMilliseconds(m_slack));
69	70	}
70	71
71	72	bool

         };
         /**
          * Construct an empty hypothesis. This will be in New state and
          * will provisionally accept any estimate.
          * Construct an empty hypothesis. The given slack (in
          * milliseconds) determines how long the hypothesis is prepared to
          * tolerate unacceptable estimates in between accepted estimates
          * before it becomes rejected. A reasonable default is 40ms.
+         *
          * This hypothesis will be in New state and will provisionally
          * accept any estimate.
          */
         NoteHypothesis();
         NoteHypothesis(float slack);
         /**
          * Destroy the hypothesis
-...
         State m_state;
         Estimates m_pending;
         float m_slack;
     };
     #endif

     typedef NoteHypothesis::Estimate Est;
     #define DEFAULT_SLACK_MS 40
     BOOST_AUTO_TEST_SUITE(TestAgentFeeder)
     BOOST_AUTO_TEST_CASE(feederEmpty)
+    {
         AgentFeeder f;
         AgentFeeder f(DEFAULT_SLACK_MS);
         f.finish();
         AgentFeeder::Hypotheses accepted = f.getAcceptedHypotheses();
         BOOST_CHECK(accepted.empty());
-...
         Est e20(low, ms(20), 1);
         Est e30(low, ms(30), 1);
         AgentFeeder f;
         AgentFeeder f(DEFAULT_SLACK_MS);
         f.feed(e0);
         f.feed(e10);
         f.feed(e20);
-...
         Est f20(high, ms(2020), 1);
         Est f30(high, ms(2030), 1);
         AgentFeeder f;
         AgentFeeder f(DEFAULT_SLACK_MS);
         f.feed(e0);
         f.feed(e10);
         f.feed(e20);
-...
         Est f43(high, ms(43), 1);
         Est f44(high, ms(44), 1);
         AgentFeeder f;
         AgentFeeder f(DEFAULT_SLACK_MS);
         f.feed(e0);
         f.feed(e10);
         f.feed(e20);
-...
         Est f70(high, ms(70), 1);
         Est f80(high, ms(80), 1);
         AgentFeeder f;
         AgentFeeder f(DEFAULT_SLACK_MS);
         f.feed(e0);
         f.feed(e10);
         f.feed(e20);
-...
         Est f40(high, ms(40), 1);
         Est f50(high, ms(50), 1);
         AgentFeeder f;
         AgentFeeder f(DEFAULT_SLACK_MS);
         f.feed(e0);
         f.feed(e10);

     using Vamp::RealTime;
     #define DEFAULT_SLACK_MS 40
     BOOST_AUTO_TEST_SUITE(TestNoteHypothesis)
     BOOST_AUTO_TEST_CASE(emptyAccept)
+    {
         // An empty hypothesis should accept any estimate with a
         // non-negligible confidence, and enter provisional state
         NoteHypothesis h;
         NoteHypothesis h(DEFAULT_SLACK_MS);
         NoteHypothesis::Estimate e; // default estimate has confidence 1
         BOOST_CHECK_EQUAL(h.getState(), NoteHypothesis::New);
         BOOST_CHECK(h.accept(e));
-...
+    {
         // A hypothesis should reject any estimate that has a negligible
         // confidence
         NoteHypothesis h;
         NoteHypothesis h(DEFAULT_SLACK_MS);
         NoteHypothesis::Estimate e;
         e.confidence = 0;
         BOOST_CHECK_EQUAL(h.getState(), NoteHypothesis::New);
-...
+    {
         // But if we're already in process we don't go to rejected state,
         // we just ignore this hypothesis
         NoteHypothesis h;
         NoteHypothesis h(DEFAULT_SLACK_MS);
         NoteHypothesis::Estimate e;
         BOOST_CHECK_EQUAL(h.getState(), NoteHypothesis::New);
         BOOST_CHECK(h.accept(e));
-...
+    {
         // Having accepted a first estimate, a hypothesis should reject a
         // second (and enter rejected state) if there is too long a gap
         // between them for them to belong to a single note
         NoteHypothesis h;
         // between them for them to belong to a single note. Test this
         // with more than one slack parameter, since that's what
         // determines how long the gap can be.
+        {
         NoteHypothesis h(40);
         NoteHypothesis::Estimate e1(500, RealTime::fromMilliseconds(0), 1);
         NoteHypothesis::Estimate e2(500, RealTime::fromMilliseconds(50), 1);
         BOOST_CHECK_EQUAL(h.getState(), NoteHypothesis::New);
-...
         BOOST_CHECK_EQUAL(h.getState(), NoteHypothesis::Provisional);
         BOOST_CHECK(!h.accept(e2));
         BOOST_CHECK_EQUAL(h.getState(), NoteHypothesis::Rejected);
+        }
+        {
         NoteHypothesis h(100);
         NoteHypothesis::Estimate e1(500, RealTime::fromMilliseconds(0), 1);
         NoteHypothesis::Estimate e2(500, RealTime::fromMilliseconds(50), 1);
         BOOST_CHECK_EQUAL(h.getState(), NoteHypothesis::New);
         BOOST_CHECK(h.accept(e1));
         BOOST_CHECK_EQUAL(h.getState(), NoteHypothesis::Provisional);
         BOOST_CHECK(h.accept(e2));
         BOOST_CHECK_EQUAL(h.getState(), NoteHypothesis::Provisional);
+        }
+    }
     BOOST_AUTO_TEST_CASE(simpleSatisfy)
-...
         // A hypothesis should enter satisfied state after accepting three
         // consistent estimates, and then remain satisfied while accepting
         // further consistent estimates
         NoteHypothesis h;
         NoteHypothesis h(DEFAULT_SLACK_MS);
         NoteHypothesis::Estimate e1(500, RealTime::fromMilliseconds(0), 1);
         NoteHypothesis::Estimate e2(500, RealTime::fromMilliseconds(10), 1);
         NoteHypothesis::Estimate e3(500, RealTime::fromMilliseconds(20), 1);
-...
         // offered an estimate that follows too long a gap, should enter
         // expired state rather than rejected state (showing that it has a
         // valid note but that the note has apparently finished)
         NoteHypothesis h;
         NoteHypothesis h(DEFAULT_SLACK_MS);
         NoteHypothesis::Estimate e1(500, RealTime::fromMilliseconds(0), 1);
         NoteHypothesis::Estimate e2(500, RealTime::fromMilliseconds(10), 1);
         NoteHypothesis::Estimate e3(500, RealTime::fromMilliseconds(20), 1);
-...
+    {
         // A wildly different frequency occurring in the middle of a
         // provisionally accepted note should be ignored
         NoteHypothesis h;
         NoteHypothesis h(DEFAULT_SLACK_MS);
         NoteHypothesis::Estimate e1(500, RealTime::fromMilliseconds(0), 1);
         NoteHypothesis::Estimate e2(1000, RealTime::fromMilliseconds(10), 1);
         NoteHypothesis::Estimate e3(500, RealTime::fromMilliseconds(20), 1);
-...
+    {
         // A wildly different frequency occurring in the middle of a
         // satisfied note should be ignored
         NoteHypothesis h;
         NoteHypothesis h(DEFAULT_SLACK_MS);
         NoteHypothesis::Estimate e1(500, RealTime::fromMilliseconds(0), 1);
         NoteHypothesis::Estimate e2(500, RealTime::fromMilliseconds(10), 1);
         NoteHypothesis::Estimate e3(500, RealTime::fromMilliseconds(20), 1);
-...
+    {
         // Behaviour with slightly varying frequencies should be as for
         // that with fixed frequency
         NoteHypothesis h;
         NoteHypothesis h(DEFAULT_SLACK_MS);
         NoteHypothesis::Estimate e1(500, RealTime::fromMilliseconds(0), 0.5);
         NoteHypothesis::Estimate e2(502, RealTime::fromMilliseconds(10), 0.5);
         NoteHypothesis::Estimate e3(504, RealTime::fromMilliseconds(20), 0.5);
-...
+    {
         // But there's a limit: outside a certain range we should reject
         //!!! (but what is this range? is it part of the spec?)
         NoteHypothesis h;
         NoteHypothesis h(DEFAULT_SLACK_MS);
         NoteHypothesis::Estimate e1(440, RealTime::fromMilliseconds(0), 1);
         NoteHypothesis::Estimate e2(448, RealTime::fromMilliseconds(10), 1);
         NoteHypothesis::Estimate e3(444, RealTime::fromMilliseconds(20), 1);
-...
     BOOST_AUTO_TEST_CASE(acceptedEstimates)
+    {
         // Check that getAcceptedEstimates() returns the right result
         NoteHypothesis h;
         NoteHypothesis h(DEFAULT_SLACK_MS);
         NoteHypothesis::Estimate e1(440, RealTime::fromMilliseconds(0), 1);
         NoteHypothesis::Estimate e2(448, RealTime::fromMilliseconds(10), 1);
         NoteHypothesis::Estimate e3(444, RealTime::fromMilliseconds(20), 1);
-...
     BOOST_AUTO_TEST_CASE(meanFrequency)
+    {
         // Check that the mean frequency is the mean of the frequencies
         NoteHypothesis h;
         NoteHypothesis h(DEFAULT_SLACK_MS);
         NoteHypothesis::Estimate e1(440, RealTime::fromMilliseconds(0), 1);
         NoteHypothesis::Estimate e2(448, RealTime::fromMilliseconds(10), 1);
         NoteHypothesis::Estimate e3(444, RealTime::fromMilliseconds(20), 1);
-...
     BOOST_AUTO_TEST_CASE(averagedNote)
+    {
         // Check that getAveragedNote returns something sane
         NoteHypothesis h;
         NoteHypothesis h(DEFAULT_SLACK_MS);
         NoteHypothesis::Estimate e1(440, RealTime::fromMilliseconds(10), 1);
         NoteHypothesis::Estimate e2(448, RealTime::fromMilliseconds(20), 1);
         NoteHypothesis::Estimate e3(444, RealTime::fromMilliseconds(30), 1);

Cepstral Pitch Tracker

Revision 66:7ad142c710c6