TimeDomainAnalysisFramework.cpp

Go to the documentation of this file.

//=====================================================================================
//=====================================================================================
 
#include "TimeDomainAnalysisFramework.h"
// #include "Utilities.h"
 
//=====================================================================================
krotos::TimeDomainAnalysisFramework::TimeDomainAnalysisFramework(int analysisFrameSize, int sampleRate)
    : m_rmsCalculated(false), m_rmsValue(0), m_energyDifferenceCalculated(false), m_previousEnergyDifferenceValue(0),
      m_signalFrameSize(analysisFrameSize)
{
    jassert(sampleRate > 0);
    setSamplingFrequency(sampleRate);
    initialisePitchTrackingAlgorithms();
}
 
//=====================================================================================
void krotos::TimeDomainAnalysisFramework::setSamplingFrequency(int fs) { m_samplingFrequency = fs; }
 
//=====================================================================================
void krotos::TimeDomainAnalysisFramework::initialisePitchTrackingAlgorithms()
{
    m_pitchTrackerMcLeod.initialise(static_cast<double>(m_samplingFrequency), m_signalFrameSize);
    m_pitchTrackerAutocorrelation.initialise(static_cast<double>(m_samplingFrequency), m_signalFrameSize);
}
 
//=====================================================================================
int krotos::TimeDomainAnalysisFramework::getSamplingFrequency()
{
    jassert(m_samplingFrequency > -1); // Sampling frequency has not been set to a valid value
    return m_samplingFrequency;
}
 
//=====================================================================================
void krotos::TimeDomainAnalysisFramework::setSignalFrame(std::vector<float> timeFrame)
{
    m_signalFrame = timeFrame;
 
    // You need to instantiate the class with the same analysisFrameSize as the
    // input signalFrame jassert(m_signalFrame.size() == m_signalFrameSize);
 
    // Set flags indicating whether features have been calculated to false
    m_energyDifferenceCalculated = false;
    m_rmsCalculated = false;
 
    m_rmsValue = getRMS();
 
    // m_pitchMcLeod = m_pitchTrackerMcLeod.getPitch(m_signalFrame);
 
    // AudioSampleBuffer tempBuf(1, m_signalFrameSize);
    // tempBuf.copyFrom(0, 0, m_signalFrame.data(), m_signalFrameSize);
    // m_pitchAutocorrelation = m_pitchTrackerAutocorrelation.getPitch(tempBuf);
}
 
//=====================================================================================
float krotos::TimeDomainAnalysisFramework::getPeakEnergy()
{
    float maxVal = 0.0;
 
    for (int i = 0; i < m_signalFrame.size(); i++)
    {
        float value = fabsf(m_signalFrame[i]);
 
        if (value > maxVal)
        {
            maxVal = value;
        }
    }
 
    return maxVal;
}
 
//=====================================================================================
float krotos::TimeDomainAnalysisFramework::getPitchMcLeod() { return m_pitchMcLeod; }
 
//=====================================================================================
float krotos::TimeDomainAnalysisFramework::getPitchAutocorrelation() { return m_pitchAutocorrelation; }
 
//=====================================================================================
float krotos::TimeDomainAnalysisFramework::getRMS()
{
    if (m_rmsCalculated)
    {
        return m_rmsValue;
    }
    else
    {
        float sumOfSquares = 0;
 
        for (int i = 0; i < m_signalFrame.size(); i++)
        {
            sumOfSquares += m_signalFrame[i] * m_signalFrame[i];
        }
 
        float meanValue = sumOfSquares / (float)m_signalFrameSize;
 
        m_rmsValue = sqrtf(meanValue);
 
        m_rmsCalculated = true;
 
        return m_rmsValue;
    }
}
 
//=====================================================================================
void krotos::TimeDomainAnalysisFramework::setSignalEnvelopeSmoothingFactor(float smoothingFactor)
{
    // !
    // The smoothing factor should be between 0.0 and 1.0
    assert(smoothingFactor < 1.f);
    assert(smoothingFactor >= 0.f);
 
    float cutoff = 0.5f - (smoothingFactor / 2.f);
 
    m_lowpassFilter.configure(cutoff);
}
 
//=====================================================================================
float krotos::TimeDomainAnalysisFramework::getSignalEnvelope()
{
    float rmsValue = getRMS();
 
    return fmaxf(0, m_lowpassFilter.processSample(rmsValue));
}
 
//=====================================================================================
float krotos::TimeDomainAnalysisFramework::getEnergyDifference()
{
    if (m_energyDifferenceCalculated)
    {
        return m_energyDifferenceValue;
    }
    else
    {
        float energyValue = getRMS();
 
        m_energyDifferenceValue = fabsf(energyValue - m_previousEnergyDifferenceValue);
 
        m_previousEnergyDifferenceValue = energyValue;
 
        m_energyDifferenceCalculated = true;
 
        return m_energyDifferenceValue;
    }
}