Autocorrelation.cpp

Go to the documentation of this file.

/*
  ==============================================================================
 
    SpectralAutocorrelation.cpp
    Created: 9 Nov 2016 2:48:10pm
    Author:  KrotosMacMini
 
  ==============================================================================
*/
#include "Autocorrelation.h"
 
krotos::Autocorrelation::Autocorrelation() { initialise(DEFAULT_SAMPLE_RATE, MAX_BUFFER_SIZE); }
 
krotos::Autocorrelation::Autocorrelation(double newSampleRate, int newBufferSize)
{
    initialise(newSampleRate, newBufferSize);
}
 
krotos::Autocorrelation::~Autocorrelation() {}
 
void krotos::Autocorrelation::initialise(double newSampleRate, int newBufferSize)
{
    sampleRate = newSampleRate;
    bufferSize = newBufferSize;
 
    // set up the buffers
    autocorrelationBuffer.resize(bufferSize);
    smoothedAutocorrelation.resize(bufferSize);
    audioFrame.resize(newBufferSize);
    // create the hanningz window
    window.resize(bufferSize);
 
    for (int i = 0; i < bufferSize; ++i)
    {
        window[i] = static_cast<float>(0.5 * (1.0 - std::cos(TWO_PI * double(i) / double(bufferSize))));
        autocorrelationBuffer[i] = 0.0f;
        smoothedAutocorrelation[i] = 0.0f;
    }
}
 
float krotos::Autocorrelation::getPitch(AudioSampleBuffer buffer)
{
    // window the input
    for (int i = 0; i < buffer.getNumSamples(); ++i)
    {
        audioFrame[i] = buffer.getSample(0, i) * window[i];
    }
 
    // Simple Autocorrelation
    getAutocorrelation(audioFrame);
 
    // Smooth it out (w/ coeff. alpha = 0.9)
    smoothingFilter(autocorrelationBuffer, 0.9f);
 
    // and find the minimum
    float tmp = smoothedAutocorrelation[0];
    position = -1;
 
    for (int i = 0; i < bufferSize; ++i)
    {
        if (smoothedAutocorrelation[i] < tmp)
        {
            tmp = smoothedAutocorrelation[i];
            position = i;
        }
    }
 
    pitchEstimate = -1.0f;
    tauEstimate = -1.0f;
 
    if (position < 1)
    {
        pitchEstimate = -1;
        // std::cout << "F0 = " << pitchEstimate << "Hz" <<std::endl;
        return pitchEstimate;
    }
    else if (position == bufferSize - 1)
    {
        tauEstimate = 2.f * float(position);
        pitchEstimate = float(sampleRate) / tauEstimate;
        // std::cout << "F0 = " << pitchEstimate << "Hz" <<std::endl;
        return pitchEstimate;
    }
    else
    {
        tauEstimate = 2 * getParabolicInterpolation(position);
        pitchEstimate = float(sampleRate) / tauEstimate;
        // std::cout << "F0 = " << pitchEstimate << "Hz" <<std::endl;
        return pitchEstimate;
    }
}
 
void krotos::Autocorrelation::getAutocorrelation(std::vector<float> data)
{
 
    for (int tau = 0; tau < 0.5 * bufferSize; ++tau)
    {
        float sum = 0.0f;
        for (int index = 0; index < 0.5 * bufferSize; ++index)
        {
            sum += data[index] * data[index + tau];
        }
        autocorrelationBuffer[tau] = sum / bufferSize;
    }
}
 
void krotos::Autocorrelation::smoothingFilter(std::vector<float> in, float coefficient)
{
    smoothedAutocorrelation[0] = in[0];
    for (int i = 1; i < bufferSize; ++i)
    {
        smoothedAutocorrelation[i] =
                smoothedAutocorrelation[i - 1] + coefficient * (in[i] - smoothedAutocorrelation[i - 1]);
    }
}
 
float krotos::Autocorrelation::getParabolicInterpolation(int tauEstimation)
{
    float previous = autocorrelationBuffer[tauEstimation - 1];
    float current = autocorrelationBuffer[tauEstimation];
    float next = autocorrelationBuffer[tauEstimation + 1];
 
    float divisor = next + previous - 2 * current;
    float newEstimation;
    if (divisor == 0.0f)
    {
        newEstimation = float(tauEstimation);
    }
    else
    {
        newEstimation = float(tauEstimation) + (previous - next) / (2 * divisor);
    }
    return newEstimation;
}