Cepstral Pitch Tracker

syntax: glob

*.o

*.so

*.bak

test/test-*

f31b2da9258dfc05000ab2741d2ce63aa45637ba v1.0

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

    This file is Copyright (c) 2012 Chris Cannam

    Permission is hereby granted, free of charge, to any person

    obtaining a copy of this software and associated documentation

    files (the "Software"), to deal in the Software without

    restriction, including without limitation the rights to use, copy,

    modify, merge, publish, distribute, sublicense, and/or sell copies

    of the Software, and to permit persons to whom the Software is

    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be

    included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

    ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#include "AgentFeeder.h"

void AgentFeeder::feed(NoteHypothesis::Estimate e)

{

    if (m_haveCurrent) {

        if (m_current.accept(e)) {

            return;

        }

        if (m_current.getState() == NoteHypothesis::Expired) {

            m_accepted.push_back(m_current);

            m_haveCurrent = false;

        }

    }

    bool swallowed = false;

    Hypotheses newCandidates;

    for (Hypotheses::iterator i = m_candidates.begin();

         i != m_candidates.end(); ++i) {

        NoteHypothesis h = *i;

        if (swallowed) {

            // don't offer: each observation can only belong to one

            // satisfied hypothesis

            newCandidates.push_back(h);

        } else {

            if (h.accept(e)) {

                if (h.getState() == NoteHypothesis::Satisfied) {

                    swallowed = true;

                    if (!m_haveCurrent ||

                        m_current.getState() == NoteHypothesis::Expired ||

                        m_current.getState() == NoteHypothesis::Rejected) {

                        m_current = h;

                        m_haveCurrent = true;

                    } else {

                        newCandidates.push_back(h);

                    }

                } else {

                    newCandidates.push_back(h);

                }

            }

        }

    }

    if (!swallowed) {

        NoteHypothesis h;

        if (h.accept(e)) {

            newCandidates.push_back(h);

        }

    }

    m_candidates = reap(newCandidates);

}

AgentFeeder::Hypotheses

AgentFeeder::reap(Hypotheses candidates)

{

    // reap rejected/expired hypotheses from list of candidates

    Hypotheses survived;

    for (Hypotheses::const_iterator i = candidates.begin();

         i != candidates.end(); ++i) {

        NoteHypothesis h = *i;

        if (h.getState() != NoteHypothesis::Rejected && 

            h.getState() != NoteHypothesis::Expired) {

            survived.push_back(h);

        }

    }

    return survived;

}

void

AgentFeeder::finish()

{

    if (m_current.getState() == NoteHypothesis::Satisfied) {

	m_accepted.push_back(m_current);

    }

}

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

    This file is Copyright (c) 2012 Chris Cannam

    Permission is hereby granted, free of charge, to any person

    obtaining a copy of this software and associated documentation

    files (the "Software"), to deal in the Software without

    restriction, including without limitation the rights to use, copy,

    modify, merge, publish, distribute, sublicense, and/or sell copies

    of the Software, and to permit persons to whom the Software is

    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be

    included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

    ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#ifndef _AGENT_FEEDER_H_

#define _AGENT_FEEDER_H_

#include "NoteHypothesis.h"

#include <vector>

/**

 * Take a series of estimates (one at a time) and feed them to a set

 * of note hypotheses, creating a new candidate hypothesis for each

 * observation and also testing the observation against the existing

 * set of hypotheses.

 *

 * One satisfied hypothesis is considered to be "accepted" at any

 * moment (that is, the earliest contemporary hypothesis to have

 * become satisfied). The series of accepted and completed hypotheses

 * from construction to the present time can be queried through

 * getAcceptedHypotheses().

 *

 * Call feed() to provide a new observation. Call finish() when all

 * observations have been provided. The set of hypotheses returned by

 * getAcceptedHypotheses() will not be complete unless finish() has

 * been called.

 */

class AgentFeeder

{

public:

    AgentFeeder() : m_haveCurrent(false) { }

    void feed(NoteHypothesis::Estimate);

    void finish();

    typedef std::vector<NoteHypothesis> Hypotheses;

