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

 *                                                                            *

 * Copyright (C) 2023 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at:

 *

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 *

 *****************************************************************************

 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore

*/

#include <string.h>

#include <ixheaac_type_def.h>

#include <ixheaac_constants.h>

#include <ixheaac_basic_ops32.h>

#include <ixheaac_basic_ops16.h>

#include <ixheaac_basic_ops40.h>

#include "ixheaacd_sbr_common.h"

#include "ixheaacd_intrinsics.h"

#include "ixheaacd_common_rom.h"

#include "ixheaacd_sbrdecsettings.h"

#include "ixheaacd_bitbuffer.h"

#include "ixheaacd_defines.h"

#include "ixheaacd_pns.h"

#include <ixheaacd_aac_rom.h>

#include "ixheaacd_pulsedata.h"

#include "ixheaacd_lt_predict.h"

#include "ixheaacd_cnst.h"

#include "ixheaacd_drc_data_struct.h"

#include "ixheaacd_ec_defines.h"

#include "ixheaacd_ec_rom.h"

#include "ixheaacd_ec_struct_def.h"

#include "ixheaacd_channelinfo.h"

#include "ixheaacd_interface.h"

#include "ixheaacd_acelp_info.h"

#include "ixheaacd_tns_usac.h"

#include "ixheaacd_info.h"

#include "ixheaacd_drc_dec.h"

#include "ixheaacd_sbrdecoder.h"

#include "ixheaacd_mps_polyphase.h"

#include "ixheaac_sbr_const.h"

#include "ixheaacd_ec_defines.h"

#include "ixheaacd_ec_struct_def.h"

#include "ixheaacd_main.h"

#include "ixheaacd_acelp_com.h"

static WORD32 ixheaacd_usac_ec_get_win_seq(WORD32 prev_win_seq) {

  if (prev_win_seq == LONG_START_SEQUENCE || prev_win_seq == EIGHT_SHORT_SEQUENCE) {

    return LONG_STOP_SEQUENCE;

  } else {

    return ONLY_LONG_SEQUENCE;

  }

}

static VOID ixheaacd_usac_flip_spec_sign(WORD32 *ptr_spec_coeff, WORD32 samples_per_frame,

                                         UWORD32 *seed_value) {

  WORD32 i;

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

    ptr_spec_coeff[i] = ixheaac_mult32x16in32_sat(ptr_spec_coeff[i],

                            (WORD16)ixheaacd_randomsign(seed_value));

  }

}

