/******************************************************************************

 *                                                                            *

 * 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 <stdlib.h>

#include "ixheaac_type_def.h"

#include "ixheaac_constants.h"

#include "ixheaace_sbr_def.h"

#include "ixheaace_resampler.h"

#include "ixheaace_sbr_rom.h"

#include "ixheaace_common_rom.h"

#include "ixheaace_sbr_hbe.h"

#include "ixheaace_sbr_qmf_enc.h"

#include "ixheaace_sbr_hybrid.h"

#include "ixheaace_aac_constants.h"

#include "ixheaac_basic_ops32.h"

#include "ixheaac_basic_ops16.h"

#include "ixheaac_basic_ops40.h"

#include "ixheaac_basic_ops.h"

#include "ixheaace_psy_const.h"

#include "ixheaace_tns.h"

#include "ixheaace_tns_params.h"

#include "ixheaace_rom.h"

#include "ixheaace_fft.h"

static VOID ia_enhaacplus_enc_fct3_4(FLOAT32 *ptr_x) {

  FLOAT32 tmp00, tmp01, tmp10, tmp11, xp, xp2;

  xp2 = ptr_x[1];

  xp = ptr_x[0];

  xp2 = xp2 * IXHEAACE_COS_PI_BY_4;

  tmp00 = xp + xp2;

  tmp01 = xp - xp2;

  xp = ptr_x[2];

  xp2 = ptr_x[3];

  tmp10 = (xp * IXHEAACE_COS_PI_BY_8) + (xp2 * IXHEAACE_SIN_PI_BY_8);

  ptr_x[0] = tmp00 + tmp10;

  ptr_x[3] = tmp00 - tmp10;

  tmp11 = (xp * IXHEAACE_SIN_PI_BY_8) - (xp2 * IXHEAACE_COS_PI_BY_8);

  ptr_x[1] = tmp01 + tmp11;

  ptr_x[2] = tmp01 - tmp11;

}

static VOID ia_enhaacplus_enc_fst3_4r(FLOAT32 *ptr_x) {

  FLOAT32 tmp00, tmp01, tmp10, tmp11, xp, xp2;

  xp2 = ptr_x[2];

  xp = ptr_x[3];

  xp2 = xp2 * IXHEAACE_COS_PI_BY_4;

  tmp00 = xp + xp2;

  tmp01 = xp - xp2;

  xp = ptr_x[1];

  xp2 = ptr_x[0];

  tmp10 = (xp * IXHEAACE_COS_PI_BY_8) + (xp2 * IXHEAACE_SIN_PI_BY_8);

  ptr_x[3] = tmp00 + tmp10;

  ptr_x[0] = tmp10 - tmp00;

  tmp11 = (xp2 * IXHEAACE_COS_PI_BY_8) - (xp * IXHEAACE_SIN_PI_BY_8);

  ptr_x[2] = tmp11 - tmp01;

  ptr_x[1] = tmp11 + tmp01;

}

static VOID ia_enhaacplus_enc_fct4_4r(FLOAT32 *ptr_x) {

  FLOAT32 tmp00, tmp01, tmp10, tmp11, xp, xp2;

  xp = ptr_x[1];

  xp2 = ptr_x[0];

  xp = xp * IXHEAACE_COS_PI_BY_4;

  tmp00 = xp2 + xp;

  tmp01 = xp2 - xp;

  xp = ptr_x[2];

  xp2 = ptr_x[3];

  xp = xp * IXHEAACE_COS_PI_BY_4;

  tmp11 = xp2 - xp;

  tmp10 = xp2 + xp;

  ptr_x[3] = tmp00 * IXHEAACE_COS_PI_BY_16 + tmp10 * IXHEAACE_SIN_PI_BY_16;

  ptr_x[0] = tmp00 * IXHEAACE_SIN_PI_BY_16 - tmp10 * IXHEAACE_COS_PI_BY_16;

  ptr_x[2] = tmp01 * IXHEAACE_COS_3_PI_BY_16 - tmp11 * IXHEAACE_SIN_3_PI_BY_16;

  ptr_x[1] = tmp01 * IXHEAACE_SIN_3_PI_BY_16 + tmp11 * IXHEAACE_COS_3_PI_BY_16;

}

static VOID ia_enhaacplus_enc_fst4_4(FLOAT32 *ptr_x) {

  FLOAT32 tmp00, tmp01, tmp10, tmp11, xp, xp2;

  xp = ptr_x[1];

  xp2 = ptr_x[0];

  xp = xp * IXHEAACE_COS_PI_BY_4;

  tmp10 = xp2 + xp;

  tmp11 = xp2 - xp;

  xp = ptr_x[2];

  xp2 = ptr_x[3];

  xp = xp * IXHEAACE_COS_PI_BY_4;

  tmp01 = xp2 - xp;

  tmp00 = xp2 + xp;

  ptr_x[0] = tmp00 * IXHEAACE_COS_PI_BY_16 + tmp10 * IXHEAACE_SIN_PI_BY_16;

  ptr_x[3] = tmp10 * IXHEAACE_COS_PI_BY_16 - tmp00 * IXHEAACE_SIN_PI_BY_16;

  ptr_x[1] = tmp11 * IXHEAACE_SIN_3_PI_BY_16 - tmp01 * IXHEAACE_COS_3_PI_BY_16;

  ptr_x[2] = tmp01 * IXHEAACE_SIN_3_PI_BY_16 + tmp11 * IXHEAACE_COS_3_PI_BY_16;

}

static VOID ia_enhaacplus_enc_fct3_64(FLOAT32 *ptr_a, ixheaace_str_qmf_tabs *pstr_qmf_tab) {

  WORD32 k;

  const FLOAT32 *ptr_t1;

  FLOAT32 xp, xp2, xp3, xp4, wc, ws;

  FLOAT32 *ptr1, *ptr2;

  FLOAT32 *ptr_ap, *ptr_an;

  /* bit reversal */

  xp = ptr_a[1];

  ptr_a[1] = ptr_a[32];

  ptr_a[32] = xp;

  xp = ptr_a[2];

  ptr_a[2] = ptr_a[16];

  ptr_a[16] = xp;

  xp = ptr_a[3];

  ptr_a[3] = ptr_a[48];

  ptr_a[48] = xp;

  xp = ptr_a[4];

  ptr_a[4] = ptr_a[8];

  ptr_a[8] = xp;

  xp = ptr_a[5];

  ptr_a[5] = ptr_a[40];

  ptr_a[40] = xp;

  xp = ptr_a[6];

  ptr_a[6] = ptr_a[24];

  ptr_a[24] = xp;

  xp = ptr_a[7];

  ptr_a[7] = ptr_a[56];

  ptr_a[56] = xp;

  xp = ptr_a[9];

  ptr_a[9] = ptr_a[36];

  ptr_a[36] = xp;

  xp = ptr_a[10];

  ptr_a[10] = ptr_a[20];

  ptr_a[20] = xp;

  xp = ptr_a[11];

  ptr_a[11] = ptr_a[52];

  ptr_a[52] = xp;

  xp = ptr_a[13];

  ptr_a[13] = ptr_a[44];

  ptr_a[44] = xp;

  xp = ptr_a[14];

  ptr_a[14] = ptr_a[28];

  ptr_a[28] = xp;

  xp = ptr_a[15];

  ptr_a[15] = ptr_a[60];

  ptr_a[60] = xp;

  xp = ptr_a[17];

  ptr_a[17] = ptr_a[34];

  ptr_a[34] = xp;

  xp = ptr_a[19];

  ptr_a[19] = ptr_a[50];

  ptr_a[50] = xp;

  xp = ptr_a[21];

  ptr_a[21] = ptr_a[42];

  ptr_a[42] = xp;

  xp = ptr_a[22];

  ptr_a[22] = ptr_a[26];

  ptr_a[26] = xp;

  xp = ptr_a[23];

  ptr_a[23] = ptr_a[58];

  ptr_a[58] = xp;

  xp = ptr_a[25];

  ptr_a[25] = ptr_a[38];

  ptr_a[38] = xp;

  xp = ptr_a[27];

  ptr_a[27] = ptr_a[54];

  ptr_a[54] = xp;

  xp = ptr_a[29];

  ptr_a[29] = ptr_a[46];

  ptr_a[46] = xp;

  xp = ptr_a[31];

  ptr_a[31] = ptr_a[62];

  ptr_a[62] = xp;

  xp = ptr_a[35];

  ptr_a[35] = ptr_a[49];

  ptr_a[49] = xp;

  xp = ptr_a[37];

  ptr_a[37] = ptr_a[41];

  ptr_a[41] = xp;

  xp = ptr_a[39];

  ptr_a[39] = ptr_a[57];

  ptr_a[57] = xp;

  xp = ptr_a[43];

  ptr_a[43] = ptr_a[53];

  ptr_a[53] = xp;

  xp = ptr_a[47];

  ptr_a[47] = ptr_a[61];

  ptr_a[61] = xp;

  xp = ptr_a[55];

  ptr_a[55] = ptr_a[59];

  ptr_a[59] = xp;

  xp = ptr_a[33];

  xp2 = ptr_a[62];

  ptr_a[62] = xp2 - xp;

  ptr_a[33] = xp2 + xp;

  xp = ptr_a[34];

  xp2 = ptr_a[60];

  ptr_a[60] = xp2 - xp;

  ptr_a[34] = xp2 + xp;

  xp = ptr_a[35];

  xp2 = ptr_a[61];

  ptr_a[61] = xp2 - xp;

  ptr_a[35] = xp2 + xp;

  xp = ptr_a[36];

  xp2 = ptr_a[56];

  ptr_a[56] = xp2 - xp;

  ptr_a[36] = xp2 + xp;

  xp = ptr_a[37];

  xp2 = ptr_a[57];

  ptr_a[57] = xp2 - xp;

  ptr_a[37] = xp2 + xp;

  xp = ptr_a[38];

  xp2 = ptr_a[58];

  ptr_a[58] = xp2 - xp;

  ptr_a[38] = xp2 + xp;

  xp = ptr_a[39];

  xp2 = ptr_a[59];

  ptr_a[59] = xp2 - xp;

  ptr_a[39] = xp2 + xp;

  xp = ptr_a[40];

  xp2 = ptr_a[48];

  ptr_a[48] = xp2 - xp;

  ptr_a[40] = xp2 + xp;

  xp = ptr_a[41];

  xp2 = ptr_a[49];

  ptr_a[49] = xp2 - xp;

  ptr_a[41] = xp2 + xp;

  xp = ptr_a[42];

  xp2 = ptr_a[50];

  ptr_a[50] = xp2 - xp;

  ptr_a[42] = xp2 + xp;

  xp = ptr_a[43];

  xp2 = ptr_a[51];

  ptr_a[51] = xp2 - xp;

  ptr_a[43] = xp2 + xp;

  xp = ptr_a[44];

  xp2 = ptr_a[52];

  ptr_a[52] = xp2 - xp;

  ptr_a[44] = xp2 + xp;

  xp = ptr_a[45];

  xp2 = ptr_a[53];

  ptr_a[53] = xp2 - xp;

  ptr_a[45] = xp2 + xp;

  xp = ptr_a[46];

  xp2 = ptr_a[54];

  ptr_a[54] = xp2 - xp;

  ptr_a[46] = xp2 + xp;

  xp = ptr_a[47];

  xp2 = ptr_a[55];

  ptr_a[55] = xp2 - xp;

  ptr_a[47] = xp2 + xp;

  xp = ptr_a[17];

  xp2 = ptr_a[30];

  ptr_a[30] = xp2 - xp;

  ptr_a[17] = xp2 + xp;

  xp = ptr_a[18];

  xp2 = ptr_a[28];

  ptr_a[28] = xp2 - xp;

  ptr_a[18] = xp2 + xp;

  xp = ptr_a[19];

  xp2 = ptr_a[29];

  ptr_a[29] = xp2 - xp;

  ptr_a[19] = xp2 + xp;

  xp = ptr_a[20];

  xp2 = ptr_a[24];

  ptr_a[24] = xp2 - xp;

  ptr_a[20] = xp2 + xp;

  xp = ptr_a[21];

  xp2 = ptr_a[25];

  ptr_a[25] = xp2 - xp;

  ptr_a[21] = xp2 + xp;

  xp = ptr_a[22];

  xp2 = ptr_a[26];

  ptr_a[26] = xp2 - xp;

  ptr_a[22] = xp2 + xp;

  xp = ptr_a[23];

  xp2 = ptr_a[27];

  ptr_a[27] = xp2 - xp;

  ptr_a[23] = xp2 + xp;

  xp = ptr_a[9];

  xp2 = ptr_a[14];

  ptr_a[14] = xp2 - xp;

  ptr_a[9] = xp2 + xp;

  xp = ptr_a[10];

  xp2 = ptr_a[12];

  ptr_a[12] = xp2 - xp;

  ptr_a[10] = xp2 + xp;

  xp = ptr_a[11];

  xp2 = ptr_a[13];

  ptr_a[13] = xp2 - xp;

  ptr_a[11] = xp2 + xp;

  xp = ptr_a[41];

  xp2 = ptr_a[46];

  ptr_a[46] = xp2 - xp;

  ptr_a[41] = xp2 + xp;

  xp = ptr_a[42];

  xp2 = ptr_a[44];

  ptr_a[44] = xp2 - xp;

  ptr_a[42] = xp2 + xp;

  xp = ptr_a[43];

  xp2 = ptr_a[45];

  ptr_a[45] = xp2 - xp;

  ptr_a[43] = xp2 + xp;

  xp = ptr_a[49];

  xp2 = ptr_a[54];

  ptr_a[49] = xp - xp2;

  ptr_a[54] = xp2 + xp;

  xp = ptr_a[50];

  xp2 = ptr_a[52];

  ptr_a[50] = xp - xp2;

  ptr_a[52] = xp2 + xp;

  xp = ptr_a[51];

  xp2 = ptr_a[53];

  ptr_a[51] = xp - xp2;

  ptr_a[53] = xp2 + xp;

  xp = ptr_a[5];

  xp2 = ptr_a[6];

  ptr_a[6] = xp2 - xp;

  ptr_a[5] = xp2 + xp;

  xp = ptr_a[21];

  xp2 = ptr_a[22];

  ptr_a[22] = xp2 - xp;

  ptr_a[21] = xp2 + xp;

  xp = ptr_a[25];

  xp2 = ptr_a[26];

  ptr_a[25] = xp - xp2;

  ptr_a[26] = xp2 + xp;

  xp = ptr_a[37];

  xp2 = ptr_a[38];

  ptr_a[38] = xp2 - xp;

  ptr_a[37] = xp2 + xp;

  xp = ptr_a[57];

  xp2 = ptr_a[58];

  ptr_a[57] = xp - xp2;

  ptr_a[58] = xp2 + xp;

  ia_enhaacplus_enc_fct3_4(ptr_a);

  ia_enhaacplus_enc_fct4_4r(ptr_a + 4);

  ia_enhaacplus_enc_fct3_4(ptr_a + 8);

  ia_enhaacplus_enc_fst3_4r(ptr_a + 12);

  ia_enhaacplus_enc_fct3_4(ptr_a + 16);

  ia_enhaacplus_enc_fct4_4r(ptr_a + 20);

  ia_enhaacplus_enc_fst4_4(ptr_a + 24);

  ia_enhaacplus_enc_fst3_4r(ptr_a + 28);

  ia_enhaacplus_enc_fct3_4(ptr_a + 32);

  ia_enhaacplus_enc_fct4_4r(ptr_a + 36);

  ia_enhaacplus_enc_fct3_4(ptr_a + 40);

  ia_enhaacplus_enc_fst3_4r(ptr_a + 44);

  ia_enhaacplus_enc_fct3_4(ptr_a + 48);

  ia_enhaacplus_enc_fst3_4r(ptr_a + 52);

  ia_enhaacplus_enc_fst4_4(ptr_a + 56);

  ia_enhaacplus_enc_fst3_4r(ptr_a + 60);

  ptr_ap = ptr_a;

  ptr_an = ptr_a + 7;

  for (k = 4; k != 0; k--) {

    xp = *ptr_ap++;

    xp2 = *ptr_an--;

    xp3 = *(ptr_ap + 15);

    xp4 = *(ptr_an + 17);

    *(ptr_an + 1) = xp - xp2;

    *(ptr_ap - 1) = xp + xp2;

    xp = *(ptr_ap + 23);

    xp2 = *(ptr_an + 25);

    *(ptr_an + 17) = xp3 - xp4;

    *(ptr_ap + 15) = xp3 + xp4;

    xp3 = *(ptr_ap + 31);

    xp4 = *(ptr_an + 33);

    *(ptr_ap + 23) = xp - xp2;

    *(ptr_an + 25) = xp + xp2;

    xp = *(ptr_ap + 55);

    xp2 = *(ptr_an + 57);

    *(ptr_an + 33) = xp3 - xp4;

    *(ptr_ap + 31) = xp3 + xp4;

    *(ptr_ap + 55) = xp - xp2;

    *(ptr_an + 57) = xp + xp2;

  }

  ptr_t1 = pstr_qmf_tab->cos_sin_fct4_8;

  ptr_ap = ptr_a + 8;

  ptr_an = ptr_a + 15;

  for (k = 4; k != 0; k--) {

    wc = *ptr_t1++;

    ws = *ptr_t1++;

    xp = *ptr_ap * wc + *ptr_an * ws;

    *ptr_ap = *ptr_ap * ws - *ptr_an * wc;

    ptr_ap++;

    *ptr_an-- = xp;

    xp = *(ptr_ap + 31) * wc + *(ptr_an + 33) * ws;

    *(ptr_ap + 31) = *(ptr_ap + 31) * ws - *(ptr_an + 33) * wc;

    *(ptr_an + 33) = xp;

    xp = *(ptr_ap + 39) * ws + *(ptr_an + 41) * wc;

    *(ptr_an + 41) = *(ptr_ap + 39) * wc - *(ptr_an + 41) * ws;

    *(ptr_ap + 39) = xp;

  }

  ptr_ap = ptr_a;

  ptr_an = ptr_a + 15;

  for (k = 8; k != 0; k--) {

    xp = *ptr_ap++;

    xp2 = *ptr_an--;

    xp3 = *(ptr_ap + 31);

    xp4 = *(ptr_an + 33);

    *(ptr_an + 1) = xp - xp2;

    *(ptr_ap - 1) = xp + xp2;

    xp = *(ptr_ap + 47);

    xp2 = *(ptr_an + 49);

    *(ptr_an + 33) = xp3 - xp4;

    *(ptr_ap + 31) = xp3 + xp4;

    *(ptr_ap + 47) = xp - xp2;

    *(ptr_an + 49) = xp + xp2;

  }

  ptr_t1 = pstr_qmf_tab->cos_sin_fct4_16;

  ptr1 = &ptr_a[16];

  ptr2 = &ptr_a[31];

  for (k = 7; k >= 0; k--) {

    wc = *ptr_t1++;

    ws = *ptr_t1++;

    xp = *ptr1;

    xp2 = *ptr2;

    *ptr2-- = xp * wc + xp2 * ws;

    *ptr1++ = xp * ws - xp2 * wc;

  }

  ptr1 = &ptr_a[0];

  ptr2 = &ptr_a[31];

  for (k = 15; k >= 0; k--) {

    xp = *ptr1;

    xp2 = *ptr2;

    *ptr1++ = xp + xp2;

    *ptr2-- = xp - xp2;

  }

  ptr_t1 = pstr_qmf_tab->cos_sin_fct4_32;

  ptr1 = &ptr_a[32];

  ptr2 = &ptr_a[63];

  for (k = 15; k >= 0; k--) {

    wc = *ptr_t1++;

    ws = *ptr_t1++;

    xp = *ptr1;

    xp2 = *ptr2;

    *ptr2-- = xp * wc + xp2 * ws;

    *ptr1++ = xp * ws - xp2 * wc;

  }

  ptr1 = &ptr_a[0];

  ptr2 = &ptr_a[63];

  for (k = 31; k >= 0; k--) {

    xp = *ptr1;

    xp2 = *ptr2;

    *ptr1++ = xp + xp2;

    *ptr2-- = xp - xp2;

  }

}

