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

 *                                                                            *

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

#include <float.h>

#include <stdlib.h>

#include <stdio.h>

#include <math.h>

#include <string.h>

#include "ixheaac_type_def.h"

#include "ixheaacd_bitbuffer.h"

#include "ixheaacd_interface.h"

#include "ixheaacd_defines.h"

#include "ixheaacd_aac_rom.h"

#include "ixheaacd_tns_usac.h"

#include "ixheaacd_cnst.h"

#include "ixheaacd_acelp_info.h"

#include "ixheaacd_sbrdecsettings.h"

#include "ixheaacd_info.h"

#include "ixheaacd_sbr_common.h"

#include "ixheaacd_drc_data_struct.h"

#include "ixheaacd_drc_dec.h"

#include "ixheaacd_sbrdecoder.h"

#include "ixheaacd_mps_polyphase.h"

#include "ixheaac_sbr_const.h"

#include "ixheaacd_pulsedata.h"

#include "ixheaacd_pns.h"

#include "ixheaacd_lt_predict.h"

#include "ixheaacd_ec_defines.h"

#include "ixheaacd_ec_struct_def.h"

#include "ixheaacd_main.h"

#include "ixheaacd_channelinfo.h"

#include "ixheaacd_ec.h"

#include "ixheaacd_arith_dec.h"

#include "ixheaacd_func_def.h"

#include "ixheaacd_windows.h"

#include "ixheaacd_acelp_com.h"

#include "ixheaac_constants.h"

#include "ixheaac_basic_ops32.h"

#include "ixheaac_basic_ops40.h"

#define LSF_GAP_F 50.0f

#define FREQ_MAX_F 6400.0f

#define FREQ_DIV_F 400.0f

extern const FLOAT32 ixheaacd_fir_lp_filt[1 + FILTER_DELAY];

const WORD32 ixheaacd_pow_10_i_by_128[128] = {

    16384,     17788,     19312,     20968,     22765,     24716,     26835,

    29135,     31632,     34343,     37287,     40483,     43953,     47720,

    51810,     56251,     61072,     66307,     71990,     78161,     84860,

    92134,     100030,    108604,    117913,    128019,    138992,    150905,

    163840,    177882,    193129,    209682,    227654,    247167,    268352,

    291353,    316325,    343438,    372874,    404834,    439532,    477205,

    518107,    562515,    610728,    663075,    719908,    781612,    848605,

    921340,    1000309,   1086046,   1179133,   1280197,   1389925,   1509057,

    1638400,   1778829,   1931294,   2096827,   2276549,   2471675,   2683525,

    2913532,   3163255,   3434381,   3728745,   4048340,   4395328,   4772057,

    5181075,   5625151,   6107289,   6630752,   7199081,   7816122,   8486051,

    9213400,   10003091,  10860467,  11791330,  12801978,  13899250,  15090570,

    16384000,  17788290,  19312945,  20968279,  22765494,  24716750,  26835250,

    29135329,  31632551,  34343813,  37287459,  40483409,  43953287,  47720573,

    51810757,  56251515,  61072895,  66307521,  71990813,  78161226,  84860513,

    92134002,  100030911, 108604672, 117913300, 128019781, 138992500, 150905703,

    163840000, 177882909, 193129453, 209682794, 227654941, 247167501, 268352504,

    291353298, 316325515, 343438130, 372874596, 404834095, 439532879, 477205734,

    518107571, 562515151};

VOID ixheaacd_lsf_weight_2st_flt(float *lsfq, float *w, WORD32 mode);

static PLATFORM_INLINE WORD32 ixheaacd_mult32_m(WORD32 a, WORD32 b) {

  WORD32 result;

  WORD64 temp_result;

  temp_result = (WORD64)a * (WORD64)b;

  result = (WORD32)(temp_result >> 31);

  return (result);

}