static VOID iexheaace_ec_sfb_nrg_q(WORD32 *ptr_spectrum, ia_ec_sfb_str *pstr_ec_sfb,

                                   WORD32 win_seq, WORD32 win_trans, WORD32 *ptr_sfb_enrg) {

  WORD16 *ptr_sfb_offset = pstr_ec_sfb->ptr_sfb_long;

  WORD32 l = 0, sfb, num_sfb = pstr_ec_sfb->num_sfb_long;

  switch (win_seq) {

    case EIGHT_SHORT_SEQUENCE:

      if (win_trans == NO_TRANSITION) {

        num_sfb = pstr_ec_sfb->num_sfb_short;

        ptr_sfb_offset = pstr_ec_sfb->ptr_sfb_short;

        for (sfb = 0; sfb < num_sfb; sfb++) {

          WORD64 accu = (WORD64)1;

          WORD32 q_nrg = (sizeof(accu) << 3) -

                         ixheaac_norm32(ptr_sfb_offset[sfb + 1] - ptr_sfb_offset[sfb]);

          for (; l < ptr_sfb_offset[sfb + 1]; l++) {

            accu += ixheaac_mul32_sh(ptr_spectrum[l], ptr_spectrum[l], q_nrg);

          }

          ptr_sfb_enrg[sfb] = ixheaac_norm32((WORD32)accu);

        }

      } else {

        num_sfb = pstr_ec_sfb->num_sfb_long;

        ptr_sfb_offset = pstr_ec_sfb->ptr_sfb_long;

        for (sfb = 0; sfb < num_sfb; sfb++) {

          WORD64 accu = (WORD64)1;

          WORD32 q_nrg = (sizeof(accu) << 3) -

                         ixheaac_norm32(ptr_sfb_offset[sfb + 1] - ptr_sfb_offset[sfb]);

          for (; l < ptr_sfb_offset[sfb + 1]; l++) {

            accu += ixheaac_mul32_sh(ptr_spectrum[(l >> 3)], ptr_spectrum[(l >> 3)], q_nrg);

          }

          ptr_sfb_enrg[sfb] = ixheaac_norm32((WORD32)accu);

        }

      }

      break;

    case ONLY_LONG_SEQUENCE:

    case LONG_START_SEQUENCE:

    case LONG_STOP_SEQUENCE:

      if (win_trans == NO_TRANSITION) {

        num_sfb = pstr_ec_sfb->num_sfb_long;

        ptr_sfb_offset = pstr_ec_sfb->ptr_sfb_long;

        for (sfb = 0; sfb < num_sfb; sfb++) {

          WORD64 accu = (WORD64)1;

          WORD32 q_nrg = (sizeof(accu) << 3) -

                         ixheaac_norm32(ptr_sfb_offset[sfb + 1] - ptr_sfb_offset[sfb]);

          for (; l < ptr_sfb_offset[sfb + 1]; l++) {

            accu += ixheaac_mul32_sh(ptr_spectrum[l], ptr_spectrum[l], q_nrg);

          }

          ptr_sfb_enrg[sfb] = ixheaac_norm32((WORD32)accu);

        }

      } else {

        num_sfb = pstr_ec_sfb->num_sfb_short;

        ptr_sfb_offset = pstr_ec_sfb->ptr_sfb_short;

        for (sfb = 0; sfb < num_sfb; sfb++) {

          WORD64 accu = (WORD64)1;

          WORD32 q_nrg = (sizeof(accu) << 3) -

                         ixheaac_norm32(ptr_sfb_offset[sfb + 1] - ptr_sfb_offset[sfb]);

          for (; l < ptr_sfb_offset[sfb + 1] << 3; l++) {

            accu += (accu + (ixheaac_mul32_sh(ptr_spectrum[l], ptr_spectrum[l], q_nrg))) >> 3;

          }

          ptr_sfb_enrg[sfb] = ixheaac_norm32((WORD32)accu);

        }

      }

      break;

  }

}

static VOID ixheaacd_usac_ec_interpolate(WORD32 *ptr_spectrum, WORD16 *pq_spec_coeff_prev,

                                         WORD16 *pq_spec_coeff_act, WORD16 *pq_spec_coeff_out,

                                         WORD32 *ptr_nrg_prev, WORD32 *ptr_nrg_act,

                                         WORD32 num_sfb, WORD16 *ptr_sfb_offset) {

  WORD32 sfb, l = 0;

  WORD32 fac_shift;

  WORD32 fac_mod;

  for (sfb = 0; sfb < num_sfb; sfb++) {

    fac_shift =

        ptr_nrg_prev[sfb] - ptr_nrg_act[sfb] + ((*pq_spec_coeff_act - *pq_spec_coeff_prev) << 1);

    fac_mod = fac_shift & 3;

    fac_shift = (fac_shift >> 2) + 1;

    fac_shift += *pq_spec_coeff_prev - ixheaac_max16(*pq_spec_coeff_prev, *pq_spec_coeff_act);

    fac_shift = ixheaac_max32(ixheaac_min32(fac_shift, INT_BITS - 1), -(INT_BITS - 1));

    for (; l < ptr_sfb_offset[sfb + 1]; l++) {

      WORD32 accu = ixheaac_shl32_sat(

          ixheaac_mult32x32in32(ptr_spectrum[l], (WORD32)(ia_ec_interpolation_fac[fac_mod])), 1);

      ptr_spectrum[l] = ixheaac_shl32_dir_sat((WORD32)accu, fac_shift);

    }

  }

  *pq_spec_coeff_out = ixheaac_max16(*pq_spec_coeff_prev, *pq_spec_coeff_act);

}

