/src/libxaac/encoder/ixheaace_fft.c

Source
/******************************************************************************
 *                                                                            *
 * Copyright (C) 2023 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *****************************************************************************
 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
 */

#include <string.h>

#include "ixheaac_type_def.h"
#include "ixheaac_constants.h"
#include "ixheaace_psy_const.h"
#include "ixheaace_tns.h"
#include "ixheaace_tns_params.h"
#include "ixheaace_rom.h"
#include "ixheaace_common_rom.h"
#include "ixheaace_bitbuffer.h"
#include "ixheaace_aac_constants.h"
#include "ixheaace_fft.h"
#include "ixheaac_basic_ops32.h"
#include "ixheaac_basic_ops40.h"
#include "ixheaac_basic_ops.h"
#include "iusace_basic_ops_flt.h"

static VOID ia_enhaacplus_enc_shift_mdct_delay_buffer(FLOAT32 *ptr_mdct_delay_buffer,
                                                      const FLOAT32 *ptr_time_signal,
                                                      WORD32 ch_increment,
                                                      WORD32 long_frame_len) {
  WORD32 i;
  FLOAT32 *ptr_mdct_buff = ptr_mdct_delay_buffer;
  if (ch_increment == 2) {
    const FLOAT32 *ptr_input = ptr_time_signal;
    FLOAT32 temp1, temp2, temp3, temp4;
    temp1 = *ptr_input++;
    ptr_input++;
    temp2 = *ptr_input++;
    ptr_input++;
    temp3 = *ptr_input++;
    ptr_input++;
    for (i = ((long_frame_len >> 2) - 2); i >= 0; i--) {
      *ptr_mdct_buff++ = temp1;
      temp4 = *ptr_input++;
      ptr_input++;

      *ptr_mdct_buff++ = temp2;
      *ptr_mdct_buff++ = temp3;
      *ptr_mdct_buff++ = temp4;

      temp1 = *ptr_input++;
      ptr_input++;
      temp2 = *ptr_input++;
      ptr_input++;
      temp3 = *ptr_input++;
      ptr_input++;
    }
    *ptr_mdct_buff++ = temp1;
    temp4 = *ptr_input;
    *ptr_mdct_buff++ = temp2;
    *ptr_mdct_buff++ = temp3;
    *ptr_mdct_buff++ = temp4;
  } else {
    for (i = 0; i < long_frame_len; i += 2) {
      *ptr_mdct_buff++ = ptr_time_signal[i * ch_increment];
      *ptr_mdct_buff++ = ptr_time_signal[(i + 1) * ch_increment];
    }
  }
}

static VOID ia_eaacp_enc_inverse_transform_512(FLOAT32 *ptr_data, FLOAT32 *ptr_win_buf,
                                               const FLOAT32 *ptr_cos_sin_tbl,
                                               WORD8 *ptr_scratch) {
  WORD32 n = FRAME_LEN_512;
  WORD32 n_by_2 = n >> 1;

  ixheaace_scratch_mem *pstr_scratch = (ixheaace_scratch_mem *)ptr_scratch;

  ia_eaacp_enc_pre_twiddle_aac(ptr_win_buf, ptr_data, n, ptr_cos_sin_tbl);

  ia_enhaacplus_enc_complex_fft(ptr_win_buf, n_by_2, pstr_scratch);

  ia_enhaacplus_enc_post_twiddle(ptr_data, ptr_win_buf, ptr_cos_sin_tbl, n);
}

static VOID ixheaace_pre_mdct(FLOAT32 *ptr_x, WORD32 m, const FLOAT32 *ptr_sine_window) {
  WORD32 i;
  FLOAT32 wre, wim, re1, re2, im1, im2;

  for (i = 0; i < m / 4; i++) {
    re1 = ptr_x[2 * i];
    im2 = ptr_x[2 * i + 1];
    re2 = ptr_x[m - 2 - 2 * i];
    im1 = ptr_x[m - 1 - 2 * i];

    wim = ptr_sine_window[i * 2];
    wre = ptr_sine_window[m - 1 - 2 * i];

    ptr_x[2 * i] = im1 * wim + re1 * wre;

    ptr_x[2 * i + 1] = im1 * wre - re1 * wim;

    wim = ptr_sine_window[m - 2 - 2 * i];
    wre = ptr_sine_window[2 * i + 1];

    ptr_x[m - 2 - 2 * i] = im2 * wim + re2 * wre;

    ptr_x[m - 1 - 2 * i] = im2 * wre - re2 * wim;
  }
}

static VOID ia_enhaacplus_enc_tranform_mac4(FLOAT32 *ptr_op, const FLOAT32 *ptr_win,
                                            FLOAT32 *ptr_buf1, FLOAT32 *ptr_buf2,
                                            FLOAT32 *ptr_buf3, FLOAT32 *ptr_buf4, UWORD32 len,
                                            WORD32 increment) {
  WORD32 i;

  if (increment > 0) {
    for (i = len >> 2; i > 0; i--) {
      *ptr_op = ((ptr_win[0] * (*ptr_buf1++)) + (ptr_win[1] * (*ptr_buf2++)));
      *ptr_op = (*ptr_op + (ptr_win[2] * (*ptr_buf3--)));
      *ptr_op = (*ptr_op + (ptr_win[3] * (*ptr_buf4--)));
      ptr_op++;

      *ptr_op = ((ptr_win[4] * (*ptr_buf1++)) + (ptr_win[5] * (*ptr_buf2++)));
      *ptr_op = (*ptr_op + (ptr_win[6] * (*ptr_buf3--)));
      *ptr_op = (*ptr_op + (ptr_win[7] * (*ptr_buf4--)));
      ptr_op++;

      *ptr_op = ((ptr_win[8] * (*ptr_buf1++)) + (ptr_win[9] * (*ptr_buf2++)));
      *ptr_op = (*ptr_op + (ptr_win[10] * (*ptr_buf3--)));
      *ptr_op = (*ptr_op + (ptr_win[11] * (*ptr_buf4--)));
      ptr_op++;

      *ptr_op = ((ptr_win[12] * (*ptr_buf1++)) + (ptr_win[13] * (*ptr_buf2++)));
      *ptr_op = (*ptr_op + (ptr_win[14] * (*ptr_buf3--)));
      *ptr_op = (*ptr_op + (ptr_win[15] * (*ptr_buf4--)));
      ptr_op++;
      ptr_win += 16;
    }
  } else {
    for (i = len >> 2; i > 0; i--) {
      *ptr_op = ((ptr_win[0] * (*ptr_buf1++)) + (ptr_win[1] * (*ptr_buf2++)));
      *ptr_op = (*ptr_op + (ptr_win[2] * (*ptr_buf3--)));
      *ptr_op = (*ptr_op + (ptr_win[3] * (*ptr_buf4--)));
      ptr_op--;

      *ptr_op = ((ptr_win[4] * (*ptr_buf1++)) + (ptr_win[5] * (*ptr_buf2++)));
      *ptr_op = (*ptr_op + (ptr_win[6] * (*ptr_buf3--)));
      *ptr_op = (*ptr_op + (ptr_win[7] * (*ptr_buf4--)));
      ptr_op--;

      *ptr_op = ((ptr_win[8] * (*ptr_buf1++)) + (ptr_win[9] * (*ptr_buf2++)));
      *ptr_op = (*ptr_op + (ptr_win[10] * (*ptr_buf3--)));
      *ptr_op = (*ptr_op + (ptr_win[11] * (*ptr_buf4--)));
      ptr_op--;

      *ptr_op = ((ptr_win[12] * (*ptr_buf1++)) + (ptr_win[13] * (*ptr_buf2++)));
      *ptr_op = (*ptr_op + (ptr_win[14] * (*ptr_buf3--)));
      *ptr_op = (*ptr_op + (ptr_win[15] * (*ptr_buf4--)));
      ptr_op--;
      ptr_win += 16;
    }
  }
}

static VOID ia_enhaacplus_enc_tranform_mac3(FLOAT32 *ptr_op, const FLOAT32 *ptr_win,
                                            FLOAT32 *ptr_buf1, FLOAT32 *ptr_buf2,
                                            FLOAT32 *ptr_buf3, UWORD32 len, WORD32 increment) {
  WORD32 i;

  if (increment > 0) {
    for (i = len >> 2; i > 0; i--) {
      *ptr_op = ((ptr_win[0] * (*ptr_buf1++)) + (ptr_win[1] * (*ptr_buf2--)));
      *ptr_op = (*ptr_op + (ptr_win[2] * (*ptr_buf3--)));
      ptr_op++;

      *ptr_op = ((ptr_win[3] * (*ptr_buf1++)) + (ptr_win[4] * (*ptr_buf2--)));
      *ptr_op = (*ptr_op + (ptr_win[5] * (*ptr_buf3--)));
      ptr_op++;

      *ptr_op = ((ptr_win[6] * (*ptr_buf1++)) + (ptr_win[7] * (*ptr_buf2--)));
      *ptr_op = (*ptr_op + (ptr_win[8] * (*ptr_buf3--)));
      ptr_op++;

      *ptr_op = ((ptr_win[9] * (*ptr_buf1++)) + (ptr_win[10] * (*ptr_buf2--)));
      *ptr_op = (*ptr_op + (ptr_win[11] * (*ptr_buf3--)));
      ptr_op++;
      ptr_win += 12;
    }
  } else {
    for (i = len >> 2; i > 0; i--) {
      *ptr_op = ((ptr_win[0] * (*ptr_buf1++)) + (ptr_win[1] * (*ptr_buf2--)));
      *ptr_op = (*ptr_op + (ptr_win[2] * (*ptr_buf3--)));
      ptr_op--;

      *ptr_op = ((ptr_win[3] * (*ptr_buf1++)) + (ptr_win[4] * (*ptr_buf2--)));
      *ptr_op = (*ptr_op + (ptr_win[5] * (*ptr_buf3--)));
      ptr_op--;

      *ptr_op = ((ptr_win[6] * (*ptr_buf1++)) + (ptr_win[7] * (*ptr_buf2--)));
      *ptr_op = (*ptr_op + (ptr_win[8] * (*ptr_buf3--)));
      ptr_op--;

      *ptr_op = ((ptr_win[9] * (*ptr_buf1++)) + (ptr_win[10] * (*ptr_buf2--)));
      *ptr_op = (*ptr_op + (ptr_win[11] * (*ptr_buf3--)));
      ptr_op--;
      ptr_win += 12;
    }
  }
}

VOID ia_enhaacplus_enc_transform_real(FLOAT32 *ptr_mdct_delay_buffer,
                                      const FLOAT32 *ptr_time_signal, WORD32 ch_increment,
                                      FLOAT32 *ptr_real_out, ixheaace_mdct_tables *pstr_mdct_tab,
                                      FLOAT32 *ptr_shared_buffer1, WORD8 *ptr_shared_buffer5,
                                      WORD32 long_frame_len) {
  WORD32 n, n1;
  FLOAT32 *ptr_windowed_buf = ptr_shared_buffer1;
  const FLOAT32 *ptr_ws1;
  WORD32 i, len = long_frame_len;
  FLOAT32 *ptr_real_in;
  FLOAT32 *ptr_data1, *ptr_data2, *ptr_data3, *ptr_data4;
  FLOAT32 *ptr_op1;

  ptr_real_in = ptr_mdct_delay_buffer;

  n = long_frame_len << 1;
  n1 = long_frame_len >> 1;

  ptr_ws1 =
      (long_frame_len == FRAME_LEN_512) ? pstr_mdct_tab->win_512_ld : pstr_mdct_tab->win_480_ld;

  ptr_op1 = ptr_real_out;
  ptr_data1 = &ptr_real_in[n1];
  ptr_data2 = &ptr_real_in[n + n1];
  ptr_data3 = &ptr_real_in[n1 - 1];
  ptr_data4 = &ptr_real_in[n + n1 - 1];

  ia_enhaacplus_enc_tranform_mac4(ptr_op1, ptr_ws1, ptr_data1, ptr_data2, ptr_data3, ptr_data4,
                                  n1, 1);
  ptr_ws1 += ((SIZE_T)n1 << 2);

  for (i = 0; i < long_frame_len << 1; i++) {
    ptr_mdct_delay_buffer[i] = ptr_mdct_delay_buffer[long_frame_len + i];
  }
  ia_enhaacplus_enc_shift_mdct_delay_buffer(&ptr_mdct_delay_buffer[2 * long_frame_len],
                                            ptr_time_signal, ch_increment, long_frame_len);

  ptr_op1 = &ptr_real_out[long_frame_len - 1];
  ptr_data1 = &ptr_real_in[n + len - n1];
  ptr_data2 = &ptr_real_in[len - n1];
  ptr_data3 = &ptr_real_in[len - n1 - 1];
  ptr_data4 = &ptr_real_in[n + len - n1 - 1];

  ia_enhaacplus_enc_tranform_mac4(ptr_op1, ptr_ws1, ptr_data1, ptr_data2, ptr_data3, ptr_data4,
                                  (n1 >> 1), -1);
  ptr_op1 -= (n1 >> 1);
  ptr_ws1 += ((SIZE_T)n1 << 1);
  ptr_data2 += (n1 >> 1);
  ptr_data3 -= (n1 >> 1);
  ptr_data4 -= (n1 >> 1);
  ia_enhaacplus_enc_tranform_mac3(ptr_op1, ptr_ws1, ptr_data2, ptr_data3, ptr_data4, (n1 >> 1),
                                  -1);

  if (long_frame_len == FRAME_LEN_480) {
    ia_aac_ld_enc_mdct_480(ptr_real_out, ptr_windowed_buf, 1, pstr_mdct_tab);
  } else {
    ia_eaacp_enc_inverse_transform_512(ptr_real_out, ptr_windowed_buf,
                                       pstr_mdct_tab->cosine_array_1024, ptr_shared_buffer5);
  }
}