    const Hypotheses &getAcceptedHypotheses() const {

        return m_accepted;

    }

    Hypotheses reap(Hypotheses);

private:

    Hypotheses m_candidates;

    NoteHypothesis m_current;

    bool m_haveCurrent;

    Hypotheses m_accepted;

};

#endif

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

    This file is Copyright (c) 2012 Chris Cannam

    Permission is hereby granted, free of charge, to any person

    obtaining a copy of this software and associated documentation

    files (the "Software"), to deal in the Software without

    restriction, including without limitation the rights to use, copy,

    modify, merge, publish, distribute, sublicense, and/or sell copies

    of the Software, and to permit persons to whom the Software is

    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be

    included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

    ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#include "CepstralPitchTracker.h"

#include "Cepstrum.h"

#include "MeanFilter.h"

#include "PeakInterpolator.h"

#include "AgentFeeder.h"

#include "vamp-sdk/FFT.h"

#include <vector>

#include <algorithm>

#include <cstdio>

#include <cmath>

#include <complex>

using std::string;

using std::vector;

using Vamp::RealTime;

CepstralPitchTracker::CepstralPitchTracker(float inputSampleRate) :

    Plugin(inputSampleRate),

    m_channels(0),

    m_stepSize(256),

    m_blockSize(1024),

    m_fmin(50),

    m_fmax(900),

    m_vflen(1),

    m_binFrom(0),

    m_binTo(0),

    m_bins(0),

    m_nAccepted(0),

    m_feeder(0)

{

}

CepstralPitchTracker::~CepstralPitchTracker()

{

    delete m_feeder;

}

string

CepstralPitchTracker::getIdentifier() const

{

    return "cepstral-pitchtracker";

}

string

CepstralPitchTracker::getName() const

{

    return "Cepstral Pitch Tracker";

}

string

CepstralPitchTracker::getDescription() const

{

    return "Estimate f0 of monophonic material using a cepstrum method.";

}

string

CepstralPitchTracker::getMaker() const

{

    return "Chris Cannam";

}

int

CepstralPitchTracker::getPluginVersion() const

{

    // Increment this each time you release a version that behaves

    // differently from the previous one

    return 1;

}

string

CepstralPitchTracker::getCopyright() const

{

    return "Freely redistributable (BSD license)";

}

CepstralPitchTracker::InputDomain

CepstralPitchTracker::getInputDomain() const

{

    return FrequencyDomain;

}

size_t

CepstralPitchTracker::getPreferredBlockSize() const

{

    return 1024;

}

size_t 

CepstralPitchTracker::getPreferredStepSize() const

{

    return 256;

}

size_t

CepstralPitchTracker::getMinChannelCount() const

{

    return 1;

}

size_t

CepstralPitchTracker::getMaxChannelCount() const

{

    return 1;

}

CepstralPitchTracker::ParameterList

CepstralPitchTracker::getParameterDescriptors() const

{

    ParameterList list;

    return list;

}

float

CepstralPitchTracker::getParameter(string identifier) const

{

    return 0.f;

}

void

CepstralPitchTracker::setParameter(string identifier, float value) 

{

}

CepstralPitchTracker::ProgramList

CepstralPitchTracker::getPrograms() const

{

    ProgramList list;

    return list;

}

string

CepstralPitchTracker::getCurrentProgram() const

{

    return ""; // no programs

}

void

CepstralPitchTracker::selectProgram(string name)

{

}

CepstralPitchTracker::OutputList

CepstralPitchTracker::getOutputDescriptors() const

{

    OutputList outputs;

    OutputDescriptor d;

    d.identifier = "f0";

    d.name = "Estimated f0";

    d.description = "Estimated fundamental frequency";

    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 = false;

    outputs.push_back(d);

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

    return outputs;

}

bool

CepstralPitchTracker::initialise(size_t channels, size_t stepSize, size_t blockSize)

