#define FFT_N 512

void DoFFT (byte *pInData, byte iWindow)
{
  float a_inReal1[FFT_N], a_inReal2[FFT_N];
  float a_outRe1[FFT_N], a_outIm1[FFT_N];
  float a_outRe2[FFT_N], a_outIm2[FFT_N];
  int i;
  float temp;

  // 1. Заполнение входных массивов
  for (i=0; i<FFT_N; i++)
  {
    temp = (float)pInData[i];
    a_inReal1[i] = a_inReal2[i] = temp;
  } // for
  
  // 2. FFT
  fn_a_2RealFFT ( FFT_N, a_inReal1, a_inReal2,
                 a_outRe1, a_outIm1, a_outRe2, a_outIm2,
                 a_TTransf, STEP(FFT_N, 1536) );

  // 3. Расчёт спектра
  for ( i = 0; i < FFT_N; i ++ )
  {
    float Re2, Im2;
    
    Re2 = a_outRe1 [ i ];
    Im2 = a_outIm1 [ i ];

    // Squareing
    Spectrum [i] = (int) sqrt ( Re2 + Im2 );
  } // for
} // DoFFT

  float a_inReal1[FFT_N/2], a_inReal2[FFT_N/2];
  float a_outRe1[FFT_N/2], a_outIm1[FFT_N/2];
  float a_outRe2[FFT_N/2], a_outIm2[FFT_N/2];
  int i;

  // 1. Заполнение входных массивов
  for (i=0; i<FFT_N/2; i++)
  {
    a_inReal1[i] = (float)pInData[i];
    a_inReal2[i] = (float)pInData[i+FFT_N/2];
  } // for

int Spectrum [FFT_N];

  for ( i = 0; i < FFT_N/2; i ++ )
  {
    float Re2, Im2;
    
    Re2 = a_outRe1 [ i ];
    Im2 = a_outIm1 [ i ];
    Spectrum [i] = (int) sqrt ( Re2 + Im2 );
    
    Re2 = a_outRe1 [ i + FFT_N/2 ];
    Im2 = a_outIm1 [ i + FFT_N/2 ];
    Spectrum [i + FFT_N/2] = (int) sqrt ( Re2 + Im2 );
  } // for

ui_N = cuic_RN>>1;

  float a_inReal1[FFT_N/2], a_inReal2[FFT_N/2];
  float a_outRe1[FFT_N/2], a_outIm1[FFT_N/2];
  float a_outRe2[FFT_N/2], a_outIm2[FFT_N/2];
  int i;

  // 1. Заполнение входных массивов
  for (i=0; i<FFT_N/2; i++)
  {
    a_inReal1[i] = (float)pInData[i];
    a_inReal2[i] = (float)pInData[i+FFT_N/2];
  } // for
  
  // 2. FFT
  fn_a_2RealFFT ( FFT_N/2, a_inReal1, a_inReal2,
                 a_outRe1, a_outIm1, a_outRe2, a_outIm2,
                 a_TTransf, STEP(FFT_N/2, 1536) );

  // 3. Расчёт спектра
  for ( i = 0; i < FFT_N/2; i ++ )
  {
    float Re2, Im2;
    
    Re2 = a_outRe1 [ i ];
    Im2 = a_outIm1 [ i ];
    Spectrum [i] = (int) sqrt ( Re2 + Im2 );
    
    Re2 = a_outRe1 [ i + FFT_N/2 ];
    Im2 = a_outIm1 [ i + FFT_N/2 ];
    Spectrum [i + FFT_N/2] = (int) sqrt ( Re2 + Im2 );
  } // for

  // 3. Расчёт спектра
  for ( i = 0; i < FFT_N/2; i ++ )
  {
    float Re2, Im2;
    
    Re2 = a_outRe1 [ i ];
    Im2 = a_outIm1 [ i ];
    Spectrum [i] = (int) sqrt ( Re2*Re2 + Im2*Im2 );
    
    Re2 = a_outRe1 [ FFT_N/2 + i ];
    Im2 = a_outIm1 [ FFT_N/2 + i ];
    Spectrum [ FFT_N/2 + i ] = (int) sqrt ( Re2*Re2 + Im2*Im2 );
  } // for

  // 3. Расчёт спектра
  for ( i = 0; i < FFT_N/2; i ++ )
  {
    float Re2, Im2;
    
    Re2 = a_outRe1 [ i ];
    Im2 = a_outIm1 [ i ];
    Spectrum [i] = (int) sqrt ( Re2*Re2 + Im2*Im2 );
    
    Re2 = a_outRe2 [ i ];
    Im2 = a_outIm2 [ i ];
    Spectrum [ FFT_N/2 + i ] = (int) sqrt ( Re2*Re2 + Im2*Im2 );
  } // for

