/******************************************************************************
 *                                                                            *
 * 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 "ixheaace_psy_const.h"
#include "ixheaace_tns.h"
#include "ixheaace_tns_params.h"
#include "ixheaace_rom.h"
#include "ixheaace_common_rom.h"
#include "ixheaac_constants.h"
#include "ixheaace_aac_constants.h"

#include "ixheaace_fft.h"

void ia_aac_ld_enc_rearrange(WORD32 *ip, WORD32 *op, WORD32 N, UWORD8 *re_arr_tab) {
  WORD32 n, i = 0;

  for (n = 0; n < N; n++) {
    WORD32 idx = re_arr_tab[n] << 1;

    op[i++] = ip[idx];
    op[i++] = ip[idx + 1];
  }

  return;
}

static VOID ia_enhaacplus_enc_fft15(FLOAT32 *ptr_vec) {
  FLOAT32 r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, i0, i1,
      i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, tmp0, tmp1, tmp2,
      tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16,
      tmp17, tmp18, tmp19, tmp20, tmp21, tmp22, tmp23, tmp24, tmp25, tmp26, tmp27, tmp28, tmp29;

  /* Pre-additions real part */
  r1 = ptr_vec[2] + ptr_vec[8];
  r2 = ptr_vec[2] - ptr_vec[8];
  r3 = ptr_vec[4] + ptr_vec[16];
  r4 = ptr_vec[4] - ptr_vec[16];
  r5 = ptr_vec[6] + ptr_vec[24];
  r6 = ptr_vec[6] - ptr_vec[24];
  r7 = ptr_vec[10] + ptr_vec[20];
  r8 = ptr_vec[10] - ptr_vec[20];
  r9 = ptr_vec[12] + ptr_vec[18];
  r10 = ptr_vec[12] - ptr_vec[18];
  r11 = ptr_vec[14] + ptr_vec[26];
  r12 = ptr_vec[14] - ptr_vec[26];
  r13 = ptr_vec[22] + ptr_vec[28];
  r14 = ptr_vec[22] - ptr_vec[28];

  tmp2 = r1 + r3;
  tmp4 = r1 - r3;
  tmp6 = r2 + r14;
  tmp8 = r2 - r14;
  tmp10 = r4 + r12;
  tmp12 = r4 - r12;
  tmp14 = r5 + r9;
  tmp16 = r5 - r9;
  tmp18 = r11 + r13;
  tmp20 = r11 - r13;

  /* Pre-additions imaginary part */
  i1 = ptr_vec[3] + ptr_vec[9];
  i2 = ptr_vec[3] - ptr_vec[9];
  i3 = ptr_vec[5] + ptr_vec[17];
  i4 = ptr_vec[5] - ptr_vec[17];
  i5 = ptr_vec[7] + ptr_vec[25];
  i6 = ptr_vec[7] - ptr_vec[25];
  i7 = ptr_vec[11] + ptr_vec[21];
  i8 = ptr_vec[11] - ptr_vec[21];
  i9 = ptr_vec[13] + ptr_vec[19];
  i10 = ptr_vec[13] - ptr_vec[19];
  i11 = ptr_vec[15] + ptr_vec[27];
  i12 = ptr_vec[15] - ptr_vec[27];
  i13 = ptr_vec[23] + ptr_vec[29];
  i14 = ptr_vec[23] - ptr_vec[29];

  tmp3 = i1 + i3;
  tmp5 = i1 - i3;
  tmp7 = i2 + i14;
  tmp9 = i2 - i14;
  tmp11 = i4 + i12;
  tmp13 = i4 - i12;
  tmp15 = i5 + i9;
  tmp17 = i5 - i9;
  tmp19 = i11 + i13;
  tmp21 = i11 - i13;

  /* Pre-additions and core multiplications */
  tmp28 = tmp4 + tmp20;
  tmp29 = tmp5 + tmp21;
  r4 = tmp2 + tmp18;
  i4 = tmp3 + tmp19;
  r3 = (FLOAT32)((r4 + tmp14) * -1.25);
  i3 = (FLOAT32)((i4 + tmp15) * -1.25);
  r2 = (FLOAT32)((tmp29 - i8) * -8.660254037844387e-1);
  i2 = (FLOAT32)((tmp28 - r8) * 8.660254037844387e-1);
  r1 = r4 + r7;
  i1 = i4 + i7;
  r0 = r1 + ptr_vec[0] + tmp14;
  i0 = i1 + ptr_vec[1] + tmp15;
  r7 = tmp4 - tmp20;
  i7 = tmp5 - tmp21;
  r8 = (FLOAT32)((tmp3 - tmp19) * -4.841229182759272e-1);
  i8 = (FLOAT32)((tmp2 - tmp18) * 4.841229182759272e-1);
  tmp0 = tmp6 + r10;
  tmp1 = tmp7 + i10;
  tmp2 = r6 - tmp10;
  tmp3 = i6 - tmp11;
  r10 = (FLOAT32)(tmp7 * -2.308262652881440);
  i10 = (FLOAT32)(tmp6 * 2.308262652881440);
  r11 = (FLOAT32)(tmp8 * 1.332676064001459);
  i11 = (FLOAT32)(tmp9 * 1.332676064001459);
  r6 = (FLOAT32)((r7 - tmp16) * 5.590169943749475e-1);
  i6 = (FLOAT32)((i7 - tmp17) * 5.590169943749475e-1);
  r12 = (FLOAT32)((tmp1 + tmp3) * 5.877852522924733e-1);
  i12 = (FLOAT32)((tmp0 + tmp2) * -5.877852522924733e-1);
  r13 = (FLOAT32)((tmp7 - tmp11) * -8.816778784387098e-1);
  i13 = (FLOAT32)((tmp6 - tmp10) * 8.816778784387098e-1);
  r14 = (FLOAT32)((tmp8 + tmp12) * 5.090369604551274e-1);
  i14 = (FLOAT32)((tmp9 + tmp13) * 5.090369604551274e-1);
  r16 = (FLOAT32)(tmp11 * 5.449068960040204e-1);
  i16 = (FLOAT32)(tmp10 * -5.449068960040204e-1);
  r17 = (FLOAT32)(tmp12 * 3.146021430912046e-1);
  i17 = (FLOAT32)(tmp13 * 3.146021430912046e-1);

  r4 *= 1.875;
  i4 *= 1.875;
  r1 *= -1.5;
  i1 *= -1.5;
  r7 *= (FLOAT32)(-8.385254915624212e-1);
  i7 *= (FLOAT32)(-8.385254915624212e-1);
  r5 = (FLOAT32)(tmp29 * 1.082531754730548);
  i5 = (FLOAT32)(tmp28 * -1.082531754730548);
  r9 = (FLOAT32)(tmp1 * 1.5388417685876270);
  i9 = (FLOAT32)(tmp0 * -1.538841768587627);
  r15 = (FLOAT32)(tmp3 * 3.632712640026803e-1);
  i15 = (FLOAT32)(tmp2 * -3.632712640026803e-1);

  /* Post-additions real part */
  tmp2 = r0 + r1;
  tmp4 = r3 + r6;
  tmp6 = r3 - r6;
  tmp8 = r4 + r5;
  tmp10 = r4 - r5;
  tmp12 = r7 + r8;
  tmp14 = r7 - r8;
  tmp16 = r13 + r16;
  tmp18 = r14 + r17;
  tmp20 = r10 - r13;
  tmp22 = r11 - r14;
  tmp24 = r12 + r15;
  tmp26 = r12 - r9;

  r1 = tmp2 + r2;
  r2 = tmp2 - r2;
  r3 = tmp4 + tmp26;
  r4 = tmp4 - tmp26;
  r5 = tmp6 + tmp24;
  r6 = tmp6 - tmp24;
  r7 = tmp16 + tmp18;
  r8 = tmp16 - tmp18;
  r9 = tmp20 - tmp22;
  r10 = tmp20 + tmp22;
  r11 = r1 + tmp8;
  r12 = r2 + tmp10;
  r13 = r11 - tmp12;
  r14 = r12 - tmp14;
  r15 = r12 + tmp14;
  r16 = r11 + tmp12;

  /* Post-additions imaginary part */
  tmp3 = i0 + i1;
  tmp5 = i3 + i6;
  tmp7 = i3 - i6;
  tmp9 = i4 + i5;
  tmp11 = i4 - i5;
  tmp13 = i7 + i8;
  tmp15 = i7 - i8;
  tmp17 = i13 + i16;
  tmp19 = i14 + i17;
  tmp21 = i10 - i13;
  tmp23 = i11 - i14;
  tmp25 = i12 + i15;
  tmp27 = i12 - i9;

  i1 = tmp3 + i2;
  i2 = tmp3 - i2;
  i3 = tmp5 + tmp27;
  i4 = tmp5 - tmp27;
  i5 = tmp7 + tmp25;
  i6 = tmp7 - tmp25;
  i7 = tmp17 + tmp19;
  i8 = tmp17 - tmp19;
  i9 = tmp21 - tmp23;
  i10 = tmp21 + tmp23;
  i11 = i1 + tmp9;
  i12 = i2 + tmp11;
  i13 = i11 - tmp13;
  i14 = i12 - tmp15;
  i15 = i12 + tmp15;
  i16 = i11 + tmp13;

  *ptr_vec++ = r0;
  *ptr_vec++ = i0;
  *ptr_vec++ = r13 + r5 + r7;
  *ptr_vec++ = i13 + i5 + i7;
  *ptr_vec++ = r15 + r3 - r9;
  *ptr_vec++ = i15 + i3 - i9;
  *ptr_vec++ = r0 + r4;
  *ptr_vec++ = i0 + i4;
  *ptr_vec++ = r13 + r6 - r7;
  *ptr_vec++ = i13 + i6 - i7;
  *ptr_vec++ = r2;
  *ptr_vec++ = i2;
  *ptr_vec++ = r0 + r5;
  *ptr_vec++ = i0 + i5;
  *ptr_vec++ = r16 + r3 - r10;
  *ptr_vec++ = i16 + i3 - i10;
  *ptr_vec++ = r15 + r4 + r9;
  *ptr_vec++ = i15 + i4 + i9;
  *ptr_vec++ = r0 + r6;
  *ptr_vec++ = i0 + i6;
  *ptr_vec++ = r1;
  *ptr_vec++ = i1;
  *ptr_vec++ = r14 + r5 + r8;
  *ptr_vec++ = i14 + i5 + i8;
  *ptr_vec++ = r0 + r3;
  *ptr_vec++ = i0 + i3;
  *ptr_vec++ = r16 + r4 + r10;
  *ptr_vec++ = i16 + i4 + i10;
  *ptr_vec++ = r14 + r6 - r8;
  *ptr_vec++ = i14 + i6 - i8;
}