static VOID ixheaacd_usac_ec_interpolate_frame(ia_usac_data_struct *pstr_usac_data,

                                               ia_ec_state_str *pstr_ec_state,

                                               const ia_usac_samp_rate_info *pstr_samp_rate_info,

                                               WORD32 frame_ok, WORD32 chn) {

  WORD32 frame_length = pstr_usac_data->ccfl;

  WORD32 *ptr_spec_coeff = pstr_usac_data->coef_fix[chn];

  WORD16 *ptr_spec_sf = pstr_usac_data->spec_scale[chn];

  WORD32 i;

  ia_ec_scratch_str *pstr_ec_scratch = pstr_ec_state->pstr_ec_scratch;

  WORD16 num_sfb_long;

  WORD16 *ptr_sfb_long = NULL;

  WORD16 num_sfb_short;

  WORD16 *ptr_sfb_short = NULL;

  if (pstr_usac_data->core_mode == CORE_MODE_FD) {

    num_sfb_long = pstr_samp_rate_info->num_sfb_1024;

    ptr_sfb_long = (WORD16 *)pstr_samp_rate_info->ptr_sfb_1024;

    num_sfb_short = pstr_samp_rate_info->num_sfb_128;

    ptr_sfb_short = (WORD16 *)pstr_samp_rate_info->ptr_sfb_128;

    if (pstr_usac_data->ccfl == WIN_LEN_768) {

      num_sfb_long = pstr_samp_rate_info->num_sfb_768;

      ptr_sfb_long = (WORD16 *)pstr_samp_rate_info->ptr_sfb_768;

      num_sfb_short = pstr_samp_rate_info->num_sfb_96;

      ptr_sfb_short = (WORD16 *)pstr_samp_rate_info->ptr_sfb_96;

    }

    pstr_ec_state->str_ec_sfb.num_sfb_long = num_sfb_long;

    pstr_ec_state->str_ec_sfb.num_sfb_long = num_sfb_long;

    pstr_ec_state->str_ec_sfb.ptr_sfb_long = ptr_sfb_long;

    pstr_ec_state->str_ec_sfb.ptr_sfb_long = ptr_sfb_long;

    memset(pstr_ec_scratch->prev_sfb_nrg, 0, sizeof(pstr_ec_scratch->prev_sfb_nrg));

    memset(pstr_ec_scratch->pres_sfb_nrg, 0, sizeof(pstr_ec_scratch->pres_sfb_nrg));

    if (!frame_ok) {

      pstr_usac_data->window_shape[chn] = pstr_ec_state->win_shape;

      pstr_usac_data->window_sequence[chn] = pstr_ec_state->win_seq;

      memcpy(ptr_spec_coeff, pstr_ec_state->spectral_coeff,

             sizeof(*ptr_spec_coeff) * frame_length);

      memcpy(ptr_spec_sf, pstr_ec_state->q_spec_coeff, sizeof(pstr_ec_state->q_spec_coeff));

    }

  }

  if (!pstr_ec_state->prev_frame_ok[1]) {

    if (frame_ok && pstr_ec_state->prev_frame_ok[0] &&

        pstr_usac_data->core_mode == CORE_MODE_FD) {

      if (pstr_usac_data->window_sequence[chn] == EIGHT_SHORT_SEQUENCE) {

        WORD32 wnd;

        if (pstr_ec_state->win_seq == EIGHT_SHORT_SEQUENCE) {

          WORD32 num_sfb = num_sfb_short;

          WORD16 *ptr_sfb_offset = ptr_sfb_short;

          pstr_usac_data->window_shape[chn] = 1;

          pstr_usac_data->window_sequence[chn] = EIGHT_SHORT_SEQUENCE;

          for (wnd = 0; wnd < 8; wnd++) {

            iexheaace_ec_sfb_nrg_q(&ptr_spec_coeff[wnd * (frame_length >> 3)],

                                   &pstr_ec_state->str_ec_sfb, EIGHT_SHORT_SEQUENCE,

                                   NO_TRANSITION, pstr_ec_scratch->prev_sfb_nrg);

            iexheaace_ec_sfb_nrg_q(&pstr_ec_state->spectral_coeff[wnd * (frame_length >> 3)],

                                   &pstr_ec_state->str_ec_sfb, EIGHT_SHORT_SEQUENCE,

                                   NO_TRANSITION, pstr_ec_scratch->pres_sfb_nrg);

            ixheaacd_usac_ec_interpolate(&ptr_spec_coeff[wnd * (frame_length / 8)],

                                         &ptr_spec_sf[wnd], &pstr_ec_state->q_spec_coeff[wnd],

                                         &ptr_spec_sf[wnd], pstr_ec_scratch->prev_sfb_nrg,

                                         pstr_ec_scratch->pres_sfb_nrg, num_sfb, ptr_sfb_offset);

          }

        } else {

          WORD32 num_sfb = num_sfb_long;

          WORD16 *ptr_sfb_offset = ptr_sfb_long;

          WORD16 q_spec_coeff_out;

          iexheaace_ec_sfb_nrg_q(&ptr_spec_coeff[frame_length - (frame_length >> 3)],

                                 &pstr_ec_state->str_ec_sfb, EIGHT_SHORT_SEQUENCE,

                                 TRANS_SHORT_LONG, pstr_ec_scratch->pres_sfb_nrg);

          iexheaace_ec_sfb_nrg_q(pstr_ec_state->spectral_coeff, &pstr_ec_state->str_ec_sfb,

                                 ONLY_LONG_SEQUENCE, NO_TRANSITION,

                                 pstr_ec_scratch->prev_sfb_nrg);

          pstr_usac_data->window_shape[chn] = 0;

          pstr_usac_data->window_sequence[chn] = LONG_STOP_SEQUENCE;

          memcpy(&ptr_spec_coeff[0], pstr_ec_state->spectral_coeff,

                 frame_length * sizeof(ptr_spec_coeff[0]));

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

            if (ptr_spec_sf[i] > ptr_spec_sf[0]) {

              ptr_spec_sf[0] = ptr_spec_sf[i];

            }

          }

          ixheaacd_usac_ec_interpolate(ptr_spec_coeff, &pstr_ec_state->q_spec_coeff[0],

                                       &ptr_spec_sf[0], &q_spec_coeff_out,

                                       pstr_ec_scratch->prev_sfb_nrg,

                                       pstr_ec_scratch->pres_sfb_nrg, num_sfb, ptr_sfb_offset);

          ptr_spec_sf[0] = q_spec_coeff_out;

        }

      } else {

        WORD32 num_sfb = num_sfb_long;

        WORD16 *ptr_sfb_offset = ptr_sfb_long;

        WORD16 q_spec_coeff_act = pstr_ec_state->q_spec_coeff[0];

        iexheaace_ec_sfb_nrg_q(ptr_spec_coeff, &pstr_ec_state->str_ec_sfb, ONLY_LONG_SEQUENCE,

                               NO_TRANSITION, pstr_ec_scratch->prev_sfb_nrg);

        if (pstr_ec_state->win_seq == EIGHT_SHORT_SEQUENCE) {

          pstr_usac_data->window_shape[chn] = 1;

          pstr_usac_data->window_sequence[chn] = LONG_START_SEQUENCE;

          for (i = 1; i < 8; i++) {

            if (pstr_ec_state->q_spec_coeff[i] > q_spec_coeff_act) {

              q_spec_coeff_act = pstr_ec_state->q_spec_coeff[i];

            }

          }

          iexheaace_ec_sfb_nrg_q(pstr_ec_state->spectral_coeff, &pstr_ec_state->str_ec_sfb,

                                 EIGHT_SHORT_SEQUENCE, TRANS_SHORT_LONG,

                                 pstr_ec_scratch->pres_sfb_nrg);

        } else {

          pstr_usac_data->window_shape[chn] = 0;

          pstr_usac_data->window_sequence[chn] = ONLY_LONG_SEQUENCE;

          iexheaace_ec_sfb_nrg_q(pstr_ec_state->spectral_coeff, &pstr_ec_state->str_ec_sfb,

                                 ONLY_LONG_SEQUENCE, NO_TRANSITION,

                                 pstr_ec_scratch->pres_sfb_nrg);

        }

        ixheaacd_usac_ec_interpolate(ptr_spec_coeff, &ptr_spec_sf[0], &q_spec_coeff_act,

                                     &ptr_spec_sf[0], pstr_ec_scratch->prev_sfb_nrg,

                                     pstr_ec_scratch->pres_sfb_nrg, num_sfb, ptr_sfb_offset);

      }

    }

    ixheaacd_usac_flip_spec_sign(ptr_spec_coeff, frame_length, &pstr_usac_data->seed_value[chn]);

  }

  if (FRAME_MUTE == pstr_ec_state->conceal_state) {

    pstr_usac_data->window_shape[chn] = pstr_ec_state->win_shape;

    pstr_usac_data->window_sequence[chn] = ixheaacd_usac_ec_get_win_seq(pstr_ec_state->win_seq);

    pstr_ec_state->win_seq = pstr_usac_data->window_sequence[chn];

    memset(ptr_spec_coeff, 0, frame_length * sizeof(ptr_spec_coeff[0]));

  }

  return;

}