static VOID ia_eaacp_enc_pre_twiddle_compute(FLOAT32 *ptr_in1, FLOAT32 *ptr_in2, FLOAT32 *ptr_x,
                                             const FLOAT32 *ptr_cos_sin, WORD n_by_4) {
  WORD32 i;
  FLOAT32 temp_r, temp_i;
  FLOAT32 temp_r1, temp_i1;
  FLOAT32 *ptr_x1 = ptr_x + (SIZE_T)((n_by_4 << 2) - 1);
  FLOAT32 c, c1, s, s1;

  for (i = 0; i < n_by_4; i++) {
    c = *ptr_cos_sin++;
    s = *ptr_cos_sin++;
    s1 = *ptr_cos_sin++;
    c1 = *ptr_cos_sin++;

    temp_r = *ptr_in1++;
    temp_i1 = *ptr_in1++;
    temp_i = *ptr_in2--;
    temp_r1 = *ptr_in2--;
    *ptr_x = ((temp_r * c) + (temp_i * s));
    ptr_x++;

    *ptr_x = ((temp_i * c) - (temp_r * s));
    ptr_x++;

    *ptr_x1 = ((temp_i1 * c1) - (temp_r1 * s1));
    ptr_x1--;

    *ptr_x1 = ((temp_r1 * c1) + (temp_i1 * s1));
    ptr_x1--;
  }
}

VOID ia_enhaacplus_enc_post_twiddle(FLOAT32 *ptr_out, FLOAT32 *ptr_x,
                                    const FLOAT32 *ptr_cos_sin_tbl, WORD m) {
  WORD i;
  FLOAT32 c, c1, s, s1;
  FLOAT32 tmp_var;
  FLOAT32 tempr, tempr1, tempi, tempi1;
  FLOAT32 *ptr_out1 = ptr_out + m - 1;
  FLOAT32 *ptr_x1 = ptr_x + m - 1;

  for (i = 0; i < (m >> 2); i++) {
    c = *ptr_cos_sin_tbl++;
    s = *ptr_cos_sin_tbl++;
    s1 = *ptr_cos_sin_tbl++;
    c1 = *ptr_cos_sin_tbl++;
    tempr = *ptr_x++;
    tempi = *ptr_x++;
    tempi1 = *ptr_x1--;
    tempr1 = *ptr_x1--;

    tmp_var = ((tempr * c) + (tempi * s));
    *ptr_out++ = tmp_var;

    tmp_var = ((tempr * s) - (tempi * c));
    *ptr_out1-- = tmp_var;

    tmp_var = ((tempr1 * c1) + (tempi1 * s1));
    *ptr_out1-- = tmp_var;

    tmp_var = ((tempr1 * s1) - (tempi1 * c1));
    *ptr_out++ = tmp_var;
  }
}

VOID ia_eaacp_enc_pre_twiddle_aac(FLOAT32 *ptr_x, FLOAT32 *ptr_data, WORD32 n,
                                  const FLOAT32 *ptr_cos_array) {
  WORD n_by_4;
  FLOAT32 *ptr_in1, *ptr_in2;

  n_by_4 = n >> 2;

  ptr_in1 = ptr_data;
  ptr_in2 = ptr_data + n - 1;

  ia_eaacp_enc_pre_twiddle_compute(ptr_in1, ptr_in2, ptr_x, ptr_cos_array, n_by_4);
}

static PLATFORM_INLINE WORD8 ia_enhaacplus_enc_calc_norm(WORD32 a) {
  WORD8 norm_val;

  if (a == 0) {
    norm_val = 31;
  } else {
    if (a == (WORD32)0xffffffffL) {
      norm_val = 31;
    } else {
      if (a < 0) {
        a = ~a;
      }
      for (norm_val = 0; a < (WORD32)0x40000000L; norm_val++) {
        a <<= 1;
      }
    }
  }

  return norm_val;
}

static PLATFORM_INLINE VOID ia_enhaacplus_enc_complex_3point_fft(FLOAT32 *ptr_in,
                                                                 FLOAT32 *ptr_out) {
  FLOAT32 add_r, sub_r;
  FLOAT32 add_i, sub_i;
  FLOAT32 x_01_r, x_01_i, temp;
  FLOAT32 p1, p2, p3, p4;
  FLOAT64 sin_mu = 0.866025403784439f;

  x_01_r = ptr_in[0] + ptr_in[2];
  x_01_i = ptr_in[1] + ptr_in[3];

  add_r = ptr_in[2] + ptr_in[4];
  add_i = ptr_in[3] + ptr_in[5];

  sub_r = ptr_in[2] - ptr_in[4];
  sub_i = ptr_in[3] - ptr_in[5];

  p1 = add_r / (FLOAT32)2.0f;
  p4 = add_i / (FLOAT32)2.0f;
  p2 = (FLOAT32)((FLOAT64)sub_i * sin_mu);
  p3 = (FLOAT32)((FLOAT64)sub_r * sin_mu);

  temp = ptr_in[0] - p1;

  ptr_out[0] = x_01_r + ptr_in[4];
  ptr_out[1] = x_01_i + ptr_in[5];
  ptr_out[2] = temp + p2;
  ptr_out[3] = (ptr_in[1] - p3) - p4;
  ptr_out[4] = temp - p2;
  ptr_out[5] = (ptr_in[1] + p3) - p4;
}

