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

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.

/* -*- 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

PLUGIN_EXT	?= .so

CXX	?= g++

CC	?= gcc

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

OBJECTS := $(SOURCES:.cpp=.o)

OBJECTS := $(OBJECTS:.c=.o)

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)

clean:

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

distclean:	clean

		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

CXXFLAGS := $(CFLAGS)

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

PLUGIN_EXT := .so

include Makefile.inc

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