{

    if (channels < getMinChannelCount() ||

	channels > getMaxChannelCount()) return false;

//    std::cerr << "CepstralPitchTracker::initialise: channels = " << channels

//	      << ", stepSize = " << stepSize << ", blockSize = " << blockSize

//	      << std::endl;

    m_channels = channels;

    m_stepSize = stepSize;

    m_blockSize = blockSize;

    m_binFrom = int(m_inputSampleRate / m_fmax);

    m_binTo = int(m_inputSampleRate / m_fmin); 

    if (m_binTo >= (int)m_blockSize / 2) {

        m_binTo = m_blockSize / 2 - 1;

    }

    if (m_binFrom >= m_binTo) {

        // shouldn't happen except for degenerate samplerate / blocksize combos

        m_binFrom = m_binTo - 1;

    }

    m_bins = (m_binTo - m_binFrom) + 1;

    reset();

    return true;

}

void

CepstralPitchTracker::reset()

{

    delete m_feeder;

    m_feeder = new AgentFeeder();

    m_nAccepted = 0;

}

void

CepstralPitchTracker::addFeaturesFrom(NoteHypothesis h, FeatureSet &fs)

{

    NoteHypothesis::Estimates es = h.getAcceptedEstimates();

    for (int i = 0; i < (int)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;

    NoteHypothesis::Note n = h.getAveragedNote();

    nf.timestamp = n.time;

    nf.duration = n.duration;

    nf.values.push_back(n.freq);

    fs[1].push_back(nf);

}

void

CepstralPitchTracker::addNewFeatures(FeatureSet &fs)

{

    int n = m_feeder->getAcceptedHypotheses().size();

    if (n == m_nAccepted) return;

    AgentFeeder::Hypotheses accepted = m_feeder->getAcceptedHypotheses();

    for (int i = m_nAccepted; i < n; ++i) {

        addFeaturesFrom(accepted[i], fs);

    }

    m_nAccepted = n;

}

CepstralPitchTracker::FeatureSet

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

{

    double *rawcep = new double[m_blockSize];

    double magmean = Cepstrum(m_blockSize).process(inputBuffers[0], rawcep);

    int n = m_bins;

    double *data = new double[n];

    MeanFilter(m_vflen).filterSubsequence

        (rawcep, data, m_blockSize, n, m_binFrom);

    delete[] rawcep;

    double maxval = 0.0;

    int maxbin = -1;

    for (int i = 0; i < n; ++i) {

        if (data[i] > maxval) {

            maxval = data[i];

            maxbin = i;

        }

    }

    if (maxbin < 0) {

        delete[] data;

        return FeatureSet();

    }

    double nextPeakVal = 0.0;

    for (int i = 1; i+1 < n; ++i) {

        if (data[i] > data[i-1] &&

            data[i] > data[i+1] &&

            i != maxbin &&

            data[i] > nextPeakVal) {

            nextPeakVal = data[i];

        }

    }

    PeakInterpolator pi;

    double cimax = pi.findPeakLocation(data, m_bins, maxbin);

    double peakfreq = m_inputSampleRate / (cimax + m_binFrom);

    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;

    }

    delete[] data;

    NoteHypothesis::Estimate e;

    e.freq = peakfreq;

    e.time = timestamp;

    e.confidence = confidence;

    m_feeder->feed(e);

    FeatureSet fs;

    addNewFeatures(fs);

    return fs;

}

CepstralPitchTracker::FeatureSet

CepstralPitchTracker::getRemainingFeatures()

{

    m_feeder->finish();

    FeatureSet fs;

    addNewFeatures(fs);

    return fs;

}

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

    This file is Copyright (c) 2012 Chris Cannam

    Permission is hereby granted, free of charge, to any person

    obtaining a copy of this software and associated documentation

    files (the "Software"), to deal in the Software without

    restriction, including without limitation the rights to use, copy,

    modify, merge, publish, distribute, sublicense, and/or sell copies

    of the Software, and to permit persons to whom the Software is

    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be

    included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

    ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#ifndef _CEPSTRAL_PITCH_H_

#define _CEPSTRAL_PITCH_H_

#include <vamp-sdk/Plugin.h>

#include "NoteHypothesis.h"

class AgentFeeder;

