MelFrequencySpectrum.cpp

Go to the documentation of this file.

//=====================================================================================
//=====================================================================================
 
#include "MelFrequencySpectrum.h"
 
//=====================================================================================
krotos::MelFrequencySpectrum::MelFrequencySpectrum()
{
    m_fftSize = 512;
    m_magnitudeSpectrumSize = 257;
    //    numCoefficients = 20; // sw- 20 seems like a lot
    m_numCoefficients = 5;
    m_samplingFrequency = 44100;
 
    setParameters(m_fftSize, m_numCoefficients);
    setSamplingFrequency(m_samplingFrequency);
}
 
//=====================================================================================
float krotos::MelFrequencySpectrum::m_hertzToMel(float f) { return 1127 * log(1 + (f / 700.f)); }
 
//=====================================================================================
float krotos::MelFrequencySpectrum::m_melToHertz(float m) { return 700.f * (exp(m / 1127.f) - 1.f); }
 
//=====================================================================================
void krotos::MelFrequencySpectrum::setParameters(int audioFrameSize, int numCoeffs)
{
    m_fftSize = audioFrameSize;
    m_magnitudeSpectrumSize = (audioFrameSize / 2) + 1;
    m_numCoefficients = numCoeffs;
 
    buildMelFilterbank();
}
 
//=====================================================================================
void krotos::MelFrequencySpectrum::setSamplingFrequency(int fs)
{
    m_samplingFrequency = fs;
 
    buildMelFilterbank();
}
 
//=====================================================================================
std::vector<float> krotos::MelFrequencySpectrum::calculateMelSpectrum(std::vector<float> magnitudeSpectrum)
{
    // !
    // We are expecting to receive a magnitude spectrum with a size that is
    // (N / 2) + 1, where N is the audioFrameSize that you initialised the
    // Mel-spectrum object with. This isn't the case and so it is being
    // initialised wrongly.
    assert(magnitudeSpectrum.size() == m_magnitudeSpectrumSize);
 
    std::vector<float> melSpectrum;
 
    for (int m = 0; m < m_numCoefficients; m++)
    {
        float melValue = 0;
 
        for (int k = 0; k < magnitudeSpectrum.size(); k++)
        {
            melValue += (magnitudeSpectrum[k] * magnitudeSpectrum[k]) * m_melFilterBank[m][k];
        }
 
        melSpectrum.push_back(melValue);
    }
 
    return melSpectrum;
}
 
//=====================================================================================
void krotos::MelFrequencySpectrum::buildMelFilterbank()
{
    float lowFreq = 20;
    float highFreq = ((float)m_samplingFrequency) / 2.f;
 
    float lowMelFrequency = m_hertzToMel(lowFreq);
    float highMelFrequency = m_hertzToMel(highFreq);
 
    m_melFilterBank.resize(m_magnitudeSpectrumSize);
 
    for (int i = 0; i < m_numCoefficients; i++)
    {
        m_melFilterBank[i].resize(m_magnitudeSpectrumSize);
        // std::fill(m_melFilterBank[i].begin(), m_melFilterBank[i].end(), 0);
        for (auto& mel : m_melFilterBank)
        {
            if (mel.size() > 0)
            {
                FloatVectorOperations::fill(&mel[0], 0.f, mel.size());
            }
        }
    }
 
    std::vector<float> melPoints;
 
    float melRange = highMelFrequency - lowMelFrequency;
 
    float stepSize = melRange / ((float)m_numCoefficients + 1);
 
    melPoints.push_back(lowMelFrequency);
    for (int i = 0; i < m_numCoefficients; i++)
    {
        melPoints.push_back(lowMelFrequency + ((i + 1) * stepSize));
    }
    melPoints.push_back(highMelFrequency);
 
    std::vector<int> melFilterBins;
 
    for (int i = 0; i < melPoints.size(); i++)
    {
        float h = m_melToHertz(melPoints[i]);
 
        int k = static_cast<int>(((float)m_fftSize) * (h / ((float)m_samplingFrequency)));
 
        melFilterBins.push_back(k);
    }
 
    for (int m = 0; m < m_numCoefficients; m++)
    {
        // !
        // If you are getting this assertion failure, then you are trying to get
        // too many separate Mel-frequency bins from a FFT magnitude spectrum that
        // isn't large enough to give you the separation you need. Either increase
        // your FFT size or set the number of Mel-frequency coefficients to a
        // smaller number
        assert(melFilterBins[m] < melFilterBins[m + 1]);
 
        for (int k = 0; k < m_magnitudeSpectrumSize; k++)
        {
            if ((k >= melFilterBins[m]) && (k <= melFilterBins[m + 1]))
            {
                float t1 = (float)(k - melFilterBins[m]);
                float t2 = (float)(melFilterBins[m + 1] - melFilterBins[m]);
 
                m_melFilterBank[m][k] = t1 / t2;
            }
            else if ((k >= melFilterBins[m + 1]) && (k <= melFilterBins[m + 2]))
            {
                float t1 = (float)(melFilterBins[m + 2] - k);
                float t2 = (float)(melFilterBins[m + 2] - melFilterBins[m + 1]);
 
                m_melFilterBank[m][k] = t1 / t2;
            }
            else
            {
                m_melFilterBank[m][k] = 0.0;
            }
        }
    }
}