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

 *                                                                            *

 * Copyright (C) 2018 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 "ixheaacd_sbr_common.h"

#include "ixheaac_type_def.h"

#include "ixheaac_constants.h"

#include "ixheaac_basic_ops32.h"

#include "ixheaac_basic_ops16.h"

#include "ixheaac_basic_ops40.h"

#include "ixheaac_basic_ops.h"

#include "ixheaacd_intrinsics.h"

#include "ixheaacd_common_rom.h"

#include "ixheaacd_bitbuffer.h"

#include "ixheaacd_sbrdecsettings.h"

#include "ixheaacd_sbr_scale.h"

#include "ixheaacd_lpp_tran.h"

#include "ixheaacd_env_extr_part.h"

#include "ixheaacd_sbr_rom.h"

#include "ixheaacd_hybrid.h"

#include "ixheaacd_ps_dec.h"

#include "ixheaacd_env_extr.h"

#include "ixheaacd_qmf_dec.h"

#include "ixheaac_basic_op.h"

#include "ixheaacd_env_calc.h"

#include "ixheaacd_interface.h"

#include "ixheaacd_function_selector.h"

#include "ixheaacd_audioobjtypes.h"

#if !__ARM_NEON__

#define DCT3_LEN (32)

#define DCT2_LEN (64)

#define LP_SHIFT_VAL 7

#define HQ_SHIFT_64 4

#define RADIXSHIFT 1

#define HQ_SHIFT_VAL 4

extern const WORD32 ixheaacd_ldmps_polyphase_filter_coeff_fix[1280];

VOID ixheaacd_dct3_32(WORD32 *input, WORD32 *output,

                      const WORD16 *main_twidle_fwd, const WORD16 *post_tbl,

                      const WORD16 *w_16, const WORD32 *p_table) {

  WORD32 n, k;

  WORD32 temp1[6];

  WORD32 temp2[4];

  WORD16 twid_re, twid_im;

  WORD32 *ptr_reverse, *ptr_forward, *p_out, *ptr_out1;

  const WORD16 *twidle_fwd, *twidle_rev;

  ptr_forward = &input[49];

  ptr_reverse = &input[47];

  p_out = output;

  twidle_fwd = main_twidle_fwd;

  twidle_fwd += 4;

  *p_out++ = input[48] >> LP_SHIFT_VAL;

  *p_out++ = 0;

  for (n = 1; n < DCT3_LEN / 2; n++) {

    temp1[0] = *ptr_forward++;

    temp1[1] = *ptr_reverse--;

    temp1[0] = ixheaac_add32_sat(ixheaac_shr32(temp1[0], LP_SHIFT_VAL),

                                  ixheaac_shr32(temp1[1], LP_SHIFT_VAL));

    temp1[2] = *(ptr_forward - 33);

    temp1[3] = *(ptr_reverse - 31);

    temp1[1] = ixheaac_sub32_sat(ixheaac_shr32(temp1[2], LP_SHIFT_VAL),

                                  ixheaac_shr32(temp1[3], LP_SHIFT_VAL));

    twid_re = *twidle_fwd++;

    twid_im = *twidle_fwd;

    twidle_fwd += 3;

    *p_out++ = ixheaac_mult32x16in32(temp1[0], twid_re) +

               ixheaac_mult32x16in32(temp1[1], twid_im);

    *p_out++ = -ixheaac_mult32x16in32(temp1[1], twid_re) +

               ixheaac_mult32x16in32(temp1[0], twid_im);

  }

  twid_re = *twidle_fwd++;

  twid_im = *twidle_fwd;

  twidle_fwd += 3;

  temp1[1] = *ptr_reverse--;

  temp1[0] = *(ptr_reverse - 31);

  temp1[1] = ixheaac_sub32_sat(ixheaac_shr32(temp1[1], LP_SHIFT_VAL),

                                ixheaac_shr32(temp1[0], LP_SHIFT_VAL));

  temp1[0] = temp1[1];

  temp2[2] = ixheaac_mult32x16in32(temp1[0], twid_re) +

             ixheaac_mult32x16in32(temp1[1], twid_im);

  temp2[3] = -ixheaac_mult32x16in32(temp1[1], twid_re) +

             ixheaac_mult32x16in32(temp1[0], twid_im);

  ptr_forward = output;

  ptr_reverse = &output[DCT3_LEN - 1];

  temp2[0] = *ptr_forward++;

  temp2[1] = *ptr_forward--;

  temp1[0] = -temp2[1] - temp2[3];

  temp1[1] = temp2[0] - temp2[2];

  temp2[0] = (temp2[0] + temp2[2] + temp1[0]);

  temp2[1] = (temp2[1] - temp2[3] + temp1[1]);

  temp2[0] >>= 1;

  temp2[1] >>= 1;

  *ptr_forward++ = temp2[0];

  *ptr_forward++ = temp2[1];

  twidle_fwd = post_tbl + 2;

  twidle_rev = post_tbl + 14;

  for (n = 1; n < DCT3_LEN / 4; n++) {

    temp2[0] = *ptr_forward++;

    temp2[1] = *ptr_forward--;

    temp2[3] = *ptr_reverse--;

    temp2[2] = *ptr_reverse++;

    twid_re = *twidle_rev;

    twidle_rev -= 2;

    twid_im = *twidle_fwd;

    twidle_fwd += 2;

    temp1[0] = temp2[0] - temp2[2];

    temp1[1] = (temp2[0] + temp2[2]);

    temp1[2] = temp2[1] + temp2[3];

    temp1[3] = (temp2[1] - temp2[3]);

    temp1[4] = ixheaac_mult32x16in32(temp1[0], twid_re) +

               ixheaac_mult32x16in32(temp1[2], twid_im);

    temp1[5] = -ixheaac_mult32x16in32(temp1[2], twid_re) +

               ixheaac_mult32x16in32(temp1[0], twid_im);

    temp1[1] >>= 1;

    temp1[3] >>= 1;

    *ptr_forward++ = temp1[1] - temp1[4];

    *ptr_forward++ = temp1[3] + temp1[5];

    *ptr_reverse-- = -temp1[3] + temp1[5];

    *ptr_reverse-- = temp1[1] + temp1[4];

  }

  temp2[0] = *ptr_forward++;

  temp2[1] = *ptr_forward--;

  temp2[3] = *ptr_reverse--;

  temp2[2] = *ptr_reverse++;

  twid_re = -*twidle_rev;

  twidle_rev -= 2;

  twid_im = *twidle_fwd;

  twidle_fwd += 2;

  temp1[0] = temp2[0] - temp2[2];

  temp1[1] = (temp2[0] + temp2[2]);

  temp1[2] = temp2[1] + temp2[3];

  temp1[3] = (temp2[1] - temp2[3]);

  temp1[4] = ixheaac_mult32x16in32(temp1[0], twid_re) -

             ixheaac_mult32x16in32(temp1[2], twid_im);

  temp1[5] = ixheaac_mult32x16in32(temp1[2], twid_re) +

             ixheaac_mult32x16in32(temp1[0], twid_im);

  temp1[1] >>= 1;

  temp1[3] >>= 1;

  *ptr_forward++ = temp1[1] + temp1[4];

  *ptr_forward++ = temp1[3] + temp1[5];

  ixheaacd_radix4bfly(w_16, output, 1, 4);

  ixheaacd_postradixcompute4(input, output, p_table, 16);

  output[0] = input[0];

  output[2] = input[1];

  p_out = input + 2;

  ptr_forward = output + 1;

  ptr_reverse = output + 30;

  ptr_out1 = input + 18;

  for (k = (DCT3_LEN / 4) - 1; k != 0; k--) {

    WORD32 tempre, tempim;

    tempre = *p_out++;

    tempim = *p_out++;

    *ptr_forward = (tempim);

    ptr_forward += 2;

    *ptr_forward = (tempre);

    ptr_forward += 2;

    tempre = *ptr_out1++;

    tempim = *ptr_out1++;

    *ptr_reverse = (tempim);

    ptr_reverse -= 2;

    *ptr_reverse = (tempre);

    ptr_reverse -= 2;

  }

  {

    WORD32 tempre, tempim;

    tempre = *p_out++;

    tempim = *p_out++;

    *ptr_forward = (tempim);

    ptr_forward += 2;

    *ptr_forward = (tempre);

    ptr_forward += 2;

  }

  return;

}