void ixheaacd_reset_acelp_data_fix(ia_usac_data_struct *usac_data,

                                   ia_usac_lpd_decoder_handle st,

                                   WORD32 *ptr_overlap_buf,

                                   WORD32 was_last_short, WORD32 tw_mdct) {

  WORD32 i;

  if (was_last_short == 1) {

    st->mode_prev = -2;

  } else {

    st->mode_prev = -1;

  }

  for (i = 0; i < NUM_SUBFR_SUPERFRAME_BY2 - 1; i++) {

    st->pitch_prev[i] = 64;

    st->gain_prev[i] = 0;

  }

  st->bpf_active_prev = 0;

  if (ptr_overlap_buf != NULL && !tw_mdct) {

    const WORD32 *ptr_window_coeff;

    WORD32 fac_length;

    if (was_last_short) {

      fac_length = (usac_data->ccfl) / 16;

    } else {

      fac_length = (usac_data->len_subfrm) / 2;

    }

    if (fac_length == 48) {

      ptr_window_coeff = ixheaacd_sine_win_96;

    } else if (fac_length == 64) {

      ptr_window_coeff = ixheaacd_sine_win_128;

    } else if (fac_length == 96) {

      ptr_window_coeff = ixheaacd_sine_win_192;

    } else {

      ptr_window_coeff = ixheaacd_sine_win_256;

    }

    for (i = 0; i < 2 * fac_length; i++) {

      ptr_overlap_buf[(usac_data->ccfl) / 2 - fac_length + i] =

          ixheaacd_mult32_m(

              ptr_overlap_buf[(usac_data->ccfl) / 2 - fac_length + i],

              ptr_window_coeff[2 * fac_length - 1 - i]);

    }

    for (i = 0; i < (usac_data->ccfl) / 2 - fac_length; i++) {

      ptr_overlap_buf[(usac_data->ccfl) / 2 + fac_length + i] = 0;

    }

    if (ptr_overlap_buf != NULL) {

      for (i = 0; i < (usac_data->len_subfrm) / 2 - fac_length; i++) {

        st->exc_prev[i] = 0.0f;

      }

      for (i = 0; i < 2 * fac_length + 1; i++) {

        st->exc_prev[(usac_data->len_subfrm) / 2 - fac_length + i] =

            ptr_overlap_buf[i + usac_data->ccfl / 2 - fac_length - 1] /

            (float)(16384);

      }

    } else {

      ixheaacd_memset(st->exc_prev, 1 + (2 * FAC_LENGTH));

    }

  }

  return;

}

VOID ixheaacd_fix2flt_data(ia_usac_data_struct *usac_data,

                           ia_usac_lpd_decoder_handle st, WORD32 k) {

  WORD32 i;

  WORD32 fac_length;

  WORD32 window_sequence_last = usac_data->window_sequence_last[k];

  WORD32 *p_ola_buffer = usac_data->overlap_data_ptr[k];

  if (window_sequence_last == EIGHT_SHORT_SEQUENCE) {

    fac_length = (usac_data->ccfl) / 16;

  } else {

    fac_length = (usac_data->len_subfrm) / 2;

  }

  ixheaacd_memset(st->lp_flt_coeff_a_prev, 2 * (ORDER + 1));

  ixheaacd_memset(st->xcitation_prev, MAX_PITCH + INTER_LP_FIL_ORDER + 1);

  ixheaacd_memset(st->synth_prev, MAX_PITCH + SYNTH_DELAY_LMAX);

  ixheaacd_memset(st->bpf_prev, FILTER_DELAY + LEN_SUBFR);

  st->gain_threshold = 0.0f;

  if (p_ola_buffer != NULL) {

    for (i = 0; i < (usac_data->len_subfrm) / 2 - fac_length; i++) {

      st->exc_prev[i] = 0;

    }

    for (i = 0; i < 2 * fac_length + 1; i++) {

      st->exc_prev[(usac_data->len_subfrm) / 2 - fac_length + i] = (FLOAT32)(

          p_ola_buffer[i + usac_data->ccfl / 2 - fac_length - 1] / 16384.0);

    }

  } else {

    ixheaacd_memset(st->exc_prev, 1 + (2 * FAC_LENGTH));

  }

  return;

}

void ixheaacd_init_acelp_data(ia_usac_data_struct *usac_data,

                              ia_usac_lpd_decoder_handle st) {

  ixheaacd_reset_acelp_data_fix(usac_data, st, NULL, 0, 0);

}

#define PI_BY_6400 (PI / 6400.0)

#define SCALE1 (6400.0 / PI)

void ixheaacd_lsp_2_lsf_conversion(float lsp[], float lsf[], WORD32 m) {

  short i;

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

    lsf[i] = (float)(acos(lsp[i]) * SCALE1);

  }

  return;

}

static VOID ixheaacd_lsf_2_lsp_conversion_float(FLOAT32 lsf[], FLOAT32 lsp[],

                                                WORD32 m) {

  WORD32 i;

  for (i = 0; i < m; i++)

    lsp[i] = (FLOAT32)cos((double)lsf[i] * (double)PI_BY_6400);

  return;

}