static VOID ia_enhaacplus_enc_fft16(FLOAT32 *ptr_vec) {
  FLOAT32 var10, var11, var12, var13, var14, var15, var16, var17, var18, var19, var110, var111,
      var112, var113, var114, var115, var20, var21, var22, var23, var24, var25, var26, var27,
      var28, var29, var210, var211, var212, var213, var214, var215, arr0, arr1, arr2, arr3, arr4,
      arr5, arr6, arr7, arr8, arr9, arr10, arr11, arr12, arr13, arr14, arr15;

  /* Pre-additions */
  arr0 = ptr_vec[0] + ptr_vec[16];
  arr8 = ptr_vec[8] + ptr_vec[24];
  var10 = arr0 + arr8;
  var12 = arr0 - arr8;
  arr1 = ptr_vec[1] + ptr_vec[17];
  arr9 = ptr_vec[9] + ptr_vec[25];
  var11 = arr1 + arr9;
  var13 = arr1 - arr9;
  arr2 = ptr_vec[2] + ptr_vec[18];
  arr10 = ptr_vec[10] + ptr_vec[26];
  var14 = arr2 + arr10;
  var16 = arr2 - arr10;
  arr3 = ptr_vec[3] + ptr_vec[19];
  arr11 = ptr_vec[11] + ptr_vec[27];
  var15 = arr3 + arr11;
  var17 = arr3 - arr11;
  arr4 = ptr_vec[4] + ptr_vec[20];
  arr12 = ptr_vec[12] + ptr_vec[28];
  var18 = arr4 + arr12;
  var110 = arr4 - arr12;
  arr5 = ptr_vec[5] + ptr_vec[21];
  arr13 = ptr_vec[13] + ptr_vec[29];
  var19 = arr5 + arr13;
  var111 = arr5 - arr13;
  arr6 = ptr_vec[6] + ptr_vec[22];
  arr14 = ptr_vec[14] + ptr_vec[30];
  var112 = arr6 + arr14;
  var114 = arr6 - arr14;
  arr7 = ptr_vec[7] + ptr_vec[23];
  arr15 = ptr_vec[15] + ptr_vec[31];
  var113 = arr7 + arr15;
  var115 = arr7 - arr15;

  /* Pre-additions and core multiplications */
  var20 = var10 + var18;
  var24 = var10 - var18;
  var21 = var11 + var19;
  var25 = var11 - var19;
  var28 = var12 - var111;
  var210 = var12 + var111;
  var29 = var13 + var110;
  var211 = var13 - var110;
  var22 = var14 + var112;
  var27 = var14 - var112;
  var23 = var15 + var113;
  var26 = var113 - var15;

  var11 = var16 + var114;
  var12 = var16 - var114;
  var10 = var17 + var115;
  var13 = var17 - var115;
  var212 = (var10 + var12) * IXHEAACE_INV_SQRT2;
  var214 = (var10 - var12) * IXHEAACE_INV_SQRT2;
  var213 = (var13 - var11) * IXHEAACE_INV_SQRT2;
  var215 = (var11 + var13) * -IXHEAACE_INV_SQRT2;

  /* odd */
  arr0 = ptr_vec[0] - ptr_vec[16];
  arr1 = ptr_vec[1] - ptr_vec[17];
  arr2 = ptr_vec[2] - ptr_vec[18];
  arr3 = ptr_vec[3] - ptr_vec[19];
  arr4 = ptr_vec[4] - ptr_vec[20];
  arr5 = ptr_vec[5] - ptr_vec[21];
  arr6 = ptr_vec[6] - ptr_vec[22];
  arr7 = ptr_vec[7] - ptr_vec[23];
  arr8 = ptr_vec[8] - ptr_vec[24];
  arr9 = ptr_vec[9] - ptr_vec[25];
  arr10 = ptr_vec[10] - ptr_vec[26];
  arr11 = ptr_vec[11] - ptr_vec[27];
  arr12 = ptr_vec[12] - ptr_vec[28];
  arr13 = ptr_vec[13] - ptr_vec[29];
  arr14 = ptr_vec[14] - ptr_vec[30];
  arr15 = ptr_vec[15] - ptr_vec[31];

  /* Pre-additions and core multiplications */
  var19 = (arr2 + arr14) * -IXHEAACE_COS_3PI_DIV8;
  var110 = (arr2 - arr14) * IXHEAACE_COS_PI_DIV8;
  var18 = (arr3 + arr15) * IXHEAACE_COS_3PI_DIV8;
  var111 = (arr3 - arr15) * IXHEAACE_COS_PI_DIV8;
  var15 = (arr4 + arr12) * -IXHEAACE_INV_SQRT2;
  var16 = (arr4 - arr12) * IXHEAACE_INV_SQRT2;
  var14 = (arr5 + arr13) * IXHEAACE_INV_SQRT2;
  var17 = (arr5 - arr13) * IXHEAACE_INV_SQRT2;
  var113 = (arr6 + arr10) * -IXHEAACE_COS_PI_DIV8;
  var114 = (arr6 - arr10) * IXHEAACE_COS_3PI_DIV8;
  var112 = (arr7 + arr11) * IXHEAACE_COS_PI_DIV8;
  var115 = (arr7 - arr11) * IXHEAACE_COS_3PI_DIV8;

  /* Core multiplications */
  arr2 = var18 * IXHEAACE_SQRT2PLUS1 - var112 * IXHEAACE_SQRT2MINUS1;
  arr3 = var19 * IXHEAACE_SQRT2PLUS1 - var113 * IXHEAACE_SQRT2MINUS1;
  arr4 = var110 * IXHEAACE_SQRT2MINUS1 - var114 * IXHEAACE_SQRT2PLUS1;
  arr5 = var111 * IXHEAACE_SQRT2MINUS1 - var115 * IXHEAACE_SQRT2PLUS1;

  /* Post-additions */
  var18 = var18 + var112;
  var19 = var19 + var113;
  var110 = var110 + var114;
  var111 = var111 + var115;
  arr6 = arr0 + var14;
  arr10 = arr0 - var14;
  arr7 = arr1 + var15;
  arr11 = arr1 - var15;

  arr12 = var16 - arr9;
  arr14 = var16 + arr9;
  arr13 = arr8 + var17;
  arr15 = arr8 - var17;

  var10 = arr6 - arr14;
  var12 = arr6 + arr14;
  var11 = arr7 + arr15;
  var13 = arr7 - arr15;
  var14 = arr10 + arr12;
  var16 = arr10 - arr12;
  var15 = arr11 + arr13;
  var17 = arr11 - arr13;

  arr10 = var18 + var110;
  var110 = var18 - var110;
  arr11 = var19 + var111;
  var111 = var19 - var111;

  var112 = arr2 + arr4;
  var114 = arr2 - arr4;
  var113 = arr3 + arr5;
  var115 = arr3 - arr5;

  /* Post-additions */
  ptr_vec[0] = var20 + var22;
  ptr_vec[1] = var21 + var23;
  ptr_vec[2] = var12 + arr10;
  ptr_vec[3] = var13 + arr11;
  ptr_vec[4] = var210 + var212;
  ptr_vec[5] = var211 + var213;
  ptr_vec[6] = var10 + var112;
  ptr_vec[7] = var11 + var113;
  ptr_vec[8] = var24 - var26;
  ptr_vec[9] = var25 - var27;
  ptr_vec[10] = var16 + var114;
  ptr_vec[11] = var17 + var115;
  ptr_vec[12] = var28 + var214;
  ptr_vec[13] = var29 + var215;
  ptr_vec[14] = var14 + var110;
  ptr_vec[15] = var15 + var111;
  ptr_vec[16] = var20 - var22;
  ptr_vec[17] = var21 - var23;
  ptr_vec[18] = var12 - arr10;
  ptr_vec[19] = var13 - arr11;
  ptr_vec[20] = var210 - var212;
  ptr_vec[21] = var211 - var213;
  ptr_vec[22] = var10 - var112;
  ptr_vec[23] = var11 - var113;
  ptr_vec[24] = var24 + var26;
  ptr_vec[25] = var25 + var27;
  ptr_vec[26] = var16 - var114;
  ptr_vec[27] = var17 - var115;
  ptr_vec[28] = var28 - var214;
  ptr_vec[29] = var29 - var215;
  ptr_vec[30] = var14 - var110;
  ptr_vec[31] = var15 - var111;
}