VOID ixheaacd_dct2_64(WORD32 *x, WORD32 *X,

                      ia_qmf_dec_tables_struct *qmf_dec_tables_ptr,

                      WORD16 *filter_states) {

  ixheaacd_pretwdct2(x, X);

  ixheaacd_radix4bfly(qmf_dec_tables_ptr->w_32, X, 1, 8);

  ixheaacd_radix4bfly(qmf_dec_tables_ptr->w_32 + 48, X, 4, 2);

  ixheaacd_postradixcompute2(x, X, qmf_dec_tables_ptr->dig_rev_table2_32, 32);

  ixheaacd_fftposttw(x, qmf_dec_tables_ptr);

  ixheaacd_posttwdct2(x, filter_states, qmf_dec_tables_ptr);

  return;

}

VOID ixheaacd_cos_sin_mod(WORD32 *subband,

                          ia_sbr_qmf_filter_bank_struct *qmf_bank,

                          WORD16 *p_twiddle, WORD32 *p_dig_rev_tbl) {

  WORD32 re2, re3;

  WORD16 wim, wre;

  WORD32 i, M_2;

  WORD32 M = ixheaac_shr32(qmf_bank->no_channels, 1);

  const WORD16 *p_sin;

  const WORD16 *p_sin_cos = &qmf_bank->cos_twiddle[0];

  WORD32 subband_tmp[128];

  WORD32 re;

  WORD32 im;

  WORD32 *psubband, *psubband1;

  WORD32 *psubband_t, *psubband1_t;

  WORD32 *psubband2, *psubband12;

  WORD32 *psubband_t2, *psubband1_t2;

  M_2 = ixheaac_shr32(M, 1);

  psubband = &subband[0];

  psubband1 = &subband[2 * M - 1];

  psubband_t = subband_tmp;

  psubband1_t = &subband_tmp[2 * M - 1];

  psubband2 = &subband[64];

  psubband12 = &subband[2 * M - 1 + 64];

  psubband_t2 = &subband_tmp[64];

  psubband1_t2 = &subband_tmp[2 * M - 1 + 64];

  for (i = (M_2 >> 1) - 1; i >= 0; i--) {

    re = *psubband++;

    im = *psubband1--;

    wim = *p_sin_cos++;

    wre = *p_sin_cos++;

    *psubband_t++ = ixheaac_add32_sat(ixheaac_mult32x16in32(re, wre),

                                       ixheaac_mult32x16in32(im, wim));

    *psubband_t++ = ixheaac_sub32_sat(ixheaac_mult32x16in32(im, wre),

                                       ixheaac_mult32x16in32(re, wim));

    re = *psubband2++;

    im = *psubband12--;

    *psubband_t2++ = ixheaac_sub32_sat(ixheaac_mult32x16in32(im, wim),

                                        ixheaac_mult32x16in32(re, wre));

    *psubband_t2++ = ixheaac_add32_sat(ixheaac_mult32x16in32(re, wim),

                                        ixheaac_mult32x16in32(im, wre));

    re = *psubband1--;

    im = *psubband++;

    wim = *p_sin_cos++;

    wre = *p_sin_cos++;

    *psubband1_t-- = ixheaac_sub32_sat(ixheaac_mult32x16in32(im, wre),

                                        ixheaac_mult32x16in32(re, wim));

    *psubband1_t-- = ixheaac_add32_sat(ixheaac_mult32x16in32(re, wre),

                                        ixheaac_mult32x16in32(im, wim));

    re = *psubband12--;

    im = *psubband2++;

    *psubband1_t2-- = ixheaac_add32_sat(ixheaac_mult32x16in32(re, wim),

                                         ixheaac_mult32x16in32(im, wre));

    *psubband1_t2-- = ixheaac_sub32_sat(ixheaac_mult32x16in32(im, wim),

                                         ixheaac_mult32x16in32(re, wre));

    re = *psubband++;

    im = *psubband1--;

    wim = *p_sin_cos++;

    wre = *p_sin_cos++;

    *psubband_t++ = ixheaac_add32_sat(ixheaac_mult32x16in32(re, wre),

                                       ixheaac_mult32x16in32(im, wim));

    *psubband_t++ = ixheaac_sub32_sat(ixheaac_mult32x16in32(im, wre),

                                       ixheaac_mult32x16in32(re, wim));

    re = *psubband2++;

    im = *psubband12--;

    *psubband_t2++ = ixheaac_sub32_sat(ixheaac_mult32x16in32(im, wim),

                                        ixheaac_mult32x16in32(re, wre));

    *psubband_t2++ = ixheaac_add32_sat(ixheaac_mult32x16in32(re, wim),

                                        ixheaac_mult32x16in32(im, wre));

    re = *psubband1--;

    im = *psubband++;

    wim = *p_sin_cos++;

    wre = *p_sin_cos++;

    *psubband1_t-- = ixheaac_sub32_sat(ixheaac_mult32x16in32(im, wre),

                                        ixheaac_mult32x16in32(re, wim));

    *psubband1_t-- = ixheaac_add32_sat(ixheaac_mult32x16in32(re, wre),

                                        ixheaac_mult32x16in32(im, wim));

    re = *psubband12--;

    im = *psubband2++;

    ;

    *psubband1_t2-- = ixheaac_add32_sat(ixheaac_mult32x16in32(re, wim),

                                         ixheaac_mult32x16in32(im, wre));

    *psubband1_t2-- = ixheaac_sub32_sat(ixheaac_mult32x16in32(im, wim),

                                         ixheaac_mult32x16in32(re, wre));

  }

  if (M == 32) {

    ixheaacd_radix4bfly(p_twiddle, subband_tmp, 1, 8);

    ixheaacd_radix4bfly(p_twiddle + 48, subband_tmp, 4, 2);

    ixheaacd_postradixcompute2(subband, subband_tmp, p_dig_rev_tbl, 32);

    ixheaacd_radix4bfly(p_twiddle, &subband_tmp[64], 1, 8);

    ixheaacd_radix4bfly(p_twiddle + 48, &subband_tmp[64], 4, 2);

    ixheaacd_postradixcompute2(&subband[64], &subband_tmp[64], p_dig_rev_tbl,

                               32);

  } else {

    ixheaacd_radix4bfly(p_twiddle, subband_tmp, 1, 4);

    ixheaacd_postradixcompute4(subband, subband_tmp, p_dig_rev_tbl, 16);

    ixheaacd_radix4bfly(p_twiddle, &subband_tmp[64], 1, 4);

    ixheaacd_postradixcompute4(&subband[64], &subband_tmp[64], p_dig_rev_tbl,

                               16);

  }

  psubband = &subband[0];

  psubband1 = &subband[2 * M - 1];

  re = *psubband1;

  *psubband = *psubband >> 1;

  psubband++;

  *psubband1 = ixheaac_negate32_sat(*psubband >> 1);

  psubband1--;

  p_sin = &qmf_bank->alt_sin_twiddle[0];

  wim = *p_sin++;

  wre = *p_sin++;

  im = *psubband1;

  *psubband1-- = ixheaac_add32_sat(ixheaac_mult32x16in32(re, wre),

                                    ixheaac_mult32x16in32(im, wim));

  *psubband++ = ixheaac_sub32_sat(ixheaac_mult32x16in32(im, wre),

                                   ixheaac_mult32x16in32(re, wim));

  psubband2 = &subband[64];

  psubband12 = &subband[2 * M - 1 + 64];

  re = *psubband12;

  *psubband12-- = ixheaac_negate32_sat(*psubband2 >> 1);

  *psubband2 = psubband2[1] >> 1;

  psubband2++;

  im = *psubband12;

  *psubband2++ = ixheaac_negate32_sat(ixheaac_add32_sat(

      ixheaac_mult32x16in32(re, wre), ixheaac_mult32x16in32(im, wim)));

  *psubband12-- = ixheaac_sub32_sat(ixheaac_mult32x16in32(re, wim),

                                     ixheaac_mult32x16in32(im, wre));

  for (i = (M_2 - 2); i >= 0; i--) {

    im = psubband[0];

    re = psubband[1];

    re2 = *psubband1;

    *psubband++ = ixheaac_add32_sat(ixheaac_mult32x16in32(re, wim),

                                     ixheaac_mult32x16in32(im, wre));

    *psubband1-- = ixheaac_sub32_sat(ixheaac_mult32x16in32(im, wim),

                                      ixheaac_mult32x16in32(re, wre));

    im = psubband2[0];

    re = psubband2[1];

    re3 = *psubband12;

    *psubband12-- = ixheaac_negate32_sat(ixheaac_add32_sat(

        ixheaac_mult32x16in32(re, wim), ixheaac_mult32x16in32(im, wre)));

    *psubband2++ = ixheaac_sub32_sat(ixheaac_mult32x16in32(re, wre),

                                      ixheaac_mult32x16in32(im, wim));

    wim = *p_sin++;

    wre = *p_sin++;

    im = psubband1[0];

    *psubband1-- = ixheaac_add32_sat(ixheaac_mult32x16in32(re2, wre),

                                      ixheaac_mult32x16in32(im, wim));

    *psubband++ = ixheaac_sub32_sat(ixheaac_mult32x16in32(im, wre),

                                     ixheaac_mult32x16in32(re2, wim));

    im = psubband12[0];

    *psubband2++ = ixheaac_negate32_sat(ixheaac_add32_sat(

        ixheaac_mult32x16in32(re3, wre), ixheaac_mult32x16in32(im, wim)));

    *psubband12-- = ixheaac_sub32_sat(ixheaac_mult32x16in32(re3, wim),

                                       ixheaac_mult32x16in32(im, wre));

  }

}