class CepstralPitchTracker : public Vamp::Plugin

{

public:

    CepstralPitchTracker(float inputSampleRate);

    virtual ~CepstralPitchTracker();

    std::string getIdentifier() const;

    std::string getName() const;

    std::string getDescription() const;

    std::string getMaker() const;

    int getPluginVersion() const;

    std::string getCopyright() const;

    InputDomain getInputDomain() const;

    size_t getPreferredBlockSize() const;

    size_t getPreferredStepSize() const;

    size_t getMinChannelCount() const;

    size_t getMaxChannelCount() const;

    ParameterList getParameterDescriptors() const;

    float getParameter(std::string identifier) const;

    void setParameter(std::string identifier, float value);

    ProgramList getPrograms() const;

    std::string getCurrentProgram() const;

    void selectProgram(std::string name);

    OutputList getOutputDescriptors() const;

    bool initialise(size_t channels, size_t stepSize, size_t blockSize);

    void reset();

    FeatureSet process(const float *const *inputBuffers,

                       Vamp::RealTime timestamp);

    FeatureSet getRemainingFeatures();

protected:

    size_t m_channels;

    size_t m_stepSize;

    size_t m_blockSize;

    float m_fmin;

    float m_fmax;

    int m_vflen;

    int m_binFrom;

    int m_binTo;

    int m_bins; // count of "interesting" bins, those returned in m_cepOutput

    int m_nAccepted;

    AgentFeeder *m_feeder;

    void addFeaturesFrom(NoteHypothesis h, FeatureSet &fs);

    void addNewFeatures(FeatureSet &fs);

};

#endif

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

    This file is Copyright (c) 2012 Chris Cannam

    Permission is hereby granted, free of charge, to any person

    obtaining a copy of this software and associated documentation

    files (the "Software"), to deal in the Software without

    restriction, including without limitation the rights to use, copy,

    modify, merge, publish, distribute, sublicense, and/or sell copies

    of the Software, and to permit persons to whom the Software is

    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be

    included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

    ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#ifndef CEPSTRUM_H

#define CEPSTRUM_H

#include "vamp-sdk/FFT.h"

#include <cmath>

#include <iostream>

#include <exception>

class Cepstrum

{

public:

    /**

     * Construct a cepstrum converter based on an n-point FFT.

     */

    Cepstrum(int n) : m_n(n) {

	if (n & (n-1)) {

	    throw "N must be a power of two";

	}

    }

    ~Cepstrum() { }

    /**

     * Convert the given frequency-domain data to the cepstral domain.

     *

     * The input must be in the format used for FrequencyDomain data

     * in the Vamp SDK: n/2+1 consecutive pairs of real and imaginary

     * component floats corresponding to bins 0..(n/2) of the FFT

     * output. Thus, n+2 values in total.

     *

     * The output consists of the raw cepstrum of length n.

     *

     * The cepstrum is calculated as the inverse FFT of a

     * synthetically symmetrical base-10 log magnitude spectrum.

     *

     * Returns the mean magnitude of the input spectrum.

     */

    double process(const float *in, double *out) {

	int hs = m_n/2 + 1;

	double *io = new double[m_n];

	double *logmag = new double[m_n];

	double epsilon = 1e-10;

	double magmean = 0.0;

	for (int i = 0; i < hs; ++i) {

            double re = in[i*2];

            double im = in[i*2+1];

            double power = re * re + im * im;

	    double mag = sqrt(power);

	    magmean += mag;

	    logmag[i] = log10(mag + epsilon);

	    if (i > 0) {

		// make the log magnitude spectrum symmetrical

		logmag[m_n - i] = logmag[i];

	    }

	}

	magmean /= hs;

	/*

	std::cerr << "logmags:" << std::endl;

	for (int i = 0; i < m_n; ++i) {

	    std::cerr << logmag[i] << " ";

	}

	std::cerr << std::endl;

	*/

	Vamp::FFT::inverse(m_n, logmag, 0, out, io);

	delete[] logmag;

	delete[] io;

	return magmean;

    }

private:

    int m_n;

};

#endif