static WORD32 ixheaacd_bass_post_filter(FLOAT32 *synth_sig, WORD32 *pitch, FLOAT32 *pitch_gain,

                                        FLOAT32 *synth_out, WORD32 len_fr, WORD32 len2,

                                        FLOAT32 bpf_prev[], WORD32 ec_flag) {

  WORD32 i, j, sf, num_subfr, pitch_lag, lg;

  FLOAT32 x_energy, xy_corr, y_energy, norm_corr, energy, gain, tmp, alpha;

  FLOAT32 noise_buf[FILTER_DELAY + (2 * LEN_SUBFR)], *noise_tmp1, *noise_tmp2,

      *x, *y;

  noise_tmp1 = noise_buf + FILTER_DELAY;

  noise_tmp2 = noise_buf + FILTER_DELAY + LEN_SUBFR;

  memcpy(synth_out, synth_sig - LEN_SUBFR, len_fr * sizeof(FLOAT32));

  if (len_fr % 64)

    memset(synth_out + len_fr, 0, (LEN_SUBFR - len_fr % 64) * sizeof(FLOAT32));

  sf = 0;

  for (num_subfr = 0; num_subfr < len_fr; num_subfr += LEN_SUBFR, sf++) {

    pitch_lag = pitch[sf];

    gain = pitch_gain[sf];

    if (((pitch_lag >> 1) + 96 - num_subfr) > MAX_PITCH) {

      if (ec_flag) {

        pitch_lag = (MAX_PITCH + num_subfr - 96) << 1;

      } else {

        return -1;

      }

    }

    if (gain > 1.0f) gain = 1.0f;

    if (gain < 0.0f) gain = 0.0f;

    x = &synth_sig[num_subfr - 96];

    y = &synth_sig[num_subfr - pitch_lag / 2 - 96];

    x_energy = 0.01f;

    xy_corr = 0.01f;

    y_energy = 0.01f;

    for (i = 0; i < LEN_SUBFR + 96; i++) {

      x_energy += x[i] * x[i];

      xy_corr += x[i] * y[i];

      y_energy += y[i] * y[i];

    }

    norm_corr = xy_corr / (FLOAT32)sqrt(x_energy * y_energy);

    if (norm_corr > 0.95f) pitch_lag >>= 1;

    lg = len_fr + len2 - pitch_lag - num_subfr;

    if (lg < 0) lg = 0;

    if (lg > LEN_SUBFR) lg = LEN_SUBFR;

    if (pitch_lag > MAX_PITCH) {

      if (ec_flag) {

        pitch_lag = MAX_PITCH;

      } else {

        return -1;

      }

    }

    if (gain > 0) {

      if (lg > 0) {

        tmp = 0.01f;

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

          tmp += synth_sig[i + num_subfr] * synth_sig[i + num_subfr];

        }

        energy = 0.01f;

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

          energy += synth_sig[i + num_subfr + pitch_lag] *

                    synth_sig[i + num_subfr + pitch_lag];

        }

        tmp = (FLOAT32)sqrt(tmp / energy);

        if (tmp < gain) gain = tmp;

      }

      alpha = 0.5f * gain;

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

        noise_tmp2[i] = alpha * (synth_sig[i + num_subfr] -

                                 0.5f * synth_sig[i + num_subfr - pitch_lag] -

                                 0.5f * synth_sig[i + num_subfr + pitch_lag]);

      }

      for (i = lg; i < LEN_SUBFR; i++) {

        noise_tmp2[i] = alpha * (synth_sig[i + num_subfr] -

                                 synth_sig[i + num_subfr - pitch_lag]);

      }

    } else {

      memset(noise_tmp2, 0, LEN_SUBFR * sizeof(FLOAT32));

    }

    memcpy(noise_buf, bpf_prev, (FILTER_DELAY + LEN_SUBFR) * sizeof(FLOAT32));

    memcpy(bpf_prev, noise_buf + LEN_SUBFR,

           (FILTER_DELAY + LEN_SUBFR) * sizeof(FLOAT32));

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

      tmp = ixheaacd_fir_lp_filt[0] * noise_tmp1[i];

      for (j = 1; j <= FILTER_DELAY; j++) {

        tmp +=

            ixheaacd_fir_lp_filt[j] * (noise_tmp1[i - j] + noise_tmp1[i + j]);

      }

      synth_out[i + num_subfr] -= tmp;

    }

  }

  return 0;

}

void ixheaacd_reorder_lsf(float *lsf, float min_dist, int n) {

  int i;

  float lsf_min;

  lsf_min = min_dist;

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

    if (lsf[i] < lsf_min) lsf[i] = lsf_min;

    lsf_min = lsf[i] + min_dist;

  }

  lsf_min = FREQ_MAX_F - min_dist;

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

    if (lsf[i] > lsf_min) lsf[i] = lsf_min;

    lsf_min = lsf[i] - min_dist;

  }

  return;

}

