c28х FPU library beta1, помогите разобраться с real FFT Опции

[sigmaN]

Имеется оптимизированная либа C28x Floating Point Unit Library, содержащая следующие функции

RFFT_f32 void RFFT_f32(RFFT_F32_STRUCT *);
This module computes a 32-bit floating-point real FFT including input bit
reversing. This version of the function requires input buffer memory alignment. If
you do not wish to align the input buffer, then use the RFFT_f32u function.

RFFT_f32u void RFFT_f32u(RFFT_F32_STRUCT *);
This module computes a 32-bit floating-point real FFT including input bit
reversing. This version of the function does not have any buffer alignment
requirements. If you can align the input buffer, then use the RFFT_f32 function
for improved performance.

RFFT_f32_mag void RFFT_f32_mag(RFFT_F32_STRUCT *);
This module computes the real FFT magnitude.

RFFT_f32s_mag void RFFT_f32s_mag(RFFT_F32_STRUCT *);
This module computes the scaled real FFT magnitude.

RFFT_f32_phase void RFFT_f32_phase(RFFT_F32_STRUCT *);
This module computes FFT Phase

RFFT_f32_sincostable void RFFT_f32_sincostable(RFFT_F32_STRUCT *);
This module generates the twiddle factors used by the real FFT.


typedef struct {
float32 *InBuf;//Input buffer
float32 *OutBuf; //Output buffer
float32 *CosSinBuf;
float32 *MagBuf;
float32 *PhaseBuf;
Uint16 FFTSize;
Uint16 FFTStages;
} RFFT_F32_STRUCT;
По поводу output buffer сказано:
Result of RFFT_f32. This buffer is used as
the input to the magnitude and phase
calculations. The output order for FFTSize
= N is:
OutBuf[0] = real[0]
OutBuf[1] = real[1]
OutBuf[2] = real[2]
………
OutBuf[N/2] = real[N/2]
OutBuf[N/2+1] = imag[N/2-1]
………
OutBuf[N-3] = imag[3]
OutBuf[N-2] = imag[2]
OutBuf[N-1] = imag[1]

Почему на выходе _REAL_ FFT видим imag, т.е. мнимую часть?
Каков смысл FFT magnitude и phase?
Как используя эти функции реализовать обратное преобразование?

[sigmaN]

Нашел пост на техасовском форуме

Код

There are two things why this won't work

-You will need a complex FFT to do the IFFT. Because your trying to place imaginaire data in the real FFT.
- You need mirror the imaginaire part.

(1)

You can use the Real FFT to do IFFT, but you have to the following steps

--Split--

    Re[0] = fft.OutBuf[0];
    Im[0] = 0;
    for (i=1; i<(FFTsize/2+1);i++)
    {
        Re[i]           =  fft.OutBuf[i];          // split real
        Im[i]           =  fft.OutBuf[FFTsize-i];  // split imag
    }
    Im[FFTsize/2] = 0;

----

---combine and split imag/real---

    for(i=0; i< FFTsize/2;i++)
    {
        tempR = Re[i] - Im[i];
        tempI = Re[i]] + Im[i];

        Re[i] = tempR; //can also be done in one step
        Im[i] = tempI;
    }



--mirror---

// ************* mirror ***************
    for (i=0; i<(FFTsize/2);i++)
    {
        Re[FFTsize-1-i] =   Re[i+1];
        Im[FFTsize-1-i] = - Im[i+1];
    }
    // ************ add *******************
    for (i=0; i<FFTsize;i++)
    {
        fft.InBuf[i] = Re[i] - Im[i];
    }



And now you can do the FFT again to get the IFFT

After this, you will need to the Split, Mirror routine again

The last step is to divide the all the result by [fftSize]

А вот отзыв человека это испробовавшего:

Код

Thanks, Leo. It's realy helpful.

I optimize you code for pre-IFFT computation and I need to change last "add" section for post-IFFT computation. And IFFT result is shifted for 3 samples rigth from source signal.

This is my code:

  RFFT_f32u(&fft1);
  
    for (int16 i=0; i<fftSize/2; i++){
        ifft.InBuf[i]=-2*fft1.OutBuf[fftSize-i];
        ifft.InBuf[fftSize-1-i]=2*fft1.OutBuf[i+1];
    }
    ifft.InBuf[0]=0;
    ifft.InBuf[fftSize/2]=fft1.OutBuf[fftSize/2];
      
    RFFT_f32u(&ifft);
      
// Split  
    Re[0] = ifft.OutBuf[0];
    Im[0] = 0;
    for (int16 i=1; i<(fftSize/2+1); i++) {
        Re[i] = ifft.OutBuf[i];            // split real
        Im[i] = ifft.OutBuf[fftSize-i]; // split imag
    }
    Im[fftSize/2] = 0;
// Combine and split imag/real
    for(int16 i=0; i<fftSize/2; i++){
        tempR = Re[i]-Im[i];
        tempI = Re[i]+Im[i];
        Re[i] = tempR; //can also be done in one step
        Im[i] = tempI;
    }

// Mirror
    for (int16 i=0; i<(fftSize/2); i++){
        Re[fftSize-1-i] = Re[i+1];
        Im[fftSize-1-i] = -Im[i+1];
    }
    // Modifed
    for (int16 i=0; i<fftSize/2+1; i++) fft2.InBuf[i] = Re[i]/fftSize;
    for (int16 i=fftSize/2+1; i<fftSize; i++) fft2.InBuf[i] = -Im[i]/fftSize;

Т.е. обходятся они одним FFT для реализации обратного преобразования....А ещё не очень я пока понял почему у него результат сдвигается на 3 отсчёта вправо.....

Но картина уже выясняется потихоньку...скоро буду перехдить к "полевым испытаниям" "боевых" алгоритмов