VOID ixheaacd_fwd_modulation(const WORD32 *p_time_in1, WORD32 *real_subband,

                             WORD32 *imag_subband,

                             ia_sbr_qmf_filter_bank_struct *qmf_bank,

                             ia_qmf_dec_tables_struct *qmf_dec_tables_ptr,

                             WORD32 ld_mps_flag) {

  WORD32 i;

  const WORD32 *p_time_in2 = &p_time_in1[2 * qmf_bank->no_channels - 1];

  WORD32 temp1, temp2;

  WORD32 *t_real_subband = real_subband;

  WORD32 *t_imag_subband = imag_subband;

  const WORD16 *tcos;

  for (i = qmf_bank->no_channels - 1; i >= 0; i--) {

    temp1 = ixheaac_shr32(*p_time_in1++, HQ_SHIFT_VAL);

    temp2 = ixheaac_shr32(*p_time_in2--, HQ_SHIFT_VAL);

    *t_real_subband++ = ixheaac_sub32_sat(temp1, temp2);

    *t_imag_subband++ = ixheaac_add32_sat(temp1, temp2);

  }

  if (qmf_bank->no_channels != 64)

    ixheaacd_cos_sin_mod(real_subband, qmf_bank, qmf_dec_tables_ptr->w_16,

                         qmf_dec_tables_ptr->dig_rev_table4_16);

  else

    ixheaacd_cos_sin_mod(real_subband, qmf_bank, qmf_dec_tables_ptr->w_32,

                         qmf_dec_tables_ptr->dig_rev_table2_32);

  if (ld_mps_flag == 0) {

    tcos = qmf_bank->t_cos;

    for (i = (qmf_bank->usb - qmf_bank->lsb - 1); i >= 0; i--) {

      WORD16 cosh, sinh;

      WORD32 re, im;

      re = *real_subband;

      im = *imag_subband;

      cosh = *tcos++;

      sinh = *tcos++;

      *real_subband++ =

          ixheaac_add32_sat(ixheaac_mult32x16in32_shl(re, cosh),

                             ixheaac_mult32x16in32_shl(im, sinh));

      *imag_subband++ =

          ixheaac_sub32_sat(ixheaac_mult32x16in32_shl(im, cosh),

                             ixheaac_mult32x16in32_shl(re, sinh));

    }

  } else {

    WORD32 i_band;

    for (i = 0; i < min(64, qmf_bank->no_channels); i += 2) {

      i_band = real_subband[i];

      real_subband[i] = -imag_subband[i];

      imag_subband[i] = i_band;

      i_band = -real_subband[i + 1];

      real_subband[i + 1] = imag_subband[i + 1];

      imag_subband[i + 1] = i_band;

    }

  }

}