CFLAGS := $(CFLAGS) 

CXXFLAGS := -I. $(CXXFLAGS)

LDFLAGS := $(LDFLAGS) -lvamp-sdk

PLUGIN_LDFLAGS := $(LDFLAGS) $(PLUGIN_LDFLAGS)

TEST_LDFLAGS := $(LDFLAGS) -lboost_unit_test_framework

PLUGIN := cepstral-pitchtracker$(PLUGIN_EXT)

HEADERS := CepstralPitchTracker.h \

           AgentFeeder.h \

           MeanFilter.h \

	   NoteHypothesis.h \

	   PeakInterpolator.h

SOURCES := CepstralPitchTracker.cpp \

           AgentFeeder.cpp \

	   NoteHypothesis.cpp \

	   PeakInterpolator.cpp

PLUGIN_MAIN := libmain.cpp

TESTS ?= test/test-meanfilter \

         test/test-fft \

	 test/test-cepstrum \

         test/test-peakinterpolator \

	 test/test-notehypothesis \

	 test/test-agentfeeder

PLUGIN_OBJECTS := $(OBJECTS) $(PLUGIN_MAIN:.cpp=.o)

all: $(PLUGIN) $(TESTS)

	for t in $(TESTS); do echo "Running $$t"; ./"$$t" || exit 1; done

$(PLUGIN): $(PLUGIN_OBJECTS)

	$(CXX) -o $@ $^ $(PLUGIN_LDFLAGS)

test/test-notehypothesis: test/TestNoteHypothesis.o $(OBJECTS)

	$(CXX) -o $@ $^ $(TEST_LDFLAGS)

test/test-agentfeeder: test/TestAgentFeeder.o $(OBJECTS)

	$(CXX) -o $@ $^ $(TEST_LDFLAGS)

test/test-meanfilter: test/TestMeanFilter.o $(OBJECTS)

	$(CXX) -o $@ $^ $(TEST_LDFLAGS)

test/test-cepstrum: test/TestCepstrum.o $(OBJECTS)

	$(CXX) -o $@ $^ $(TEST_LDFLAGS)

test/test-fft: test/TestFFT.o $(OBJECTS)

	$(CXX) -o $@ $^ $(TEST_LDFLAGS)

