Method createBandLimitedTables

src/core/PeriodicWave.cpp:137–200

Convert into time-domain wave tables. One table is created for each range for non-aliasing playback at different playback rates. Thus, higher ranges have more high-frequency partials culled out.

// One table is created for each range for non-aliasing playback at different playback rates.
// Thus, higher ranges have more high-frequency partials culled out.
void PeriodicWave::createBandLimitedTables(const float * realData, const float * imagData, int numberOfComponents)
{
    float normalizationScale = 1.f;

    int fftSize = periodicWaveSize();
    int halfSize = fftSize / 2 + 1;
    int i;

    numberOfComponents = std::min(numberOfComponents, halfSize);

    m_bandLimitedTables.reserve(numberOfRanges());

    for (int rangeIndex = 0; rangeIndex < numberOfRanges(); ++rangeIndex)
    {

        // This FFTFrame is used to cull partials (represented by frequency bins).
        FFTFrame frame(fftSize);
        float * realP = frame.realData();
        float * imagP = frame.imagData();

        // Copy from loaded frequency data and generate the complex conjugate because of the way the
        // inverse FFT is defined versus the values in the arrays.  Note also that although the IFFT
        // does a scaling by 1/N, we take care of this when the normalization scaling is done.
        float minusOne = -1;
        memcpy(realP, realData, numberOfComponents * sizeof(*realP));
        vsmul(imagData, 1, &minusOne, imagP, 1, numberOfComponents);

        // Find the starting bin where we should start culling.  We need to clear out the highest
        // frequencies to band-limit the waveform.
        int numberOfPartials = numberOfPartialsForRange(rangeIndex);

        // If fewer components were provided than 1/2 FFT size, then clear the remaining bins.
        // We also need to cull the aliasing partials for this pitch range.
        for (i = std::min(numberOfComponents, numberOfPartials + 1); i < halfSize; ++i)
        {
            realP[i] = 0;
            imagP[i] = 0;
        }

        // Clear packed-nyquist and any DC-offset.
        realP[0] = 0;
        imagP[0] = 0;

        // Create the band-limited table.
        m_bandLimitedTables.push_back(std::unique_ptr<lab::AudioFloatArray>(new lab::AudioFloatArray(periodicWaveSize())));

        // Apply an inverse FFT to generate the time-domain table data.
        float * data = m_bandLimitedTables[rangeIndex]->data();
        frame.computeInverseFFT(data);

        // For the first range (which has the highest power), calculate its peak value then compute normalization scale.
        if (!rangeIndex)
        {
            float maxValue;
            vmaxmgv(data, 1, &maxValue, fftSize);

            if (maxValue)
                normalizationScale = 1.0f / maxValue;