int fn_aT_ditNbrRadix2FFT_int
(
  const unsigned int         cuic_N,
  int                        ai_inRe[],                 // i input
  int                        ai_inIm[],                 // q input
  int                        ai_buffRe[],               // i buff
  int                        ai_buffIm[],               // q buff
  int                      **pp_outRe,                  // i output
  int                      **pp_outIm,                  // q output
  int                      **pp_inRe,                   // i input
  int                      **pp_inIm,                   // q input
  const int                  acc_trigT[],
  const unsigned int         cui_jumpT
)

  fn_aT_ditNbrRadix2FFT_int
  (
    ui_N,
    i,                                                             /* i input */
    q,                                                             /* q input */
    bi,                                                             /* i buff */
    bq,                                                             /* q buff */
    &p1,                                                          /* i output */
    &p2,                                                          /* q output */
    &p3,                                                           /* i input */
    &p4,                                                           /* q input */
    cai_TTransf,
    STEP(ui_N, dfi_3N4)
  );

int iData [FFT_N], qData [FFT_N];
int bi [FFT_N], bq [FFT_N];
...........................

void DoFFT (byte *pInData, byte iWindow)
{
  int i;
  int *p1 = 0, *p2 = 0, *p3 = 0, *p4 = 0;

  // 1. Заполнение входных массивов
  for ( i = 0; i < FFT_N; i ++ )
  {
    iData[i] = (int)pInData[i];
    qData[i] = 0;
  } // for
  
  // 2. FFT
  fn_aT_ditNbrRadix2FFT_int
  (
    FFT_N,
    iData,         // i input
    qData,         // q input
    bi,        // i buff
    bq,        // q buff
    &p1,           // i output
    &p2,           // q output
    &p3,           // i input
    &p4,           // q input
    cai_TTransf, STEP(FFT_N, dfi_3N4)
  );

  // 3. Расчёт спектра
  for ( i = 0; i < FFT_N; i ++ )
  {
    int Re2, Im2;
    
    Re2 = p1 [ i ];
    Im2 = p2 [ i ];
    Spectrum [i] = (int) sqrt ( (float)Re2*(float)Re2 + (float)Im2*(float)Im2 );
  } // for
} // DoFFT

int a_inReal1[FFT_N/2], a_inReal2[FFT_N/2];
int a_outRe1[FFT_N/2], a_outIm1[FFT_N/2];
int a_outRe2[FFT_N/2], a_outIm2[FFT_N/2];
.....................
// Выполнение FFT
//  pInData - входные данные (выборка FFT) - FFT_N
//  оконная функция: 0 - нет; 1-Hanning; 2 - Hamming
void DoFFT (byte *pInData, byte iWindow)
{
  int i;

  // 1. Заполнение входных массивов
  for ( i = 0; i < FFT_N/2; i ++ )
  {
    a_inReal1[i] = pInData [ i ];
    a_inReal2[i] = pInData [ i + FFT_N/2 ];
  } // for
  
  // 2. FFT
  fn_a_2RealFFT_int ( FFT_N/2, a_inReal1, a_inReal2,
                      a_outRe1, a_outIm1, a_outRe2, a_outIm2,
                      cai_TTransf, STEP ( FFT_N/2, dfi_3N4 ) );
  
//  memset ( Spectrum, 0, FFT_N);
  
  // 3. Расчёт спектра
  for ( i = 0; i < FFT_N/2; i ++ )
  {
    long Re2, Im2;
    long long s;
    
    Re2 = a_outRe1 [ i ];
    Im2 = a_outIm1 [ i ];
    s = Re2*Re2 + Im2*Im2;
    Spectrum [i] = sqrt_int ( s );
    
    Re2 = a_outRe2 [ i ];
    Im2 = a_outIm2 [ i ];
    s = Re2*Re2 + Im2*Im2;
    Spectrum [ FFT_N/2 + i ] = sqrt_int ( s );
  } // for
} // DoFFT

// Целочисленный sqrt
unsigned long sqrt_int ( long long l )
{
  unsigned long div = 1, rslt = 0;

  while (l > 0)
  {
   l -= div;
   div += 2;
   rslt  += (l < 0) ? 0 : 1;
  } // while

  return rslt;
} // sqrt_int

              /*----------------------------------------------------------------------------*/
              /*              умножение 2-х комплексных чисел  - бабочка                 -4-*/
              /*----------------------------------------------------------------------------*/
              temp_Re = (((acc_trigT[i_TargC]*a_Re[i_top])>>14) + ((acc_trigT[i_TargS]*a_Im[i_top])>>14))>>1;
              temp_Im = (((acc_trigT[i_TargC]*a_Im[i_top])>>14) - ((acc_trigT[i_TargS]*a_Re[i_top])>>14))>>1;
              
//              temp_Re = acc_trigT[i_TargC]*a_Re[i_top] - acc_trigT[i_TargS]*a_Im[i_top]*(cc_dir);
//              temp_Im = acc_trigT[i_TargC]*a_Im[i_top] + acc_trigT[i_TargS]*a_Re[i_top]*(cc_dir);

(l < 0) ? 0 : 1