static VOID ixheaacd_usac_lpc_ec_state(ia_ec_state_str *pstr_ec_state, WORD32 frame_ok) {

  if (frame_ok == 0) {

    if (pstr_ec_state->fade_idx < MAX_FADE_FRAMES) {

      pstr_ec_state->fade_idx++;

    }

    pstr_ec_state->conceal_state = FRAME_CONCEAL_SINGLE;

  } else {

    if (pstr_ec_state->fade_idx > 0) {

      pstr_ec_state->fade_idx--;

    }

    pstr_ec_state->conceal_state = FRAME_OKAY;

  }

  if (pstr_ec_state->fade_idx >= MAX_FADE_FRAMES) {

    pstr_ec_state->fade_idx = MAX_FADE_FRAMES;

    pstr_ec_state->conceal_state = FRAME_MUTE;

  }

  if (pstr_ec_state->fade_idx < 0) {

    pstr_ec_state->fade_idx = 0;

  }

  return;

}

static VOID ixheaacd_usac_ec_state(ia_ec_state_str *pstr_ec_state, WORD32 frame_ok) {

  WORD32 ec_state_val = (pstr_ec_state->prev_frame_ok[0] << 2) +

                        (pstr_ec_state->prev_frame_ok[1] << 1) + (frame_ok);

  switch (ec_state_val) {

    case 0:

    case 4:

      if (pstr_ec_state->fade_idx < MAX_FADE_FRAMES) {

        pstr_ec_state->fade_idx++;

      }

      pstr_ec_state->conceal_state = FRAME_CONCEAL_SINGLE;

      break;

    case 1:

    case 2:

      if (pstr_ec_state->fade_idx > 0) {

        pstr_ec_state->fade_idx--;

      }

      pstr_ec_state->conceal_state = FRAME_FADE;

      break;

    case 5:

      if (pstr_ec_state->fade_idx > 0) {

        pstr_ec_state->fade_idx--;

      }

      pstr_ec_state->conceal_state = FRAME_OKAY;

      break;

      break;

    case 3:

    case 6:

    case 7:

      if (pstr_ec_state->fade_idx > 0) {

        pstr_ec_state->fade_idx--;

      }

      pstr_ec_state->conceal_state = FRAME_OKAY;

      break;

    default:

      pstr_ec_state->conceal_state = FRAME_OKAY;

  }

  if (pstr_ec_state->fade_idx > MAX_FADE_FRAMES) {

    pstr_ec_state->fade_idx = MAX_FADE_FRAMES;

  }

  if (pstr_ec_state->fade_idx == MAX_FADE_FRAMES) {

    pstr_ec_state->conceal_state = FRAME_MUTE;

  }

  if (pstr_ec_state->fade_idx < 0) {

    pstr_ec_state->fade_idx = 0;

  }

}