test/test-peakinterpolator: test/TestPeakInterpolator.o $(OBJECTS)

	$(CXX) -o $@ $^ $(TEST_LDFLAGS)

		rm -f $(OBJECTS) test/*.o

		rm -f $(PLUGIN) $(TESTS)

depend:

		makedepend -Y -fMakefile.inc *.cpp test/*.cpp *.h test/*.h

# DO NOT DELETE

CepstralPitchTracker.o: CepstralPitchTracker.h NoteHypothesis.h Cepstrum.h

CepstralPitchTracker.o: MeanFilter.h PeakInterpolator.h

libmain.o: CepstralPitchTracker.h NoteHypothesis.h

NoteHypothesis.o: NoteHypothesis.h

PeakInterpolator.o: PeakInterpolator.h

test/TestCepstrum.o: Cepstrum.h

test/TestMeanFilter.o: MeanFilter.h

test/TestNoteHypothesis.o: NoteHypothesis.h

test/TestPeakInterpolator.o: PeakInterpolator.h

CepstralPitchTracker.o: NoteHypothesis.h

CFLAGS := -Wall -O2 -fPIC 

PLUGIN_LDFLAGS := -shared -Wl,-Bstatic -lvamp-sdk -Wl,-Bdynamic -Wl,-Bsymbolic -Wl,-z,defs -Wl,--version-script=vamp-plugin.map

CXX		= i486-mingw32-c++

CC		= i486-mingw32-gcc

LD            	= i486-mingw32-c++

AR            	= i486-mingw32-ar

RANLIB          = i486-mingw32-ranlib

TESTS		= test/null

CFLAGS := -Wall -O2 -I../include 

CXXFLAGS := $(CFLAGS)

LDFLAGS	 := -L../lib

PLUGIN_LDFLAGS := -shared -Wl,-Bstatic -static-libgcc -Wl,--version-script=vamp-plugin.map

PLUGIN_EXT := .dll

include Makefile.inc

test/null:	

		ln -s /bin/true test/null

CFLAGS := -I../inst/include -I/usr/local/boost -Wall -g -fPIC 

CXXFLAGS := $(CFLAGS)

LDFLAGS := -L../inst/lib -lvamp-sdk -L/usr/local/boost/stage/lib 

PLUGIN_LDFLAGS := -dynamiclib -exported_symbols_list=vamp-plugin.list

PLUGIN_EXT := .dylib

include Makefile.inc

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

    This file is Copyright (c) 2012 Chris Cannam

    Permission is hereby granted, free of charge, to any person

    obtaining a copy of this software and associated documentation

    files (the "Software"), to deal in the Software without

    restriction, including without limitation the rights to use, copy,

    modify, merge, publish, distribute, sublicense, and/or sell copies

    of the Software, and to permit persons to whom the Software is

    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be

    included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

    ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#ifndef MEAN_FILTER_H

#define MEAN_FILTER_H

class MeanFilter

{

public:

    /**

     * Construct a non-causal mean filter with filter length flen,

     * that replaces each sample N with the mean of samples

     * [N-floor(F/2) .. N+floor(F/2)] where F is the filter length.

     * Only odd F are supported.

     */

    MeanFilter(int flen) : m_flen(flen) { }

    ~MeanFilter() { }

    /**

     * Filter the n samples in "in" and place the results in "out"

     */

    void filter(const double *in, double *out, const int n) {

	filterSubsequence(in, out, n, n, 0);

    }

    /**

     * Filter the n samples starting at the given offset in the

     * m-element array "in" and place the results in the n-element

     * array "out"

     */

    void filterSubsequence(const double *in, double *out,

			   const int m, const int n,

			   const int offset) {

	int half = m_flen/2;

	for (int i = 0; i < n; ++i) {

	    double v = 0;

	    int n = 0;

	    for (int j = -half; j <= half; ++j) {

		int ix = i + j + offset;

		if (ix >= 0 && ix < m) {

                    double value = in[ix];

                    if (value == value) { // i.e. not NaN

                        v += value;

                    }

                    ++n;

		}

	    }

            if (n > 0) {

                out[i] = v / n;

            } else {

                out[i] = 0.0;

            }

	}

    }

private:

    int m_flen;

};

#endif

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

    This file is Copyright (c) 2012 Chris Cannam

    Permission is hereby granted, free of charge, to any person

    obtaining a copy of this software and associated documentation

    files (the "Software"), to deal in the Software without

    restriction, including without limitation the rights to use, copy,

    modify, merge, publish, distribute, sublicense, and/or sell copies

    of the Software, and to permit persons to whom the Software is

    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be

    included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

    ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#include "NoteHypothesis.h"

#include <cmath>

using Vamp::RealTime;

NoteHypothesis::NoteHypothesis()

{

    m_state = New;

}

NoteHypothesis::~NoteHypothesis()

{

}

bool

NoteHypothesis::isWithinTolerance(Estimate s) const

{

    if (m_pending.empty()) {

        return true;

    }

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

    // candidate

    Estimate last = m_pending[m_pending.size()-1];

    double r = s.freq / last.freq;

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

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

    // and within a slightly bigger tolerance of the current mean

    double meanFreq = getMeanFrequency();

    r = s.freq / meanFreq;

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

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

    return true;

}

bool

NoteHypothesis::isOutOfDateFor(Estimate s) const

{

    if (m_pending.empty()) return false;

    return ((s.time - m_pending[m_pending.size()-1].time) > 

            RealTime::fromMilliseconds(40));

}

bool 

NoteHypothesis::isSatisfied() const

{

    if (m_pending.empty()) return false;

    double meanConfidence = 0.0;

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

        meanConfidence += m_pending[i].confidence;

    }

    meanConfidence /= m_pending.size();

    int lengthRequired = 100;

    if (meanConfidence > 0.0) {

        lengthRequired = int(2.0 / meanConfidence + 0.5);

    }

    return ((int)m_pending.size() > lengthRequired);

}