val=6179 --> Line: (0,48)-(0,0);
val=296 --> Line: (1,48)-(1,0);
val=426 --> Line: (2,48)-(2,0);
val=186 --> Line: (3,48)-(3,0);
val=101 --> Line: (4,48)-(4,0);
val=382 --> Line: (5,48)-(5,0);
val=86 --> Line: (6,48)-(6,0);
val=73 --> Line: (7,48)-(7,0);
val=45 --> Line: (8,48)-(8,5);
val=20 --> Line: (9,48)-(9,30);
val=9 --> Line: (10,48)-(10,41);
val=7 --> Line: (11,48)-(11,43);
val=29 --> Line: (12,48)-(12,21);
val=18 --> Line: (13,48)-(13,32);
val=18 --> Line: (14,48)-(14,32);
val=12 --> Line: (15,48)-(15,38);
val=18 --> Line: (16,48)-(16,32);
val=23 --> Line: (17,48)-(17,27);
val=8 --> Line: (18,48)-(18,42);
val=13 --> Line: (19,48)-(19,37);
val=19 --> Line: (20,48)-(20,31);
val=13 --> Line: (21,48)-(21,37);
val=13 --> Line: (22,48)-(22,37);
val=10 --> Line: (23,48)-(23,40);
val=11 --> Line: (24,48)-(24,39);
val=22 --> Line: (25,48)-(25,28);
val=11 --> Line: (26,48)-(26,39);
val=29 --> Line: (27,48)-(27,21);
val=2 --> Line: (28,48)-(28,48);
val=7 --> Line: (29,48)-(29,43);
val=9 --> Line: (30,48)-(30,41);
val=5 --> Line: (31,48)-(31,45);
val=2 --> Line: (32,48)-(32,48);
val=16 --> Line: (33,48)-(33,34);
val=8 --> Line: (34,48)-(34,42);
val=17 --> Line: (35,48)-(35,33);
val=15 --> Line: (36,48)-(36,35);
val=7 --> Line: (37,48)-(37,43);
val=7 --> Line: (38,48)-(38,43);
val=10 --> Line: (39,48)-(39,40);
val=9 --> Line: (40,48)-(40,41);
val=12 --> Line: (41,48)-(41,38);
val=4 --> Line: (42,48)-(42,46);
val=13 --> Line: (43,48)-(43,37);
val=8 --> Line: (44,48)-(44,42);
val=15 --> Line: (45,48)-(45,35);
val=16 --> Line: (46,48)-(46,34);
val=11 --> Line: (47,48)-(47,39);
val=13 --> Line: (48,48)-(48,37);
val=6141 --> Line: (49,48)-(49,0);
val=498 --> Line: (50,48)-(50,0);
val=528 --> Line: (51,48)-(51,0);
val=165 --> Line: (52,48)-(52,0);
val=192 --> Line: (53,48)-(53,0);
val=152 --> Line: (54,48)-(54,0);
val=60 --> Line: (55,48)-(55,0);
val=15 --> Line: (56,48)-(56,35);
val=32 --> Line: (57,48)-(57,18);
val=53 --> Line: (58,48)-(58,0);
val=10 --> Line: (59,48)-(59,40);
val=25 --> Line: (60,48)-(60,25);
val=17 --> Line: (61,48)-(61,33);
val=12 --> Line: (62,48)-(62,38);
val=20 --> Line: (63,48)-(63,30);
val=21 --> Line: (64,48)-(64,29);
val=17 --> Line: (65,48)-(65,33);
val=26 --> Line: (66,48)-(66,24);
val=13 --> Line: (67,48)-(67,37);
val=14 --> Line: (68,48)-(68,36);
val=10 --> Line: (69,48)-(69,40);
val=8 --> Line: (70,48)-(70,42);
val=7 --> Line: (71,48)-(71,43);
val=25 --> Line: (72,48)-(72,25);
val=14 --> Line: (73,48)-(73,36);
val=4 --> Line: (74,48)-(74,46);
val=20 --> Line: (75,48)-(75,30);
val=3 --> Line: (76,48)-(76,47);
val=6 --> Line: (77,48)-(77,44);
val=2 --> Line: (78,48)-(78,48);
val=9 --> Line: (79,48)-(79,41);
val=15 --> Line: (80,48)-(80,35);
val=8 --> Line: (81,48)-(81,42);
val=6 --> Line: (82,48)-(82,44);
val=8 --> Line: (83,48)-(83,42);
val=10 --> Line: (84,48)-(84,40);
val=15 --> Line: (85,48)-(85,35);
val=1 --> Line: (86,48)-(86,49);
val=12 --> Line: (87,48)-(87,38);
val=8 --> Line: (88,48)-(88,42);
val=5 --> Line: (89,48)-(89,45);
val=29 --> Line: (90,48)-(90,21);
val=18 --> Line: (91,48)-(91,32);
val=6 --> Line: (92,48)-(92,44);
val=5 --> Line: (93,48)-(93,45);
val=14 --> Line: (94,48)-(94,36);
val=9 --> Line: (95,48)-(95,41);
val=0 --> Line: (96,48)-(96,50);
val=9 --> Line: (97,48)-(97,41);
Draw in FFT buffer: duration 367 ms