static VOID ia_enhaacplus_enc_fst3_64(FLOAT32 *ptr_a, ixheaace_str_qmf_tabs *pstr_qmf_tab) {

  WORD32 k;

  FLOAT32 xp, xp2;

  FLOAT32 *ptr1, *ptr2;

  ptr1 = &ptr_a[0];

  ptr2 = &ptr_a[63];

  for (k = 31; k >= 0; k--) {

    xp = *ptr1;

    xp2 = *ptr2;

    *ptr2-- = xp;

    *ptr1++ = xp2;

  }

  ia_enhaacplus_enc_fct3_64(ptr_a, pstr_qmf_tab);

  ptr1 = &ptr_a[1];

  for (k = 15; k >= 0; k--) {

    xp = *ptr1;

    xp2 = *(ptr1 + 2);

    *ptr1++ = -xp;

    ptr1++;

    *ptr1++ = -xp2;

    ptr1++;

  }

}

static VOID ixheaace_sbr_pre_mdct(FLOAT32 *ptr_x, WORD32 len, const FLOAT32 *ptr_sine_window) {

  WORD32 i;

  FLOAT32 wre, wim, re1, re2, im1, im2;

  for (i = 0; i < len / 4; i++) {

    re1 = ptr_x[2 * i];

    re2 = ptr_x[2 * i + 1];

    im2 = ptr_x[len - 2 - 2 * i];

    im1 = ptr_x[len - 1 - 2 * i];

    wim = ptr_sine_window[2 * i];

    wre = ptr_sine_window[len - 1 - 2 * i];

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

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

    wre = ptr_sine_window[len - 2 - 2 * i];

    wim = ptr_sine_window[2 * i + 1];

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

    ptr_x[len - 1 - 2 * i] = -(im2 * wre - re2 * wim);

  }

}