bool

NoteHypothesis::accept(Estimate s)

{

    bool accept = false;

    static double negligibleConfidence = 0.0001;

    if (s.confidence < negligibleConfidence) {

        // avoid piling up a lengthy sequence of estimates that are

        // all acceptable but are in total not enough to cause us to

        // be satisfied

        if (m_pending.empty()) {

            m_state = Rejected;

        }

        return false;

    }

    switch (m_state) {

    case New:

        m_state = Provisional;

        accept = true;

        break;

    case Provisional:

        if (isOutOfDateFor(s)) {

            m_state = Rejected;

        } else if (isWithinTolerance(s)) {

            accept = true;

        }

        break;

    case Satisfied:

        if (isOutOfDateFor(s)) {

            m_state = Expired;

        } else if (isWithinTolerance(s)) {

            accept = true;

        }

        break;

    case Rejected:

        break;

    case Expired:

        break;

    }

    if (accept) {

        m_pending.push_back(s);

        if (m_state == Provisional && isSatisfied()) {

            m_state = Satisfied;

        }

    }

    return accept;

}        

NoteHypothesis::State

NoteHypothesis::getState() const

{

    return m_state;

}

NoteHypothesis::Estimates

NoteHypothesis::getAcceptedEstimates() const

{

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

        return m_pending;

    } else {

        return Estimates();

    }

}

RealTime

NoteHypothesis::getStartTime() const

{

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

        return RealTime::zeroTime;

    } else {

        return m_pending.begin()->time;

    }

}

double

NoteHypothesis::getMeanFrequency() const

{

    double acc = 0.0;

    if (m_pending.empty()) return acc;

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

        acc += m_pending[i].freq;

    }

    acc /= m_pending.size();

    return acc;

}

NoteHypothesis::Note

NoteHypothesis::getAveragedNote() const

{

    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::const_iterator i = m_pending.end();

    --i;

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

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

    n.freq = getMeanFrequency();

    return n;

}

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

    This file is Copyright (c) 2012 Chris Cannam

    Permission is hereby granted, free of charge, to any person

    obtaining a copy of this software and associated documentation

    files (the "Software"), to deal in the Software without

    restriction, including without limitation the rights to use, copy,

    modify, merge, publish, distribute, sublicense, and/or sell copies

    of the Software, and to permit persons to whom the Software is

    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be

    included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

    ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#ifndef _NOTE_HYPOTHESIS_H_

#define _NOTE_HYPOTHESIS_H_

#include "vamp-sdk/RealTime.h"

#include <vector>

/**

 * An agent used to test an incoming series of instantaneous pitch

 * estimates to see whether they fit a consistent single-note

 * relationship. Contains rules specific to testing note pitch and

 * timing.

 */

class NoteHypothesis

{

public:

    enum State {

        /// Just constructed, will provisionally accept any estimate

        New,

        /// Accepted at least one estimate, but not enough evidence to satisfy

        Provisional,

        /// Could not find enough consistency in offered estimates

        Rejected,

        /// Have accepted enough consistent estimates to satisfy hypothesis

        Satisfied,

        /// Have been satisfied, but evidence has now changed: we're done

        Expired

    };

    /**

     * Construct an empty hypothesis. This will be in New state and

     * will provisionally accept any estimate.

     */

    NoteHypothesis();

    /**

     * Destroy the hypothesis

     */

    ~NoteHypothesis();

    struct Estimate {

        Estimate() : freq(0), time(), confidence(1) { }

        Estimate(double _f, Vamp::RealTime _t, double _c) :

            freq(_f), time(_t), confidence(_c) { }

        bool operator==(const Estimate &e) const {

            return e.freq == freq && e.time == time && e.confidence == confidence;

        }

        double freq;

        Vamp::RealTime time;

        double confidence;

    };

    typedef std::vector<Estimate> Estimates;

    /**

     * Test the given estimate to see whether it is consistent with

     * this hypothesis, and adjust the hypothesis' internal state

     * accordingly. If the estimate is not inconsistent with the

     * hypothesis, return true.

     */