WORD32 ixheaacd_lpd_dec(ia_usac_data_struct *usac_data,

                        ia_usac_lpd_decoder_handle st,

                        ia_td_frame_data_struct *pstr_td_frame_data,

                        FLOAT32 fsynth[], WORD32 first_lpd_flag,

                        WORD32 short_fac_flag, WORD32 bpf_control_info) {

  FLOAT32 *synth_buf = usac_data->synth_buf;

  FLOAT32 *xcitation_buff = usac_data->exc_buf;

  FLOAT32 lsp_curr[ORDER];

  FLOAT32 lsf_curr[ORDER];

  FLOAT32 *lp_flt_coff_a = usac_data->lp_flt_coff;

  FLOAT32 *synth, *xcitation_curr;

  WORD32 *pitch = usac_data->pitch;

  FLOAT32 *pitch_gain = usac_data->pitch_gain;

  FLOAT32 lsf_flt[(2 * NUM_FRAMES + 1) * ORDER];

  WORD32 i, k, tp, mode;

  WORD32 *mod;

  FLOAT32 gain, stability_factor = 0.0f;

  FLOAT32 tmp, synth_corr, synth_energy;

  WORD32 len_fr;

  WORD32 len_subfrm;

  WORD32 num_subfr;

  WORD32 num_subfr_in_superfr;

  WORD32 num_subfr_by2;

  WORD32 synth_delay;

  WORD32 num_samples = 0;

  WORD32 *ptr_scratch = &usac_data->scratch_buffer[0];

  WORD32 subfr_len = 0, n_subfr = 0;

  WORD32 err = 0;

  WORD32 ch = usac_data->present_chan;

  len_fr = usac_data->ccfl;

  len_subfrm = usac_data->len_subfrm;

  num_subfr = usac_data->num_subfrm;

  num_subfr_in_superfr = NUM_FRAMES * num_subfr;

  num_subfr_by2 = (num_subfr_in_superfr / 2) - 1;

  synth_delay = num_subfr_by2 * LEN_SUBFR;

  synth = synth_buf + MAX_PITCH + synth_delay;

  ixheaacd_mem_cpy(st->synth_prev, synth_buf, MAX_PITCH + synth_delay);

  ixheaacd_memset(synth, SYNTH_DELAY_LMAX + LEN_SUPERFRAME - synth_delay);

  xcitation_curr = xcitation_buff + MAX_PITCH + INTER_LP_FIL_ORDER + 1;

  ixheaacd_mem_cpy(st->xcitation_prev, xcitation_buff,

                   MAX_PITCH + INTER_LP_FIL_ORDER + 1);

  memset(xcitation_curr, 0, sizeof(FLOAT32) * (LEN_SUPERFRAME + 1));

  mod = pstr_td_frame_data->mod;

  if (usac_data->frame_ok == 1) {

    usac_data->num_lost_lpd_frames[usac_data->present_chan] = 0;

  }

  if (usac_data->ec_flag && usac_data->frame_ok == 0) {

    ixheaacd_usac_lpc_ec(usac_data->lsp_coeff, usac_data->lpc4_lsf, usac_data->lsf_adaptive_mean,

                         first_lpd_flag);

  }

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

    pitch[i] = st->pitch_prev[i];

    pitch_gain[i] = st->gain_prev[i];

  }

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

    pitch[i + num_subfr_by2] = 64;

    pitch_gain[i + num_subfr_by2] = 0.0f;

  }

  if (usac_data->frame_ok) {

    if (!first_lpd_flag) {

      ixheaacd_lsp_2_lsf_conversion(st->lspold, lsf_flt, ORDER);

    }

    ixheaacd_alg_vec_dequant(pstr_td_frame_data, first_lpd_flag, lsf_flt, pstr_td_frame_data->mod,

                             usac_data->ec_flag);

  }

  if (usac_data->ec_flag && !(usac_data->frame_ok)) {

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

      memcpy(&lsf_flt[i * ORDER], &usac_data->lsp_coeff[i], ORDER * sizeof(lsf_flt[0]));

    }

  }

  if (first_lpd_flag) {

    ixheaacd_mem_cpy(&lsf_flt[0], st->lsf_prev, ORDER);

    ixheaacd_lsf_2_lsp_conversion_float(st->lsf_prev, st->lspold, ORDER);

  }

  if ((first_lpd_flag && mod[0] == 0) || (first_lpd_flag && mod[1] == 0) ||

      ((first_lpd_flag && mod[2] == 0 && len_subfrm != LEN_FRAME))) {

    FLOAT32 lp_flt_coeff_a[9 * (ORDER + 1)];

    FLOAT32 tmp_buf[3 * LEN_FRAME + ORDER];

    FLOAT32 tmp_res_buf[3 * LEN_FRAME];

    FLOAT32 *tmp = &(tmp_buf[LEN_FRAME]);

    FLOAT32 *ptr_tmp = &(tmp_res_buf[LEN_FRAME]);

    WORD32 tmp_start;

    FLOAT32 mem = 0;

    WORD32 gain;

    WORD32 length;

    ixheaacd_interpolation_lsp_params(st->lspold, st->lspold, lp_flt_coeff_a,

                                      8);

    memcpy(st->lp_flt_coeff_a_prev, lp_flt_coeff_a,

           (ORDER + 1) * sizeof(FLOAT32));

    memcpy(st->lp_flt_coeff_a_prev + ORDER + 1, lp_flt_coeff_a,

           (ORDER + 1) * sizeof(FLOAT32));

    if (mod[0] == 0) {

      WORD32 fac_length;

      if (short_fac_flag) {

        fac_length = (len_subfrm * NUM_FRAMES) / 16;

      } else {

        fac_length = len_subfrm / 2;

      }

      if (usac_data->frame_ok == 0) {

        memset(&pstr_td_frame_data->fac_data[0], 0, sizeof(pstr_td_frame_data->fac_data));

      }

      gain = ixheaacd_pow_10_i_by_128[pstr_td_frame_data->fac_data[0]];

      memcpy(ptr_scratch, &pstr_td_frame_data->fac_data[0],

             129 * sizeof(WORD32));

      for (i = 0; i < fac_length / 2; i++) {

        pstr_td_frame_data->fac_data[i] = ptr_scratch[2 * i + 1] << 16;

        pstr_td_frame_data->fac_data[fac_length / 2 + i] =

            ptr_scratch[fac_length - 2 * i] << 16;

      }

      if (usac_data->ec_flag == 0) {

        if (fac_length & (fac_length - 1)) {

          if ((fac_length != 48) && (fac_length != 96) && (fac_length != 192) &&

              (fac_length != 384) && (fac_length != 768)) {

            return -1;

          }

        }

      }

      ixheaacd_fwd_alias_cancel_tool(usac_data, pstr_td_frame_data, fac_length, lp_flt_coeff_a,

                                     gain);

      memset(&usac_data->overlap_data_ptr[usac_data->present_chan][(len_fr / 2)], 0,

             fac_length * sizeof(WORD32));

    }

    for (i = 0; i < 2 * len_subfrm; i++)

      st->fd_synth[ORDER + i] = (FLOAT32)(

          (FLOAT32)usac_data->overlap_data_ptr[usac_data->present_chan][i] /

          16384.0);

    num_samples = min(2 * len_subfrm, MAX_PITCH + synth_delay);

    ixheaacd_mem_cpy(st->fd_synth + ORDER, synth - 2 * len_subfrm,

                     2 * len_subfrm);

    ixheaacd_preemphsis_tool_float(st->fd_synth + ORDER, PREEMPH_FILT_FAC,

                                   2 * len_subfrm, mem);

    ixheaacd_memset(tmp, ORDER);

    ixheaacd_mem_cpy(st->fd_synth + ORDER, tmp + ORDER, 2 * len_subfrm);

    tmp_start = 0;

    ixheaacd_memset(ptr_tmp - len_subfrm, 3 * len_subfrm);

    memset(st->fd_synth, 0, ORDER * sizeof(WORD32));

    length = (2 * len_subfrm - tmp_start) / LEN_SUBFR;

    ixheaacd_residual_tool_float1(lp_flt_coeff_a,

                                  &st->fd_synth[ORDER + tmp_start],

                                  &ptr_tmp[tmp_start], LEN_SUBFR, length);

    if (mod[0] != 0 && (len_subfrm == LEN_FRAME || mod[1] != 0)) {

      num_samples = min(len_subfrm, MAX_PITCH + INTER_LP_FIL_ORDER + 1);

    } else {

      num_samples = min(2 * len_subfrm, MAX_PITCH + INTER_LP_FIL_ORDER + 1);

    }

    ixheaacd_mem_cpy(ptr_tmp + 2 * len_subfrm - num_samples,

                     xcitation_curr - num_samples, num_samples);

  }

  k = 0;

  while (k < 4) {

    if (usac_data->ec_flag && usac_data->frame_ok == 0) {

      if (mod[k] != 0 && usac_data->frame_ok == 0 &&

          usac_data->str_error_concealment[ch].prev_frame_ok[0] == 0 && k == 0) {

        memcpy(st->lspold, usac_data->lspold_ec, sizeof(st->lspold));

      }

      usac_data->num_lost_lpd_frames[usac_data->present_chan]++;

    }

    mode = mod[k];

    if ((st->mode_prev == 0) && (mode > 0) &&

        (k != 0 || st->bpf_active_prev == 1)) {

      i = (k * num_subfr) + num_subfr_by2;

      pitch[i + 1] = pitch[i] = pitch[i - 1];

      pitch_gain[i + 1] = pitch_gain[i] = pitch_gain[i - 1];

    }

    if (usac_data->frame_ok == 0) {

      memcpy(lsf_curr, &lsf_flt[(k + 1) * ORDER], ORDER * sizeof(FLOAT32));

    } else {

      if ((mode == 0) || (mode == 1))

        memcpy(lsf_curr, &lsf_flt[(k + 1) * ORDER], ORDER * sizeof(FLOAT32));

      else if (mode == 2)

        memcpy(lsf_curr, &lsf_flt[(k + 2) * ORDER], ORDER * sizeof(FLOAT32));

      else

        memcpy(lsf_curr, &lsf_flt[(k + 4) * ORDER], ORDER * sizeof(FLOAT32));

    }

    ixheaacd_lsf_2_lsp_conversion_float(lsf_curr, lsp_curr, ORDER);

    if (usac_data->frame_ok) {

      tmp = 0.0f;

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

        tmp += (lsf_curr[i] - st->lsf_prev[i]) * (lsf_curr[i] - st->lsf_prev[i]);

      }

      stability_factor = (FLOAT32)(1.25f - (tmp / 400000.0f));

      if (stability_factor > 1.0f) {

        stability_factor = 1.0f;

      }

      if (stability_factor < 0.0f) {

        stability_factor = 0.0f;

      }

      if (usac_data->ec_flag) {

        usac_data->stability_factor_old = stability_factor;

      }

    }

    if (usac_data->ec_flag && !(usac_data->frame_ok)) {

      stability_factor = usac_data->stability_factor_old;

    }

    if (usac_data->frame_ok == 0) {

      mode = st->mode_prev;

    }

    if ((usac_data->frame_ok == 1 && mode == 0) ||

        (usac_data->frame_ok == 0 && (st->mode_prev == 0 || st->mode_prev == 1))) {

      ixheaacd_interpolation_lsp_params(st->lspold, lsp_curr, lp_flt_coff_a, num_subfr);

      if (usac_data->frame_ok == 1 || (usac_data->frame_ok == 0 && st->mode_prev == 0)) {

        ixheaacd_acelp_alias_cnx(usac_data, pstr_td_frame_data, k, lp_flt_coff_a,

                                 stability_factor, st);

      }

      if (usac_data->frame_ok == 0 && st->mode_prev == 1) {

        ixheaacd_usac_tcx_ec(usac_data, st, lsp_curr, k, lp_flt_coff_a);

      }

      if ((st->mode_prev != 0) && bpf_control_info) {

        i = (k * num_subfr) + num_subfr_by2;

        pitch[i - 1] = pitch[i];

        pitch_gain[i - 1] = pitch_gain[i];

        if (st->mode_prev != -2) {

          pitch[i - 2] = pitch[i];

          pitch_gain[i - 2] = pitch_gain[i];

        }

      }

      k++;

    } else {

      if (mode == 1) {

        subfr_len = len_subfrm;

        n_subfr = num_subfr;

      } else if (mode == 2) {

        subfr_len = len_subfrm << 1;

        n_subfr = num_subfr_in_superfr / 2;

      } else if (mode == 3) {

        subfr_len = len_subfrm << 2;

        n_subfr = num_subfr_in_superfr;

      } else {

        if (usac_data->frame_ok == 0) {

          mode = 3;

          subfr_len = len_subfrm << 2;

          n_subfr = num_subfr_in_superfr;

        }

      }

      ixheaacd_lpc_coef_gen(st->lspold, lsp_curr, lp_flt_coff_a, n_subfr,

                            ORDER);

      err = ixheaacd_tcx_mdct(usac_data, pstr_td_frame_data, k, lp_flt_coff_a,

                              subfr_len, st);

      if (err) return err;

      if (usac_data->frame_ok == 1 && k == 2) {

        memcpy(usac_data->lp_flt_coff_a_ec, &lp_flt_coff_a[k * (ORDER + 1)],

               sizeof(usac_data->lp_flt_coff_a_ec));

      }

      k += (1 << (mode - 1));

    }

    st->mode_prev = mode;

    if (usac_data->frame_ok == 0) {

      memcpy(usac_data->lspold_ec, st->lspold, sizeof(st->lspold));

    }

    ixheaacd_mem_cpy(lsp_curr, st->lspold, ORDER);

    ixheaacd_mem_cpy(lsf_curr, st->lsf_prev, ORDER);

  }

  ixheaacd_mem_cpy(xcitation_buff + len_fr, st->xcitation_prev,

                   MAX_PITCH + INTER_LP_FIL_ORDER + 1);

  ixheaacd_mem_cpy(synth_buf + len_fr, st->synth_prev, MAX_PITCH + synth_delay);

  if (!bpf_control_info) {

    if (mod[0] != 0 && st->bpf_active_prev) {

      for (i = 2; i < num_subfr_in_superfr; i++)

        pitch_gain[num_subfr_by2 + i] = 0.0;

    } else {

      for (i = 0; i < num_subfr_in_superfr; i++)

        pitch_gain[num_subfr_by2 + i] = 0.0;

    }

  }

  st->bpf_active_prev = bpf_control_info;

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

    st->pitch_prev[i] = pitch[num_subfr_in_superfr + i];

    st->gain_prev[i] = pitch_gain[num_subfr_in_superfr + i];

  }

  synth = synth_buf + MAX_PITCH;

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

    tp = pitch[i];

    gain = pitch_gain[i];

    if (gain > 0.0f) {

      synth_corr = 0.0f, synth_energy = 1e-6f;

      if ((((i * LEN_SUBFR) + LEN_SUBFR) > LEN_SUPERFRAME) ||

          ((((i * LEN_SUBFR) + LEN_SUBFR) - tp) > LEN_SUPERFRAME)) {

        if (usac_data->ec_flag) {

          tp = LEN_SUPERFRAME - LEN_SUBFR - (i * LEN_SUBFR);

        } else

          return -1;

      }

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

        synth_corr +=

            synth[i * LEN_SUBFR + k] * synth[(i * LEN_SUBFR) - tp + k];

        synth_energy +=

            synth[(i * LEN_SUBFR) - tp + k] * synth[(i * LEN_SUBFR) - tp + k];

      }

      pitch_gain[i] = synth_corr / synth_energy;

    }

  }

  if (mod[3] == 0) {

    err = ixheaacd_bass_post_filter(synth, pitch, pitch_gain, fsynth, len_fr, synth_delay,

                                    st->bpf_prev, usac_data->ec_flag);

  } else {

    err = ixheaacd_bass_post_filter(synth, pitch, pitch_gain, fsynth, len_fr,

                                    synth_delay - (len_subfrm / 2), st->bpf_prev,

                                    usac_data->ec_flag);

  }

  if (err) return err;

  if (usac_data->ec_flag && usac_data->frame_ok) {

    memcpy(usac_data->lpc4_lsf, pstr_td_frame_data->lpc4_lsf, sizeof(usac_data->lpc4_lsf));

    memcpy(usac_data->str_error_concealment[ch].lsf4, usac_data->lpc4_lsf,

           sizeof(usac_data->lpc4_lsf));

    memcpy(usac_data->lsf_adaptive_mean, pstr_td_frame_data->lsf_adaptive_mean_cand,

           sizeof(usac_data->lsf_adaptive_mean));

  }

  return err;

}