VOID ixheaacd_sbr_qmfanal32_winadd(WORD16 *inp1, WORD16 *inp2,

                                   const WORD16 *p_qmf1, const WORD16 *p_qmf2,

                                   WORD32 *p_out) {

  WORD32 n;

  for (n = 0; n < 32; n += 2) {

    WORD32 accu;

    accu = ixheaac_mult16x16in32(inp1[n + 0], p_qmf1[2 * (n + 0)]);

    accu = ixheaac_add32_sat(

        accu, ixheaac_mult16x16in32(inp1[n + 64], p_qmf1[2 * (n + 64)]));

    accu = ixheaac_add32_sat(

        accu, ixheaac_mult16x16in32(inp1[n + 128], p_qmf1[2 * (n + 128)]));

    accu = ixheaac_add32_sat(

        accu, ixheaac_mult16x16in32(inp1[n + 192], p_qmf1[2 * (n + 192)]));

    accu = ixheaac_add32_sat(

        accu, ixheaac_mult16x16in32(inp1[n + 256], p_qmf1[2 * (n + 256)]));

    p_out[n] = accu;

    accu = ixheaac_mult16x16in32(inp1[n + 1 + 0], p_qmf1[2 * (n + 1 + 0)]);

    accu = ixheaac_add32_sat(

        accu,

        ixheaac_mult16x16in32(inp1[n + 1 + 64], p_qmf1[2 * (n + 1 + 64)]));

    accu = ixheaac_add32_sat(

        accu,

        ixheaac_mult16x16in32(inp1[n + 1 + 128], p_qmf1[2 * (n + 1 + 128)]));

    accu = ixheaac_add32_sat(

        accu,

        ixheaac_mult16x16in32(inp1[n + 1 + 192], p_qmf1[2 * (n + 1 + 192)]));

    accu = ixheaac_add32_sat(

        accu,

        ixheaac_mult16x16in32(inp1[n + 1 + 256], p_qmf1[2 * (n + 1 + 256)]));

    p_out[n + 1] = accu;

    accu = ixheaac_mult16x16in32(inp2[n + 0], p_qmf2[2 * (n + 0)]);

    accu = ixheaac_add32_sat(

        accu, ixheaac_mult16x16in32(inp2[n + 64], p_qmf2[2 * (n + 64)]));

    accu = ixheaac_add32_sat(

        accu, ixheaac_mult16x16in32(inp2[n + 128], p_qmf2[2 * (n + 128)]));

    accu = ixheaac_add32_sat(

        accu, ixheaac_mult16x16in32(inp2[n + 192], p_qmf2[2 * (n + 192)]));

    accu = ixheaac_add32_sat(

        accu, ixheaac_mult16x16in32(inp2[n + 256], p_qmf2[2 * (n + 256)]));

    p_out[n + 32] = accu;

    accu = ixheaac_mult16x16in32(inp2[n + 1 + 0], p_qmf2[2 * (n + 1 + 0)]);

    accu = ixheaac_add32_sat(

        accu,

        ixheaac_mult16x16in32(inp2[n + 1 + 64], p_qmf2[2 * (n + 1 + 64)]));

    accu = ixheaac_add32_sat(

        accu,

        ixheaac_mult16x16in32(inp2[n + 1 + 128], p_qmf2[2 * (n + 1 + 128)]));

    accu = ixheaac_add32_sat(

        accu,

        ixheaac_mult16x16in32(inp2[n + 1 + 192], p_qmf2[2 * (n + 1 + 192)]));

    accu = ixheaac_add32_sat(

        accu,

        ixheaac_mult16x16in32(inp2[n + 1 + 256], p_qmf2[2 * (n + 1 + 256)]));

    p_out[n + 1 + 32] = accu;

  }

}