static VOID ixheaace_sbr_pre_mdst(FLOAT32 *ptr_x, WORD32 len, const FLOAT32 *ptr_sine_window) {

  WORD32 i;

  FLOAT32 wre, wim, re1, re2, im1, im2;

  for (i = 0; i < len / 4; i++) {

    re1 = -ptr_x[2 * i];

    re2 = ptr_x[2 * i + 1];

    im2 = -ptr_x[len - 2 - 2 * i];

    im1 = ptr_x[len - 1 - 2 * i];

    wim = ptr_sine_window[2 * i];

    wre = ptr_sine_window[len - 1 - 2 * i];

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

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

    wim = ptr_sine_window[2 * i + 1];

    wre = ptr_sine_window[len - 2 - 2 * i];

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

    ptr_x[len - 1 - 2 * i] = -(im2 * wre - re2 * wim);

  }

}

static VOID ixheaace_sbr_post_mdct(FLOAT32 *ptr_x, WORD32 len, const FLOAT32 *ptr_trig_data) {

  WORD32 i;

  FLOAT32 wre, wim, re1, re2, im1, im2;

  FLOAT32 temp1 = -ptr_x[1];

  FLOAT32 temp2 = ptr_x[len / 2];

  FLOAT32 temp3 = ptr_x[len / 2 + 1];

  FLOAT32 val = 0.70709228515625f;

  re2 = ptr_x[len - 2];

  im2 = ptr_x[len - 1];

  for (i = 1; i < len / 4; i++) {

    wim = ptr_trig_data[i];

    wre = ptr_trig_data[len / 2 - 1 - i];

    ptr_x[2 * i - 1] = (re2 * wre - im2 * wim);

    ptr_x[len - 2 * i] = (re2 * wim + im2 * wre);

    re1 = ptr_x[2 * i];

    im1 = ptr_x[2 * i + 1];

    re2 = ptr_x[len - 2 - 2 * i];

    im2 = ptr_x[len - 1 - 2 * i];

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

    ptr_x[len - 1 - 2 * i] = (re1 * wim - im1 * wre);

  }

  ptr_x[len / 2 - 1] = (temp2 - temp3) * val;

  ptr_x[len / 2] = (temp2 + temp3) * val;

  ptr_x[len - 1] = temp1;

}