VOID ixheaacd_lpd_dec_update(ia_usac_lpd_decoder_handle tddec,

                             ia_usac_data_struct *usac_data, WORD32 i_ch) {

  WORD32 i, k;

  WORD32 *ptr_overlap = &usac_data->overlap_data_ptr[i_ch][0];

  WORD32 len_fr, lpd_sbf_len, lpd_delay, num_subfr_by2, synth_delay, fac_length;

  if (usac_data->tw_mdct[0])

    ptr_overlap = &usac_data->overlap_data_ptr[i_ch][usac_data->ccfl / 2];

  len_fr = usac_data->ccfl;

  lpd_sbf_len = (NUM_FRAMES * usac_data->num_subfrm) / 2;

  lpd_delay = lpd_sbf_len * LEN_SUBFR;

  num_subfr_by2 = lpd_sbf_len - 1;

  synth_delay = num_subfr_by2 * LEN_SUBFR;

  fac_length = (usac_data->len_subfrm) / 2;

  for (i = 0; i < LEN_SUBFR + synth_delay; i++)

    ptr_overlap[i] = (WORD32)(

        (FLOAT32)tddec->synth_prev[MAX_PITCH - (LEN_SUBFR) + i] * 16384.0);

  ptr_overlap += LEN_SUBFR + synth_delay - fac_length;

  for (k = 0; k < 2 * fac_length; k++)

    ptr_overlap[k] = (WORD32)((FLOAT32)tddec->exc_prev[k + 1] * 16384.0);

  ptr_overlap = &usac_data->overlap_data_ptr[i_ch][lpd_delay + fac_length];

  for (i = 0; i < len_fr - lpd_delay - fac_length; i++) ptr_overlap[i] = 0;

  usac_data->window_shape[i_ch] = WIN_SEL_0;

  usac_data->window_sequence_last[i_ch] = EIGHT_SHORT_SEQUENCE;

  usac_data->td_frame_prev[i_ch] = 1;

  if (tddec->mode_prev == 0) {

    memmove(usac_data->lpc_prev[i_ch], &tddec->lp_flt_coeff_a_prev[ORDER + 1],

            (ORDER + 1) * sizeof(FLOAT32));

    memmove(usac_data->acelp_in[i_ch], tddec->exc_prev,

            (1 + (2 * FAC_LENGTH)) * sizeof(FLOAT32));

  }

  return;

}

