annotate VampYin.cpp @ 0:99bac62ee2da

added PYIN sources, should be compileable

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

#include "VampYin.h"
#include "MonoNote.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;


VampYin::VampYin(float inputSampleRate) :
    Plugin(inputSampleRate),
    m_channels(0),
    m_stepSize(256),
    m_blockSize(2048),
    m_fmin(40),
    m_fmax(1000),
    m_yin(2048, inputSampleRate, 0.0),
    m_outNoF0(0),
    m_outNoPeriodicity(0),
    m_outNoRms(0),
    m_outNoSalience(0),
    m_yinParameter(0.15f),
    m_outputUnvoiced(0.0f)
{
}

VampYin::~VampYin()
{
}

string
VampYin::getIdentifier() const
{
    return "yin";
}

string
VampYin::getName() const
{
    return "Yin";
}

string
VampYin::getDescription() const
{
    return "A vamp implementation of the Yin algorithm for monophonic frequency estimation.";
}

string
VampYin::getMaker() const
{
    return "Matthias Mauch";
}

int
VampYin::getPluginVersion() const
{
    // Increment this each time you release a version that behaves
    // differently from the previous one
    return 1;
}

string
VampYin::getCopyright() const
{
    return "GPL";
}

VampYin::InputDomain
VampYin::getInputDomain() const
{
    return TimeDomain;
}

size_t
VampYin::getPreferredBlockSize() const
{
    return 2048;
}

size_t 
VampYin::getPreferredStepSize() const
{
    return 256;
}

size_t
VampYin::getMinChannelCount() const
{
    return 1;
}

size_t
VampYin::getMaxChannelCount() const
{
    return 1;
}

VampYin::ParameterList
VampYin::getParameterDescriptors() const
{
    ParameterList list;
    
    ParameterDescriptor d;
    d.identifier = "yinThreshold";
    d.name = "Yin threshold";
    d.description = "The greedy Yin search for a low value difference function is done once a dip lower than this threshold is reached.";
    d.unit = "";
    d.minValue = 0.025f;
    d.maxValue = 1.0f;
    d.defaultValue = 0.15f;
    d.isQuantized = true;
    d.quantizeStep = 0.025f;
        
    list.push_back(d);

    // d.identifier = "removeunvoiced";
    // d.name = "Remove pitches classified as unvoiced.";
    // d.description = "If ticked, then the pitch estimator will return the most likely pitch, even if it 'thinks' there isn't any.";
    // d.unit = "";
    // d.minValue = 0.0f;
    // d.maxValue = 1.0f;
    // d.defaultValue = 0.0f;
    // d.isQuantized = true;
    // d.quantizeStep = 1.0f;
    // d.valueNames.clear();
    // list.push_back(d);

    d.identifier = "outputunvoiced";
    d.valueNames.clear();
    d.name = "Output estimates classified as unvoiced?";
    d.description = ".";
    d.unit = "";
    d.minValue = 0.0f;
    d.maxValue = 2.0f;
    d.defaultValue = 2.0f;
    d.isQuantized = true;
    d.quantizeStep = 1.0f;
    d.valueNames.push_back("No");
    d.valueNames.push_back("Yes");
    d.valueNames.push_back("Yes, as negative frequencies");
    list.push_back(d);

    return list;
}

float
VampYin::getParameter(string identifier) const
{
    if (identifier == "yinThreshold") {
        return m_yinParameter;
    }
    if (identifier == "outputunvoiced") {
        return m_outputUnvoiced;
    }
    return 0.f;
}

void
VampYin::setParameter(string identifier, float value) 
{
    if (identifier == "yinThreshold")
    {
        m_yinParameter = value;
    }
    if (identifier == "outputunvoiced")
    {
        m_outputUnvoiced = value;
    }
}

VampYin::ProgramList
VampYin::getPrograms() const
{
    ProgramList list;
    return list;
}

string
VampYin::getCurrentProgram() const
{
    return ""; // no programs
}

void
VampYin::selectProgram(string name)
{
}

