clear all
j = sqrt(-1);
N = 64;
s  = rand(1,N);
S = fft(s);
r = real(S(1:N/2+1)); % это реальная часть половины спектра в OutBuf
i = fliplr(imag(S(2:N/2))); % это мнимая часть половины спектра в OutBuf

r = [r fliplr(r(2:N/2))];% ОТРАЖАЮ зеркально
i = [0 fliplr(i) 0 -i]; % ОТРАЖАЮ зеркально с минусом


R = fft(r);
RR = real(R(1:N/2+1)); % это реальная часть половины спектра в OutBuf при fft(r)  
RI = fliplr(imag(R(2:N/2))); % это мнимая часть половины спектра в OutBuf при fft(r)


I = fft(-i);
IR = real(I(1:N/2+1)); % это реальная часть половины спектра в OutBuf при fft(i)  
II = fliplr(imag(I(2:N/2))); % это мнимая часть половины спектра в OutBuf при fft(i)

%отражаю вторые половины спектра:
A = [RR fliplr(RR(2:N/2))];% ОТРАЖАЮ зеркально
B = [0 fliplr(II) 0 -II]; % ОТРАЖАЮ зеркально с минусом

s0 = (A-B)/N;
plot(1:N,s,'-o',1:N,s0)

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;

N = 16;
s  = rand(1,N); %случайный входной сигнал
S0=fft(s);      %FFT вещественного входного сигнала
A = real(S0);   %реалная часть
B = imag(S0);   %мнимая часть
%расчет ifft на осове вещесвенного fft
S=fft(A+B); % A+B - чисто вещественно, S - комплексное    
s0 = (real(S)+imag(S))/N; % результат IFFT
plot(1:N,s,'-o',1:N,s0)

clear all
j = sqrt(-1);
N = 16;
s  = rand(1,N); %случайный входной сигнал
S = fft(s);
r = real(S(1:N/2+1)); % это реальная часть половины спектра в OutBuf
i = fliplr(imag(S(2:N/2))); % это мнимая часть половины спектра в OutBuf

r = [r fliplr(r(2:N/2))];% ОТРАЖАЮ зеркально
i = [0 fliplr(i) 0 -i]; % ОТРАЖАЮ зеркально с минусом

s1 = fft(r+i)/N;

s1R = real(s1(1:N/2+1)); % это реальная часть половины спектра в OutBuf при fft(r+i)  
s1I = fliplr(imag(s1(2:N/2))); % это мнимая часть половины спектра в OutBuf при fft(r+i)

SR = [s1R fliplr(s1R(2:N/2))];% ОТРАЖАЮ зеркально
SI = [0 fliplr(s1I) 0 -s1I]; % ОТРАЖАЮ зеркально с минусом
s1 = SR+SI;

plot(1:N,s,'-o',1:N,s1)

//это прямое преобразование
    RFFT_F32_STRUCT        *t=(RFFT_F32_STRUCT*)table;
    scale = 1./t->FFTSize;
    t->InBuf=in;
    t->OutBuf=out;
    RFFT_f32u(t); //делаем БПФ

    for(i=0;i<t->FFTSize;i++)
        t->OutBuf[i] *= scale;

//ОБРАТНОЕ
//готовимся к обратному преобразованию
//Re[i] содержит вещественную часть Im[i] - мнимую
//отразим мнимую часть и дополним где надо нулями
    Re[0] = in[0];
    Im[0] = 0;
    for (i=1; i<(t->FFTSize/2+1);i++){
        Re[i] = in[i];          
        Im[i] =  in[t->FFTSize-i];
    }
    Im[t->FFTSize/2] = 0;
//теперь восстанавливаем вторую половину спектра
// ************* mirror ***************
    for (i=0; i<(t->FFTSize/2);i++)
    {
        Re[t->FFTSize-1-i] = Re[i+1]; //Re просто зеркально
        Im[t->FFTSize-1-i] = - Im[i+1]; //Im зеркально с минусом
    }
//Сложить
    for (i=0; i<(t->FFTSize);i++){
        t->InBuf[i]=Re[i]+Im[i];
    }
    RFFT_f32u(t); //делаем БПФ, теперь в OutBuf имеем time domain
    Re[0] = t->OutBuf[0];
    Im[0] = 0;
    for (i=1; i<(t->FFTSize/2+1);i++){
        Re[i] = t->OutBuf[i];          
        Im[i] =  t->OutBuf[t->FFTSize-i];
    }
    Im[t->FFTSize/2] = 0;
// ************* mirror ***************
    for (i=0; i<(t->FFTSize/2);i++)
    {
        Re[t->FFTSize-1-i] = Re[i+1]; //Re просто зеркально
        Im[t->FFTSize-1-i] = - Im[i+1]; //Im зеркально с минусом
    }
//Сложить
    for (i=0; i<(t->FFTSize);i++){
        out[i]=Re[i]+Im[i];
    }
//на FFTSize делить не нужно, т.к. это делает функция прямого преобразования

---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;
    }

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]

