MusicScaleFilterBank.cpp

Go to the documentation of this file.

//=====================================================================================
//=====================================================================================
#include "MusicScaleFilterBank.h"
 
//=====================================================================================
krotos::MusicScaleFilterBank::MusicScaleFilterBank(float sampleRate)
{
    setSamplingRate(sampleRate);
    setParameters(30.0f, 17000.0f, 24, 1025);
}
 
//=====================================================================================
void krotos::MusicScaleFilterBank::setSamplingRate(float fs) { m_samplingRate = fs; }
 
//=====================================================================================
void krotos::MusicScaleFilterBank::setParameters(float fMin, float fMax, int numBandsPerOctave, int numFFTBins)
{
    m_minFreq = fMin;
    m_maxFreq = fMax;
    m_bandsPerOct = numBandsPerOctave;
    m_numFFTBins = numFFTBins;
 
    jassert(m_numFFTBins >= 128);
    jassert(m_bandsPerOct >= 2);
    jassert(m_minFreq >= 0 && m_minFreq < m_maxFreq);
 
    // Reduce fmax if necessary
    if (m_maxFreq > m_samplingRate / 2.0f)
        m_maxFreq = m_samplingRate / 2.0f;
 
    buildLogFreqAxis();
    mapNotesToFFTBins();
    buildFilterBank();
}
 
//=====================================================================================
void krotos::MusicScaleFilterBank::buildLogFreqAxis()
{
    // Calculate distance in Hz between frequencies
    float factor = std::pow(2.0f, 1.0f / m_bandsPerOct);
 
    float newFreq = m_A4;
    // initialise vector with A4
    m_freqLogAxis.push_back(m_A4);
 
    // increase frequencies until fMax
    while (newFreq <= m_maxFreq)
    {
        newFreq *= factor;
        m_freqLogAxis.push_back(newFreq);
    }
 
    // restart with A4 and decrease to fMin
    newFreq = m_A4;
    while (newFreq >= m_minFreq)
    {
        newFreq /= factor;
        m_freqLogAxis.insert(std::begin(m_freqLogAxis), newFreq);
    }
}
 
//=====================================================================================
std::vector<float> krotos::MusicScaleFilterBank::mapNotesToFFTBins()
{
    jassert(m_samplingRate != 1.0f && m_numFFTBins != -1);
 
    // Factor for mapping log frequencies to DFT bins
    float mapFactor = (m_samplingRate / 2.0f) / m_numFFTBins;
    // Map musical notes to DFT bins
    std::transform(std::begin(m_freqLogAxis), std::end(m_freqLogAxis), std::begin(m_freqLogAxis),
                   [mapFactor](float& c) { return std::round(c / mapFactor); });
 
    // Keep only unique bins
    std::vector<float>::iterator it = std::unique(std::begin(m_freqLogAxis), std::end(m_freqLogAxis));
    m_freqLogAxis.resize(std::distance(std::begin(m_freqLogAxis), it));
    // Filter out bins above the range
    m_freqLogAxis.erase(std::remove_if(std::begin(m_freqLogAxis), std::end(m_freqLogAxis),
                                       [=](float bin) { return bin >= m_numFFTBins; }),
                        std::end(m_freqLogAxis));
    // Remove zeros
    m_freqLogAxis.erase(std::remove(std::begin(m_freqLogAxis), std::end(m_freqLogAxis), 0.0f), std::end(m_freqLogAxis));
 
    return m_freqLogAxis;
}
 
//=====================================================================================
std::vector<std::vector<float>> krotos::MusicScaleFilterBank::buildFilterBank()
{
    // Number of Bands
    auto numBands = m_freqLogAxis.size() - 2;
    jassert(numBands >= 3); // Cannot create filterbank with less than 3 frequencies
 
    // Create Filterbank matrix band by band
    for (int i = 0; i < numBands; i++)
    {
        // Edge and center frequencies
        float start = m_freqLogAxis.at(i);
        float mid = m_freqLogAxis.at(i + 1);
        float stop = m_freqLogAxis.at(i + 2);
 
        // Create triangular Filter
        std::vector<float> triangFilter = triangularFilterCoeff(start, mid, stop);
        m_filterBank.push_back(triangFilter);
    }
 
    return m_filterBank;
}
 
//=====================================================================================
std::vector<float> krotos::MusicScaleFilterBank::triangularFilterCoeff(float start, float mid, float stop)
{
    // Height of the filter
    int height = 1;
 
    // Rising edge
    std::vector<float> rising;
    float incr = 1.0f / (mid - start);
    float riseVal{0.0f};
 
    while (riseVal <= height)
    {
        rising.push_back(riseVal);
        riseVal += incr;
    }
 
    // Falling edge
    std::vector<float> falling;
    float decr = -1.0f / (stop - mid);
    float dropVal = height + decr;
 
    while (dropVal >= 0.0f)
    {
        falling.push_back(dropVal);
        dropVal += decr;
    }
    // Concatenate
    std::vector<float> filterCoef(rising);
    filterCoef.insert(std::end(filterCoef), std::begin(falling), std::end(falling));
 
    std::vector<float> triangFilter(m_numFFTBins, 0.0f);
    copy(std::cbegin(filterCoef), std::cend(filterCoef), std::begin(triangFilter) + static_cast<int>(start) - 1);
 
    return triangFilter;
}
 
//=====================================================================================
std::vector<std::vector<float>> krotos::MusicScaleFilterBank::filterSpectrum(
        const std::vector<std::vector<float>>& spectrum)
{
    // Quick test to make sure we are multiplying spectrums with same number of
    // FFT bins
    jassert(m_filterBank[0].size() == spectrum[0].size() && spectrum[0].size() == m_numFFTBins);
 
    // rows
    auto numBands = m_filterBank.size();
    // columns
    auto numFrames = spectrum.size();
    std::vector<std::vector<float>> filteredLogSpec(numBands, std::vector<float>(numFrames));
 
    if (m_samplingRate == sr_96k)
    {
        for (int frame = 0; frame < numFrames; frame++)
        {
            musicScaleFilterUnrolled96000(filteredLogSpec, spectrum, frame);
        }
    }
    else if (m_samplingRate == sr_48k)
    {
        for (int frame = 0; frame < numFrames; frame++)
        {
            musicScaleFilterUnrolled48000(filteredLogSpec, spectrum, frame);
        }
    }
    else if (m_samplingRate == sr_441k)
    {
        for (int frame = 0; frame < numFrames; frame++)
        {
            musicScaleFilterUnrolled44100(filteredLogSpec, spectrum, frame);
        }
    }
    else if (m_samplingRate == sr_225k)
    {
        for (int frame = 0; frame < numFrames; frame++)
        {
            musicScaleFilterUnrolled22050(filteredLogSpec, spectrum, frame);
        }
    }
    else // Normal 3ple for loop, non major SR
    {
        for (int frame = 0; frame < numFrames; frame++)
        {
            auto spectralFrame = spectrum[frame];
 
            for (int band = 0; band < numBands; band++)
            {
                float total = 0.f;
 
                for (int bin = 0; bin < m_numFFTBins; bin++)
                {
                    float filter = m_filterBank[band][bin];
                    if (filter != 0.f)
                    {
                        if (filter == 1.f)
                        {
                            total += std::log10f(spectralFrame[bin] + 1.0f);
                        }
                        else
                        {
                            total += std::log10f(filter * spectralFrame[bin] + 1.0f);
                        }
                    }
                }
                filteredLogSpec[band][frame] = total;
            }
        }
    }
 
    return filteredLogSpec;
}