VOID ia_enhaacplus_enc_complex_fft_p2(FLOAT32 *ptr_x, WORD32 nlength,
                                      FLOAT32 *ptr_scratch_fft_p2_y) {
  WORD32 i, j, k, n_stages, h2;
  FLOAT32 x0_r, x0_i, x1_r, x1_i, x2_r, x2_i, x3_r, x3_i;
  WORD32 del, nodespacing, in_loop_cnt;
  WORD32 not_power_4;
  WORD32 dig_rev_shift;
  FLOAT32 *ptr_p2_y = ptr_scratch_fft_p2_y;
  WORD32 mpass = nlength;
  WORD32 npoints = nlength;
  FLOAT32 *ptr_y = ptr_p2_y;
  const FLOAT64 *ptr_w;
  FLOAT32 *ptr_inp;
  FLOAT32 tmk;
  const FLOAT64 *ptr_twiddles;
  FLOAT32 *ptr_data;
  FLOAT64 w_1, w_2, w_3, w_4, w_5, w_6;
  WORD32 sec_loop_cnt;
  FLOAT32 tmp;

  memset(ptr_y, 0, nlength * 2 * sizeof(*ptr_y));

  dig_rev_shift = ia_enhaacplus_enc_calc_norm(mpass) + 1 - 16;
  n_stages = 30 - ia_enhaacplus_enc_calc_norm(mpass);
  not_power_4 = n_stages & 1;

  n_stages = n_stages >> 1;

  ptr_w = ia_enhaacplus_enc_twiddle_table_fft_32x32;

  dig_rev_shift = MAX(dig_rev_shift, 0);

  for (i = 0; i < npoints; i += 4) {
    ptr_inp = ptr_x;
    DIG_REV_NEW(i, dig_rev_shift, h2);
    if (not_power_4) {
      h2 += 1;
      h2 &= ~1;
    }
    ptr_inp += (h2);

    x0_r = *ptr_inp;
    x0_i = *(ptr_inp + 1);
    ptr_inp += (npoints >> 1);

    x1_r = *ptr_inp;
    x1_i = *(ptr_inp + 1);
    ptr_inp += (npoints >> 1);

    x2_r = *ptr_inp;
    x2_i = *(ptr_inp + 1);
    ptr_inp += (npoints >> 1);

    x3_r = *ptr_inp;
    x3_i = *(ptr_inp + 1);

    x0_r = x0_r + x2_r;
    x0_i = x0_i + x2_i;

    tmk = x0_r - x2_r;
    x2_r = tmk - x2_r;
    tmk = x0_i - x2_i;
    x2_i = tmk - x2_i;

    x1_r = x1_r + x3_r;
    x1_i = x1_i + x3_i;

    tmk = x1_r - x3_r;
    x3_r = tmk - x3_r;
    tmk = x1_i - x3_i;
    x3_i = tmk - x3_i;

    x0_r = x0_r + x1_r;
    x0_i = x0_i + x1_i;

    tmk = x0_r - x1_r;
    x1_r = tmk - x1_r;
    tmk = x0_i - x1_i;
    x1_i = tmk - x1_i;

    x2_r = x2_r + x3_i;
    x2_i = x2_i - x3_r;

    tmk = x2_r - x3_i;
    x3_i = tmk - x3_i;
    tmk = x2_i + x3_r;
    x3_r = tmk + x3_r;

    *ptr_y++ = x0_r;
    *ptr_y++ = x0_i;
    *ptr_y++ = x2_r;
    *ptr_y++ = x2_i;
    *ptr_y++ = x1_r;
    *ptr_y++ = x1_i;
    *ptr_y++ = x3_i;
    *ptr_y++ = x3_r;
  }
  ptr_y -= 2 * npoints;
  del = 4;
  nodespacing = 64;
  in_loop_cnt = npoints >> 4;
  for (i = n_stages - 1; i > 0; i--) {
    ptr_twiddles = ptr_w;
    ptr_data = ptr_y;
    for (k = in_loop_cnt; k != 0; k--) {
      x0_r = (*ptr_data);
      x0_i = (*(ptr_data + 1));
      ptr_data += ((SIZE_T)del << 1);

      x1_r = (*ptr_data);
      x1_i = (*(ptr_data + 1));
      ptr_data += ((SIZE_T)del << 1);

      x2_r = (*ptr_data);
      x2_i = (*(ptr_data + 1));
      ptr_data += ((SIZE_T)del << 1);

      x3_r = (*ptr_data);
      x3_i = (*(ptr_data + 1));
      ptr_data -= 3 * (del << 1);

      x0_r = x0_r + x2_r;
      x0_i = x0_i + x2_i;
      x2_r = x0_r - (x2_r * 2);
      x2_i = x0_i - (x2_i * 2);
      x1_r = x1_r + x3_r;
      x1_i = x1_i + x3_i;
      x3_r = x1_r - (x3_r * 2);
      x3_i = x1_i - (x3_i * 2);

      x0_r = x0_r + x1_r;
      x0_i = x0_i + x1_i;
      x1_r = x0_r - (x1_r * 2);
      x1_i = x0_i - (x1_i * 2);
      x2_r = x2_r + x3_i;
      x2_i = x2_i - x3_r;
      x3_i = x2_r - (x3_i * 2);
      x3_r = x2_i + (x3_r * 2);

      *ptr_data = x0_r;
      *(ptr_data + 1) = x0_i;
      ptr_data += ((SIZE_T)del << 1);

      *ptr_data = x2_r;
      *(ptr_data + 1) = x2_i;
      ptr_data += ((SIZE_T)del << 1);

      *ptr_data = x1_r;
      *(ptr_data + 1) = x1_i;
      ptr_data += ((SIZE_T)del << 1);

      *ptr_data = x3_i;
      *(ptr_data + 1) = x3_r;
      ptr_data += ((SIZE_T)del << 1);
    }
    ptr_data = ptr_y + 2;

    sec_loop_cnt = (nodespacing * del);
    sec_loop_cnt = (sec_loop_cnt / 4) + (sec_loop_cnt / 8) - (sec_loop_cnt / 16) +
                   (sec_loop_cnt / 32) - (sec_loop_cnt / 64) + (sec_loop_cnt / 128) -
                   (sec_loop_cnt / 256);

    for (j = nodespacing; j <= sec_loop_cnt; j += nodespacing) {
      w_1 = *(ptr_twiddles + j);
      w_4 = *(ptr_twiddles + j + 257);
      w_2 = *(ptr_twiddles + ((SIZE_T)j << 1));
      w_5 = *(ptr_twiddles + ((SIZE_T)j << 1) + 257);
      w_3 = *(ptr_twiddles + j + ((SIZE_T)j << 1));
      w_6 = *(ptr_twiddles + j + ((SIZE_T)j << 1) + 257);

      for (k = in_loop_cnt; k != 0; k--) {
        ptr_data += ((SIZE_T)del << 1);

        x1_r = *ptr_data;
        x1_i = *(ptr_data + 1);
        ptr_data += ((SIZE_T)del << 1);

        x2_r = *ptr_data;
        x2_i = *(ptr_data + 1);
        ptr_data += ((SIZE_T)del << 1);

        x3_r = *ptr_data;
        x3_i = *(ptr_data + 1);
        ptr_data -= 3 * (del << 1);

        tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x1_r, w_1) - ixheaace_dmult((FLOAT64)x1_i, w_4));
        x1_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x1_r, w_4), (FLOAT64)x1_i, w_1);
        x1_r = tmp;

        tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x2_r, w_2) - ixheaace_dmult((FLOAT64)x2_i, w_5));
        x2_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x2_r, w_5), (FLOAT64)x2_i, w_2);
        x2_r = tmp;

        tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x3_r, w_3) - ixheaace_dmult((FLOAT64)x3_i, w_6));
        x3_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x3_r, w_6), (FLOAT64)x3_i, w_3);
        x3_r = tmp;

        x0_r = (*ptr_data);
        x0_i = (*(ptr_data + 1));

        x0_r = x0_r + (x2_r);
        x0_i = x0_i + (x2_i);
        x2_r = x0_r - (x2_r * 2);
        x2_i = x0_i - (x2_i * 2);
        x1_r = x1_r + x3_r;
        x1_i = x1_i + x3_i;
        x3_r = x1_r - (x3_r * 2);
        x3_i = x1_i - (x3_i * 2);

        x0_r = x0_r + (x1_r);
        x0_i = x0_i + (x1_i);
        x1_r = x0_r - (x1_r * 2);
        x1_i = x0_i - (x1_i * 2);
        x2_r = x2_r + (x3_i);
        x2_i = x2_i - (x3_r);
        x3_i = x2_r - (x3_i * 2);
        x3_r = x2_i + (x3_r * 2);

        *ptr_data = x0_r;
        *(ptr_data + 1) = x0_i;
        ptr_data += ((SIZE_T)del << 1);

        *ptr_data = x2_r;
        *(ptr_data + 1) = x2_i;
        ptr_data += ((SIZE_T)del << 1);

        *ptr_data = x1_r;
        *(ptr_data + 1) = x1_i;
        ptr_data += ((SIZE_T)del << 1);

        *ptr_data = x3_i;
        *(ptr_data + 1) = x3_r;
        ptr_data += ((SIZE_T)del << 1);
      }
      ptr_data -= 2 * npoints;
      ptr_data += 2;
    }
    for (; j <= (nodespacing * del) >> 1; j += nodespacing) {
      w_1 = *(ptr_twiddles + j);
      w_4 = *(ptr_twiddles + j + 257);
      w_2 = *(ptr_twiddles + ((SIZE_T)j << 1));
      w_5 = *(ptr_twiddles + ((SIZE_T)j << 1) + 257);
      w_3 = *(ptr_twiddles + j + ((SIZE_T)j << 1) - 256);
      w_6 = *(ptr_twiddles + j + ((SIZE_T)j << 1) + 1);

      for (k = in_loop_cnt; k != 0; k--) {
        ptr_data += ((SIZE_T)del << 1);

        x1_r = *ptr_data;
        x1_i = *(ptr_data + 1);
        ptr_data += ((SIZE_T)del << 1);

        x2_r = *ptr_data;
        x2_i = *(ptr_data + 1);
        ptr_data += ((SIZE_T)del << 1);

        x3_r = *ptr_data;
        x3_i = *(ptr_data + 1);
        ptr_data -= 3 * (del << 1);

        tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x1_r, w_1) - ixheaace_dmult((FLOAT64)x1_i, w_4));
        x1_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x1_r, w_4), (FLOAT64)x1_i, w_1);
        x1_r = tmp;

        tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x2_r, w_2) - ixheaace_dmult((FLOAT64)x2_i, w_5));
        x2_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x2_r, w_5), (FLOAT64)x2_i, w_2);
        x2_r = tmp;

        tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x3_r, w_6) + ixheaace_dmult((FLOAT64)x3_i, w_3));
        x3_i =
            (FLOAT32)(-ixheaace_dmult((FLOAT64)x3_r, w_3) + ixheaace_dmult((FLOAT64)x3_i, w_6));
        x3_r = tmp;

        x0_r = (*ptr_data);
        x0_i = (*(ptr_data + 1));

        x0_r = x0_r + (x2_r);
        x0_i = x0_i + (x2_i);
        x2_r = x0_r - (x2_r * 2);
        x2_i = x0_i - (x2_i * 2);
        x1_r = x1_r + x3_r;
        x1_i = x1_i + x3_i;
        x3_r = x1_r - (x3_r * 2);
        x3_i = x1_i - (x3_i * 2);

        x0_r = x0_r + (x1_r);
        x0_i = x0_i + (x1_i);
        x1_r = x0_r - (x1_r * 2);
        x1_i = x0_i - (x1_i * 2);
        x2_r = x2_r + (x3_i);
        x2_i = x2_i - (x3_r);
        x3_i = x2_r - (x3_i * 2);
        x3_r = x2_i + (x3_r * 2);

        *ptr_data = x0_r;
        *(ptr_data + 1) = x0_i;
        ptr_data += ((SIZE_T)del << 1);

        *ptr_data = x2_r;
        *(ptr_data + 1) = x2_i;
        ptr_data += ((SIZE_T)del << 1);

        *ptr_data = x1_r;
        *(ptr_data + 1) = x1_i;
        ptr_data += ((SIZE_T)del << 1);

        *ptr_data = x3_i;
        *(ptr_data + 1) = x3_r;
        ptr_data += ((SIZE_T)del << 1);
      }
      ptr_data -= 2 * npoints;
      ptr_data += 2;
    }
    for (; j <= sec_loop_cnt * 2; j += nodespacing) {
      w_1 = *(ptr_twiddles + j);
      w_4 = *(ptr_twiddles + j + 257);
      w_2 = *(ptr_twiddles + (SIZE_T)((j << 1) - 256));
      w_5 = *(ptr_twiddles + (SIZE_T)((j << 1) + 1));
      w_3 = *(ptr_twiddles + (SIZE_T)(j + (j << 1) - 256));
      w_6 = *(ptr_twiddles + (SIZE_T)(j + (j << 1) + 1));

      for (k = in_loop_cnt; k != 0; k--) {
        ptr_data += ((SIZE_T)del << 1);

        x1_r = *ptr_data;
        x1_i = *(ptr_data + 1);
        ptr_data += ((SIZE_T)del << 1);

        x2_r = *ptr_data;
        x2_i = *(ptr_data + 1);
        ptr_data += ((SIZE_T)del << 1);

        x3_r = *ptr_data;
        x3_i = *(ptr_data + 1);
        ptr_data -= 3 * (del << 1);

        tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x1_r, w_1) - ixheaace_dmult((FLOAT64)x1_i, w_4));
        x1_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult(x1_r, w_4), x1_i, w_1);
        x1_r = tmp;

        tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x2_r, w_5) + ixheaace_dmult((FLOAT64)x2_i, w_2));
        x2_i = (FLOAT32)(-ixheaace_dmult(x2_r, w_2) + ixheaace_dmult(x2_i, w_5));
        x2_r = tmp;

        tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x3_r, w_6) + ixheaace_dmult((FLOAT64)x3_i, w_3));
        x3_i =
            (FLOAT32)(-ixheaace_dmult((FLOAT64)x3_r, w_3) + ixheaace_dmult((FLOAT64)x3_i, w_6));
        x3_r = tmp;

        x0_r = (*ptr_data);
        x0_i = (*(ptr_data + 1));

        x0_r = x0_r + (x2_r);
        x0_i = x0_i + (x2_i);
        x2_r = x0_r - (x2_r * 2);
        x2_i = x0_i - (x2_i * 2);
        x1_r = x1_r + x3_r;
        x1_i = x1_i + x3_i;
        x3_r = x1_r - (x3_r * 2);
        x3_i = x1_i - (x3_i * 2);

        x0_r = x0_r + (x1_r);
        x0_i = x0_i + (x1_i);
        x1_r = x0_r - (x1_r * 2);
        x1_i = x0_i - (x1_i * 2);
        x2_r = x2_r + (x3_i);
        x2_i = x2_i - (x3_r);
        x3_i = x2_r - (x3_i * 2);
        x3_r = x2_i + (x3_r * 2);

        *ptr_data = x0_r;
        *(ptr_data + 1) = x0_i;
        ptr_data += ((SIZE_T)del << 1);

        *ptr_data = x2_r;
        *(ptr_data + 1) = x2_i;
        ptr_data += ((SIZE_T)del << 1);

        *ptr_data = x1_r;
        *(ptr_data + 1) = x1_i;
        ptr_data += ((SIZE_T)del << 1);

        *ptr_data = x3_i;
        *(ptr_data + 1) = x3_r;
        ptr_data += ((SIZE_T)del << 1);
      }
      ptr_data -= 2 * npoints;
      ptr_data += 2;
    }
    for (; j < nodespacing * del; j += nodespacing) {
      w_1 = *(ptr_twiddles + j);
      w_4 = *(ptr_twiddles + j + 257);
      w_2 = *(ptr_twiddles + (SIZE_T)((j << 1) - 256));
      w_5 = *(ptr_twiddles + (SIZE_T)((j << 1) + 1));
      w_3 = *(ptr_twiddles + (SIZE_T)(j + (j << 1) - 512));
      w_6 = *(ptr_twiddles + (SIZE_T)(j + (j << 1) - 512 + 257));

      for (k = in_loop_cnt; k != 0; k--) {
        ptr_data += ((SIZE_T)del << 1);

        x1_r = *ptr_data;
        x1_i = *(ptr_data + 1);
        ptr_data += ((SIZE_T)del << 1);

        x2_r = *ptr_data;
        x2_i = *(ptr_data + 1);
        ptr_data += ((SIZE_T)del << 1);

        x3_r = *ptr_data;
        x3_i = *(ptr_data + 1);
        ptr_data -= 3 * (del << 1);

        tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x1_r, w_1) - ixheaace_dmult((FLOAT64)x1_i, w_4));
        x1_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x1_r, w_4), (FLOAT64)x1_i, w_1);
        x1_r = tmp;

        tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x2_r, w_5) + ixheaace_dmult((FLOAT64)x2_i, w_2));
        x2_i =
            (FLOAT32)(-ixheaace_dmult((FLOAT64)x2_r, w_2) + ixheaace_dmult((FLOAT64)x2_i, w_5));
        x2_r = tmp;

        tmp = (FLOAT32)(-ixheaace_dmult((FLOAT64)x3_r, w_3) + ixheaace_dmult((FLOAT64)x3_i, w_6));
        x3_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x3_r, w_6), (FLOAT64)x3_i, w_3);
        x3_r = tmp;

        x0_r = (*ptr_data);
        x0_i = (*(ptr_data + 1));

        x0_r = x0_r + (x2_r);
        x0_i = x0_i + (x2_i);
        x2_r = x0_r - (x2_r * 2);
        x2_i = x0_i - (x2_i * 2);
        x1_r = x1_r + x3_r;
        x1_i = x1_i - x3_i;
        x3_r = x1_r - (x3_r * 2);
        x3_i = x1_i + (x3_i * 2);

        x0_r = x0_r + (x1_r);
        x0_i = x0_i + (x1_i);
        x1_r = x0_r - (x1_r * 2);
        x1_i = x0_i - (x1_i * 2);
        x2_r = x2_r + (x3_i);
        x2_i = x2_i - (x3_r);
        x3_i = x2_r - (x3_i * 2);
        x3_r = x2_i + (x3_r * 2);

        *ptr_data = x0_r;
        *(ptr_data + 1) = x0_i;
        ptr_data += ((SIZE_T)del << 1);

        *ptr_data = x2_r;
        *(ptr_data + 1) = x2_i;
        ptr_data += ((SIZE_T)del << 1);

        *ptr_data = x1_r;
        *(ptr_data + 1) = x1_i;
        ptr_data += ((SIZE_T)del << 1);

        *ptr_data = x3_i;
        *(ptr_data + 1) = x3_r;
        ptr_data += ((SIZE_T)del << 1);
      }
      ptr_data -= 2 * npoints;
      ptr_data += 2;
    }
    nodespacing >>= 2;
    del <<= 2;
    in_loop_cnt >>= 2;
  }
  if (not_power_4) {
    ptr_twiddles = ptr_w;
    nodespacing <<= 1;

    for (j = del / 2; j != 0; j--) {
      w_1 = *ptr_twiddles;
      w_4 = *(ptr_twiddles + 257);
      ptr_twiddles += nodespacing;

      x0_r = *ptr_y;
      x0_i = *(ptr_y + 1);
      ptr_y += ((SIZE_T)del << 1);

      x1_r = *ptr_y;
      x1_i = *(ptr_y + 1);

      tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x1_r, w_1) - ixheaace_dmult((FLOAT64)x1_i, w_4));
      x1_i = (FLOAT32)ixheaace_dmac(ixheaace_dmult((FLOAT64)x1_r, w_4), (FLOAT64)x1_i, w_1);
      x1_r = tmp;

      *ptr_y = (x0_r) - (x1_r);
      *(ptr_y + 1) = (x0_i) - (x1_i);
      ptr_y -= ((SIZE_T)del << 1);

      *ptr_y = (x0_r) + (x1_r);
      *(ptr_y + 1) = (x0_i) + (x1_i);
      ptr_y += 2;
    }
    ptr_twiddles = ptr_w;
    for (j = del / 2; j != 0; j--) {
      w_1 = *ptr_twiddles;
      w_4 = *(ptr_twiddles + 257);
      ptr_twiddles += nodespacing;

      x0_r = *ptr_y;
      x0_i = *(ptr_y + 1);
      ptr_y += ((SIZE_T)del << 1);

      x1_r = *ptr_y;
      x1_i = *(ptr_y + 1);

      tmp = (FLOAT32)(ixheaace_dmult((FLOAT64)x1_r, w_4) +
                      ixheaace_dmult((FLOAT64)x1_i, w_1)) /*/2*/;
      x1_i = (FLOAT32)(-ixheaace_dmult((FLOAT64)x1_r, w_1) +
                       ixheaace_dmult((FLOAT64)x1_i, w_4)) /*/2*/;
      x1_r = tmp;

      *ptr_y = (x0_r) - (x1_r);
      *(ptr_y + 1) = (x0_i) - (x1_i);
      ptr_y -= ((SIZE_T)del << 1);

      *ptr_y = (x0_r) + (x1_r);
      *(ptr_y + 1) = (x0_i) + (x1_i);
      ptr_y += 2;
    }
  }

  for (i = 0; i < nlength; i++) {
    *(ptr_x + 2 * i) = ptr_p2_y[2 * i];
    *(ptr_x + 2 * i + 1) = ptr_p2_y[2 * i + 1];
  }
}