VampYin::OutputList
VampYin::getOutputDescriptors() const
{
    OutputList outputs;

    OutputDescriptor d;
    
    int outputNumber = 0;

    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 = 500;
    d.isQuantized = false;
    d.sampleType = OutputDescriptor::FixedSampleRate;
    d.sampleRate = (m_inputSampleRate / m_stepSize);
    d.hasDuration = false;
    outputs.push_back(d);
    m_outNoF0 = outputNumber++;

    d.identifier = "periodicity";
    d.name = "Periodicity";
    d.description = "by-product of Yin f0 estimation";
    d.unit = "";
    d.hasFixedBinCount = true;
    d.binCount = 1;
    d.hasKnownExtents = true;
    d.minValue = 0;
    d.maxValue = 1;
    d.isQuantized = false;
    d.sampleType = OutputDescriptor::FixedSampleRate;
    d.sampleRate = (m_inputSampleRate / m_stepSize);
    d.hasDuration = false;
    outputs.push_back(d);
    m_outNoPeriodicity = outputNumber++;

    d.identifier = "rms";
    d.name = "root mean square";
    d.description = "Root mean square of the waveform.";
    d.unit = "";
    d.hasFixedBinCount = true;
    d.binCount = 1;
    d.hasKnownExtents = true;
    d.minValue = 0;
    d.maxValue = 1;
    d.isQuantized = false;
    d.sampleType = OutputDescriptor::FixedSampleRate;
    d.sampleRate = (m_inputSampleRate / m_stepSize);
    d.hasDuration = false;
    outputs.push_back(d);
    m_outNoRms = outputNumber++;

    d.identifier = "salience";
    d.name = "Salience";
    d.description = "Yin Salience";
    d.hasFixedBinCount = true;
    d.binCount = m_blockSize / 2;
    d.hasKnownExtents = true;
    d.minValue = 0;
    d.maxValue = 1;
    d.isQuantized = false;
    d.sampleType = OutputDescriptor::FixedSampleRate;
    d.sampleRate = (m_inputSampleRate / m_stepSize);
    d.hasDuration = false;
    outputs.push_back(d);
    m_outNoSalience = outputNumber++;

    return outputs;
}

bool
VampYin::initialise(size_t channels, size_t stepSize, size_t blockSize)
{
    if (channels < getMinChannelCount() ||
	channels > getMaxChannelCount()) return false;

    std::cerr << "VampYin::initialise: channels = " << channels
          << ", stepSize = " << stepSize << ", blockSize = " << blockSize
          << std::endl;

    m_channels = channels;
    m_stepSize = stepSize;
    m_blockSize = blockSize;
    
    reset();

    return true;
}

void
VampYin::reset()
{    
    m_yin.setThreshold(m_yinParameter);
    m_yin.setFrameSize(m_blockSize);
        
    std::cerr << "VampYin::reset: yin threshold set to " << (m_yinParameter)
          << ", blockSize = " << m_blockSize
          << std::endl;
}

VampYin::FeatureSet
VampYin::process(const float *const *inputBuffers, RealTime timestamp)
{
    timestamp = timestamp + Vamp::RealTime::frame2RealTime(m_blockSize/4, lrintf(m_inputSampleRate));
    FeatureSet fs;
    
    double *dInputBuffers = new double[m_blockSize];
    for (size_t i = 0; i < m_blockSize; ++i) dInputBuffers[i] = inputBuffers[0][i];
    
    Yin::YinOutput yo = m_yin.process(dInputBuffers);
    // std::cerr << "f0 in VampYin: " << yo.f0 << std::endl;
    Feature f;
    f.hasTimestamp = true;
    f.timestamp = timestamp;
    if (m_outputUnvoiced == 0.0f)
    {
        // std::cerr << "f0 in VampYin: " << yo.f0 << std::endl;
        if (yo.f0 > 0 && yo.f0 < m_fmax && yo.f0 > m_fmin) {
            f.values.push_back(yo.f0);
            fs[m_outNoF0].push_back(f);
        }
    } else if (m_outputUnvoiced == 1.0f)
    {
        if (abs(yo.f0) < m_fmax && abs(yo.f0) > m_fmin) {
            f.values.push_back(abs(yo.f0));
            fs[m_outNoF0].push_back(f);
        }
    } else
    {
        if (abs(yo.f0) < m_fmax && abs(yo.f0) > m_fmin) {
            f.values.push_back(yo.f0);
            fs[m_outNoF0].push_back(f);
        }
    }

    f.values.clear();
    f.values.push_back(yo.rms);
    fs[m_outNoRms].push_back(f);
    
    f.values.clear();
    for (size_t iBin = 0; iBin < yo.salience.size(); ++iBin)
    {
        f.values.push_back(yo.salience[iBin]);
    }
    fs[m_outNoSalience].push_back(f);
    
    f.values.clear();
    // f.values[0] = yo.periodicity;
    f.values.push_back(yo.periodicity);
    fs[m_outNoPeriodicity].push_back(f);
    
    delete [] dInputBuffers;

    return fs;
}

VampYin::FeatureSet
VampYin::getRemainingFeatures()
{
    FeatureSet fs;
    return fs;
}