WORD32 ixheaacd_lpd_bpf_fix(ia_usac_data_struct *usac_data,

                            WORD32 is_short_flag, FLOAT32 out_buffer[],

                            ia_usac_lpd_decoder_handle st) {

  WORD32 i, tp, k;

  float synth_buf[MAX_PITCH + SYNTH_DELAY_LMAX + LEN_SUPERFRAME];

  float signal_out[LEN_SUPERFRAME];

  float *synth, synth_corr, synth_energy;

  WORD32 pitch[NUM_SUBFR_SUPERFRAME_BY2 + 3];

  float pitch_gain[NUM_SUBFR_SUPERFRAME_BY2 + 3];

  WORD32 len_fr, lpd_sbf_len, num_subfr_by2, synth_delay;

  WORD32 err = 0;

  len_fr = usac_data->ccfl;

  lpd_sbf_len = (NUM_FRAMES * usac_data->num_subfrm) / 2;

  num_subfr_by2 = lpd_sbf_len - 1;

  synth_delay = num_subfr_by2 * LEN_SUBFR;

  ixheaacd_memset(synth_buf, MAX_PITCH + synth_delay + len_fr);

  ixheaacd_mem_cpy(st->synth_prev, synth_buf, MAX_PITCH + synth_delay);

  ixheaacd_mem_cpy(out_buffer, synth_buf + MAX_PITCH - (LEN_SUBFR),

                   synth_delay + len_fr + (LEN_SUBFR));

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

    pitch[i] = st->pitch_prev[i];

    pitch_gain[i] = st->gain_prev[i];

  }

  for (i = num_subfr_by2; i < lpd_sbf_len + 3; i++) {

    pitch[i] = 64;

    pitch_gain[i] = 0.0f;

  }

  if (st->mode_prev == 0) {

    pitch[num_subfr_by2] = pitch[num_subfr_by2 - 1];

    pitch_gain[num_subfr_by2] = pitch_gain[num_subfr_by2 - 1];

    if (!is_short_flag) {

      pitch[num_subfr_by2 + 1] = pitch[num_subfr_by2];

      pitch_gain[num_subfr_by2 + 1] = pitch_gain[num_subfr_by2];

    }

  }

  synth = synth_buf + MAX_PITCH;

  for (i = 0; i < num_subfr_by2 + 2; i++) {

    tp = pitch[i];

    if ((i * LEN_SUBFR + MAX_PITCH) < tp) {

      if (usac_data->ec_flag == 0)

        return -1;

      else {

        tp = MAX_PITCH - (i * LEN_SUBFR);

      }

    } else if (((i * LEN_SUBFR + MAX_PITCH - tp) >= 1883) ||

               (((i * LEN_SUBFR) + LEN_SUBFR) > LEN_SUPERFRAME) ||

               ((((i * LEN_SUBFR) + LEN_SUBFR) - tp) > LEN_SUPERFRAME)) {

      if (usac_data->ec_flag == 0)

        return -1;

      else {

        tp = (i * LEN_SUBFR + MAX_PITCH - 1882);

      }

    }

    if (pitch_gain[i] > 0.0f) {

      synth_corr = 0.0f, synth_energy = 1e-6f;

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

        synth_corr +=

            synth[i * LEN_SUBFR + k] * synth[(i * LEN_SUBFR) - tp + k];

        synth_energy +=

            synth[(i * LEN_SUBFR) - tp + k] * synth[(i * LEN_SUBFR) - tp + k];

      }

      pitch_gain[i] = synth_corr / synth_energy;

    }

  }

  err = ixheaacd_bass_post_filter(

      synth, pitch, pitch_gain, signal_out, (lpd_sbf_len + 2) * LEN_SUBFR + LEN_SUBFR,

      len_fr - (lpd_sbf_len + 4) * LEN_SUBFR, st->bpf_prev, usac_data->ec_flag);

  if (err != 0) return err;

  ixheaacd_mem_cpy(signal_out, out_buffer,

                   (lpd_sbf_len + 2) * LEN_SUBFR + LEN_SUBFR);

  return err;

}