/******************************************************************************
 *                                                                            *
 * 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 <math.h>
#include "ixheaac_type_def.h"
#include "ixheaace_adjust_threshold_data.h"
#include "iusace_bitbuffer.h"

/* DRC */
#include "impd_drc_common_enc.h"
#include "impd_drc_uni_drc.h"
#include "impd_drc_tables.h"
#include "impd_drc_api.h"
#include "impd_drc_uni_drc_eq.h"
#include "impd_drc_uni_drc_filter_bank.h"
#include "impd_drc_gain_enc.h"
#include "impd_drc_struct_def.h"

#include "iusace_cnst.h"
#include "iusace_tns_usac.h"
#include "iusace_psy_mod.h"
#include "iusace_tns_usac.h"
#include "iusace_config.h"
#include "iusace_fft.h"
#include "iusace_tcx_mdct.h"
#include "iusace_arith_enc.h"
#include "iusace_fd_qc_util.h"
#include "iusace_fd_quant.h"
#include "iusace_block_switch_const.h"
#include "iusace_block_switch_struct_def.h"
#include "iusace_ms.h"
#include "iusace_signal_classifier.h"
#include "ixheaace_sbr_header.h"
#include "ixheaace_config.h"
#include "ixheaace_asc_write.h"
#include "iusace_main.h"
#include "iusace_lpd_rom.h"
#include "iusace_lpd.h"
#include "iusace_avq_enc.h"
#include "ixheaace_common_utils.h"

const UWORD32 iusace_pow10_gain_div28[128] = {
    1024,     1112,     1207,     1311,     1423,     1545,     1677,     1821,     1977,
    2146,     2330,     2530,     2747,     2983,     3238,     3516,     3817,     4144,
    4499,     4885,     5304,     5758,     6252,     6788,     7370,     8001,     8687,
    9432,     10240,    11118,    12071,    13105,    14228,    15448,    16772,    18210,
    19770,    21465,    23305,    25302,    27471,    29825,    32382,    35157,    38171,
    41442,    44994,    48851,    53038,    57584,    62519,    67878,    73696,    80012,
    86870,    94316,    102400,   111177,   120706,   131052,   142284,   154480,   167720,
    182096,   197703,   214649,   233047,   253021,   274708,   298254,   323817,   351572,
    381706,   414422,   449943,   488508,   530378,   575838,   625193,   678779,   736958,
    800124,   868703,   943161,   1024000,  1111768,  1207059,  1310517,  1422843,  1544797,
    1677203,  1820958,  1977034,  2146488,  2330466,  2530213,  2747080,  2982536,  3238172,
    3515720,  3817056,  4144220,  4499426,  4885077,  5303782,  5758375,  6251932,  6787792,
    7369581,  8001236,  8687031,  9431606,  10240000, 11117682, 12070591, 13105175, 14228434,
    15447969, 16772032, 18209581, 19770345, 21464883, 23304662, 25302131, 27470805, 29825358,
    32381723, 35157197};

static const FLOAT64 iusace_lpc_pre_twid_cos[ORDER + 1] = {1.0,
                                                           0.99969881867944277,
                                                           0.99879545613814691,
                                                           0.99729045666498317,
                                                           0.99518472640441780,
                                                           0.99247953486470630,
                                                           0.98917650991010153,
                                                           0.98527764316379052,
                                                           0.98078527933727178,
                                                           0.97570212991605565,
                                                           0.97003125425052761,
                                                           0.96377606826277584,
                                                           0.95694033551585822,
                                                           0.94952817722361749,
                                                           0.94154406823678738,
                                                           0.93299279849944938,
                                                           0.92387952832938047};

static const FLOAT64 iusace_lpc_pre_twid_sin[ORDER + 1] = {0,
                                                           0.024541229205697054,
                                                           0.049067675691753569,
                                                           0.073564563785488826,
                                                           0.098017143048367339,
                                                           0.12241067304257494,
                                                           0.14673047482398086,
                                                           0.17096188429473480,
                                                           0.19509032737506427,
                                                           0.21910124070226658,
                                                           0.24298017568754085,
                                                           0.26671274855909161,
                                                           0.29028467796767482,
                                                           0.31368175059826858,
                                                           0.33688984485751389,
                                                           0.35989503740419343,
                                                           0.38268344246110436};