static VOID ixheaace_sbr_post_mdst(FLOAT32 *ptr_x, WORD32 len, const FLOAT32 *ptr_trig_data) {

  WORD32 i;

  FLOAT32 wre, wim, re1, re2, im1, im2;

  FLOAT32 temp0 = -ptr_x[0];

  FLOAT32 temp1 = ptr_x[1];

  FLOAT32 temp2 = ptr_x[len / 2];

  FLOAT32 temp3 = ptr_x[len / 2 + 1];

  FLOAT32 val = 0.70709228515625f;

  re2 = ptr_x[len - 2];

  im2 = ptr_x[len - 1];

  for (i = 1; i < len / 4; i++) {

    wim = ptr_trig_data[i];

    wre = ptr_trig_data[len / 2 - 1 - i];

    ptr_x[2 * i - 1] = -(re2 * wim + im2 * wre);

    ptr_x[len - 2 * i] = -(re2 * wre - im2 * wim);

    re1 = ptr_x[2 * i];

    im1 = ptr_x[2 * i + 1];

    re2 = ptr_x[len - 2 - 2 * i];

    im2 = ptr_x[len - 1 - 2 * i];

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

    ptr_x[2 * i] = -(re1 * wim - im1 * wre);

  }

  ptr_x[len / 2] = (temp3 - temp2) * val;

  ptr_x[len / 2 - 1] = -(temp3 + temp2) * val;

  ptr_x[0] = temp1;

  ptr_x[len - 1] = temp0;

}