    bool accept(Estimate);

    /**

     * Return the current state of this hypothesis.

     */

    State getState() const;

    /**

     * If the hypothesis has been satisfied (i.e. is in Satisfied or

     * Expired state), return the series of estimates that it

     * accepted. Otherwise return an empty list

     */

    Estimates getAcceptedEstimates() const;

    struct Note {

        Note() : freq(0), time(), duration() { }

        Note(double _f, Vamp::RealTime _t, Vamp::RealTime _d) :

            freq(_f), time(_t), duration(_d) { }

        bool operator==(const Note &e) const {

            return e.freq == freq && e.time == time && e.duration == duration;

        }

        double freq;

        Vamp::RealTime time;

        Vamp::RealTime duration;

    };

    /**

     * Return the time of the first accepted estimate

     */

    Vamp::RealTime getStartTime() const;

    /**

     * Return the mean frequency of the accepted estimates

     */

    double getMeanFrequency() const;

    /**

     * Return a single note roughly matching this hypothesis

     */

    Note getAveragedNote() const;

private:

    bool isWithinTolerance(Estimate) const;

    bool isOutOfDateFor(Estimate) const;

    bool isSatisfied() const;

    State m_state;

    Estimates m_pending;

};

#endif

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

    This file is Copyright (c) 2012 Chris Cannam

    Permission is hereby granted, free of charge, to any person

    obtaining a copy of this software and associated documentation

    files (the "Software"), to deal in the Software without

    restriction, including without limitation the rights to use, copy,

    modify, merge, publish, distribute, sublicense, and/or sell copies

    of the Software, and to permit persons to whom the Software is

    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be

    included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

    ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#include "PeakInterpolator.h"

#include <iostream>

double

PeakInterpolator::findPeakLocation(const double *data, int size)

{

    double maxval;

    int maxidx = 0;

    int i;

    for (i = 0; i < size; ++i) {

        if (i == 0 || data[i] > maxval) {

            maxval = data[i];

            maxidx = i;

        }

    }

    return findPeakLocation(data, size, maxidx);

}

double

PeakInterpolator::findPeakLocation(const double *data, int size, int peakIndex)

{

    // after jos, 

    // https://ccrma.stanford.edu/~jos/sasp/Quadratic_Interpolation_Spectral_Peaks.html

    if (peakIndex < 1 || peakIndex > size - 2) {

        return peakIndex;

    }

    double alpha = data[peakIndex-1];

    double beta  = data[peakIndex];

    double gamma = data[peakIndex+1];

    double denom = (alpha - 2*beta + gamma);

    if (denom == 0) {

        // flat

        return peakIndex;

    }

    double p = ((alpha - gamma) / denom) / 2.0;

    return double(peakIndex) + p;

}

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

    This file is Copyright (c) 2012 Chris Cannam

    Permission is hereby granted, free of charge, to any person

    obtaining a copy of this software and associated documentation

    files (the "Software"), to deal in the Software without

    restriction, including without limitation the rights to use, copy,

    modify, merge, publish, distribute, sublicense, and/or sell copies

    of the Software, and to permit persons to whom the Software is

    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be

    included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

    ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

    CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#ifndef _PEAK_INTERPOLATOR_H_

#define _PEAK_INTERPOLATOR_H_

class PeakInterpolator

{

public:

    PeakInterpolator() { } 

    ~PeakInterpolator() { }

    /**

     * Return the interpolated location (i.e. possibly between sample

     * point indices) of the peak in the given sampled range.

     *

     * "The peak" is defined as the (approximate) location of the

     * maximum of a function interpolating between the points

     * neighbouring the sample index with the maximum value in the

     * range.

     *

     * If multiple local peak samples in the input range are equal,

     * i.e. there is more than one apparent peak in the range, the one

     * with the lowest index will be used. This is the case even if a

     * later peak would be of superior height after interpolation.

     */

    double findPeakLocation(const double *data, int size);

    /**

     * Return the interpolated location (i.e. between sample point

     * indices) of the peak whose nearest sample is found at peakIndex