static VOID iusace_lpc_mdct(FLOAT32 *ptr_lpc_coeffs, FLOAT32 *mdct_gains, WORD32 length,
                            iusace_scratch_mem *pstr_scratch) {
  FLOAT32 *in_out = pstr_scratch->p_in_out_tcx;
  WORD32 i;

  for (i = 0; i < ORDER + 1; i++) {
    in_out[2 * i] = (FLOAT32)(ptr_lpc_coeffs[i] * iusace_lpc_pre_twid_cos[i]);
    in_out[2 * i + 1] = (FLOAT32)(-ptr_lpc_coeffs[i] * iusace_lpc_pre_twid_sin[i]);
  }
  for (; i < length; i++) {
    in_out[2 * i] = 0.f;
    in_out[2 * i + 1] = 0.f;
  }

  iusace_complex_fft(in_out, length, pstr_scratch);

  for (i = 0; i<length>> 1; i++) {
    mdct_gains[i] = (FLOAT32)(
        1.0f / sqrt(in_out[2 * i] * in_out[2 * i] + in_out[2 * i + 1] * in_out[2 * i + 1]));
  }

  return;
}

UWORD32 iusace_rounded_sqrt(UWORD32 pos_num) {
  UWORD32 num = pos_num;
  UWORD32 value = 0;
  UWORD32 bit_set = 1 << 30;

  while (bit_set > num) {
    bit_set >>= 2;
  }
  while (bit_set) {
    if (num >= value + bit_set) {
      num -= value + bit_set;
      value += bit_set << 1;
    }
    value >>= 1;
    bit_set >>= 2;
  }
  num = value + 1;
  if (num * num - pos_num < pos_num - value * value) {
    return num;
  }
  return value;
}

static VOID iusace_noise_shaping(FLOAT32 *rr, WORD32 lg, WORD32 M, FLOAT32 *gain1,
                                 FLOAT32 *gain2) {
  WORD32 i, k;
  FLOAT32 r, r_prev, g1, g2, a = 0, b = 0;

  k = lg/M;

  r_prev = 0;
  for (i = 0; i < lg; i++) {
    if ((i % k) == 0) {
      g1 = gain1[i / k];
      g2 = gain2[i / k];
      a = 2.0f * g1 * g2 / (g1 + g2);
      b = (g2 - g1) / (g1 + g2);
    }

    r = a * rr[i] + b * r_prev;

    rr[i] = r;
    r_prev = r;
  }

  return;
}

static VOID iusace_pre_shaping(FLOAT32 *rr, WORD32 lg, WORD32 M, FLOAT32 *gain1, FLOAT32 *gain2) {
  WORD32 i, k;
  FLOAT32 r, r_prev, g1, g2, a = 0, b = 0;

  k = lg / M;

  r_prev = 0;
  for (i = 0; i < lg; i++) {
    if ((i % k) == 0) {
      g1 = gain1[i / k];
      g2 = gain2[i / k];

      a = (g1 + g2) / (2.0f * g1 * g2);
      b = (g1 - g2) / (2.0f * g1 * g2);
    }

    r = a * rr[i] + b * r_prev;

    r_prev = rr[i];
    rr[i] = r;
  }

  return;
}

static VOID iusace_adapt_lo_freq_emph(FLOAT32 *signal, WORD32 length) {
  WORD32 i, j, i_max;
  FLOAT32 max_energy, factor, temp;

  i_max = length >> 2;

  max_energy = 0.01f;
  for (i = 0; i < i_max; i += 8) {
    temp = 0.01f;
    for (j = i; j < i + 8; j++) {
      temp += signal[j] * signal[j];
    }
    if (temp > max_energy) {
      max_energy = temp;
    }
  }

  factor = 10.0f;
  for (i = 0; i < i_max; i += 8) {
    temp = 0.01f;
    for (j = i; j < i + 8; j++) {
      temp += signal[j] * signal[j];
    }
    temp = (FLOAT32)sqrt(sqrt(max_energy / temp));
    if (temp < factor) {
      factor = temp;
    }
    for (j = i; j < i + 8; j++) {
      signal[j] *= factor;
    }
  }
  return;
}