VOID ixheaacd_cplx_anal_qmffilt(const WORD16 *time_sample_buf,

                                ia_sbr_scale_fact_struct *sbr_scale_factor,

                                WORD32 **qmf_real, WORD32 **qmf_imag,

                                ia_sbr_qmf_filter_bank_struct *qmf_bank,

                                ia_qmf_dec_tables_struct *qmf_dec_tables_ptr,

                                WORD32 ch_fac, WORD32 low_pow_flag,

                                WORD audio_object_type) {

  WORD32 i, k;

  WORD32 num_time_slots = qmf_bank->num_time_slots;

  WORD32 analysis_buffer[4 * NO_ANALYSIS_CHANNELS] = { 0 };

  WORD16 *filter_states = qmf_bank->core_samples_buffer;

  WORD16 *fp1, *fp2, *tmp;

  WORD16 *filter_1;

  WORD16 *filter_2;

  WORD16 *filt_ptr;

  WORD32 start_slot = 0;

  if (audio_object_type != AOT_ER_AAC_ELD &&

      audio_object_type != AOT_ER_AAC_LD) {

    qmf_bank->filter_pos +=

        (qmf_dec_tables_ptr->qmf_c - qmf_bank->analy_win_coeff);

    qmf_bank->analy_win_coeff = qmf_dec_tables_ptr->qmf_c;

  } else {

    qmf_bank->filter_pos +=

        (qmf_dec_tables_ptr->qmf_c_eld3 - qmf_bank->analy_win_coeff);

    qmf_bank->analy_win_coeff = qmf_dec_tables_ptr->qmf_c_eld3;

  }

  filter_1 = qmf_bank->filter_pos;

  if (audio_object_type != AOT_ER_AAC_ELD &&

      audio_object_type != AOT_ER_AAC_LD) {

    filter_2 = filter_1 + 64;

  } else {

    filter_2 = filter_1 + qmf_bank->no_channels;

  }

  sbr_scale_factor->st_lb_scale = 0;

  sbr_scale_factor->lb_scale = -10;

  if (!low_pow_flag) {

    if (audio_object_type != AOT_ER_AAC_ELD &&

        audio_object_type != AOT_ER_AAC_LD) {

      sbr_scale_factor->lb_scale = -8;

    } else {

      sbr_scale_factor->lb_scale = -9;

    }

    if (qmf_bank->no_channels != 64) {

      qmf_bank->cos_twiddle =

          (WORD16 *)qmf_dec_tables_ptr->sbr_sin_cos_twiddle_l32;

      qmf_bank->alt_sin_twiddle =

          (WORD16 *)qmf_dec_tables_ptr->sbr_alt_sin_twiddle_l32;

    } else {

      qmf_bank->cos_twiddle =

          (WORD16 *)qmf_dec_tables_ptr->sbr_sin_cos_twiddle_l64;

      qmf_bank->alt_sin_twiddle =

          (WORD16 *)qmf_dec_tables_ptr->sbr_alt_sin_twiddle_l64;

    }

    if (audio_object_type != AOT_ER_AAC_ELD &&

        audio_object_type != AOT_ER_AAC_LD) {

      qmf_bank->t_cos = (WORD16 *)qmf_dec_tables_ptr->sbr_t_cos_sin_l32;

    } else {

      qmf_bank->t_cos =

          (WORD16 *)qmf_dec_tables_ptr->ixheaacd_sbr_t_cos_sin_l32_eld;

    }

  }

  fp1 = qmf_bank->anal_filter_states;

  fp2 = qmf_bank->anal_filter_states + qmf_bank->no_channels;

  if (audio_object_type == AOT_ER_AAC_ELD ||

      audio_object_type == AOT_ER_AAC_LD) {

    filter_2 = qmf_bank->filter_2;

    fp1 = qmf_bank->fp1_anal;

    fp2 = qmf_bank->fp2_anal;

  }

  for (i = start_slot; i < num_time_slots + start_slot; i++) {

    for (k = 0; k < qmf_bank->no_channels; k++)

      filter_states[qmf_bank->no_channels - 1 - k] =

          time_sample_buf[ch_fac * k];

    if (audio_object_type != AOT_ER_AAC_ELD &&

        audio_object_type != AOT_ER_AAC_LD) {

      ixheaacd_sbr_qmfanal32_winadd(fp1, fp2, filter_1, filter_2,

                                    analysis_buffer);

    } else {

      ixheaacd_sbr_qmfanal32_winadd_eld(fp1, fp2, filter_1, filter_2,

                                        analysis_buffer);

    }

    time_sample_buf += qmf_bank->no_channels * ch_fac;

    filter_states -= qmf_bank->no_channels;

    if (filter_states < qmf_bank->anal_filter_states) {

      filter_states = qmf_bank->anal_filter_states +

                      ((qmf_bank->no_channels * 10) - qmf_bank->no_channels);

    }

    tmp = fp1;

    fp1 = fp2;

    fp2 = tmp;

    if (audio_object_type != AOT_ER_AAC_ELD &&

        audio_object_type != AOT_ER_AAC_LD) {

      filter_1 += 64;

      filter_2 += 64;

    } else {

      filter_1 += qmf_bank->no_channels;

      filter_2 += qmf_bank->no_channels;

    }

    filt_ptr = filter_1;

    filter_1 = filter_2;

    filter_2 = filt_ptr;

    if (audio_object_type != AOT_ER_AAC_ELD &&

        audio_object_type != AOT_ER_AAC_LD) {

      if (filter_2 > (qmf_bank->analy_win_coeff + 640)) {

        filter_1 = (WORD16 *)qmf_bank->analy_win_coeff;

        filter_2 = (WORD16 *)qmf_bank->analy_win_coeff + 64;

      }

    } else {

      if (filter_2 >

          (qmf_bank->analy_win_coeff + (qmf_bank->no_channels * 10))) {

        filter_1 = (WORD16 *)qmf_bank->analy_win_coeff;

        filter_2 = (WORD16 *)qmf_bank->analy_win_coeff + qmf_bank->no_channels;

      }

    }

    if (!low_pow_flag) {

      ixheaacd_fwd_modulation(analysis_buffer, qmf_real[i], qmf_imag[i],

                              qmf_bank, qmf_dec_tables_ptr, 0);

    } else {

      ixheaacd_dct3_32(

          (WORD32 *)analysis_buffer, qmf_real[i], qmf_dec_tables_ptr->dct23_tw,

          qmf_dec_tables_ptr->post_fft_tbl, qmf_dec_tables_ptr->w_16,

          qmf_dec_tables_ptr->dig_rev_table4_16);

    }

  }

  qmf_bank->filter_pos = filter_1;

  qmf_bank->core_samples_buffer = filter_states;

  if (audio_object_type == AOT_ER_AAC_ELD || audio_object_type == AOT_ER_AAC_LD)

  {

    qmf_bank->fp1_anal = fp1;

    qmf_bank->fp2_anal = fp2;

    qmf_bank->filter_2 = filter_2;

  }

}