VOID ixheaacd_usac_ec_init(ia_ec_state_str *pstr_ec_state, WORD32 core_coder_mode) {

  pstr_ec_state->win_shape = 1;

  pstr_ec_state->win_seq = ONLY_LONG_SEQUENCE;

  pstr_ec_state->prev_win_group_len = 1;

  pstr_ec_state->conceal_state = FRAME_OKAY;

  memset(pstr_ec_state->spectral_coeff, 0, sizeof(pstr_ec_state->spectral_coeff));

  memset(pstr_ec_state->q_spec_coeff, 0, sizeof(pstr_ec_state->q_spec_coeff));

  pstr_ec_state->prev_frame_ok[0] = 1;

  pstr_ec_state->prev_frame_ok[1] = 1;

  pstr_ec_state->fade_idx = 0;

  pstr_ec_state->prev_core_mode = core_coder_mode;

}

VOID ixheaacd_usac_lpc_ec(FLOAT32 lsp[][ORDER], FLOAT32 *lpc4_lsf, FLOAT32 *lsf_adaptive_mean,

                          const WORD32 first_lpd_flag) {

  WORD32 i, j;

  if (first_lpd_flag) {

    memcpy(lsp[0], lsf_init, sizeof(lsf_init));

    memcpy(lpc4_lsf, lsf_init, sizeof(lsf_init));

  } else {

    memcpy(lsp[0], lpc4_lsf, ORDER * sizeof(lpc4_lsf[0]));

  }

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

    FLOAT32 lsf_mean = (BETA * lsf_init[i]) + (ONE_BETA * lsf_adaptive_mean[i]);

    lsp[1][i] = (BFI_FAC * lpc4_lsf[i]) + (ONE_BFI_FAC * lsf_mean);

  }

  for (j = 2; j <= 4; j++) {

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

      FLOAT32 lsf_mean = ((BETA + (j * ONE_BFI_FAC)) * lsf_init[i]) +

                         ((ONE_BETA - (j * ONE_BFI_FAC)) * lsf_adaptive_mean[i]);

      lsp[j][i] = (BFI_FAC * lsp[j - 1][i]) + (ONE_BFI_FAC * lsf_mean);

    }

  }

  memcpy(lpc4_lsf, lsp[4], ORDER * sizeof(lpc4_lsf[0]));

}