static VOID ixheaace_sbr_mdct(FLOAT32 *ptr_dct_data, WORD32 n, FLOAT32 *ptr_sbr_scratch) {

  ixheaace_sbr_pre_mdct(ptr_dct_data, n, &long_window_sine_ld_64[0]);

  ia_enhaacplus_enc_complex_fft_p2(ptr_dct_data, n / 2, ptr_sbr_scratch);

  ixheaace_sbr_post_mdct(ptr_dct_data, n, &fft_twiddle_tab_32[0]);

}

static VOID ixheaace_sbr_mdst(FLOAT32 *ptr_dct_data, WORD32 n, FLOAT32 *ptr_sbr_scratch) {

  ixheaace_sbr_pre_mdst(ptr_dct_data, n, &long_window_sine_ld_64[0]);

  ia_enhaacplus_enc_complex_fft_p2(ptr_dct_data, n / 2, ptr_sbr_scratch);

  ixheaace_sbr_post_mdst(ptr_dct_data, n, &fft_twiddle_tab_32[0]);

}

static VOID ia_enhaacplus_enc_forward_modulation(const FLOAT32 *ptr_time_in,

                                                 FLOAT32 *ptr_r_subband, FLOAT32 *ptr_i_subband,

                                                 ixheaace_str_qmf_tabs *pstr_qmf_tab,

                                                 WORD32 is_ld_sbr, FLOAT32 *ptr_sbr_scratch) {

  WORD32 i;

  FLOAT32 tmp1, tmp2, tmp3, tmp4;

  const FLOAT32 *ptr_inp1, *ptr_inp2;

  FLOAT32 *ptr_re, *ptr_im;

  FLOAT32 real, imag;

  const FLOAT32 *ptr_window = &sbr_sin_cos_window[0];

  if (is_ld_sbr) {

    ptr_re = &ptr_r_subband[0];

    ptr_im = &ptr_i_subband[0];

    ptr_inp1 = &ptr_time_in[0];

  } else {

    ptr_r_subband[0] = ptr_time_in[0];

    ptr_re = &ptr_r_subband[1];

    ptr_im = &ptr_i_subband[0];

    ptr_inp1 = &ptr_time_in[1];

  }

  ptr_inp2 = &ptr_time_in[127];

  if (is_ld_sbr) {

    i = IXHEAACE_QMF_CHANNELS / 2 - 1;

    while (i >= 0) {

      tmp1 = *ptr_inp1++;

      tmp2 = *ptr_inp2--;

      tmp3 = *ptr_inp1++;

      tmp4 = *ptr_inp2--;

      *ptr_re++ = (tmp1 - tmp2);

      *ptr_im++ = (tmp1 + tmp2);

      *ptr_re++ = (tmp3 - tmp4);

      *ptr_im++ = (tmp3 + tmp4);

      i--;

    }

    ixheaace_sbr_mdct(ptr_r_subband, 64, ptr_sbr_scratch);

    ixheaace_sbr_mdst(ptr_i_subband, 64, ptr_sbr_scratch);

    i = 0;

    while (i < IXHEAACE_QMF_CHANNELS) {

      real = ptr_r_subband[i];

      imag = ptr_i_subband[i];

      ptr_r_subband[i] =

          imag * ptr_window[i] + real * ptr_window[2 * IXHEAACE_QMF_CHANNELS - 1 - i];

      ptr_i_subband[i] =

          imag * ptr_window[2 * IXHEAACE_QMF_CHANNELS - 1 - i] - real * ptr_window[i];

      i++;

    }

  } else {

    for (i = 30; i >= 0; i--) {

      tmp1 = *ptr_inp1++;

      tmp2 = *ptr_inp2--;

      tmp3 = *ptr_inp1++;

      *ptr_re++ = tmp1 - tmp2;

      tmp4 = *ptr_inp2--;

      *ptr_im++ = tmp1 + tmp2;

      *ptr_re++ = tmp3 - tmp4;

      *ptr_im++ = tmp3 + tmp4;

    }

    tmp1 = *ptr_inp1;

    tmp2 = *ptr_inp2;

    *ptr_re = tmp1 - tmp2;

    *ptr_im = tmp1 + tmp2;

    ptr_i_subband[63] = ptr_time_in[64];

    ia_enhaacplus_enc_fct3_64(ptr_r_subband, pstr_qmf_tab);

    ia_enhaacplus_enc_fst3_64(ptr_i_subband, pstr_qmf_tab);

  }

}