static VOID ia_enhaacplus_enc_complex_fft_p3(FLOAT32 *ptr_data, WORD32 nlength,
                                             ixheaace_scratch_mem *pstr_scratch) {
  WORD32 i, j;
  FLOAT32 *ptr_data_3 = pstr_scratch->p_fft_p3_data_3;
  FLOAT32 *ptr_p3_y = pstr_scratch->p_fft_p3_y;
  WORD32 cnfac;
  WORD32 mpass = nlength;
  FLOAT32 *ptr_x = ptr_data;
  FLOAT32 *ptr_y = ptr_p3_y;
  cnfac = 0;
  const FLOAT64 *ptr_w1_r, *ptr_w1_i;
  FLOAT32 tmp;
  ptr_w1_r = ia_enhaacplus_enc_twiddle_table_3pr;
  ptr_w1_i = ia_enhaacplus_enc_twiddle_table_3pi;

  while (mpass % 3 == 0) {
    mpass /= 3;
    cnfac++;
  }

  for (i = 0; i < 3 * cnfac; i++) {
    for (j = 0; j < mpass; j++) {
      ptr_data_3[2 * j] = ptr_data[3 * (2 * j) + (2 * i)];
      ptr_data_3[2 * j + 1] = ptr_data[3 * (2 * j) + 1 + (2 * i)];
    }
    ia_enhaacplus_enc_complex_fft_p2(ptr_data_3, mpass, pstr_scratch->p_fft_p2_y);

    for (j = 0; j < mpass; j++) {
      ptr_data[3 * (2 * j) + (2 * i)] = ptr_data_3[2 * j];
      ptr_data[3 * (2 * j) + 1 + (2 * i)] = ptr_data_3[2 * j + 1];
    }
  }

  {
    for (i = 0; i < nlength; i += 3) {
      tmp = (FLOAT32)((FLOAT64)ptr_data[2 * i] * (*ptr_w1_r) -
                      (FLOAT64)ptr_data[2 * i + 1] * (*ptr_w1_i));
      ptr_data[2 * i + 1] = (FLOAT32)((FLOAT64)ptr_data[2 * i] * (*ptr_w1_i) +
                                      (FLOAT64)ptr_data[2 * i + 1] * (*ptr_w1_r));
      ptr_data[2 * i] = tmp;

      ptr_w1_r++;
      ptr_w1_i++;

      tmp = (FLOAT32)((FLOAT64)ptr_data[2 * (i + 1)] * (*ptr_w1_r) -
                      (FLOAT64)ptr_data[2 * (i + 1) + 1] * (*ptr_w1_i));
      ptr_data[2 * (i + 1) + 1] = (FLOAT32)((FLOAT64)ptr_data[2 * (i + 1)] * (*ptr_w1_i) +
                                            (FLOAT64)ptr_data[2 * (i + 1) + 1] * (*ptr_w1_r));
      ptr_data[2 * (i + 1)] = tmp;

      ptr_w1_r++;
      ptr_w1_i++;

      tmp = (FLOAT32)((FLOAT64)ptr_data[2 * (i + 2)] * (*ptr_w1_r) -
                      (FLOAT64)ptr_data[2 * (i + 2) + 1] * (*ptr_w1_i));
      ptr_data[2 * (i + 2) + 1] = (FLOAT32)((FLOAT64)ptr_data[2 * (i + 2)] * (*ptr_w1_i) +
                                            (FLOAT64)ptr_data[2 * (i + 2) + 1] * (*ptr_w1_r));
      ptr_data[2 * (i + 2)] = tmp;

      ptr_w1_r += 3 * (128 / mpass - 1) + 1;
      ptr_w1_i += 3 * (128 / mpass - 1) + 1;
    }
  }

  for (i = 0; i < mpass; i++) {
    ia_enhaacplus_enc_complex_3point_fft(ptr_x, ptr_y);

    ptr_x = ptr_x + 6;
    ptr_y = ptr_y + 6;
  }

  for (i = 0; i < mpass; i++) {
    ptr_data[2 * i] = ptr_p3_y[6 * i];
    ptr_data[2 * i + 1] = ptr_p3_y[6 * i + 1];
  }

  for (i = 0; i < mpass; i++) {
    ptr_data[2 * (i + mpass)] = ptr_p3_y[6 * i + 2];
    ptr_data[2 * (i + mpass) + 1] = ptr_p3_y[6 * i + 3];
  }

  for (i = 0; i < mpass; i++) {
    ptr_data[2 * (i + 2 * mpass)] = ptr_p3_y[6 * i + 4];
    ptr_data[2 * (i + 2 * mpass) + 1] = ptr_p3_y[6 * i + 5];
  }
}

VOID ia_enhaacplus_enc_complex_fft(FLOAT32 *ptr_data, WORD32 len,
                                   ixheaace_scratch_mem *pstr_scratch) {
  if (len & (len - 1)) {
    ia_enhaacplus_enc_complex_fft_p3(ptr_data, len, pstr_scratch);
  } else {
    ia_enhaacplus_enc_complex_fft_p2(ptr_data, len, pstr_scratch->p_fft_p2_y);
  }
}

static VOID ixheaace_post_mdct(FLOAT32 *ptr_x, WORD32 m, const FLOAT32 *ptr_trig_data,
                               WORD32 step, WORD32 trig_data_size) {
  WORD32 i;
  FLOAT32 w_re, w_im, re1, re2, im1, im2;
  const FLOAT32 *ptr_sin = ptr_trig_data;
  const FLOAT32 *ptr_cos = ptr_trig_data + trig_data_size;

  w_im = *ptr_sin;
  w_re = *ptr_cos;

  for (i = 0; i < m / 4; i++) {
    re1 = ptr_x[2 * i];
    im1 = ptr_x[2 * i + 1];
    re2 = ptr_x[m - 2 - 2 * i];
    im2 = ptr_x[m - 1 - 2 * i];

    ptr_x[2 * i] = (re1 * w_re + im1 * w_im);

    ptr_x[m - 1 - 2 * i] = (re1 * w_im - im1 * w_re);

    ptr_sin += step;
    ptr_cos -= step;

    w_im = *ptr_sin;
    w_re = *ptr_cos;

    ptr_x[m - 2 - 2 * i] = (re2 * w_im + im2 * w_re);

    ptr_x[2 * i + 1] = (re2 * w_re - im2 * w_im);
  }
}

static VOID ixheaace_cplx_mult_twid(FLOAT32 *ptr_re, FLOAT32 *ptr_im, FLOAT32 a, FLOAT32 b,
                                    FLOAT32 twid_table, FLOAT32 twid_table_h) {
  *ptr_re = (a * twid_table) - (b * twid_table_h);
  *ptr_im = (a * twid_table_h) + (b * twid_table);
}

static VOID ixheaace_cfft_15_twiddle(FLOAT32 *ptr_inp) {
  const FLOAT32 *ptr_tw_flt = &ixheaace_mix_rad_twid_tbl[0];
  const FLOAT32 *ptr_tw_flt_h = &ixheaace_mix_rad_twid_tbl_h[0];
  FLOAT32 accu1, accu2;
  WORD32 i, j;
  ptr_inp += 12;

  for (j = 0; j < 2; j++) {
    for (i = 0; i < 4; i++) {
      ixheaace_cplx_mult_twid(&accu1, &accu2, ptr_inp[2 * i + 0], ptr_inp[2 * i + 1],
                              ptr_tw_flt[i], ptr_tw_flt_h[i]);
      ptr_inp[2 * i + 0] = accu1;
      ptr_inp[2 * i + 1] = accu2;
    }
    ptr_inp += 10;
    ptr_tw_flt += 4;
    ptr_tw_flt_h += 4;
  }
}

static VOID ixheaace_cfft_15_480(FLOAT32 *ptr_inp, FLOAT32 *ptr_op, FLOAT32 *ptr_fft3_out) {
  WORD32 i, idx;
  FLOAT32 *ptr_buf1, *ptr_buf2, *ptr_buf3;
  FLOAT32 add_r, sub_r;
  FLOAT32 add_i, sub_i;
  FLOAT32 x_01_r, x_01_i, temp;
  FLOAT32 p1, p2, p3, p4;

  FLOAT32 sin_mu_flt = 0.866027832f;
  FLOAT32 c51_flt = 0.951049805f;
  FLOAT32 c52_flt = -0.76940918f;
  FLOAT32 c53_flt = -0.36328125f;
  FLOAT32 c54_flt = 0.559020996f;
  FLOAT32 c55_flt = -0.625f;

  FLOAT32 r1, r2, r3, r4;
  FLOAT32 s1, s2, s3, s4, t, temp1, temp2;
  FLOAT32 *ptr_out_fft3 = ptr_fft3_out;

  FLOAT32 xr_0, xr_1, xr_2;
  FLOAT32 xi_0, xi_1, xi_2;

  ptr_buf2 = ptr_fft3_out;
  ptr_buf1 = ptr_buf3 = ptr_fft3_out;

  for (i = 0; i < FFT3; i++) {
    *ptr_buf1++ = ptr_inp[0 + 64 * i];
    *ptr_buf1++ = ptr_inp[1 + 64 * i];

    *ptr_buf1++ = ptr_inp[192 + 64 * i];
    *ptr_buf1++ = ptr_inp[193 + 64 * i];

    *ptr_buf1++ = ptr_inp[384 + 64 * i];
    *ptr_buf1++ = ptr_inp[385 + 64 * i];

    *ptr_buf1++ = ptr_inp[576 + 64 * i];
    *ptr_buf1++ = ptr_inp[577 + 64 * i];

    *ptr_buf1++ = ptr_inp[768 + 64 * i];
    *ptr_buf1++ = ptr_inp[769 + 64 * i];

    r1 = ptr_buf3[2] + ptr_buf3[8];
    r4 = ptr_buf3[2] - ptr_buf3[8];
    r3 = ptr_buf3[4] + ptr_buf3[6];
    r2 = ptr_buf3[4] - ptr_buf3[6];
    t = ((r1 - r3) * c54_flt);

    r1 = r1 + r3;

    temp1 = ptr_buf3[0] + r1;

    r1 = temp1 + ((r1 * c55_flt) * 2);

    r3 = r1 - t;
    r1 = r1 + t;

    t = ((r4 + r2) * c51_flt);
    r4 = t + ((r4 * c52_flt) * 2);
    r2 = t + (r2 * c53_flt);

    s1 = ptr_buf3[3] + ptr_buf3[9];
    s4 = ptr_buf3[3] - ptr_buf3[9];
    s3 = ptr_buf3[5] + ptr_buf3[7];
    s2 = ptr_buf3[5] - ptr_buf3[7];

    t = ((s1 - s3) * c54_flt);

    s1 = s1 + s3;

    temp2 = ptr_buf3[1] + s1;

    s1 = temp2 + (((s1 * c55_flt)) * 2);

    s3 = s1 - t;
    s1 = s1 + t;

    t = ((s4 + s2) * c51_flt);
    s4 = t + (((s4 * c52_flt)) * 2);
    s2 = t + ((s2 * c53_flt));

    *ptr_buf2++ = temp1;
    *ptr_buf2++ = temp2;
    *ptr_buf2++ = r1 + s2;
    *ptr_buf2++ = s1 - r2;
    *ptr_buf2++ = r3 - s4;
    *ptr_buf2++ = s3 + r4;
    *ptr_buf2++ = r3 + s4;
    *ptr_buf2++ = s3 - r4;
    *ptr_buf2++ = r1 - s2;
    *ptr_buf2++ = s1 + r2;
    ptr_buf3 = ptr_buf1;
  }

  idx = 0;
  ixheaace_cfft_15_twiddle(ptr_out_fft3);

  for (i = 0; i < FFT5; i++) {
    xr_0 = ptr_out_fft3[0];
    xi_0 = ptr_out_fft3[1];

    xr_1 = ptr_out_fft3[10];
    xi_1 = ptr_out_fft3[11];

    xr_2 = ptr_out_fft3[20];
    xi_2 = ptr_out_fft3[21];

    x_01_r = (xr_0 + xr_1);
    x_01_i = (xi_0 + xi_1);

    add_r = (xr_1 + xr_2);
    add_i = (xi_1 + xi_2);

    sub_r = (xr_1 - xr_2);
    sub_i = (xi_1 - xi_2);

    p1 = add_r / 2;

    p2 = (sub_i * sin_mu_flt);
    p3 = (sub_r * sin_mu_flt);

    p4 = add_i / 2;

    temp = (xr_0 - p1);
    temp1 = (xi_0 + p3);
    temp2 = (xi_0 - p3);

    ptr_op[idx] = (x_01_r + xr_2);
    ptr_op[idx + 1] = (x_01_i + xi_2);

    idx = idx + 320;
    ptr_op[idx] = (temp + p2);
    ptr_op[idx + 1] = (temp2 - p4);

    idx = idx + 320;
    ptr_op[idx] = (temp - p2);
    ptr_op[idx + 1] = (temp1 - p4);
    ptr_out_fft3 += 2;
    idx = idx - 576;
  }
}

static VOID ixheaace_cfft_twiddle_mult(FLOAT32 *ptr_inp, FLOAT32 *ptr_op, WORD32 dim1,
                                       WORD32 dim2, const FLOAT32 *ptr_tw_flt,
                                       const FLOAT32 *ptr_tw_h_flt) {
  FLOAT32 accu1, accu2;
  WORD32 i, j;
  WORD32 step_val = (dim2 - 1) << 1;
  for (i = 0; i < dim2; i++) {
    ptr_op[0] = ptr_inp[0];
    ptr_op[1] = ptr_inp[1];
    ptr_op += 2;
    ptr_inp += 2;
  }

  for (j = 0; j < (dim1 - 1); j++) {
    ptr_op[0] = ptr_inp[0];
    ptr_op[1] = ptr_inp[1];
    ptr_inp += 2;
    ptr_op += 2;
    for (i = 0; i < (dim2 - 1); i++) {
      ixheaace_cplx_mult_twid(&accu1, &accu2, ptr_inp[2 * i + 0], ptr_inp[2 * i + 1],
                              ptr_tw_flt[i], ptr_tw_h_flt[i]);
      ptr_op[2 * i + 0] = accu1;
      ptr_op[2 * i + 1] = accu2;
    }
    ptr_inp += step_val;
    ptr_op += step_val;
    ptr_tw_flt += (dim2 - 1);
    ptr_tw_h_flt += (dim2 - 1);
  }
}