VOID ixheaacd_usac_ec_save_states(ia_ec_state_str *pstr_ec_state,

                                  ia_usac_data_struct *pstr_usac_data, WORD32 ch) {

  if (pstr_usac_data->core_mode == CORE_MODE_FD &&

      (pstr_usac_data->frame_ok == 1 && pstr_ec_state->prev_frame_ok[1] == 1)) {

    WORD32 *ptr_spec_coeff = pstr_usac_data->coef_fix[ch];

    WORD16 *ptr_spec_scale = pstr_usac_data->spec_scale[ch];

    WORD16 q_spec_coeff[MAX_SPEC_SCALE_LEN_EC];

    UWORD8 win_shape = pstr_ec_state->win_shape;

    UWORD8 win_shape_prev = pstr_ec_state->win_shape_prev;

    WORD32 win_seq = pstr_ec_state->win_seq;

    WORD32 td_frame_prev = pstr_ec_state->td_frame_prev;

    WORD32 fac_data_present = pstr_ec_state->fac_data_present;

    ia_sfb_info_struct *sfb_info =

        pstr_usac_data->pstr_usac_winmap[pstr_usac_data->window_sequence[ch]];

    WORD32 *ptr_scratch_buf = &pstr_ec_state->pstr_ec_scratch->spec_coeff[0];

    memcpy(q_spec_coeff, pstr_ec_state->q_spec_coeff, sizeof(q_spec_coeff));

    pstr_ec_state->win_seq = pstr_usac_data->window_sequence[ch];

    pstr_ec_state->win_shape = pstr_usac_data->window_shape[ch];

    pstr_ec_state->td_frame_prev = pstr_usac_data->td_frame_prev[ch];

    pstr_ec_state->fac_data_present = pstr_usac_data->fac_data_present[ch];

    pstr_ec_state->win_shape_prev = pstr_usac_data->window_shape_prev[ch];

    pstr_ec_state->prev_win_group_len = (WORD32)sfb_info->group_len[sfb_info->num_groups - 1];

    memcpy(pstr_ec_state->q_spec_coeff, ptr_spec_scale, sizeof(pstr_ec_state->q_spec_coeff));

    memcpy(ptr_scratch_buf, ptr_spec_coeff, pstr_usac_data->ccfl * sizeof(ptr_scratch_buf[0]));

    memcpy(ptr_spec_coeff, &pstr_ec_state->spectral_coeff[0],

           pstr_usac_data->ccfl * sizeof(ptr_spec_coeff[0]));

    memcpy(&pstr_ec_state->spectral_coeff[0], ptr_scratch_buf,

           pstr_usac_data->ccfl * sizeof(ptr_spec_coeff[0]));

    if (!pstr_usac_data->first_frame) {

      pstr_usac_data->window_sequence[ch] = win_seq;

      pstr_usac_data->window_shape[ch] = win_shape;

      pstr_usac_data->td_frame_prev_ec[ch] = td_frame_prev;

      pstr_usac_data->fac_data_present[ch] = fac_data_present;

      pstr_usac_data->window_shape_prev[ch] = win_shape_prev;

    }

    memcpy(ptr_spec_scale, q_spec_coeff, sizeof(q_spec_coeff));

  }

}