static VOID ia_enhaacplus_enc_sbr_qmf_analysis_win_add(const FLOAT32 *ptr_pf_l,

                                                       const FLOAT32 *ptr_pf_r, FLOAT32 *ptr_fp1,

                                                       FLOAT32 *ptr_fp2,

                                                       FLOAT32 *ptr_syn_buffer) {

  FLOAT32 accu_l = 0, accu_r = 0;

  WORD k;

  for (k = 0; k < 64; k++) {

    accu_l = 0;

    accu_r = 0;

    {

      accu_l += *ptr_pf_l++ * ptr_fp1[k];

      accu_l += *ptr_pf_l++ * ptr_fp1[128 + k];

      accu_l += *ptr_pf_l++ * ptr_fp1[256 + k];

      accu_l += *ptr_pf_l++ * ptr_fp1[384 + k];

      accu_l += *ptr_pf_l++ * ptr_fp1[512 + k];

      accu_r += *--ptr_pf_r * ptr_fp2[k];

      accu_r += *--ptr_pf_r * ptr_fp2[128 + k];

      accu_r += *--ptr_pf_r * ptr_fp2[256 + k];

      accu_r += *--ptr_pf_r * ptr_fp2[384 + k];

      accu_r += *--ptr_pf_r * ptr_fp2[512 + k];

    }

    ptr_syn_buffer[127 - k] = accu_l;

    ptr_syn_buffer[63 - k] = accu_r;

    ptr_pf_l += 5;

    ptr_pf_r -= 5;

  }

}

static VOID ia_enhaacplus_enc_sbr_cld_analysis_win_add(FLOAT32 *ptr_filter_states,

                                                       const FLOAT32 *ptr_coeffs,

                                                       FLOAT32 *ptr_sync_buffer,

                                                       WORD32 num_qmf_ch, WORD32 time_sn_stride) {

  WORD32 i;

  WORD32 len = num_qmf_ch * time_sn_stride;

  FLOAT32 *ptr_fil_states = &ptr_filter_states[CLD_FILTER_LENGTH - 1];

  memset(ptr_sync_buffer, 0, len * sizeof(*ptr_sync_buffer));

  for (i = 0; i < CLD_FILTER_LENGTH; i++) {

    ptr_sync_buffer[i % len] += (*ptr_fil_states-- * ptr_coeffs[i]);

  }

}