static VOID ixheaace_cfft_32_480(FLOAT32 *ptr_in, FLOAT32 *ptr_out) {
  WORD32 i, l1, l2, h2;
  FLOAT32 xh0_0, xh1_0, xl0_0, xl1_0;
  FLOAT32 xh0_1, xh1_1, xl0_1, xl1_1;
  FLOAT32 x_0, x_1, x_2, x_3;
  FLOAT32 x_4, x_5, x_6, x_7;
  FLOAT32 *ptr_x;
  FLOAT32 *ptr_y;
  FLOAT32 interm_y[FFT32X2];
  FLOAT32 n00, n10, n20, n30, n01, n11, n21, n31;

  FLOAT32 inp_0qi, inp_0qr;
  FLOAT32 inp_1qi, inp_1qr;
  FLOAT32 inp_2qi, inp_2qr;
  FLOAT32 inp_3qi, inp_3qr;
  FLOAT32 mul_0qi, mul_0qr;
  FLOAT32 mul_1qi, mul_1qr;
  FLOAT32 mul_2qi, mul_2qr;
  FLOAT32 mul_3qi, mul_3qr;
  FLOAT32 sum_0qi, sum_0qr;
  FLOAT32 sum_1qi, sum_1qr;
  FLOAT32 sum_2qi, sum_2qr;
  FLOAT32 sum_3qi, sum_3qr;
  WORD32 idx1 = 0, idx2 = FFT15 * FFT32;
  FLOAT32 mul_i, mul_r;

  ptr_x = ptr_in;

  // This computes first and second stage butterflies. So, 4-point FFT is done.
  for (i = 0; i < 8; i++) {
    x_0 = ptr_x[0];
    x_1 = ptr_x[1];
    x_2 = ptr_x[16];
    x_3 = ptr_x[16 + 1];
    x_4 = ptr_x[32];
    x_5 = ptr_x[32 + 1];
    x_6 = ptr_x[48];
    x_7 = ptr_x[48 + 1];

    xh0_0 = x_0 + x_4;
    xh1_0 = x_1 + x_5;
    xl0_0 = x_0 - x_4;
    xl1_0 = x_1 - x_5;
    xh0_1 = x_2 + x_6;
    xh1_1 = x_3 + x_7;
    xl0_1 = x_2 - x_6;
    xl1_1 = x_3 - x_7;

    n00 = xh0_0 + xh0_1;
    n01 = xh1_0 + xh1_1;
    n10 = xl0_0 + xl1_1;
    n11 = xl1_0 - xl0_1;
    n20 = xh0_0 - xh0_1;
    n21 = xh1_0 - xh1_1;
    n30 = xl0_0 - xl1_1;
    n31 = xl1_0 + xl0_1;

    ptr_x[0] = n00;
    ptr_x[1] = n01;
    ptr_x[16] = n10;
    ptr_x[16 + 1] = n11;
    ptr_x[32] = n20;
    ptr_x[32 + 1] = n21;
    ptr_x[48] = n30;
    ptr_x[48 + 1] = n31;

    ptr_x += 2;
  }

  // This computes third and fourth stage butterflies. So, next 4-point FFT is done.
  {
    h2 = 16 >> 1;
    l1 = 16;
    l2 = 16 + (16 >> 1);

    ptr_x = ptr_in;
    ptr_y = &interm_y[0];

    /* Butter fly summation in 2 steps */
    inp_0qr = ptr_x[0];
    inp_0qi = ptr_x[1];
    inp_1qr = ptr_x[4];
    inp_1qi = ptr_x[5];
    inp_2qr = ptr_x[8];
    inp_2qi = ptr_x[9];
    inp_3qr = ptr_x[12];
    inp_3qi = ptr_x[13];

    mul_0qr = inp_0qr;
    mul_0qi = inp_0qi;
    mul_1qr = inp_1qr;
    mul_1qi = inp_1qi;
    mul_2qr = inp_2qr;
    mul_2qi = inp_2qi;
    mul_3qr = inp_3qr;
    mul_3qi = inp_3qi;

    sum_0qr = mul_0qr + mul_2qr;
    sum_0qi = mul_0qi + mul_2qi;
    sum_1qr = mul_0qr - mul_2qr;
    sum_1qi = mul_0qi - mul_2qi;
    sum_2qr = mul_1qr + mul_3qr;
    sum_2qi = mul_1qi + mul_3qi;
    sum_3qr = mul_1qr - mul_3qr;
    sum_3qi = mul_1qi - mul_3qi;

    ptr_y[0] = sum_0qr + sum_2qr;
    ptr_y[1] = sum_0qi + sum_2qi;
    ptr_y[h2] = sum_1qr + sum_3qi;
    ptr_y[h2 + 1] = sum_1qi - sum_3qr;
    ptr_y[l1] = sum_0qr - sum_2qr;
    ptr_y[l1 + 1] = sum_0qi - sum_2qi;
    ptr_y[l2] = sum_1qr - sum_3qi;
    ptr_y[l2 + 1] = sum_1qi + sum_3qr;

    ptr_y += 2;
    ptr_x += 16;

    /* 2nd butter fly */

    inp_0qr = ptr_x[0];
    inp_0qi = ptr_x[1];
    inp_1qr = ptr_x[4];
    inp_1qi = ptr_x[5];
    inp_2qr = ptr_x[8];
    inp_2qi = ptr_x[9];
    inp_3qr = ptr_x[12];
    inp_3qi = ptr_x[13];

    mul_0qr = inp_0qr;
    mul_0qi = inp_0qi;

    mul_1qr = (inp_1qr * 0.461929321f) + (inp_1qi * 0.191329956f);
    mul_1qi = (inp_1qr * -0.191329956f) + (inp_1qi * 0.461929321f);

    mul_2qr = ((inp_2qr + inp_2qi) * 0.353546143f);
    mul_2qi = ((-inp_2qr + inp_2qi) * 0.353546143f);

    mul_3qr = (inp_3qr * 0.191329956f) + (inp_3qi * 0.461929321f);
    mul_3qi = (inp_3qr * -0.461929321f) + (inp_3qi * 0.191329956f);

    sum_0qr = mul_0qr + (mul_2qr * 2);
    sum_0qi = mul_0qi + (mul_2qi * 2);
    sum_1qr = mul_0qr - (mul_2qr * 2);
    sum_1qi = mul_0qi - (mul_2qi * 2);

    sum_2qr = mul_1qr + mul_3qr;
    sum_2qi = mul_1qi + mul_3qi;
    sum_3qr = mul_1qr - mul_3qr;
    sum_3qi = mul_1qi - mul_3qi;

    ptr_y[0] = sum_0qr + (sum_2qr * 2);
    ptr_y[1] = sum_0qi + (sum_2qi * 2);
    ptr_y[h2] = sum_1qr + (sum_3qi * 2);
    ptr_y[h2 + 1] = sum_1qi - (sum_3qr * 2);
    ptr_y[l1] = sum_0qr - (sum_2qr * 2);
    ptr_y[l1 + 1] = sum_0qi - (sum_2qi * 2);
    ptr_y[l2] = sum_1qr - (sum_3qi * 2);
    ptr_y[l2 + 1] = sum_1qi + (sum_3qr * 2);

    ptr_y += 2;
    ptr_x += 16;

    /* 3rd butter fly */

    inp_0qr = ptr_x[0];
    inp_0qi = ptr_x[1];
    inp_1qr = ptr_x[4];
    inp_1qi = ptr_x[5];
    inp_2qr = ptr_x[8];
    inp_2qi = ptr_x[9];
    inp_3qr = ptr_x[12];
    inp_3qi = ptr_x[13];

    mul_0qr = inp_0qr;
    mul_0qi = inp_0qi;

    mul_1qr = ((inp_1qr + inp_1qi) * 0.353546143f);
    mul_1qi = ((-inp_1qr + inp_1qi) * 0.353546143f);

    mul_2qr = inp_2qi;
    mul_2qi = inp_2qr;

    mul_3qr = ((-inp_3qr + inp_3qi) * 0.353546143f);
    mul_3qi = ((inp_3qr + inp_3qi) * -0.353546143f);

    sum_0qr = mul_0qr + mul_2qr;
    sum_0qi = mul_0qi - mul_2qi;
    sum_1qr = mul_0qr - mul_2qr;
    sum_1qi = mul_0qi + mul_2qi;
    sum_2qr = mul_1qr + mul_3qr;
    sum_2qi = mul_1qi + mul_3qi;
    sum_3qr = mul_1qr - mul_3qr;
    sum_3qi = mul_1qi - mul_3qi;

    ptr_y[0] = sum_0qr + (sum_2qr * 2);
    ptr_y[1] = sum_0qi + (sum_2qi * 2);
    ptr_y[h2] = sum_1qr + (sum_3qi * 2);
    ptr_y[h2 + 1] = sum_1qi - (sum_3qr * 2);
    ptr_y[l1] = sum_0qr - (sum_2qr * 2);
    ptr_y[l1 + 1] = sum_0qi - (sum_2qi * 2);
    ptr_y[l2] = sum_1qr - (sum_3qi * 2);
    ptr_y[l2 + 1] = sum_1qi + (sum_3qr * 2);

    ptr_y += 2;
    ptr_x += 16;

    /* 4th butter fly */

    inp_0qr = ptr_x[0];
    inp_0qi = ptr_x[1];
    inp_1qr = ptr_x[4];
    inp_1qi = ptr_x[5];
    inp_2qr = ptr_x[8];
    inp_2qi = ptr_x[9];
    inp_3qr = ptr_x[12];
    inp_3qi = ptr_x[13];

    mul_0qr = inp_0qr;
    mul_0qi = inp_0qi;

    mul_1qr = (inp_1qr * 0.191329956f) + (inp_1qi * 0.461929321f);
    mul_1qi = (inp_1qr * -0.461929321f) + (inp_1qi * 0.191329956f);

    mul_2qr = ((-inp_2qr + inp_2qi) * 0.353546143f);
    mul_2qi = ((inp_2qr + inp_2qi) * -0.353546143f);

    mul_3qr = (inp_3qr * -0.461929321f) + (inp_3qi * -0.191329956f);
    mul_3qi = (inp_3qr * 0.191329956f) + (inp_3qi * -0.461929321f);

    sum_0qr = mul_0qr + (mul_2qr * 2);
    sum_0qi = mul_0qi + (mul_2qi * 2);
    sum_1qr = mul_0qr - (mul_2qr * 2);
    sum_1qi = mul_0qi - (mul_2qi * 2);

    sum_2qr = mul_1qr + mul_3qr;
    sum_2qi = mul_1qi + mul_3qi;
    sum_3qr = mul_1qr - mul_3qr;
    sum_3qi = mul_1qi - mul_3qi;

    ptr_y[0] = sum_0qr + (sum_2qr * 2);
    ptr_y[1] = sum_0qi + (sum_2qi * 2);
    ptr_y[h2] = sum_1qr + (sum_3qi * 2);
    ptr_y[h2 + 1] = sum_1qi - (sum_3qr * 2);
    ptr_y[l1] = sum_0qr - (sum_2qr * 2);
    ptr_y[l1 + 1] = sum_0qi - (sum_2qi * 2);
    ptr_y[l2] = sum_1qr - (sum_3qi * 2);
    ptr_y[l2 + 1] = sum_1qi + (sum_3qr * 2);

    ptr_x = ptr_in;
    ptr_y = &interm_y[32];

    /* Butter fly summation in 2 steps */
    inp_0qr = ptr_x[2];
    inp_0qi = ptr_x[3];
    inp_1qr = ptr_x[6];
    inp_1qi = ptr_x[7];
    inp_2qr = ptr_x[10];
    inp_2qi = ptr_x[11];
    inp_3qr = ptr_x[14];
    inp_3qi = ptr_x[15];

    mul_0qr = inp_0qr;
    mul_0qi = inp_0qi;
    mul_1qr = inp_1qr;
    mul_1qi = inp_1qi;
    mul_2qr = inp_2qr;
    mul_2qi = inp_2qi;
    mul_3qr = inp_3qr;
    mul_3qi = inp_3qi;

    sum_0qr = mul_0qr + mul_2qr;
    sum_0qi = mul_0qi + mul_2qi;
    sum_1qr = mul_0qr - mul_2qr;
    sum_1qi = mul_0qi - mul_2qi;
    sum_2qr = mul_1qr + mul_3qr;
    sum_2qi = mul_1qi + mul_3qi;
    sum_3qr = mul_1qr - mul_3qr;
    sum_3qi = mul_1qi - mul_3qi;

    ptr_y[0] = sum_0qr + sum_2qr;
    ptr_y[1] = sum_0qi + sum_2qi;
    ptr_y[h2] = sum_1qr + sum_3qi;
    ptr_y[h2 + 1] = sum_1qi - sum_3qr;
    ptr_y[l1] = sum_0qr - sum_2qr;
    ptr_y[l1 + 1] = sum_0qi - sum_2qi;
    ptr_y[l2] = sum_1qr - sum_3qi;
    ptr_y[l2 + 1] = sum_1qi + sum_3qr;

    ptr_y += 2;
    ptr_x += 16;

    /* 2nd butter fly */

    inp_0qr = ptr_x[2];
    inp_0qi = ptr_x[3];
    inp_1qr = ptr_x[6];
    inp_1qi = ptr_x[7];
    inp_2qr = ptr_x[10];
    inp_2qi = ptr_x[11];
    inp_3qr = ptr_x[14];
    inp_3qi = ptr_x[15];

    mul_0qr = inp_0qr;
    mul_0qi = inp_0qi;

    mul_1qr = (inp_1qr * 0.461929321f) + (inp_1qi * 0.191329956f);
    mul_1qi = (inp_1qr * -0.191329956f) + (inp_1qi * 0.461929321f);

    mul_2qr = ((inp_2qr + inp_2qi) * 0.353546143f);
    mul_2qi = ((-inp_2qr + inp_2qi) * 0.353546143f);

    mul_3qr = (inp_3qr * 0.191329956f) + (inp_3qi * 0.461929321f);
    mul_3qi = (inp_3qr * -0.461929321f) + (inp_3qi * 0.191329956f);

    sum_0qr = mul_0qr + (mul_2qr * 2);
    sum_0qi = mul_0qi + (mul_2qi * 2);
    sum_1qr = mul_0qr - (mul_2qr * 2);
    sum_1qi = mul_0qi - (mul_2qi * 2);

    sum_2qr = mul_1qr + mul_3qr;
    sum_2qi = mul_1qi + mul_3qi;
    sum_3qr = mul_1qr - mul_3qr;
    sum_3qi = mul_1qi - mul_3qi;

    ptr_y[0] = sum_0qr + (sum_2qr * 2);
    ptr_y[1] = sum_0qi + (sum_2qi * 2);
    ptr_y[h2] = sum_1qr + (sum_3qi * 2);
    ptr_y[h2 + 1] = sum_1qi - (sum_3qr * 2);
    ptr_y[l1] = sum_0qr - (sum_2qr * 2);
    ptr_y[l1 + 1] = sum_0qi - (sum_2qi * 2);
    ptr_y[l2] = sum_1qr - (sum_3qi * 2);
    ptr_y[l2 + 1] = sum_1qi + (sum_3qr * 2);

    ptr_y += 2;
    ptr_x += 16;

    /* 3rd butter fly */

    inp_0qr = ptr_x[2];
    inp_0qi = ptr_x[3];
    inp_1qr = ptr_x[6];
    inp_1qi = ptr_x[7];
    inp_2qr = ptr_x[10];
    inp_2qi = ptr_x[11];
    inp_3qr = ptr_x[14];
    inp_3qi = ptr_x[15];

    mul_0qr = inp_0qr;
    mul_0qi = inp_0qi;

    mul_1qr = ((inp_1qr + inp_1qi) * 0.353546143f);
    mul_1qi = ((-inp_1qr + inp_1qi) * 0.353546143f);

    mul_2qr = inp_2qi;
    mul_2qi = inp_2qr;

    mul_3qr = ((-inp_3qr + inp_3qi) * 0.353546143f);
    mul_3qi = ((inp_3qr + inp_3qi) * -0.353546143f);

    sum_0qr = mul_0qr + mul_2qr;
    sum_0qi = mul_0qi - mul_2qi;
    sum_1qr = mul_0qr - mul_2qr;
    sum_1qi = mul_0qi + mul_2qi;
    sum_2qr = mul_1qr + mul_3qr;
    sum_2qi = mul_1qi + mul_3qi;
    sum_3qr = mul_1qr - mul_3qr;
    sum_3qi = mul_1qi - mul_3qi;

    ptr_y[0] = sum_0qr + (sum_2qr * 2);
    ptr_y[1] = sum_0qi + (sum_2qi * 2);
    ptr_y[h2] = sum_1qr + (sum_3qi * 2);
    ptr_y[h2 + 1] = sum_1qi - (sum_3qr * 2);
    ptr_y[l1] = sum_0qr - (sum_2qr * 2);
    ptr_y[l1 + 1] = sum_0qi - (sum_2qi * 2);
    ptr_y[l2] = sum_1qr - (sum_3qi * 2);
    ptr_y[l2 + 1] = sum_1qi + (sum_3qr * 2);

    ptr_y += 2;
    ptr_x += 16;

    /* 4th butter fly */

    inp_0qr = ptr_x[2];
    inp_0qi = ptr_x[3];
    inp_1qr = ptr_x[6];
    inp_1qi = ptr_x[7];
    inp_2qr = ptr_x[10];
    inp_2qi = ptr_x[11];
    inp_3qr = ptr_x[14];
    inp_3qi = ptr_x[15];

    mul_0qr = inp_0qr;
    mul_0qi = inp_0qi;

    mul_1qr = (inp_1qr * 0.191329956f) + (inp_1qi * 0.461929321f);
    mul_1qi = (inp_1qr * -0.461929321f) + (inp_1qi * 0.191329956f);

    mul_2qr = ((-inp_2qr + inp_2qi) * 0.353546143f);
    mul_2qi = ((inp_2qr + inp_2qi) * -0.353546143f);

    mul_3qr = (inp_3qr * -0.461929321f) + (inp_3qi * -0.191329956f);
    mul_3qi = (inp_3qr * 0.191329956f) + (inp_3qi * -0.461929321f);

    sum_0qr = mul_0qr + (mul_2qr * 2);
    sum_0qi = mul_0qi + (mul_2qi * 2);
    sum_1qr = mul_0qr - (mul_2qr * 2);
    sum_1qi = mul_0qi - (mul_2qi * 2);

    sum_2qr = mul_1qr + mul_3qr;
    sum_2qi = mul_1qi + mul_3qi;
    sum_3qr = mul_1qr - mul_3qr;
    sum_3qi = mul_1qi - mul_3qi;

    ptr_y[0] = sum_0qr + (sum_2qr * 2);
    ptr_y[1] = sum_0qi + (sum_2qi * 2);
    ptr_y[h2] = sum_1qr + (sum_3qi * 2);
    ptr_y[h2 + 1] = sum_1qi - (sum_3qr * 2);
    ptr_y[l1] = sum_0qr - (sum_2qr * 2);
    ptr_y[l1 + 1] = sum_0qi - (sum_2qi * 2);
    ptr_y[l2] = sum_1qr - (sum_3qi * 2);
    ptr_y[l2 + 1] = sum_1qi + (sum_3qr * 2);
  }

  // Last stage of 32 point FFT
  {
    ptr_y = ptr_out;
    ptr_y[idx1] = interm_y[0] + interm_y[32];
    ptr_y[idx1 + 1] = interm_y[1] + interm_y[33];
    ptr_y[idx2] = interm_y[0] - interm_y[32];
    ptr_y[idx2 + 1] = interm_y[1] - interm_y[33];
    idx1 += FFT15X2;
    idx2 += FFT15X2;
    for (i = 1; i < FFT16; i++) {
      mul_r = (interm_y[FFT32 + 2 * i + 0] * ixheaace_fft_mix_rad_twid_tbl_32[i - 1]) -
              (interm_y[FFT32 + 2 * i + 1] * ixheaace_fft_mix_rad_twid_tbl_h_32[i - 1]);
      mul_i = (interm_y[FFT32 + 2 * i + 0] * ixheaace_fft_mix_rad_twid_tbl_h_32[i - 1]) +
              (interm_y[FFT32 + 2 * i + 1] * ixheaace_fft_mix_rad_twid_tbl_32[i - 1]);

      mul_r = mul_r / 2;
      mul_i = mul_i / 2;
      ptr_y[idx1] = interm_y[2 * i + 0] + (mul_r * 2);
      ptr_y[idx1 + 1] = interm_y[2 * i + 1] + (mul_i * 2);
      ptr_y[idx2] = interm_y[2 * i + 0] - (mul_r * 2);
      ptr_y[idx2 + 1] = interm_y[2 * i + 1] - (mul_i * 2);
      idx1 += FFT15X2;
      idx2 += FFT15X2;
    }
  }
}