VOID ixheaacd_usac_apply_ec(ia_usac_data_struct *pstr_usac_data,

                            const ia_usac_samp_rate_info *pstr_samp_rate_info, WORD32 ch) {

  WORD32 frame_ok = pstr_usac_data->frame_ok;

  ia_ec_state_str *pstr_ec_state = &pstr_usac_data->str_error_concealment[ch];

  if (pstr_usac_data->core_mode == CORE_MODE_FD) {

    if (pstr_ec_state->win_shape == (UWORD8)-1) {

      pstr_ec_state->win_shape = pstr_usac_data->window_shape[ch];

    }

    ixheaacd_usac_ec_state(pstr_ec_state, frame_ok);

    if (pstr_ec_state->conceal_state == FRAME_OKAY) {

      pstr_ec_state->prev_core_mode = pstr_usac_data->core_mode;

      ixheaacd_usac_ec_save_states(pstr_ec_state, pstr_usac_data, ch);

    } else if (pstr_ec_state->conceal_state == FRAME_CONCEAL_SINGLE) {

      ixheaacd_usac_ec_interpolate_frame(pstr_usac_data, pstr_ec_state, pstr_samp_rate_info,

                                         frame_ok, ch);

    } else {

    }

    if (!frame_ok) {

      WORD32 *ptr_spec_coeff = pstr_usac_data->coef_fix[ch];

      WORD16 *ptr_spec_scale = pstr_usac_data->spec_scale[ch];

      pstr_usac_data->window_sequence[ch] = pstr_ec_state->win_seq;

      pstr_usac_data->window_shape[ch] = pstr_ec_state->win_shape;

      if (pstr_ec_state->conceal_state != FRAME_MUTE) {

        memcpy(ptr_spec_scale, pstr_ec_state->q_spec_coeff, sizeof(pstr_ec_state->q_spec_coeff));

        memcpy(ptr_spec_coeff, pstr_ec_state->spectral_coeff,

               sizeof(pstr_ec_state->spectral_coeff));

      } else {

        memset(ptr_spec_scale, 0, MAX_SPEC_SCALE_LEN * sizeof(ptr_spec_scale[0]));

        memset(ptr_spec_coeff, 0, pstr_usac_data->ccfl * sizeof(ptr_spec_coeff[0]));

      }

    }

  } else {

    ixheaacd_usac_lpc_ec_state(pstr_ec_state, frame_ok);

    if (pstr_ec_state->conceal_state == FRAME_OKAY) {

      memcpy(pstr_ec_state->lsf4, pstr_usac_data->lpc4_lsf, sizeof(pstr_ec_state->lsf4));

    } else if (pstr_ec_state->conceal_state == FRAME_CONCEAL_SINGLE) {

      WORD32 frame_length = pstr_usac_data->ccfl;

      WORD32 *ptr_spec_coeff = pstr_usac_data->tcx_spec_coeffs[ch];

      ixheaacd_usac_flip_spec_sign(ptr_spec_coeff, frame_length,

                                   &pstr_usac_data->seed_value[ch]);

    } else {

      WORD32 *ptr_spec_coeff = pstr_usac_data->tcx_spec_coeffs[ch];

      memset(ptr_spec_coeff, 0, pstr_usac_data->ccfl * sizeof(ptr_spec_coeff[0]));

    }

    if (!frame_ok) {

      memcpy(pstr_usac_data->lpc4_lsf, pstr_ec_state->lsf4, sizeof(pstr_usac_data->lpc4_lsf));

    }

  }

  pstr_ec_state->prev_frame_ok[0] = pstr_ec_state->prev_frame_ok[1];

  pstr_ec_state->prev_frame_ok[1] = frame_ok;

  return;

}

static VOID ixheaacd_lpc_wt_tool(FLOAT32 a[], WORD32 l) {

  WORD32 i;

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

    a[i] = a[i] * ixheaacd_gamma_table[i];

  }

  return;

}

static VOID ixheaacd_lpc_coef_gen_ec(FLOAT32 lsf_old[], FLOAT32 lsf_new[], FLOAT32 a[],

                                     WORD32 m) {

  FLOAT32 lsf[ORDER], *ptr_a;

  FLOAT32 inc, fnew, fold;

  WORD32 i;

  ptr_a = a;

  inc = 1.0f / (FLOAT32)m;

  fnew = 0.5f - (0.5f * inc);

  fold = 1.0f - fnew;

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

    lsf[i] = (lsf_old[i] * fold) + (lsf_new[i] * fnew);

  }

  ixheaacd_lsp_to_lp_conversion(lsf, ptr_a);

  return;

}