VOID ixheaace_sbr_analysis_filtering(const FLOAT32 *ptr_time_in, WORD32 time_sn_stride,

                                     FLOAT32 **ptr_ana_r, FLOAT32 **ptr_ana_i,

                                     ixheaace_pstr_sbr_qmf_filter_bank pstr_qmf_bank,

                                     ixheaace_str_qmf_tabs *pstr_qmf_tab, WORD32 num_qmf_subsamp,

                                     WORD32 is_ld_sbr, FLOAT32 *ptr_sbr_scratch,

                                     WORD32 is_ps_960) {

  WORD32 i, k;

  const FLOAT32 *ptr_pf_l, *ptr_pf_r;

  FLOAT32 *ptr_fp1, *ptr_fp2, *ptr_tmp;

  FLOAT32 syn_buffer[2 * IXHEAACE_QMF_CHANNELS] = {0};

  const FLOAT32 *ptr_start_coeff_l;

  const FLOAT32 *ptr_start_coeff_r;

  FLOAT32 *ptr_qmf_states_curr_pos;

  WORD32 start_coeff_cnt = 0;

  WORD16 flag = 0;

  WORD32 offset;

  if (is_ld_sbr) {

    offset = 576;

    i = 0;

    while (i < num_qmf_subsamp) {

      ptr_qmf_states_curr_pos = pstr_qmf_bank->ptr_qmf_states_curr_pos;

      if (ptr_time_in) {

        FLOAT32 *ptr_qmf_states = pstr_qmf_bank->ptr_qmf_states_curr_pos + offset;

        const FLOAT32 *ptr_inp = &ptr_time_in[(i * 64 * time_sn_stride)];

        FLOAT32 tmp1, tmp2, tmp3, tmp4;

        for (k = 15; k >= 0; k--) {

          tmp1 = *ptr_inp;

          ptr_inp += time_sn_stride;

          tmp2 = *ptr_inp;

          ptr_inp += time_sn_stride;

          tmp3 = *ptr_inp;

          ptr_inp += time_sn_stride;

          *ptr_qmf_states++ = tmp1;

          tmp4 = *ptr_inp;

          ptr_inp += time_sn_stride;

          *ptr_qmf_states++ = tmp2;

          *ptr_qmf_states++ = tmp3;

          *ptr_qmf_states++ = tmp4;

        }

      } else {

        memset(&ptr_qmf_states_curr_pos[0], 0,

               sizeof(ptr_qmf_states_curr_pos[0]) * IXHEAACE_QMF_CHANNELS);

      }

      ia_enhaacplus_enc_sbr_cld_analysis_win_add(&ptr_qmf_states_curr_pos[0],

                                                 pstr_qmf_bank->ptr_filter, syn_buffer,

                                                 IXHEAACE_QMF_CHANNELS, time_sn_stride);

      ia_enhaacplus_enc_forward_modulation(syn_buffer, &(ptr_ana_r[i][0]), &(ptr_ana_i[i][0]),

                                           pstr_qmf_tab, is_ld_sbr, ptr_sbr_scratch);

      for (k = 0; k < offset; k++) {

        pstr_qmf_bank->ptr_qmf_states_curr_pos[k] =

            pstr_qmf_bank->ptr_qmf_states_curr_pos[64 + k];

      }

      i++;

    }

  } else {

    flag = pstr_qmf_bank->flag;

    ptr_fp1 = pstr_qmf_bank->ptr_qmf_states_buf;

    ptr_fp2 = pstr_qmf_bank->ptr_qmf_states_buf + 64;

    pstr_qmf_bank->ptr_qmf_states_curr_pos =

        ((FLOAT32 *)(pstr_qmf_bank->ptr_qmf_states_buf) + (pstr_qmf_bank->offset * 64));

    if (pstr_qmf_bank->offset == 8) {

      pstr_qmf_bank->offset = 0;

    } else {

      pstr_qmf_bank->offset += 2;

    }

    ptr_start_coeff_l = pstr_qmf_bank->ptr_ref_coeff_l + pstr_qmf_bank->offset_l;

    ptr_start_coeff_r = pstr_qmf_bank->ptr_ref_coeff_r - pstr_qmf_bank->offset_r;

    for (i = 0; i < num_qmf_subsamp; i++) {

      ptr_qmf_states_curr_pos = pstr_qmf_bank->ptr_qmf_states_curr_pos;

      ptr_tmp = ptr_fp1;

      ptr_fp1 = ptr_fp2;

      ptr_fp2 = ptr_tmp;

      if (((1 == is_ld_sbr) && start_coeff_cnt) || ((0 == is_ld_sbr) && (i % 2))) {

        ptr_start_coeff_l--;

        if (ptr_start_coeff_l == pstr_qmf_bank->ptr_ref_coeff_l) {

          ptr_start_coeff_l += 5;

        }

      } else {

        ptr_start_coeff_r++;

        if (ptr_start_coeff_r == pstr_qmf_bank->ptr_ref_coeff_r) {

          ptr_start_coeff_r -= 5;

        }

      }

      if (ptr_time_in) {

        FLOAT32 *ptr_qmf_states = &ptr_qmf_states_curr_pos[0];

        const FLOAT32 *ptr_inp = &ptr_time_in[(i * 64 * time_sn_stride)];

        FLOAT32 tmp1, tmp2, tmp3, tmp4;

        for (k = 15; k >= 0; k--) {

          tmp1 = *ptr_inp;

          ptr_inp += time_sn_stride;

          tmp2 = *ptr_inp;

          ptr_inp += time_sn_stride;

          tmp3 = *ptr_inp;

          ptr_inp += time_sn_stride;

          *ptr_qmf_states++ = tmp1;

          tmp4 = *ptr_inp;

          ptr_inp += time_sn_stride;

          *ptr_qmf_states++ = tmp2;

          *ptr_qmf_states++ = tmp3;

          *ptr_qmf_states++ = tmp4;

        }

      } else {

        memset(&ptr_qmf_states_curr_pos[0], 0,

               sizeof(ptr_qmf_states_curr_pos[0]) * IXHEAACE_QMF_CHANNELS);

      }

      ptr_pf_l = ptr_start_coeff_l;

      ptr_pf_r = ptr_start_coeff_r;

      ia_enhaacplus_enc_sbr_qmf_analysis_win_add(ptr_pf_l, ptr_pf_r, ptr_fp1, ptr_fp2,

                                                 syn_buffer);

      ia_enhaacplus_enc_forward_modulation(syn_buffer, &(ptr_ana_r[i][0]), &(ptr_ana_i[i][0]),

                                           pstr_qmf_tab, is_ld_sbr, ptr_sbr_scratch);

      pstr_qmf_bank->ptr_qmf_states_curr_pos = pstr_qmf_bank->ptr_qmf_states_curr_pos + 64;

      if (pstr_qmf_bank->ptr_qmf_states_curr_pos == pstr_qmf_bank->ptr_qmf_states_buf + 640) {

        pstr_qmf_bank->ptr_qmf_states_curr_pos = pstr_qmf_bank->ptr_qmf_states_buf;

      }

    }

    pstr_qmf_bank->offset_l = ptr_start_coeff_l - pstr_qmf_bank->ptr_ref_coeff_l;

    pstr_qmf_bank->offset_r = pstr_qmf_bank->ptr_ref_coeff_r - ptr_start_coeff_r;

    pstr_qmf_bank->flag = flag;

  }

  if (is_ps_960 == 1) {

    memset(&ptr_ana_r[num_qmf_subsamp][0], 0, sizeof(ptr_ana_r[num_qmf_subsamp][0]) *

           IXHEAACE_QMF_CHANNELS * (IXHEAACE_QMF_TIME_SLOTS - num_qmf_subsamp));

    memset(&ptr_ana_i[num_qmf_subsamp][0], 0, sizeof(ptr_ana_i[num_qmf_subsamp][0]) *

           IXHEAACE_QMF_CHANNELS * (IXHEAACE_QMF_TIME_SLOTS - num_qmf_subsamp));

  }

}