VOID ixheaacd_cplx_anal_qmffilt_32(const WORD32 *time_sample_buf,

                                   ia_sbr_scale_fact_struct *sbr_scale_factor,

                                   WORD32 **qmf_real, WORD32 **qmf_imag,

                                   ia_sbr_qmf_filter_bank_struct *qmf_bank,

                                   ia_qmf_dec_tables_struct *qmf_dec_tables_ptr,

                                   WORD32 ch_fac, WORD32 ldsbr_present) {

  WORD32 i, k;

  WORD32 num_time_slots = qmf_bank->num_time_slots;

  WORD32 analysis_buffer[4 * NO_ANALYSIS_CHANNELS];

  WORD32 *filter_states = qmf_bank->core_samples_buffer_32;

  WORD32 *fp1, *fp2, *tmp;

  WORD32 *filter_1;

  WORD32 *filter_2;

  WORD32 *filt_ptr;

  WORD32 start_slot = 2;

  if (ldsbr_present) {

    qmf_bank->filter_pos_32 +=

        (qmf_dec_tables_ptr->qmf_c_ldsbr_mps - qmf_bank->analy_win_coeff_32);

    qmf_bank->analy_win_coeff_32 = qmf_dec_tables_ptr->qmf_c_ldsbr_mps;

  } else {

    qmf_bank->filter_pos_32 += (ixheaacd_ldmps_polyphase_filter_coeff_fix -

                                qmf_bank->analy_win_coeff_32);

    qmf_bank->analy_win_coeff_32 =

        (WORD32 *)ixheaacd_ldmps_polyphase_filter_coeff_fix;

  }

  filter_1 = qmf_bank->filter_pos_32;

  filter_2 = filter_1 + qmf_bank->no_channels;

  sbr_scale_factor->st_lb_scale = 0;

  sbr_scale_factor->lb_scale = -10;

  sbr_scale_factor->lb_scale = -9;

  if (qmf_bank->no_channels != 64) {

    qmf_bank->cos_twiddle =

        (WORD16 *)qmf_dec_tables_ptr->sbr_sin_cos_twiddle_l32;

    qmf_bank->alt_sin_twiddle =

        (WORD16 *)qmf_dec_tables_ptr->sbr_alt_sin_twiddle_l32;

  } else {

    qmf_bank->cos_twiddle =

        (WORD16 *)qmf_dec_tables_ptr->sbr_sin_cos_twiddle_l64;

    qmf_bank->alt_sin_twiddle =

        (WORD16 *)qmf_dec_tables_ptr->sbr_alt_sin_twiddle_l64;

  }

  qmf_bank->t_cos =

      (WORD16 *)qmf_dec_tables_ptr->ixheaacd_sbr_t_cos_sin_l32_eld;

  fp1 = qmf_bank->anal_filter_states_32;

  fp2 = qmf_bank->anal_filter_states_32 + qmf_bank->no_channels;

  filter_2 = qmf_bank->filter_2_32;

  fp1 = qmf_bank->fp1_anal_32;

  fp2 = qmf_bank->fp2_anal_32;

  for (i = start_slot; i < num_time_slots + start_slot; i++) {

    for (k = 0; k < qmf_bank->no_channels; k++)

      filter_states[qmf_bank->no_channels - 1 - k] =

          time_sample_buf[ch_fac * k];

    if (ldsbr_present) {

      ixheaacd_sbr_qmfanal32_winadd_eld_32(fp1, fp2, filter_1, filter_2,

                                           analysis_buffer);

    } else {

      ixheaacd_sbr_qmfanal32_winadd_eld_mps(fp1, fp2, filter_1, filter_2,

                                            analysis_buffer);

    }

    time_sample_buf += qmf_bank->no_channels * ch_fac;

    filter_states -= qmf_bank->no_channels;

    if (filter_states < qmf_bank->anal_filter_states_32) {

      filter_states = qmf_bank->anal_filter_states_32 +

                      ((qmf_bank->no_channels * 10) - qmf_bank->no_channels);

    }

    tmp = fp1;

    fp1 = fp2;

    fp2 = tmp;

    filter_1 += qmf_bank->no_channels;

    filter_2 += qmf_bank->no_channels;

    filt_ptr = filter_1;

    filter_1 = filter_2;

    filter_2 = filt_ptr;

    if (filter_2 >

        (qmf_bank->analy_win_coeff_32 + (qmf_bank->no_channels * 10))) {

      filter_1 = (WORD32 *)qmf_bank->analy_win_coeff_32;

      filter_2 = (WORD32 *)qmf_bank->analy_win_coeff_32 + qmf_bank->no_channels;

    }

    ixheaacd_fwd_modulation(analysis_buffer, qmf_real[i], qmf_imag[i], qmf_bank,

                            qmf_dec_tables_ptr, 1);

  }

  qmf_bank->filter_pos_32 = filter_1;

  qmf_bank->core_samples_buffer_32 = filter_states;

  qmf_bank->fp1_anal_32 = fp1;

  qmf_bank->fp2_anal_32 = fp2;

  qmf_bank->filter_2_32 = filter_2;

}