static VOID iusace_adapt_lo_freq_deemph(FLOAT32 *signal, WORD32 length, FLOAT32 *gains) {
  WORD32 i, j, i_max;
  FLOAT32 max_energy, factor, energy, rm;

  i_max = length >> 2;

  max_energy = 0.01f;
  for (i = 0; i < i_max; i += 8) {
    energy = 0.01f;
    for (j = i; j < i + 8; j++) {
      energy += signal[j] * signal[j];
    }
    if (energy > max_energy) {
      max_energy = energy;
    }
  }

  factor = 0.1f;
  for (i = 0; i < i_max; i += 8) {
    energy = 0.01f;
    for (j = i; j < i + 8; j++) {
      energy += signal[j] * signal[j];
    }

    rm = (FLOAT32)sqrt(energy / max_energy);
    if (rm > factor) {
      factor = rm;
    }
    for (j = i; j < i + 8; j++) {
      signal[j] *= factor;
    }
    gains[i / 8] = factor;
  }

  return;
}

VOID iusace_tcx_fac_encode(ia_usac_data_struct *usac_data, FLOAT32 *lpc_coeffs,
                           FLOAT32 *lpc_coeffs_quant, FLOAT32 *speech, WORD32 frame_len,
                           WORD32 num_bits_per_supfrm, ia_usac_lpd_state_struct *lpd_state,
                           WORD32 *params, WORD32 *n_param, WORD32 ch_idx, WORD32 k_idx) {
  ia_usac_td_encoder_struct *st = usac_data->td_encoder[ch_idx];
  iusace_scratch_mem *pstr_scratch = &usac_data->str_scratch;
  FLOAT32 *weighted_sig = &pstr_scratch->p_wsig_buf[k_idx * st->len_subfrm];
  FLOAT32 *wsynth = pstr_scratch->p_wsyn_tcx_buf;
  FLOAT32 *synth = pstr_scratch->p_synth_tcx_buf;
  WORD32 i, k, n, mode, i_subfr, lg, lext, index, target_bits;
  FLOAT32 tmp, gain, fac_ns, energy, gain_tcx, nsfill_en_thres;
  FLOAT32 *ptr_lp_flt_coeffs, lp_flt_coeffs[ORDER + 1];
  const FLOAT32 *sine_window_prev, *sine_window;
  FLOAT32 mem_tcx_q;
  FLOAT32 *xn;
  FLOAT32 *xn1 = pstr_scratch->p_xn1_tcx;
  FLOAT32 *xn_buf = pstr_scratch->p_xn_buf_tcx;
  FLOAT32 *x = pstr_scratch->p_x_tcx;
  FLOAT32 *x_tmp = pstr_scratch->p_x_tmp_tcx;
  FLOAT32 *en = pstr_scratch->p_en_tcx;
  FLOAT32 sq_gain;
  FLOAT32 gain_prev, gain_next;
  FLOAT32 *alfd_gains = pstr_scratch->p_alfd_gains_tcx;
  FLOAT32 *sq_enc = pstr_scratch->p_sq_enc_tcx;
  WORD32 *sq_quant = pstr_scratch->p_sq_quant_tcx;
  FLOAT32 sq_err_energy;
  WORD32 max_k;
  FLOAT32 *gain1 = pstr_scratch->p_gain1_tcx;
  FLOAT32 *gain2 = pstr_scratch->p_gain2_tcx;
  FLOAT32 *facelp = pstr_scratch->p_facelp_tcx;
  FLOAT32 *xn2 = pstr_scratch->p_xn2_tcx;
  FLOAT32 *fac_window = pstr_scratch->p_fac_window_tcx;
  FLOAT32 *x1 = pstr_scratch->p_x1_tcx;
  FLOAT32 *x2 = pstr_scratch->p_x2_tcx;
  WORD32 *y = pstr_scratch->p_y_tcx;

  WORD32 TTT;
  FLOAT32 corr = 0;
  WORD32 len_subfrm = st->len_subfrm;
  WORD32 fac_length = len_subfrm >> 1;
  WORD32 fac_len_prev, fac_len;

  if (frame_len == 4 * st->len_subfrm) {
    if (st->last_was_short) {
      fac_len_prev = (st->len_frame) / 16;
    } else {
      fac_len_prev = st->len_subfrm / 2;
    }
    if (st->next_is_short) {
      fac_len = (st->len_frame) / 16;
    } else {
      fac_len = st->len_subfrm / 2;
    }
  } else if (frame_len == 2 * st->len_subfrm) {
    if (k_idx == 0 && st->last_was_short) {
      fac_len_prev = (st->len_frame) / 16;
    } else {
      fac_len_prev = st->len_subfrm / 2;
    }
    if (k_idx == 2 && st->next_is_short) {
      fac_len = (st->len_frame) / 16;
    } else {
      fac_len = st->len_subfrm / 2;
    }
  } else {
    if (k_idx == 0 && st->last_was_short) {
      fac_len_prev = (st->len_frame) / 16;
    } else {
      fac_len_prev = st->len_subfrm / 2;
    }
    if (k_idx == 3 && st->next_is_short) {
      fac_len = (st->len_frame) / 16;
    } else {
      fac_len = st->len_subfrm / 2;
    }
  }

  memset(xn_buf, 0, (128 + frame_len + 128) * sizeof(FLOAT32));

  mode = frame_len / len_subfrm;

  if (mode > 2) {
    mode = 3;
  }

  if (lpd_state->mode == 0) {
    params += fac_len_prev;
  }
  switch (fac_len_prev) {
    case 64:
      sine_window_prev = iusace_sin_window_128;
      break;
    default:
      sine_window_prev = iusace_sin_window_256;
      break;
  }
  switch (fac_len) {
    case 64:
      sine_window = iusace_sin_window_128;
      break;
    default:
      sine_window = iusace_sin_window_256;
      break;
  }

  lg = frame_len;
  lext = fac_length;
  xn = xn_buf + fac_length;

  *n_param = lg;

  target_bits = num_bits_per_supfrm - 10;

  for (i = 0; i < fac_length; i++) {
    xn_buf[i] = lpd_state->tcx_mem[i + 128 - fac_length];
  }

  memcpy(xn, speech, (frame_len + fac_length) * sizeof(FLOAT32));

  tmp = xn[-1];

  iusace_apply_deemph(xn, TILT_FAC, frame_len, &tmp);

  memcpy(lpd_state->tcx_mem, &xn[frame_len - 128], 128 * sizeof(FLOAT32));

  memcpy(&xn[frame_len], &speech[frame_len], lext * sizeof(FLOAT32));
  iusace_apply_deemph(&xn[frame_len], TILT_FAC, lext, &tmp);

  for (i = 0; i < ORDER + fac_len_prev; i++) {
    xn1[i] = xn_buf[fac_length - ORDER + i];
  }
  for (i = 0; i < ORDER + fac_len; i++) {
    xn2[i] = xn_buf[frame_len - ORDER + i];
  }

  if (lpd_state->mode >= -1) {
    for (i = 0; i < fac_length - fac_len_prev; i++) {
      xn_buf[i] = 0.0f;
    }
    for (i = fac_length - fac_len_prev; i < (fac_length + fac_len_prev); i++) {
      xn_buf[i] *= sine_window_prev[i - fac_length + fac_len_prev];
    }
    for (i = 0; i < (2 * fac_len); i++) {
      xn_buf[frame_len + fac_length - fac_len + i] *= sine_window[(2 * fac_len) - 1 - i];
    }
    for (i = 0; i < fac_length - fac_len; i++) {
      xn_buf[frame_len + fac_length + fac_len + i] = 0.0f;
    }
  }

  iusace_tcx_mdct_main(xn_buf, x, (2 * fac_length), frame_len - (2 * fac_length),
                       (2 * fac_length), pstr_scratch);

  iusace_get_weighted_lpc(lpc_coeffs_quant + (ORDER + 1), lp_flt_coeffs);
  iusace_lpc_mdct(lp_flt_coeffs, gain1, ((FDNS_RESOLUTION * len_subfrm) / LEN_FRAME) << 1,
                  pstr_scratch);

  iusace_get_weighted_lpc(lpc_coeffs_quant + (2 * (ORDER + 1)), lp_flt_coeffs);
  iusace_lpc_mdct(lp_flt_coeffs, gain2, ((FDNS_RESOLUTION * len_subfrm) / LEN_FRAME) << 1,
                  pstr_scratch);

  iusace_pre_shaping(x, lg, ((FDNS_RESOLUTION * len_subfrm) / LEN_FRAME), gain1, gain2);

  for (i = 0; i < lg; i++) {
    x_tmp[i] = x[i];
  }

  iusace_adapt_lo_freq_emph(x, lg);

  sq_gain = iusace_calc_sq_gain(x, target_bits, lg, pstr_scratch->p_sq_gain_en);

  for (i = 0; i < lg; i++) {
    sq_enc[i] = x[i] / sq_gain;

    if (sq_enc[i] > 0.f)
      sq_quant[i] = ((WORD32)(0.5f + sq_enc[i]));
    else
      sq_quant[i] = ((WORD32)(-0.5f + sq_enc[i]));
  }

  for (i = 0; i < lg; i++) {
    params[i + 2] = sq_quant[i];
    x[i] = (FLOAT32)sq_quant[i];
  }

  for (i = 0; i < lg; i++) {
    en[i] = x[i] * x[i];
  }
  if (mode == 3) {
    tmp = 0.9441f;
  } else if (mode == 2) {
    tmp = 0.8913f;
  } else {
    tmp = 0.7943f;
  }
  energy = 0.0f;
  for (i = 0; i < lg; i++) {
    if (en[i] > energy) {
      energy = en[i];
    }
    en[i] = energy;
    energy *= tmp;
  }
  energy = 0.0f;
  for (i = lg - 1; i >= 0; i--) {
    if (en[i] > energy) {
      energy = en[i];
    }
    en[i] = energy;
    energy *= tmp;
  }

  nsfill_en_thres = 0.707f;

  tmp = 0.0625f;
  k = 1;
  for (i = 0; i < lg; i++) {
    if (en[i] <= nsfill_en_thres) {
      tmp += sq_enc[i] * sq_enc[i];
      k++;
    }
  }

  iusace_adapt_lo_freq_deemph(x, lg, alfd_gains);

  energy = 1e-6f;
  for (i = 0; i < lg; i++) {
    corr += x_tmp[i] * x[i];
    energy += x[i] * x[i];
  }
  gain_tcx = (corr / energy);

  if (gain_tcx == 0.0f) {
    gain_tcx = sq_gain;
  }

  energy = 0.0001f;
  for (i = 0; i < lg; i++) {
    tmp = x_tmp[i] - gain_tcx * x[i];
    energy += tmp * tmp;
  }

  tmp = (FLOAT32)sqrt((energy * (2.0f / (FLOAT32)lg)) / (FLOAT32)lg);

  for (i = 0; i < frame_len; i++) {
    wsynth[i] = weighted_sig[i] + tmp;
  }

  energy = 0.01f;
  for (i = 0; i < lg; i++) {
    energy += x[i] * x[i];
  }

  tmp = (FLOAT32)(2.0f * sqrt(energy) / (FLOAT32)lg);
  gain = gain_tcx * tmp;

  index = (WORD32)floor(0.5f + (28.0f * (FLOAT32)log10(gain)));
  if (index < 0) {
    index = 0;
  }
  if (index > 127) {
    index = 127;
  }
  params[1] = index;

  gain_tcx = (FLOAT32)pow(10.0f, ((FLOAT32)index) / 28.0f) / tmp;
  st->gain_tcx = gain_tcx;

  sq_err_energy = 0.f;
  n = 0;
  for (k = lg / 2; k < lg;) {
    tmp = 0.f;

    max_k = MIN(lg, k + 8);
    for (i = k; i < max_k; i++) {
      tmp += (FLOAT32)sq_quant[i] * sq_quant[i];
    }
    if (tmp == 0.f) {
      tmp = 0.f;
      for (i = k; i < max_k; i++) {
        tmp += sq_enc[i] * sq_enc[i];
      }

      sq_err_energy += (FLOAT32)log10((tmp / (FLOAT64)8) + 0.000000001);
      n += 1;
    }
    k = max_k;
  }
  if (n > 0) {
    fac_ns = (FLOAT32)pow(10., sq_err_energy / (FLOAT64)(2 * n));
  } else {
    fac_ns = 0.f;
  }

  tmp = 8.0f - (16.0f * fac_ns);

  index = (WORD32)floor(tmp + 0.5);
  if (index < 0) {
    index = 0;
  }
  if (index > 7) {
    index = 7;
  }

  params[0] = index;

  iusace_noise_shaping(x, lg, ((FDNS_RESOLUTION * len_subfrm) / LEN_FRAME), gain1, gain2);

  iusace_tcx_imdct(x, xn_buf, (2 * fac_length), frame_len - (2 * fac_length), (2 * fac_length),
                   pstr_scratch);
  for (i = 0; i < frame_len + (2 * fac_length); i++) {
    xn_buf[i] = xn_buf[i] * (2.0f / lg);
  }

  for (i = 0; i < fac_len_prev; i++) {
    fac_window[i] = sine_window_prev[i] * sine_window_prev[(2 * fac_len_prev) - 1 - i];
    fac_window[fac_len_prev + i] =
        1.0f - (sine_window_prev[fac_len_prev + i] * sine_window_prev[fac_len_prev + i]);
  }

  for (i = 0; i < fac_len_prev; i++) {
    xn1[ORDER + i] -= sq_gain * xn_buf[fac_length + i] * sine_window_prev[fac_len_prev + i];
  }
  for (i = 0; i < fac_len; i++) {
    xn2[ORDER + i] -= sq_gain * xn_buf[i + frame_len] * sine_window[(2 * fac_len) - 1 - i];
  }

  for (i = 0; i < ORDER; i++) {
    xn1[i] -= lpd_state->tcx_quant[1 + 128 - ORDER + i];
    xn2[i] -= sq_gain * xn_buf[frame_len - ORDER + i];
  }

  for (i = 0; i < fac_len_prev; i++) {
    facelp[i] = lpd_state->tcx_quant[1 + 128 + i] * fac_window[fac_len_prev + i] +
                lpd_state->tcx_quant[1 + 128 - 1 - i] * fac_window[fac_len_prev - 1 - i];
  }

  energy = 0.0f;
  for (i = 0; i < fac_len_prev; i++) energy += xn1[ORDER + i] * xn1[ORDER + i];
  energy *= 2.0f;
  tmp = 0.0f;
  for (i = 0; i < fac_len_prev; i++) tmp += facelp[i] * facelp[i];
  if (tmp > energy)
    gain = (FLOAT32)sqrt(energy / tmp);
  else
    gain = 1.0f;

  for (i = 0; i < fac_len_prev; i++) {
    xn1[ORDER + i] -= gain * facelp[i];
  }

  iusace_get_weighted_lpc(lpc_coeffs_quant + (ORDER + 1), lp_flt_coeffs);
  iusace_compute_lp_residual(lp_flt_coeffs, xn1 + ORDER, x1, fac_len_prev);

  iusace_get_weighted_lpc(lpc_coeffs_quant + (2 * (ORDER + 1)), lp_flt_coeffs);
  iusace_compute_lp_residual(lp_flt_coeffs, xn2 + ORDER, x2, fac_len);

  iusace_tcx_mdct(x1, x1, fac_len_prev, pstr_scratch);
  iusace_tcx_mdct(x2, x2, fac_len, pstr_scratch);

  gain_prev = (FLOAT32)(sq_gain * 0.5f * sqrt(((FLOAT32)fac_len_prev) / (FLOAT32)frame_len));
  gain_next = (FLOAT32)(sq_gain * 0.5f * sqrt(((FLOAT32)fac_len) / (FLOAT32)frame_len));

  for (i = 0; i < fac_len_prev; i++) {
    x1[i] /= gain_prev;
  }
  for (i = 0; i < fac_len; i++) {
    x2[i] /= gain_next;
  }
  for (i = 0; i < fac_len_prev / 4; i++) {
    k = i * lg / (8 * fac_len_prev);
    x1[i] /= alfd_gains[k];
  }
  for (i = 0; i < fac_len / 4; i++) {
    k = i * lg / (8 * fac_len);
    x2[i] /= alfd_gains[k];
  }

  for (i = 0; i < fac_len; i += 8) {
    iusace_find_nearest_neighbor(&x2[i], &y[i]);
  }
  for (i = 0; i < fac_len; i++) {
    lpd_state->avq_params[i] = y[i];
    x2[i] = (FLOAT32)y[i];
  }

  for (i = 0; i < fac_len_prev; i += 8) {
    iusace_find_nearest_neighbor(&x1[i], &y[i]);
  }

  for (i = 0; i < fac_len_prev; i++) {
    x1[i] = (FLOAT32)y[i];
  }

  gain_prev = (FLOAT32)(gain_tcx * 0.5f * sqrt(((FLOAT32)fac_len_prev) / (FLOAT32)frame_len));
  gain_next = (FLOAT32)(gain_tcx * 0.5f * sqrt(((FLOAT32)fac_len) / (FLOAT32)frame_len));

  for (i = 0; i < fac_len_prev; i++) {
    x1[i] *= gain_prev;
  }
  for (i = 0; i < fac_len; i++) {
    x2[i] *= gain_next;
  }
  for (i = 0; i<fac_len_prev>> 2; i++) {
    k = i * lg / (fac_len_prev << 3);
    x1[i] *= alfd_gains[k];
  }
  for (i = 0; i<fac_len>> 2; i++) {
    k = i * lg / (fac_len << 3);
    x2[i] *= alfd_gains[k];
  }
  iusace_tcx_mdct(x1, xn1, fac_len_prev, pstr_scratch);
  iusace_tcx_mdct(x2, xn2, fac_len, pstr_scratch);

  FLOAT32 coeff1 = (2.0f / (FLOAT32)fac_len_prev), coeff2 = (2.0f / (FLOAT32)fac_len);

  for (i = 0; i < fac_len_prev; i++) {
    xn1[i] = xn1[i] * coeff1;
  }

  for (i = 0; i < fac_len; i++) {
    xn2[i] = xn2[i] * coeff2;
  }

  memset(xn1 + fac_len_prev, 0, fac_len_prev * sizeof(FLOAT32));
  memset(xn2 + fac_len, 0, fac_len * sizeof(FLOAT32));

  iusace_get_weighted_lpc(lpc_coeffs_quant + (ORDER + 1), lp_flt_coeffs);
  iusace_synthesis_tool_float(lp_flt_coeffs, xn1, xn1, 2 * fac_len_prev, xn1 + fac_len_prev,
                              pstr_scratch->p_buf_synthesis_tool);

  iusace_get_weighted_lpc(lpc_coeffs_quant + (2 * (ORDER + 1)), lp_flt_coeffs);
  iusace_synthesis_tool_float(lp_flt_coeffs, xn2, xn2, fac_len, xn2 + fac_len,
                              pstr_scratch->p_buf_synthesis_tool);

  for (i = 0; i < fac_len_prev; i++) {
    xn1[i] += facelp[i];
  }

  for (i = 0; i < frame_len + (fac_length << 1); i++) {
    xn_buf[i] *= gain_tcx;
  }

  if (lpd_state->mode >= -1) {
    for (i = 0; i < (2 * fac_len_prev); i++) {
      xn_buf[i + fac_length - fac_len_prev] *= sine_window_prev[i];
    }
    for (i = 0; i < fac_length - fac_len_prev; i++) {
      xn_buf[i] = 0.0f;
    }
  }
  for (i = 0; i < (2 * fac_len); i++) {
    xn_buf[i + frame_len + fac_length - fac_len] *= sine_window[(2 * fac_len) - 1 - i];
  }
  for (i = 0; i < fac_length - fac_len; i++) {
    xn_buf[i + frame_len + fac_length + fac_len] = 0.0f;
  }

  if (lpd_state->mode != 0) {
    for (i = 0; i < (2 * fac_length); i++) {
      xn_buf[i] += lpd_state->tcx_quant[1 + 128 - fac_length + i];
    }

    mem_tcx_q = lpd_state->tcx_quant[128 - fac_length];
  } else {
    for (i = 0; i < fac_len_prev; i++) {
      params[i - fac_len_prev] = y[i];
    }

    for (i = 0; i < (2 * fac_len_prev); i++) {
      xn_buf[i + fac_length] += xn1[i];
    }
    mem_tcx_q = lpd_state->tcx_quant[128];
  }

  memcpy(lpd_state->tcx_quant, xn_buf + frame_len + fac_length - 128 - 1,
         (1 + 256) * sizeof(FLOAT32));

  for (i = 0; i < fac_len; i++) {
    xn_buf[i + frame_len + (fac_length - fac_len)] += xn2[i];
  }

  if (lpd_state->mode > 0) {
    iusace_apply_preemph(xn_buf, TILT_FAC, fac_length, &mem_tcx_q);

    ptr_lp_flt_coeffs = lpd_state->lpc_coeffs_quant;

    TTT = fac_length % LEN_SUBFR;
    if (TTT != 0) {
      memcpy(&(lpd_state->synth[ORDER + 128 - fac_length]), &xn_buf[0], TTT * sizeof(FLOAT32));
      iusace_compute_lp_residual(ptr_lp_flt_coeffs, &(lpd_state->synth[ORDER + 128 - fac_length]),
                                 &(lpd_state->acelp_exc[(2 * len_subfrm) - fac_length]), TTT);

      ptr_lp_flt_coeffs += (ORDER + 1);
    }

    for (i_subfr = TTT; i_subfr < fac_length; i_subfr += LEN_SUBFR) {
      memcpy(&(lpd_state->synth[ORDER + 128 - fac_length + i_subfr]), &xn_buf[i_subfr],
             LEN_SUBFR * sizeof(FLOAT32));
      iusace_compute_lp_residual(
          ptr_lp_flt_coeffs, &(lpd_state->synth[ORDER + 128 - fac_length + i_subfr]),
          &(lpd_state->acelp_exc[(2 * len_subfrm) - fac_length + i_subfr]), LEN_SUBFR);
      ptr_lp_flt_coeffs += (ORDER + 1);
    }

    ptr_lp_flt_coeffs = lpd_state->lpc_coeffs;
    for (i_subfr = 0; i_subfr < fac_length; i_subfr += LEN_SUBFR) {
      iusace_get_weighted_lpc(ptr_lp_flt_coeffs, lp_flt_coeffs);
      iusace_compute_lp_residual(lp_flt_coeffs,
                                 &(lpd_state->synth[ORDER + 128 - fac_length + i_subfr]),
                                 &(lpd_state->wsynth[1 + 128 - fac_length + i_subfr]), LEN_SUBFR);
      ptr_lp_flt_coeffs += (ORDER + 1);
    }
    tmp = lpd_state->wsynth[0 + 128 - fac_length];
    iusace_apply_deemph(&(lpd_state->wsynth[1 + 128 - fac_length]), TILT_FAC, fac_length, &tmp);
  }

  k = ((frame_len / LEN_SUBFR) - 2) * (ORDER + 1);
  memcpy(lpd_state->lpc_coeffs, lpc_coeffs + k, 2 * (ORDER + 1) * sizeof(FLOAT32));

  memcpy(lpd_state->lpc_coeffs_quant, lpc_coeffs_quant + (2 * (ORDER + 1)),
         (ORDER + 1) * sizeof(FLOAT32));
  memcpy(lpd_state->lpc_coeffs_quant + (ORDER + 1), lpd_state->lpc_coeffs_quant,
         (ORDER + 1) * sizeof(FLOAT32));

  memcpy(synth - 128, &(lpd_state->synth[ORDER]), 128 * sizeof(FLOAT32));
  lpd_state->tcx_fac = xn[frame_len - 1];

  iusace_apply_preemph(xn, TILT_FAC, frame_len, &mem_tcx_q);
  for (i_subfr = 0; i_subfr < frame_len; i_subfr += LEN_SUBFR) {
    memcpy(&synth[i_subfr], &xn[i_subfr], LEN_SUBFR * sizeof(FLOAT32));
    iusace_compute_lp_residual(lpc_coeffs_quant + (2 * (ORDER + 1)), &synth[i_subfr],
                               &xn[i_subfr], LEN_SUBFR);
  }
  memcpy(lpd_state->synth, synth + frame_len - (ORDER + 128), (ORDER + 128) * sizeof(FLOAT32));

  if (frame_len == len_subfrm) {
    memcpy(x, lpd_state->acelp_exc + len_subfrm, len_subfrm * sizeof(FLOAT32));
    memcpy(lpd_state->acelp_exc, x, len_subfrm * sizeof(FLOAT32));
    memcpy(lpd_state->acelp_exc + len_subfrm, xn, len_subfrm * sizeof(FLOAT32));
  } else {
    memcpy(lpd_state->acelp_exc, xn + frame_len - (2 * len_subfrm),
           2 * len_subfrm * sizeof(FLOAT32));
  }

  memcpy(wsynth - 128, &(lpd_state->wsynth[1]), 128 * sizeof(FLOAT32));

  ptr_lp_flt_coeffs = lpc_coeffs;
  for (i_subfr = 0; i_subfr < frame_len; i_subfr += LEN_SUBFR) {
    iusace_get_weighted_lpc(ptr_lp_flt_coeffs, lp_flt_coeffs);
    iusace_compute_lp_residual(lp_flt_coeffs, &synth[i_subfr], &wsynth[i_subfr], LEN_SUBFR);
    ptr_lp_flt_coeffs += (ORDER + 1);
  }
  tmp = wsynth[-1];
  iusace_apply_deemph(wsynth, TILT_FAC, frame_len, &tmp);

  memcpy(lpd_state->wsynth, wsynth + frame_len - (1 + 128), (1 + 128) * sizeof(FLOAT32));

  lpd_state->mode = mode;

  lpd_state->num_bits = 10 + target_bits;

  return;
}