VOID ixheaace_get_energy_from_cplx_qmf(

    FLOAT32 **ptr_energy_vals, FLOAT32 **ptr_real_values, FLOAT32 **ptr_imag_values,

    WORD32 is_ld_sbr, WORD32 num_time_slots, WORD32 samp_ratio_fac,

    ixheaace_str_hbe_enc *pstr_hbe_enc, WORD32 op_delay, WORD32 harmonic_sbr)

{

  WORD32 j, k;

  FLOAT32 avg_fac = 0.5f;

  if (samp_ratio_fac == 4) {

    avg_fac = 0.25f;

  }

  if (0 == is_ld_sbr) {

    FLOAT32 *ptr_energy_val = &ptr_energy_vals[0][0];

    FLOAT32 *ptr_hbe_real = NULL;

    FLOAT32 *ptr_hbe_imag = NULL;

    if (harmonic_sbr == 1) {

      ptr_hbe_real = &pstr_hbe_enc->qmf_buf_real[op_delay][0];

      ptr_hbe_imag = &pstr_hbe_enc->qmf_buf_imag[op_delay][0];

    }

    for (k = 0; k < num_time_slots; k++) {

      for (j = 0; j < IXHEAACE_QMF_CHANNELS; j++) {

        FLOAT32 tmp = 0.0f;

        if (harmonic_sbr == 1) {

          FLOAT32 real_hbe, imag_hbe;

          real_hbe = *(ptr_hbe_real);

          imag_hbe = *(ptr_hbe_imag);

          tmp += (real_hbe * real_hbe) + (imag_hbe * imag_hbe);

          *ptr_energy_val = tmp;

          ptr_hbe_real++;

          ptr_hbe_imag++;

          ptr_energy_val++;

        } else {

          FLOAT32 real, imag;

          WORD32 i, subband;

          subband = samp_ratio_fac * k;

          for (i = 0; i < samp_ratio_fac; i++) {

            real = ptr_real_values[subband + i][j];

            imag = ptr_imag_values[subband + i][j];

            tmp += (real * real) + (imag * imag);

          }

          ptr_energy_vals[k][j] = tmp * avg_fac;

        }

      }

      if (harmonic_sbr == 1) {

        ptr_hbe_real += 64;

        ptr_hbe_imag += 64;

      }

    }

  } else {

    FLOAT32 *ptr_real = &ptr_real_values[0][0];

    FLOAT32 *ptr_imag = &ptr_imag_values[0][0];

    for (k = 0; k < num_time_slots; k++) {

      FLOAT32 *ptr_energy_val = &ptr_energy_vals[k][0];

      for (j = 0; j < 64; j++) {

        FLOAT32 real, imag, tmp;

        real = *ptr_real;

        ptr_real++;

        imag = *ptr_imag;

        ptr_imag++;

        tmp = (real * real) + (imag * imag);

        *ptr_energy_val = tmp;

        ptr_energy_val++;

      }

    }

  }

}

VOID ixheaace_fft16(FLOAT32 *vector) {

  FLOAT32 var10, var11, var12, var13, var14, var15, var16, var17, var18, var19, var110, var111,

      var112, var113, var114, var115;