Function rffts1

src/core/_SoundPipe_FFT.cpp:3067–3126

}

static void rffts1(SPFLOAT * ioptr, int M, SPFLOAT * Utbl, int16_t * BRLow)
{
    /* Compute in-place real fft on the rows of the input array           */
    /* The result is the complex spectra of the positive frequencies      */
    /* except the location for the first complex number contains the real */
    /* values for DC and Nyquest                                          */
    /* INPUTS                                                             */
    /*   *ioptr = real input data array                                   */
    /*   M = log2 of fft size                                             */
    /*   *Utbl = cosine table                                             */
    /*   *BRLow = bit reversed counter table                              */
    /* OUTPUTS                                                            */
    /*   *ioptr = output data array   in the following order              */
    /*     Re(x[0]), Re(x[N/2]), Re(x[1]), Im(x[1]), Re(x[2]), Im(x[2]),  */
    /*     ... Re(x[N/2-1]), Im(x[N/2-1]).                                */

    SPFLOAT scale;
    int StageCnt;
    int NDiffU;

    M = M - 1;
    switch (M)
    {
        case -1:
            break;
        case 0:
            rfft1pt(ioptr); /* a 2 pt fft */
            break;
        case 1:
            rfft2pt(ioptr); /* a 4 pt fft */
            break;
        case 2:
            rfft4pt(ioptr); /* an 8 pt fft */
            break;
        case 3:
            rfft8pt(ioptr); /* a 16 pt fft */
            break;
        default:
            scale = 0.5;
            /* bit reverse and first radix 2 stage */
            scbitrevR2(ioptr, M, BRLow, scale);
            StageCnt = (M - 1) / 3; /* number of radix 8 stages           */
            NDiffU = 2; /* one radix 2 stage already complete */
            if ((M - 1 - (StageCnt * 3)) == 1)
            {
                bfR2(ioptr, M, NDiffU); /* 1 radix 2 stage */
                NDiffU *= 2;
            }
            if ((M - 1 - (StageCnt * 3)) == 2)
            {
                bfR4(ioptr, M, NDiffU); /* 1 radix 4 stage */
                NDiffU *= 4;
            }
            if (M <= (int) MCACHE)
                bfstages(ioptr, M, Utbl, 2, NDiffU, StageCnt); /* RADIX 8 Stages */
            else
                fftrecurs(ioptr, M, Utbl, 2, NDiffU, StageCnt); /* RADIX 8 Stages */
            frstage(ioptr, M + 1, Utbl);