Method generateBasicWaveform

src/core/PeriodicWave.cpp:202–286

}

void PeriodicWave::generateBasicWaveform(OscillatorType shape)
{
    unsigned fftSize = periodicWaveSize();
    unsigned halfSize = fftSize / 2;

    lab::AudioFloatArray real(halfSize);
    lab::AudioFloatArray imag(halfSize);
    float * realP = real.data();
    float * imagP = imag.data();

    // Clear DC and Nyquist.
    realP[0] = 0;
    imagP[0] = 0;

    for (unsigned n = 1; n < halfSize; ++n)
    {
        float piFactor = 2 / (n * static_cast<float>(LAB_PI));

        // All waveforms are odd functions with a positive slope at time 0. Hence the coefficients
        // for cos() are always 0.

        // Fourier coefficients according to standard definition:
        // b = 1/pi*integrate(f(x)*sin(n*x), x, -pi, pi)
        //   = 2/pi*integrate(f(x)*sin(n*x), x, 0, pi)
        // since f(x) is an odd function.

        float b;  // Coefficient for sin().

        // Calculate Fourier coefficients depending on the shape. Note that the overall scaling
        // (magnitude) of the waveforms is normalized in createBandLimitedTables().
        switch (shape)
        {
            case OscillatorType::SINE:
                // Standard sine wave function.
                b = (n == 1) ? 1.f : 0;
                break;
            case OscillatorType::SQUARE:
                // Square-shaped waveform with the first half its maximum value and the second half its
                // minimum value.
                //
                // See http://mathworld.wolfram.com/FourierSeriesSquareWave.html
                //
                // b[n] = 2/n/pi*(1-(-1)^n)
                //      = 4/n/pi for n odd and 0 otherwise.
                //      = 2*(2/(n*pi)) for n odd
                b = (n & 1) ? 2 * piFactor : 0;
                break;
            case OscillatorType::SAWTOOTH:
                // Sawtooth-shaped waveform with the first half ramping from zero to maximum and the
                // second half from minimum to zero.
                //
                // b[n] = -2*(-1)^n/pi/n
                //      = (2/(n*pi))*(-1)^(n+1)
                b = piFactor * ((n & 1) ? 1 : -1);
                break;
            case OscillatorType::TRIANGLE:
                // Triangle-shaped waveform going from 0 at time 0 to 1 at time pi/2 and back to 0 at
                // time pi.