VOID ixheaacd_inv_modulation_lp(WORD32 *qmf_real, WORD16 *filter_states,

                                ia_sbr_qmf_filter_bank_struct *syn_qmf,

                                ia_qmf_dec_tables_struct *qmf_dec_tables_ptr) {

  WORD32 L = syn_qmf->no_channels;

  const WORD32 M = (L >> 1);

  WORD32 *dct_in = qmf_real;

  WORD32 time_out[2 * NO_SYNTHESIS_CHANNELS];

  WORD32 *ptime_out = &time_out[0];

  if (L == 64)

    ixheaacd_dct2_64(dct_in, ptime_out, qmf_dec_tables_ptr, filter_states + M);

  else

    ixheaacd_dct2_32(dct_in, time_out, qmf_dec_tables_ptr, filter_states);

  filter_states[3 * M] = 0;

}

VOID ixheaacd_inv_emodulation(WORD32 *qmf_real,

                              ia_sbr_qmf_filter_bank_struct *syn_qmf,

                              ia_qmf_dec_tables_struct *qmf_dec_tables_ptr) {

  if (syn_qmf->no_channels == 64)

    ixheaacd_cos_sin_mod(qmf_real, syn_qmf, qmf_dec_tables_ptr->w_32,

                         qmf_dec_tables_ptr->dig_rev_table2_32);

  else

    ixheaacd_cos_sin_mod(qmf_real, syn_qmf, qmf_dec_tables_ptr->w_16,

                         qmf_dec_tables_ptr->dig_rev_table4_16);

}