static VOID ixheaace_dec_rearrange_short_flt(FLOAT32 *ptr_in, FLOAT32 *ptr_out, WORD32 N,
                                             const WORD16 *ptr_re_arr_tab) {
  WORD32 n, i = 0;

  for (n = 0; n < N; n++) {
    WORD32 idx = ptr_re_arr_tab[n] << 1;
    ptr_out[i++] = ptr_in[idx];
    ptr_out[i++] = ptr_in[idx + 1];
  }
}

static VOID ixheaace_fft_5_flt(FLOAT32 *ptr_in, FLOAT32 *ptr_out) {
  FLOAT32 C51 = 0.951056516f;
  FLOAT32 C52 = -0.769420885f;
  FLOAT32 C53 = -0.363271264f;
  FLOAT32 C54 = 0.559016994f;
  FLOAT32 C55 = -0.625f;

  FLOAT32 r1, r2, r3, r4;
  FLOAT32 s1, s2, s3, s4, t, temp1, temp2;

  r1 = (ptr_in[2] + ptr_in[8]);
  r4 = (ptr_in[2] - ptr_in[8]);
  r3 = (ptr_in[4] + ptr_in[6]);
  r2 = (ptr_in[4] - ptr_in[6]);

  t = ((r1 - r3) * C54);
  r1 = (r1 + r3);

  temp1 = (ptr_in[0] + r1);
  r1 = (temp1 + (((r1 * C55)) * 2));

  r3 = (r1 - t);
  r1 = (r1 + t);

  t = ((r4 + r2) * C51);
  r4 = (t + ((r4 * C52) * 2));
  r2 = (t + (r2 * C53));

  s1 = (ptr_in[3] + ptr_in[9]);
  s4 = (ptr_in[3] - ptr_in[9]);
  s3 = (ptr_in[5] + ptr_in[7]);
  s2 = (ptr_in[5] - ptr_in[7]);

  t = ((s1 - s3) * C54);
  s1 = (s1 + s3);

  temp2 = (ptr_in[1] + s1);

  s1 = (temp2 + (((s1 * C55)) * 2));

  s3 = (s1 - t);
  s1 = (s1 + t);

  t = ((s4 + s2) * C51);
  s4 = (t + (((s4 * C52)) * 2));
  s2 = (t + ((s2 * C53)));

  ptr_out[0] = temp1;
  ptr_out[1] = temp2;
  ptr_out[2] = (r1 + s2);
  ptr_out[3] = (s1 - r2);
  ptr_out[4] = (r3 - s4);
  ptr_out[5] = (s3 + r4);
  ptr_out[6] = (r3 + s4);
  ptr_out[7] = (s3 - r4);
  ptr_out[8] = (r1 - s2);
  ptr_out[9] = (s1 + r2);
}

static VOID ixheaace_fft_3_flt(FLOAT32 *ptr_in, FLOAT32 *ptr_out) {
  FLOAT32 add_r, sub_r;
  FLOAT32 add_i, sub_i;
  FLOAT32 x_01_r, x_01_i, temp;

  FLOAT32 p1, p2, p3, p4;
  FLOAT32 sinmu = 0.866025404f;

  x_01_r = (ptr_in[0] + ptr_in[2]);
  x_01_i = (ptr_in[1] + ptr_in[3]);

  add_r = (ptr_in[2] + ptr_in[4]);
  add_i = (ptr_in[3] + ptr_in[5]);

  sub_r = (ptr_in[2] - ptr_in[4]);
  sub_i = (ptr_in[3] - ptr_in[5]);

  p1 = add_r / 2;
  p2 = (sub_i * sinmu);
  p3 = (sub_r * sinmu);
  p4 = add_i / 2;

  temp = (ptr_in[0] - p1);

  ptr_out[0] = (x_01_r + ptr_in[4]);
  ptr_out[1] = (x_01_i + ptr_in[5]);
  ptr_out[2] = (temp + p2);
  ptr_out[3] = ((ptr_in[1] - p3) - p4);
  ptr_out[4] = (temp - p2);
  ptr_out[5] = ((ptr_in[1] + p3) - p4);
}

static VOID ixheaace_pre_twiddle_120(FLOAT32 *ptr_in, FLOAT32 *ptr_data, WORD32 n,
                                     const FLOAT32 *ptr_cos_sin_tbl) {
  WORD npoints_4, i;
  FLOAT32 tempr, tempi, temp;
  FLOAT32 c, c1, s, s1;
  FLOAT32 *ptr_in1, *ptr_in2;
  FLOAT32 *ptr_x = ptr_in + (n - 1);

  npoints_4 = n >> 2;

  ptr_in1 = ptr_data;
  ptr_in2 = ptr_data + n - 1;

  for (i = 0; i < npoints_4; i++) {
    c = *ptr_cos_sin_tbl++;
    s = *ptr_cos_sin_tbl++;

    tempr = *ptr_in1++;
    tempi = *ptr_in2--;

    temp = -((tempr * c) + (tempi * s));
    *ptr_in++ = temp;

    temp = -((tempi * c) - (tempr * s));
    *ptr_in++ = temp;

    c1 = *ptr_cos_sin_tbl++;
    s1 = *ptr_cos_sin_tbl++;

    tempi = *ptr_in1++;
    tempr = *ptr_in2--;

    temp = -((tempi * c1) - (tempr * s1));
    *ptr_x-- = temp;

    temp = -((tempr * c1) + (tempi * s1));
    *ptr_x-- = temp;
  }
}

