Cepstral Pitch Tracker

using Vamp::RealTime;

    Estimate first = m_pending[0];

    // check we are within a relatively close tolerance of the last

    // candidate

    if (cents < -40 || cents > 40) return false;

    // and within a wider tolerance of our starting candidate

    r = s.freq / first.freq;

    cents = lrint(1200.0 * (log(r) / log(2.0)));

    if (cents < -80 || cents > 80) return false;

    return true;

CepstrumPitchTracker::Hypothesis::Note

CepstrumPitchTracker::Hypothesis::getAveragedNote()

{

    Note n;

    if (!(m_state == Satisfied || m_state == Expired)) {

        n.freq = 0.0;

        n.time = RealTime::zeroTime;

        n.duration = RealTime::zeroTime;

        return n;

    }

    n.time = m_pending.begin()->time;

    Estimates::iterator i = m_pending.end();

    --i;

    n.duration = i->time - n.time;

    // just mean frequency for now, but this isn't at all right

    double acc = 0.0;

    for (int i = 0; i < m_pending.size(); ++i) {

        acc += m_pending[i].freq;

    }

    acc /= m_pending.size();

    n.freq = acc;

    return n;

}

CepstrumPitchTracker::Hypothesis::addFeatures(FeatureSet &fs)

	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);

    d.identifier = "notes";

    d.name = "Notes";

    d.description = "Derived fixed-pitch note frequencies";

    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::FixedSampleRate;

    d.sampleRate = (m_inputSampleRate / m_stepSize);

    d.hasDuration = true;

    outputs.push_back(d);

CepstrumPitchTracker::process(const float *const *inputBuffers, RealTime timestamp)

            m_accepted.addFeatures(fs);

        m_accepted.addFeatures(fs);