Method getByteFrequencyData

src/core/RealtimeAnalyser.cpp:187–275

}

void RealtimeAnalyser::getByteFrequencyData(std::vector<uint8_t> & destinationArray, bool resample)
{
    if (!destinationArray.size() || !magnitudeBuffer().size())
        return;

    doFFTAnalysis();

    size_t len = destinationArray.size();
    uint8_t * dest = &destinationArray[0];
    std::vector<uint8_t> result;
    if (destinationArray.size() == frequencyBinCount())
        resample = false;
    else
    {
        if (resample) {
            len = frequencyBinCount();
            result.resize(len);
            dest = &result[0];
        }
    }

    // Convert from linear magnitude to unsigned-byte decibels.
    size_t sourceLength = magnitudeBuffer().size();
    const double rangeScaleFactor = m_maxDecibels == m_minDecibels ? 1 : 1 / (m_maxDecibels - m_minDecibels);
    const double minDecibels = m_minDecibels;

    const float * source = magnitudeBuffer().data();
    for (size_t i = 0; i < len; ++i)
    {
        float linearValue = source[i];
        double dbMag = !linearValue ? minDecibels : AudioUtilities::linearToDecibels(linearValue);

        // The range m_minDecibels to m_maxDecibels will be scaled to byte values from 0 to UCHAR_MAX.
        double scaledValue = UCHAR_MAX * (dbMag - minDecibels) * rangeScaleFactor;

        // Clip to valid range.
        if (scaledValue < 0)
            scaledValue = 0;
        if (scaledValue > UCHAR_MAX)
            scaledValue = UCHAR_MAX;

        dest[i] = static_cast<unsigned char>(scaledValue);
    }
    if (!resample)
        return;

    uint8_t * normalized_data = dest;
    dest = &destinationArray[0];

    size_t src_size = frequencyBinCount();
    size_t dst_size = destinationArray.size();

    if (dst_size > src_size)
    {
        // upsample via linear interpolation
        size_t steps = dst_size;
        float u_step = 1.f / static_cast<float>(steps);
        float u = 0;