VOID ixheaacd_usac_tcx_ec(ia_usac_data_struct *pstr_usac_data, ia_usac_lpd_decoder_handle st,

                          FLOAT32 *ptr_lsp_curr, WORD32 frame_idx, FLOAT32 *lp_flt_coff_a) {

  WORD32 ch = pstr_usac_data->present_chan;

  FLOAT32 synth_buf[ORDER + LEN_FRAME], temp;

  FLOAT32 exc_buf[MAX_PITCH + ORDER + 1 + LEN_FRAME];

  FLOAT32 *ptr_syn = synth_buf + ORDER;

  FLOAT32 *ptr_exc = exc_buf + MAX_PITCH + ORDER + 1;

  FLOAT32 est_fac_est = 0.1f;

  WORD32 i, sf_idx;

  FLOAT32 synth_sig_buf[LEN_SUBFR + 1];

  FLOAT32 *synth_signal = synth_sig_buf + 1;

  WORD32 num_lost_frames = pstr_usac_data->num_lost_lpd_frames[ch];

  WORD32 len_subfrm = pstr_usac_data->len_subfrm;

  FLOAT32 past_tcx_gain = pstr_usac_data->past_gain_tcx[ch];

  WORD32 l_div_part = MAX_PITCH + ORDER + 1 - len_subfrm;

  FLOAT32 *synth = pstr_usac_data->synth_buf + MAX_PITCH - LEN_SUBFR;

  FLOAT32 *ptr_synth = &synth[512 + frame_idx * len_subfrm];

  FLOAT32 syn_buf[MAX_PITCH + ORDER + 1];

  FLOAT32 *ptr_syn_buf = &syn_buf[ORDER];

  memcpy(syn_buf, &ptr_synth[-(MAX_PITCH + ORDER + 1)],

         sizeof(syn_buf));

  memcpy(st->synth_prev_ec, &syn_buf[MAX_PITCH + 1], sizeof(st->synth_prev_ec));

  ixheaacd_residual_tool_float(pstr_usac_data->lp_flt_coff_a_ec, ptr_syn_buf, st->xcitation_prev,

                               pstr_usac_data->len_subfrm, 1);

  ixheaacd_residual_tool_float(lp_flt_coff_a, &syn_buf[l_div_part],

                               st->xcitation_prev + l_div_part, pstr_usac_data->len_subfrm, 1);

  if (st->last_tcx_pitch > MAX_PITCH) {

    st->last_tcx_pitch = MAX_PITCH;

  }

  memcpy(synth_buf, st->synth_prev_ec, ORDER * sizeof(FLOAT32));

  memcpy(exc_buf, st->xcitation_prev, (MAX_PITCH + ORDER + 1) * sizeof(FLOAT32));

  if (num_lost_frames <= 8) {

    est_fac_est = ixheaacd_exc_fade_fac[num_lost_frames - 1];

  }

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

    ptr_exc[i] = est_fac_est * ptr_exc[i - st->last_tcx_pitch];

  }

  synth_signal[-1] = ptr_exc[-1];

  for (sf_idx = 0; sf_idx < len_subfrm; sf_idx += LEN_SUBFR) {

    FLOAT32 lp_coef[ORDER + 1];

    ixheaacd_lpc_coef_gen_ec(st->lspold, ptr_lsp_curr, lp_coef, len_subfrm / LEN_SUBFR);

    ixheaacd_synthesis_tool_float(lp_coef, &ptr_exc[sf_idx], &ptr_syn[sf_idx], LEN_SUBFR,

                                  synth_buf);

    ixheaacd_lpc_wt_tool(lp_coef, ORDER);

    ixheaacd_residual_tool_float(lp_coef, &ptr_syn[sf_idx], synth_signal, LEN_SUBFR, 1);

    ixheaacd_deemphsis_tool(synth_signal, LEN_SUBFR, synth_signal[-1]);

    temp = (est_fac_est * past_tcx_gain);

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

      if (synth_signal[i] > temp) {

        synth_signal[i] = temp;

      } else {

        if (synth_signal[i] < -temp) {

          synth_signal[i] = -temp;

        }

      }

    }

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

      synth_signal[i] = (synth_signal[i] - (PREEMPH_FILT_FAC * synth_signal[i - 1]));

    }

    ixheaacd_synthesis_tool_float(lp_coef, synth_signal, &ptr_syn[sf_idx], LEN_SUBFR, synth_buf);

    memmove(&ptr_synth[sf_idx], &ptr_syn[sf_idx], LEN_SUBFR * sizeof(FLOAT32));

  }

  memcpy(st->xcitation_prev, ptr_exc + len_subfrm - (MAX_PITCH + ORDER + 1),

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

  memcpy(st->synth_prev_ec, synth_buf + len_subfrm, sizeof(FLOAT32) * ORDER);

  return;

}