static VOID ixheaace_post_twiddle_120(FLOAT32 *ptr_out, FLOAT32 *ptr_x,
                                      const FLOAT32 *ptr_cos_sin_tbl, WORD m) {
  WORD i;
  FLOAT32 c, c1, s, s1;
  FLOAT32 tempr, tempi, temp;
  FLOAT32 *ptr_in2 = ptr_x + (m - 1);
  FLOAT32 *ptr_in1 = ptr_x;
  FLOAT32 *ptr_x1 = ptr_out;
  FLOAT32 *ptr_x2 = ptr_out + (m - 1);

  for (i = 0; i < m; i += 4) {
    c = *ptr_cos_sin_tbl++;
    s = *ptr_cos_sin_tbl++;
    c1 = *ptr_cos_sin_tbl++;
    s1 = *ptr_cos_sin_tbl++;

    tempr = *ptr_in1++;
    tempi = *ptr_in1++;

    temp = -((tempr * s) - (tempi * c));
    *ptr_x2-- = temp;

    temp = -((tempr * c) + (tempi * s));
    *ptr_x1++ = temp;

    tempi = *ptr_in2--;
    tempr = *ptr_in2--;

    temp = -((tempr * s1) - (tempi * c1));
    *ptr_x1++ = temp;

    temp = -((tempr * c1) + (tempi * s1));
    *ptr_x2-- = temp;
  }
}

static VOID ixheaace_fft_960_15(FLOAT32 *ptr_in_flt, FLOAT32 *ptr_out_flt) {
  WORD32 i;
  FLOAT32 *ptr_buf1_flt, *ptr_buf2_flt;
  ixheaace_dec_rearrange_short_flt(ptr_in_flt, ptr_out_flt, FFT15, re_arr_tab_5);

  ptr_buf1_flt = ptr_out_flt;
  ptr_buf2_flt = ptr_in_flt;
  for (i = 0; i < FFT3; i++) {
    ixheaace_fft_5_flt(ptr_buf1_flt, ptr_buf2_flt);

    ptr_buf1_flt += (FFT5 * 2);
    ptr_buf2_flt += (FFT5 * 2);
  }

  ixheaace_dec_rearrange_short_flt(ptr_in_flt, ptr_out_flt, FFT15, re_arr_tab_3);
  ptr_buf1_flt = ptr_out_flt;
  ptr_buf2_flt = ptr_in_flt;
  for (i = 0; i < FFT5; i++) {
    ixheaace_fft_3_flt(ptr_buf1_flt, ptr_buf2_flt);

    ptr_buf1_flt += (FFT3 * 2);
    ptr_buf2_flt += (FFT3 * 2);
  }

  ixheaace_dec_rearrange_short_flt(ptr_in_flt, ptr_out_flt, FFT15, re_arr_tab_sml);
}

static VOID ixheaace_fft_120(WORD32 npoints, FLOAT32 *ptr_x_flt, FLOAT32 *ptr_y_flt) {
  WORD32 i;
  FLOAT32 *ptr_buf1_flt, *ptr_buf2_flt;
  FLOAT32 *ptr_in_flt, *ptr_out_flt;

  ptr_in_flt = ptr_x_flt;
  ptr_out_flt = ptr_y_flt;
  ixheaace_dec_rearrange_short_flt(ptr_in_flt, ptr_out_flt, 60, re_arr_tab_4);

  ptr_buf1_flt = ptr_out_flt;
  ptr_buf2_flt = ptr_in_flt;

  for (i = 0; i < FFT15; i++) {
    {
      FLOAT32 x_0, x_1, x_2, x_3, x_4, x_5, x_6, x_7;
      FLOAT32 *y0, *y1, *y2, *y3;
      FLOAT32 *x0;
      FLOAT32 xh0_0, xh1_0, xh0_1, xh1_1, xl0_0, xl1_0, xl0_1, xl1_1;
      WORD32 h2;
      FLOAT32 n00, n01, n10, n11, n20, n21, n30, n31;

      ptr_x_flt = ptr_buf1_flt;
      ptr_y_flt = ptr_buf2_flt;
      npoints = 4;
      h2 = 0;

      y0 = ptr_y_flt;
      y2 = ptr_y_flt + (WORD32)npoints;
      x0 = ptr_x_flt;
      y1 = y0 + (WORD32)(npoints >> 1);
      y3 = y2 + (WORD32)(npoints >> 1);

      x_0 = x0[0];
      x_1 = x0[1];
      x_2 = x0[2];
      x_3 = x0[3];
      x_4 = x0[4];
      x_5 = x0[5];
      x_6 = x0[6];
      x_7 = x0[7];

      xh0_0 = x_0 + x_4;
      xh1_0 = x_1 + x_5;
      xl0_0 = x_0 - x_4;
      xl1_0 = x_1 - x_5;
      xh0_1 = x_2 + x_6;
      xh1_1 = x_3 + x_7;
      xl0_1 = x_2 - x_6;
      xl1_1 = x_3 - x_7;

      n00 = xh0_0 + xh0_1;
      n01 = xh1_0 + xh1_1;
      n10 = xl0_0 + xl1_1;
      n11 = xl1_0 - xl0_1;
      n20 = xh0_0 - xh0_1;
      n21 = xh1_0 - xh1_1;
      n30 = xl0_0 - xl1_1;
      n31 = xl1_0 + xl0_1;

      y0[2 * h2] = n00;
      y0[2 * h2 + 1] = n01;
      y1[2 * h2] = n10;
      y1[2 * h2 + 1] = n11;
      y2[2 * h2] = n20;
      y2[2 * h2 + 1] = n21;
      y3[2 * h2] = n30;
      y3[2 * h2 + 1] = n31;
    }

    ptr_buf1_flt += (FFT4 * 2);
    ptr_buf2_flt += (FFT4 * 2);
  }

  ixheaace_dec_rearrange_short_flt(ptr_in_flt, ptr_out_flt, 60, re_arr_tab_15_4);

  ptr_buf1_flt = ptr_out_flt;
  ptr_buf2_flt = ptr_in_flt;
  for (i = 0; i < FFT4; i++) {
    ixheaace_fft_960_15(ptr_buf1_flt, ptr_buf2_flt);
    ptr_buf1_flt += (FFT15 * 2);
    ptr_buf2_flt += (FFT15 * 2);
  }

  ixheaace_dec_rearrange_short_flt(ptr_in_flt, ptr_out_flt, 60, re_arr_tab_120);
}

static VOID ixheaace_cfft_480(FLOAT32 *ptr_inp, FLOAT32 *ptr_op) {
  WORD32 i;
  FLOAT32 *ptr_buf1, *ptr_buf2;
  FLOAT32 fft5_out[FFT15X2] = {0};

  ptr_buf1 = ptr_inp;
  ptr_buf2 = ptr_op;

  for (i = 0; i < FFT32; i++) {
    ixheaace_cfft_15_480(ptr_buf1, ptr_buf2, &fft5_out[0]);
    ptr_buf1 += 2;
    ptr_buf2 += 2;
  }

  ixheaace_cfft_twiddle_mult(ptr_op, ptr_inp, FFT15, FFT32, ixheaace_fft_mix_rad_twid_tbl_480,
                             ixheaace_fft_mix_rad_twid_h_tbl_480);

  ptr_buf1 = ptr_inp;
  ptr_buf2 = ptr_op;

  for (i = 0; i < FFT15; i++) {
    ixheaace_cfft_32_480(ptr_buf1, ptr_buf2);
    ptr_buf1 += (FFT32X2);
    ptr_buf2 += 2;
  }
}

static VOID ixheaace_pre_twiddle_960(FLOAT32 *ptr_x, FLOAT32 *ptr_data, WORD32 n,
                                     const FLOAT32 *ptr_cos_sin_tbl) {
  WORD npoints_4, i;
  FLOAT32 tempr, tempi, temp;
  FLOAT32 c, c1, s, s1;
  FLOAT32 *ptr_in_1, *ptr_in_2;
  FLOAT32 *ptr_x_1 = ptr_x + (n - 1);

  npoints_4 = n >> 2;

  ptr_in_1 = ptr_data;
  ptr_in_2 = ptr_data + n - 1;

  for (i = 0; i < npoints_4; i++) {
    c = *ptr_cos_sin_tbl++;
    s = *ptr_cos_sin_tbl++;

    tempr = *ptr_in_1++;
    tempi = *ptr_in_2--;

    temp = -((tempr * c) + (tempi * s));
    *ptr_x++ = temp;

    temp = -((tempi * c) - (tempr * s));
    *ptr_x++ = temp;

    c1 = *ptr_cos_sin_tbl++;
    s1 = *ptr_cos_sin_tbl++;

    tempi = *ptr_in_1++;
    tempr = *ptr_in_2--;

    temp = -((tempi * c1) - (tempr * s1));
    *ptr_x_1-- = temp;

    temp = -((tempr * c1) + (tempi * s1));
    *ptr_x_1-- = temp;
  }
}

static VOID ixheaace_post_twiddle_960(FLOAT32 *ptr_out, FLOAT32 *ptr_x,
                                      const FLOAT32 *ptr_cos_sin_tbl, WORD m) {
  WORD i;
  FLOAT32 c, c1, s, s1;
  FLOAT32 tempr, tempi, temp;
  FLOAT32 *ptr_in2 = ptr_x + (m - 1);
  FLOAT32 *ptr_in1 = ptr_x;
  FLOAT32 *ptr_x1 = ptr_out;
  FLOAT32 *ptr_x2 = ptr_out + (m - 1);

  for (i = 0; i < m; i += 4) {
    c = *ptr_cos_sin_tbl++;
    s = *ptr_cos_sin_tbl++;
    c1 = *ptr_cos_sin_tbl++;
    s1 = *ptr_cos_sin_tbl++;

    tempr = *ptr_in1++;
    tempi = *ptr_in1++;

    temp = -((tempr * s) - (tempi * c));
    *ptr_x2-- = temp;

    temp = -((tempr * c) + (tempi * s));
    *ptr_x1++ = temp;

    tempi = *ptr_in2--;
    tempr = *ptr_in2--;

    temp = -((tempr * s1) - (tempi * c1));
    *ptr_x1++ = temp;

    temp = -((tempr * c1) + (tempi * s1));
    *ptr_x2-- = temp;
  }
}

static VOID ixheaace_mdct_960(FLOAT32 *ptr_input_flt, WORD8 *ptr_scratch) {
  FLOAT32 *ptr_scratch_flt = (FLOAT32 *)ptr_scratch;
  FLOAT32 const_mult_fac = 3.142857143f;
  FLOAT32 *ptr_data = ptr_input_flt;
  WORD32 k;

  memcpy(ptr_scratch_flt, ptr_input_flt, sizeof(*ptr_scratch_flt) * FRAME_LEN_960);
  ixheaace_pre_twiddle_960(ptr_input_flt, ptr_scratch_flt, FRAME_LEN_960, cos_sin_table_flt);

  ixheaace_cfft_480(ptr_input_flt, ptr_scratch_flt);

  ixheaace_post_twiddle_960(ptr_input_flt, ptr_scratch_flt, cos_sin_table_flt, FRAME_LEN_960);

  for (k = FRAME_LEN_960 - 1; k >= 0; k -= 2) {
    *ptr_data = (*ptr_data * const_mult_fac);
    ptr_data++;
    *ptr_data = (*ptr_data * const_mult_fac);
    ptr_data++;
  }
}

static VOID ixheaace_mdct_120(FLOAT32 *ptr_input_flt, WORD8 *ptr_scratch) {
  WORD32 n, k;
  WORD32 n_by_2;
  FLOAT32 *ptr_scratch_flt = (FLOAT32 *)ptr_scratch;
  FLOAT32 const_mltfac = 3.142857143f;
  FLOAT32 *ptr_data = ptr_input_flt;
  n = 120;
  n_by_2 = n >> 1;
  memcpy(ptr_scratch_flt, ptr_input_flt, sizeof(*ptr_scratch_flt) * n);

  ixheaace_pre_twiddle_120(ptr_input_flt, ptr_scratch_flt, n, ixheaace_cosine_array_240);

  ixheaace_fft_120(n_by_2, ptr_input_flt, ptr_scratch_flt);

  ixheaace_post_twiddle_120(ptr_input_flt, ptr_scratch_flt, ixheaace_cosine_array_240, n);

  for (k = n - 1; k >= 0; k -= 2) {
    *ptr_data = (*ptr_data * const_mltfac);
    ptr_data++;
    *ptr_data = (*ptr_data * const_mltfac);
    ptr_data++;
  }
}

static VOID ixheaace_mdct(FLOAT32 *ptr_dct_data, const FLOAT32 *ptr_trig_data,
                          const FLOAT32 *ptr_sine_window, WORD32 n, WORD32 ld_n,
                          WORD8 *ptr_scratch) {
  ixheaace_pre_mdct(ptr_dct_data, n, ptr_sine_window);

  ixheaace_scratch_mem *pstr_scratch = (ixheaace_scratch_mem *)ptr_scratch;
  ia_enhaacplus_enc_complex_fft(ptr_dct_data, n / 2, pstr_scratch);

  ixheaace_post_mdct(ptr_dct_data, n, ptr_trig_data,
                     1 << (LD_FFT_TWIDDLE_TABLE_SIZE - (ld_n - 1)), FFT_TWIDDLE_TABLE_SIZE);
}