static VOID ia_enhaacplus_enc_fft240(FLOAT32 *ptr_in) {
  const WORD32 n1 = 240;
  const WORD32 n2 = 15;
  const WORD32 n3 = 16;
  const WORD32 *ptr_idx1 = ia_enhaacplus_enc_fft240_table1;
  const WORD32 *ptr_idx2 = ia_enhaacplus_enc_fft240_table2;

  WORD32 k, l;
  FLOAT32 temp[32], out[480];

  for (k = 0; k < n2; k++) {
    for (l = 0; l < n3; l++) {
      temp[2 * l] = ptr_in[2 * *ptr_idx1];
      temp[2 * l + 1] = ptr_in[2 * *ptr_idx1 + 1];
      ptr_idx1 += n2;
    }

    ia_enhaacplus_enc_fft16(temp); /* 16-point FFT */
    ptr_idx1 -= n1;

    for (l = 0; l < n3; l++) {
      ptr_in[2 * *ptr_idx1] = temp[2 * l];
      ptr_in[2 * *ptr_idx1 + 1] = temp[2 * l + 1];
      ptr_idx1 += n2;
    }

    ptr_idx1 -= n1 - 1;
  }

  ptr_idx1 -= n2;

  for (k = 0; k < n3; k++) {
    for (l = 0; l < n2; l++) {
      temp[2 * l] = ptr_in[2 * *ptr_idx1];
      temp[2 * l + 1] = ptr_in[2 * *ptr_idx1++ + 1];
    }

    ia_enhaacplus_enc_fft15(temp); /* 15-point FFT */

    for (l = 0; l < n2; l++) {
      out[2 * *ptr_idx2] = temp[2 * l];
      out[2 * *ptr_idx2++ + 1] = temp[2 * l + 1];
    }
  }

  memcpy(ptr_in, out, (2 * n1) * sizeof(out[0]));
}

VOID ia_aac_ld_enc_mdct_480(FLOAT32 *ptr_inp, FLOAT32 *ptr_scratch, WORD32 mdct_flag,
                            ixheaace_mdct_tables *pstr_mdct_tables) {
  WORD32 k;
  FLOAT32 const_mltfac = ((FLOAT32)FRAME_LEN_512) / FRAME_LEN_480;

  ia_eaacp_enc_pre_twiddle_aac(ptr_scratch, ptr_inp, FRAME_LEN_480,
                               pstr_mdct_tables->cosine_array_960);

  ia_enhaacplus_enc_fft240(ptr_scratch);

  ia_enhaacplus_enc_post_twiddle(ptr_inp, ptr_scratch, pstr_mdct_tables->cosine_array_960,
                                 FRAME_LEN_480);

  if (0 == mdct_flag) {
    for (k = 0; k < MDCT_LEN; k++) {
      ptr_inp[k] *= const_mltfac;
    }
  }
}