// ---------------------------------------------------------------------------
//
// InvRFFT()    - simulates inverse real FFT
//
// all input/output arrays are of length 2**log2n real entries
//
// on input
//
//      log2n   - base 2 log of Real FFT length
//      w       - twiddle factors table
//      x       - input array for Inverse Real FFT (stored in the order
//                      of Forward Real FFT output array)
//      f       - scratch array
//
// on input
//
//      s       - output array of inverse coeffs stored in natural order
//
// notes
//
//      this is a math exercise, not suitable for real work
//
// ---------------------------------------------------------------------------

#define real    float

void InvRFFT (int log2n, const real *w, real *x, real *f, real *s)
{
    int     i, n, n2;
    real    invn;

    n  = 1 << log2n;                        // RFFT length
    n2 = n >> 1;                            // half length

    invn = 1.0E0F / (real)(n);              // 1/N scale factor

    // add real and imag parts
    f[0] = x[0];
    for (i = 1; i < n2; i++)
    {
        f[i]   =  x[i] + x[n-i];            // add real and mirror imag
        f[n-i] =  x[i] - x[n-i];            // add mirror real and conj imag
    }
    f[n2] = x[n2];

    rfftf (log2n, (real *)w, (real *)f);    // FORWARD RFFT

    // add real and imag parts and scale down to form inverse real fft
    // get rid of scaling if done inside forward real fft
    s[0] = f[0] * invn;                     // save a few clocks on division
    for (i = 1; i < n2; i++)
    {
        s[i]   = (f[i] + f[n-i]) * invn;
        s[n-i] = (f[i] - f[n-i]) * invn;
    }
    s[n2] = f[n2] * invn;

    return;                                 // all done, exit
}

t->InBuf[0]=in[0];
    for (i=1, j=1; i<(t->FFTSize/2); i++){
        t->InBuf[i]=in[j]+in[j+1];
        j+=2;
    }
    t->InBuf[t->FFTSize/2]=in[t->FFTSize-1];
    for (i=t->FFTSize/2+1, j=(t->FFTSize-3); i<(t->FFTSize); i++){
        t->InBuf[i]=in[j]-in[j+1];
        j-=2;
    }

out[0]=t->OutBuf[0];
    for (i=1; i<(t->FFTSize/2);i++)
        out[i]=t->OutBuf[i] + t->OutBuf[t->FFTSize-i];

    out[i++]=t->OutBuf[i];
    for (; i<(t->FFTSize);i++)
        out[i]=t->OutBuf[t->FFTSize-i] - t->OutBuf[i];

;static void _TMStoSPEEXrepack(spx_word16_t *SPXpacked, spx_word16_t *TMSpacked, int N){
;//перепаковывает рузультаты FFT в формат принятый в speex
;//TMSpacked[0] = real[0] TMSpacked[1] = real[1].... TMSpacked[N/2] = real[N/2]
;//TMSpacked[N-1] = imag[1] TMSpacked[N-2] = imag[2].... TMSpacked[N/2+1] = imag[N/2-1]
;//SPXpacked = R(0),R(1),I(1),R(2),I(2)....R(N/2)
;
;SPXpacked    XAR4
;TMSpacked    XAR5
;N            AL
    .global __TMStoSPEEXrepack
    .sect "ramfuncs"
__TMStoSPEEXrepack:
    PUSH     AL
;расчитаем указатель на imag[N/2-1]
    MOVL    ACC,XAR5
    ADD        ACC,*-SP[1]
    ADD        ACC,*-SP[1];второй раз потому что float занимает 2слова
    MOVL    XAR6,ACC;XAR6 указывает на TMSpacked[N-1] т.е. на imag[1]
;подготовить счётчик цикла    
    POP        AL
    LSR        AL#1
    ADD        AL,#-2;цикл должен пройти N/2-1 раз
;до начала цикла делаем
;SPXpacked[0]=TMSpacked[0];
    MOV32    R0H,*XAR5++
    MOV32    *XAR4++,R0H
    
    .align    2
    NOP
    RPTB    fftrepack_loop,AL
        MOV32    R0H,*XAR5++;real[i]
        MOV32    *XAR4++,R0H
        MOV32    R0H,*--XAR6;imag[i]
        MOV32    *XAR4++,R0H
fftrepack_loop:
    MOV32    R0H,*XAR5++;real[i]
    MOV32    *XAR4++,R0H
    
    LRETR

;void asm_mul_by_const(float* dst, float* src, float mul, int len);
;dst XAR4
;src XAR5
;mul R0H
;len AL
;умножает каждый элемент src на mul результат ложится в dst
;dst[i]=src[i]*mul
    .global _asm_mul_by_const    
    .sect "ramfuncs"
_asm_mul_by_const:
    LSR    AL,#1;цикл unrolled, так что делим счётчик на 2
    ADDB    AL,#-1; чтобы RPTB не перестарался
    RPTB    asm_mul_by_const_loop,AL
        MOV32    R1H,*XAR5++;R1H=src[i]
        MPYF32    R1H,R1H,R0H;R1H=src[i]*mul
        MOV32    R2H,*XAR5++;R2H=src[i+1]
        MPYF32    R2H,R2H,R0H;R2H=src[i+1]*mul
        MOV32    *XAR4++,R1H;dst[i]=R1H
        MOV32    *XAR4++,R2H;dst[i+1]=R1H
asm_mul_by_const_loop:
    
    LRETR