static VOID ixheaace_shift_mdct_delay_buffer(FLOAT32 *ptr_mdct_delay_buffer,
                                             const FLOAT32 *ptr_time_signal, WORD32 ch_increment,
                                             WORD32 frame_len) {
  WORD32 i;
  WORD32 blk_switch_offset = frame_len;
  switch (frame_len) {
    case FRAME_LEN_1024:
      blk_switch_offset = BLK_SWITCH_OFFSET_LC_128;
      memmove(ptr_mdct_delay_buffer, ptr_mdct_delay_buffer + frame_len,
              (blk_switch_offset - frame_len) * sizeof(*ptr_mdct_delay_buffer));
      break;

    case FRAME_LEN_960:
      blk_switch_offset = BLK_SWITCH_OFFSET_LC_120;
      memmove(ptr_mdct_delay_buffer, ptr_mdct_delay_buffer + frame_len,
              (blk_switch_offset - frame_len) * sizeof(*ptr_mdct_delay_buffer));
      break;

    case FRAME_LEN_512:
    case FRAME_LEN_480:
      blk_switch_offset = frame_len;
      break;
  }

  for (i = 0; i < frame_len; i++) {
    ptr_mdct_delay_buffer[blk_switch_offset - frame_len + i] = ptr_time_signal[i * ch_increment];
  }
}

VOID ixheaace_transform_real_lc_ld(FLOAT32 *ptr_mdct_delay_buffer, const FLOAT32 *ptr_time_signal,
                                   WORD32 ch_increment, FLOAT32 *ptr_real_out, WORD32 block_type,
                                   WORD32 frame_len, WORD8 *ptr_scratch) {
  WORD32 i, w;
  FLOAT32 ws1, ws2;
  FLOAT32 *ptr_dct_in;
  WORD32 frame_len_short = FRAME_LEN_SHORT_128;
  WORD32 ls_trans = LS_TRANS_128;
  WORD32 trans_offset = TRANSFORM_OFFSET_SHORT_128;
  const FLOAT32 *ptr_window;
  if (frame_len == FRAME_LEN_960) {
    ls_trans = LS_TRANS_120;
    trans_offset = TRANSFORM_OFFSET_SHORT_120;
    frame_len_short = FRAME_LEN_SHORT_120;
  }
  switch (block_type) {
    case LONG_WINDOW:
      ptr_dct_in = ptr_real_out;
      ptr_window = &long_window_KBD[0];
      switch (frame_len) {
        case FRAME_LEN_1024:
          ptr_window = &long_window_KBD[0];
          break;

        case FRAME_LEN_960:
          ptr_window = &long_window_sine_960[0];
          break;

        case FRAME_LEN_512:
          ptr_window = &long_window_sine_ld[0];
          break;

        case FRAME_LEN_480:
          ptr_window = &long_window_sine_ld_480[0];
          break;
      }
      for (i = 0; i < frame_len / 2; i++) {
        ws1 = ptr_mdct_delay_buffer[i] * ptr_window[i];

        ws2 = ptr_mdct_delay_buffer[(frame_len - i - 1)] * ptr_window[frame_len - i - 1];

        ptr_dct_in[frame_len / 2 + i] = ws1 - ws2;
      }

      ixheaace_shift_mdct_delay_buffer(ptr_mdct_delay_buffer, ptr_time_signal, ch_increment,
                                       frame_len);

      for (i = 0; i < frame_len / 2; i++) {
        ws1 = ptr_mdct_delay_buffer[i] * ptr_window[frame_len - i - 1];

        ws2 = ptr_mdct_delay_buffer[(frame_len - i - 1)] * ptr_window[i];

        ptr_dct_in[frame_len / 2 - i - 1] = -(ws1 + ws2);
      }
      switch (frame_len) {
        case FRAME_LEN_1024:
          ixheaace_mdct(ptr_dct_in, fft_twiddle_tab, long_window_sine, frame_len, 10,
                        ptr_scratch);
          break;

        case FRAME_LEN_960:
          ixheaace_mdct_960(ptr_dct_in, ptr_scratch);
          break;

        case FRAME_LEN_512:
        case FRAME_LEN_480:
          ixheaace_mdct(ptr_dct_in, fft_twiddle_tab, ptr_window, frame_len, 9, ptr_scratch);
          break;
      }
      break;

    case START_WINDOW:
      ptr_dct_in = ptr_real_out;
      ptr_window = &long_window_KBD[0];
      switch (frame_len) {
        case FRAME_LEN_1024:
          ptr_window = &long_window_KBD[0];
          break;

        case FRAME_LEN_960:
          ptr_window = &long_window_sine_960[0];
          break;
      }
      for (i = 0; i < frame_len / 2; i++) {
        ws1 = ptr_mdct_delay_buffer[i] * ptr_window[i];

        ws2 = ptr_mdct_delay_buffer[(frame_len - i - 1)] * ptr_window[frame_len - i - 1];

        ptr_dct_in[frame_len / 2 + i] = ws1 - ws2;
      }

      ixheaace_shift_mdct_delay_buffer(ptr_mdct_delay_buffer, ptr_time_signal, ch_increment,
                                       frame_len);

      if (frame_len == FRAME_LEN_1024) {
        ptr_window = &short_window_sine[0];
      } else if (frame_len == FRAME_LEN_960) {
        ptr_window = &short_window_sine_120[0];
      }
      for (i = 0; i < ls_trans; i++) {
        ws1 = ptr_mdct_delay_buffer[i];
        ws2 = 0.0f;

        ptr_dct_in[frame_len / 2 - i - 1] = -(ws1 + ws2);
      }

      for (i = 0; i < frame_len_short / 2; i++) {
        ws1 = ptr_mdct_delay_buffer[i + ls_trans] * ptr_window[frame_len_short - i - 1];

        ws2 = ptr_mdct_delay_buffer[(frame_len - i - 1 - ls_trans)] * ptr_window[i];

        ptr_dct_in[frame_len / 2 - i - 1 - ls_trans] = -(ws1 + ws2);
      }
      if (frame_len == FRAME_LEN_960) {
        ixheaace_mdct_960(ptr_dct_in, ptr_scratch);
      } else {
        ixheaace_mdct(ptr_dct_in, fft_twiddle_tab, long_window_sine, frame_len, 10, ptr_scratch);
      }

      break;

    case STOP_WINDOW:
      ptr_window = &long_window_KBD[0];
      ptr_dct_in = ptr_real_out;
      if (frame_len == FRAME_LEN_1024) {
        ptr_window = &short_window_sine[0];
      } else if (frame_len == FRAME_LEN_960) {
        ptr_window = &short_window_sine_120[0];
      }
      for (i = 0; i < ls_trans; i++) {
        ws1 = 0.0f;
        ws2 = ptr_mdct_delay_buffer[(frame_len - i - 1)];
        ptr_dct_in[frame_len / 2 + i] = ws1 - ws2;
      }

      for (i = 0; i < frame_len_short / 2; i++) {
        ws1 = ptr_mdct_delay_buffer[(i + ls_trans)] * ptr_window[i];

        ws2 = ptr_mdct_delay_buffer[(frame_len - ls_trans - i - 1)] *
              ptr_window[frame_len_short - i - 1];

        ptr_dct_in[frame_len / 2 + i + ls_trans] = ws1 - ws2;
      }

      ixheaace_shift_mdct_delay_buffer(ptr_mdct_delay_buffer, ptr_time_signal, ch_increment,
                                       frame_len);

      if (frame_len == FRAME_LEN_1024) {
        ptr_window = &long_window_KBD[0];
      } else if (frame_len == FRAME_LEN_960) {
        ptr_window = &long_window_sine_960[0];
      }
      for (i = 0; i < frame_len / 2; i++) {
        ws1 = ptr_mdct_delay_buffer[i] * ptr_window[frame_len - i - 1];

        ws2 = ptr_mdct_delay_buffer[(frame_len - i - 1)] * ptr_window[i];

        ptr_dct_in[frame_len / 2 - i - 1] = -(ws1 + ws2);
      }

      if (frame_len == FRAME_LEN_960) {
        ixheaace_mdct_960(ptr_dct_in, ptr_scratch);
      } else {
        ixheaace_mdct(ptr_dct_in, fft_twiddle_tab, long_window_sine, frame_len, 10, ptr_scratch);
      }

      break;

    case SHORT_WINDOW:
      ptr_window = &short_window_sine[0];
      if (frame_len == FRAME_LEN_1024) {
        ptr_window = &short_window_sine[0];
      } else if (frame_len == FRAME_LEN_960) {
        ptr_window = &short_window_sine_120[0];
      }
      for (w = 0; w < TRANS_FAC; w++) {
        ptr_dct_in = ptr_real_out + w * frame_len_short;

        for (i = 0; i < frame_len_short / 2; i++) {
          ws1 = ptr_mdct_delay_buffer[trans_offset + w * frame_len_short + i] * ptr_window[i];

          ws2 = ptr_mdct_delay_buffer[trans_offset + w * frame_len_short + frame_len_short - i -
                                      1] *
                ptr_window[frame_len_short - i - 1];

          ptr_dct_in[frame_len_short / 2 + i] = ws1 - ws2;

          ws1 = ptr_mdct_delay_buffer[trans_offset + w * frame_len_short + frame_len_short + i] *
                ptr_window[frame_len_short - i - 1];

          ws2 = ptr_mdct_delay_buffer[trans_offset + w * frame_len_short + frame_len_short * 2 -
                                      i - 1] *
                ptr_window[i];

          ptr_dct_in[frame_len_short / 2 - i - 1] = -(ws1 + ws2);
        }
        if (frame_len == FRAME_LEN_960) {
          ixheaace_mdct_120(ptr_dct_in, ptr_scratch);
        } else {
          ixheaace_mdct(ptr_dct_in, fft_twiddle_tab, short_window_sine, frame_len_short, 7,
                        ptr_scratch);
        }
      }

      ixheaace_shift_mdct_delay_buffer(ptr_mdct_delay_buffer, ptr_time_signal, ch_increment,
                                       frame_len);
      break;
  }
}

VOID ia_enhaacplus_enc_transform_real_eld(FLOAT32 *ptr_mdct_delay_buffer,
                                          const FLOAT32 *ptr_time_signal, WORD32 ch_increment,
                                          FLOAT32 *ptr_real_out, WORD8 *ptr_shared_buffer5,
                                          WORD32 frame_len) {
  WORD32 i, loop_len;
  FLOAT32 w1, w2;
  FLOAT32 *ptr_curr_data, *ptr_prev1_data, *ptr_prev2_data, *ptr_prev3_data;
  const FLOAT32 *ptr_win0, *ptr_win1, *ptr_win2, *ptr_win3;

  loop_len = frame_len / 4;

  ptr_curr_data = &ptr_mdct_delay_buffer[3 * frame_len];
  ptr_prev1_data = &ptr_mdct_delay_buffer[2 * frame_len];
  ptr_prev2_data = &ptr_mdct_delay_buffer[frame_len];
  ptr_prev3_data = &ptr_mdct_delay_buffer[0];

  ptr_win0 = &low_delay_window_eld[0];
  ptr_win1 = &low_delay_window_eld[frame_len];
  ptr_win2 = &low_delay_window_eld[2 * frame_len];
  ptr_win3 = &low_delay_window_eld[3 * frame_len];

  memmove(&ptr_mdct_delay_buffer[0], &ptr_mdct_delay_buffer[frame_len],
          (3 * frame_len) * sizeof(ptr_mdct_delay_buffer[0]));

  for (i = 0; i < frame_len; i++) {
    ptr_curr_data[i] = ptr_time_signal[i * ch_increment];
  }

  for (i = 0; i < loop_len; i++) {
    w1 = ptr_prev3_data[(frame_len / 2) + loop_len + i] * ptr_win3[(frame_len / 2) - 1 - i];
    w1 += ptr_prev3_data[(frame_len / 2) + loop_len - 1 - i] * ptr_win3[(frame_len / 2) + i];

    w2 = (-ptr_prev1_data[(frame_len / 2) + loop_len + i] * ptr_win1[(frame_len / 2) - 1 - i]);
    w2 += (-ptr_prev1_data[(frame_len / 2) + loop_len - 1 - i] * ptr_win1[(frame_len / 2) + i]);

    ptr_real_out[i] = w1 + w2;
  }

  for (i = 0; i < loop_len; i++) {
    w1 = (-ptr_prev2_data[(frame_len / 2) + loop_len + i] * ptr_win2[(frame_len / 2) - 1 - i]);
    w1 += ptr_prev2_data[(frame_len / 2) + loop_len - 1 - i] * ptr_win2[(frame_len / 2) + i];

    w2 = ptr_curr_data[(frame_len / 2) + loop_len + i] * ptr_win0[(frame_len / 2) - 1 - i];
    w2 += (-ptr_curr_data[(frame_len / 2) + loop_len - 1 - i] * ptr_win0[(frame_len / 2) + i]);

    ptr_real_out[frame_len - 1 - i] = w1 + w2;
  }

  for (i = 0; i < loop_len; i++) {
    w1 = ptr_prev2_data[loop_len - 1 - i] * ptr_win3[i];
    w1 += ptr_prev3_data[loop_len + i] * ptr_win3[frame_len - 1 - i];

    w2 = (-ptr_curr_data[loop_len - 1 - i] * ptr_win1[i]);
    w2 += (-ptr_prev1_data[loop_len + i] * ptr_win1[frame_len - 1 - i]);

    ptr_real_out[(frame_len / 2) - 1 - i] = w1 + w2;
  }

  for (i = 0; i < loop_len; i++) {
    w1 = -(ptr_prev1_data[loop_len - 1 - i] * ptr_win2[i]);
    w1 += ptr_prev2_data[loop_len + i] * ptr_win2[frame_len - 1 - i];

    /* First 128 coeffcients are zeros in the window table so they are not used in the code here*/
    w2 = (-ptr_curr_data[loop_len + i] * ptr_win0[frame_len - 1 - i]);

    ptr_real_out[(frame_len / 2) + i] = w1 + w2;
  }

  ixheaace_mdct(ptr_real_out, fft_twiddle_tab, long_window_sine_ld, frame_len, 9,
                ptr_shared_buffer5);
}

Coverage Report

Created: 2026-01-25 06:51