xref: /aosp_15_r20/external/libxaac/decoder/ixheaacd_usac_ec.c (revision 15dc779a375ca8b5125643b829a8aa4b70d7f451)

/******************************************************************************
 *                                                                            *
 * 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;
}