VOID ixheaacd_esbr_radix4bfly(const WORD32 *w, WORD32 *x, WORD32 index1,

                              WORD32 index) {

  int i;

  WORD32 l1, l2, h2, fft_jmp;

  WORD32 xt0_0, yt0_0, xt1_0, yt1_0, xt2_0, yt2_0;

  WORD32 xh0_0, xh1_0, xh20_0, xh21_0, xl0_0, xl1_0, xl20_0, xl21_0;

  WORD32 x_0, x_1, x_l1_0, x_l1_1, x_l2_0, x_l2_1;

  WORD32 x_h2_0, x_h2_1;

  WORD32 si10, si20, si30, co10, co20, co30;

  WORD64 mul_1, mul_2, mul_3, mul_4, mul_5, mul_6;

  WORD64 mul_7, mul_8, mul_9, mul_10, mul_11, mul_12;

  const WORD32 *w_ptr = w;

  WORD32 i1;

  h2 = index << 1;

  l1 = index << 2;

  l2 = (index << 2) + (index << 1);

  fft_jmp = 6 * (index);

  for (i1 = 0; i1 < index1; i1++) {

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

      si10 = (*w_ptr++);

      co10 = (*w_ptr++);

      si20 = (*w_ptr++);

      co20 = (*w_ptr++);

      si30 = (*w_ptr++);

      co30 = (*w_ptr++);

      x_0 = x[0];

      x_h2_0 = x[h2];

      x_l1_0 = x[l1];

      x_l2_0 = x[l2];

      xh0_0 = ixheaac_add32_sat(x_0, x_l1_0);

      xl0_0 = ixheaac_sub32_sat(x_0, x_l1_0);

      xh20_0 = ixheaac_add32_sat(x_h2_0, x_l2_0);

      xl20_0 = ixheaac_sub32_sat(x_h2_0, x_l2_0);

      x[0] = ixheaac_add32_sat(xh0_0, xh20_0);

      xt0_0 = ixheaac_sub32_sat(xh0_0, xh20_0);

      x_1 = x[1];

      x_h2_1 = x[h2 + 1];

      x_l1_1 = x[l1 + 1];

      x_l2_1 = x[l2 + 1];

      xh1_0 = ixheaac_add32_sat(x_1, x_l1_1);

      xl1_0 = ixheaac_sub32_sat(x_1, x_l1_1);

      xh21_0 = ixheaac_add32_sat(x_h2_1, x_l2_1);

      xl21_0 = ixheaac_sub32_sat(x_h2_1, x_l2_1);

      x[1] = ixheaac_add32_sat(xh1_0, xh21_0);

      yt0_0 = ixheaac_sub32_sat(xh1_0, xh21_0);

      xt1_0 = ixheaac_add32_sat(xl0_0, xl21_0);

      xt2_0 = ixheaac_sub32_sat(xl0_0, xl21_0);

      yt2_0 = ixheaac_add32_sat(xl1_0, xl20_0);

      yt1_0 = ixheaac_sub32_sat(xl1_0, xl20_0);

      mul_11 = ixheaac_mult64(xt2_0, co30);

      mul_3 = ixheaac_mult64(yt2_0, si30);

      x[l2] = (WORD32)((mul_3 + mul_11) >> 32) << RADIXSHIFT;

      mul_5 = ixheaac_mult64(xt2_0, si30);

      mul_9 = ixheaac_mult64(yt2_0, co30);

      x[l2 + 1] = (WORD32)((mul_9 - mul_5) >> 32) << RADIXSHIFT;

      mul_12 = ixheaac_mult64(xt0_0, co20);

      mul_2 = ixheaac_mult64(yt0_0, si20);

      x[l1] = (WORD32)((mul_2 + mul_12) >> 32) << RADIXSHIFT;

      mul_6 = ixheaac_mult64(xt0_0, si20);

      mul_8 = ixheaac_mult64(yt0_0, co20);

      x[l1 + 1] = (WORD32)((mul_8 - mul_6) >> 32) << RADIXSHIFT;

      mul_4 = ixheaac_mult64(xt1_0, co10);

      mul_1 = ixheaac_mult64(yt1_0, si10);

      x[h2] = (WORD32)((mul_1 + mul_4) >> 32) << RADIXSHIFT;

      mul_10 = ixheaac_mult64(xt1_0, si10);

      mul_7 = ixheaac_mult64(yt1_0, co10);

      x[h2 + 1] = (WORD32)((mul_7 - mul_10) >> 32) << RADIXSHIFT;

      x += 2;

    }

    x += fft_jmp;

    w_ptr = w_ptr - fft_jmp;

  }

}

VOID ixheaacd_esbr_postradixcompute2(WORD32 *ptr_y, WORD32 *ptr_x,

                                     const WORD32 *pdig_rev_tbl,

                                     WORD32 npoints) {

  WORD32 i, k;

  WORD32 h2;

  WORD32 x_0, x_1, x_2, x_3;

  WORD32 x_4, x_5, x_6, x_7;

  WORD32 x_8, x_9, x_a, x_b, x_c, x_d, x_e, x_f;

  WORD32 n00, n10, n20, n30, n01, n11, n21, n31;

  WORD32 n02, n12, n22, n32, n03, n13, n23, n33;

  WORD32 *x2, *x0;

  WORD32 *y0, *y1, *y2, *y3;