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

 *                                                                            *

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

#include <string.h>

#include "ixheaac_type_def.h"

#include "ixheaace_adjust_threshold_data.h"

#include "iusace_bitbuffer.h"

#include "ixheaace_mps_common_define.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_ms.h"

#include "iusace_fd_qc_util.h"

#include "ixheaace_memory_standards.h"

#include "iusace_config.h"

#include "iusace_tcx_mdct.h"

#include "iusace_arith_enc.h"

#include "iusace_fd_quant.h"

#include "iusace_signal_classifier.h"

#include "iusace_block_switch_const.h"

#include "iusace_block_switch_struct_def.h"

#include "ixheaace_sbr_header.h"

#include "ixheaace_config.h"

#include "ixheaace_asc_write.h"

#include "iusace_main.h"

#include "iusace_func_prototypes.h"

#include "iusace_lpd_rom.h"

#include "iusace_lpd.h"

#include "iusace_avq_enc.h"

#include "ixheaac_error_standards.h"

#include "ixheaace_error_codes.h"

static VOID iusace_decode_fd_fac(WORD32 *ptr_fac_prms, WORD32 len_subfrm, WORD32 fac_len,

                                 FLOAT32 *ptr_lpc_coeffs, FLOAT32 *zir_sig, FLOAT32 *ptr_fac_dec,

                                 iusace_scratch_mem *pstr_scratch) {

  FLOAT32 *x = pstr_scratch->p_x;

  FLOAT32 *xn2 = pstr_scratch->p_xn_2;

  FLOAT32 fac_gain;

  WORD32 i;

  const FLOAT32 *sin_window;

  FLOAT32 *fac_window = pstr_scratch->p_fac_window;

  FLOAT32 ap[ORDER + 1];

  if (fac_len == 64) {

    sin_window = iusace_sin_window_128;

  } else {

    sin_window = iusace_sin_window_256;

  }

  if (ptr_lpc_coeffs != NULL && ptr_fac_dec != NULL) {

    fac_gain = (FLOAT32)pow(10.0f, ((FLOAT32)ptr_fac_prms[0]) / 28.0f);

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

      x[i] = (FLOAT32)ptr_fac_prms[i + 1] * fac_gain;

    }

    iusace_tcx_mdct(x, xn2, fac_len, pstr_scratch);

    iusace_get_weighted_lpc(ptr_lpc_coeffs, ap);

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

    iusace_synthesis_tool_float(ap, xn2, ptr_fac_dec, 2 * fac_len, xn2 + fac_len,

                                pstr_scratch->p_buf_synthesis_tool);

    if (zir_sig != NULL) {

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

        fac_window[i] = sin_window[i] * sin_window[(2 * fac_len) - 1 - i];

        fac_window[fac_len + i] = 1.0f - (sin_window[fac_len + i] * sin_window[fac_len + i]);

      }

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

        ptr_fac_dec[i] += zir_sig[1 + (len_subfrm / 2) + i] * fac_window[fac_len + i] +

                          zir_sig[1 + (len_subfrm / 2) - 1 - i] * fac_window[fac_len - 1 - i];

      }

    }

  }

  return;

}

VOID iusace_fac_apply(FLOAT32 *orig, WORD32 len_subfrm, WORD32 fac_len, WORD32 low_pass_line,

                      WORD32 target_br, FLOAT32 *synth, FLOAT32 *ptr_lpc_coeffs,

                      WORD16 *fac_bits_word, WORD32 *num_fac_bits,

                      iusace_scratch_mem *pstr_scratch) {

  FLOAT32 *xn2 = pstr_scratch->p_xn2;

  FLOAT32 *fac_dec = pstr_scratch->p_fac_dec;

  FLOAT32 *right_fac_spec = pstr_scratch->p_right_fac_spec;

  FLOAT32 *x2 = pstr_scratch->p_x2;

  WORD32 *param = pstr_scratch->p_param;

  FLOAT32 ap[ORDER + 1];

  FLOAT32 fac_gain;

  WORD32 i, index;

  WORD32 num_enc_bits = 0;

  WORD32 start_right = 2 * len_subfrm - fac_len;

  *num_fac_bits = 0;

  memset(xn2, 0, (FAC_LENGTH + ORDER) * sizeof(FLOAT32));

  memcpy(xn2 + ORDER, &orig[start_right], fac_len * sizeof(FLOAT32));

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

    xn2[ORDER + i] -= synth[start_right + i];

  }

  iusace_get_weighted_lpc(ptr_lpc_coeffs, ap);

  iusace_compute_lp_residual(ap, xn2 + ORDER, x2, fac_len);

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

    x2[i] = x2[i] * (2.0f / (FLOAT32)fac_len);

  }

  iusace_tcx_mdct(x2, right_fac_spec, fac_len, pstr_scratch);

  memset(&right_fac_spec[low_pass_line], 0, (fac_len - low_pass_line) * sizeof(FLOAT32));

  fac_gain = iusace_calc_sq_gain(right_fac_spec, target_br, fac_len, pstr_scratch->p_sq_gain_en);

  index = (WORD32)floor(0.5f + (28.0f * (FLOAT32)log10(fac_gain)));

  if (index < 0) index = 0;

  if (index > 127) index = 127;

  param[0] = index;

  fac_gain = (FLOAT32)pow(10.0f, ((FLOAT32)index) / 28.0f);

  for (i = 0; i < fac_len; i++) right_fac_spec[i] /= fac_gain;

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

    iusace_find_nearest_neighbor(&right_fac_spec[i], &param[i + 1]);

  }

  iusace_write_bits2buf(index, 7, fac_bits_word);

  num_enc_bits += 7;

  num_enc_bits += iusace_fd_encode_fac(&param[1], &fac_bits_word[7], fac_len);

  iusace_decode_fd_fac(&param[0], len_subfrm, fac_len, ptr_lpc_coeffs, NULL, fac_dec,

                       pstr_scratch);

  *num_fac_bits = num_enc_bits;

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

    synth[start_right + i] += fac_dec[i];

  }

  return;

}

IA_ERRORCODE iusace_fd_fac(WORD32 *sfb_offsets, WORD32 sfb_active, FLOAT64 *orig_sig_dbl,

                           WORD32 window_sequence, FLOAT64 *synth_time,

                           ia_usac_td_encoder_struct *pstr_acelp, WORD32 last_subfr_was_acelp,

                           WORD32 next_frm_lpd, WORD16 *fac_prm_out, WORD32 *num_fac_bits,

                           iusace_scratch_mem *pstr_scratch) {

  const FLOAT32 *sin_window = NULL;

  LOOPIDX i;

  FLOAT32 *zir_sig = NULL;

  FLOAT32 *lpc_coeffs_q = NULL;

  WORD32 index;

  WORD32 low_pass_line = 0;

  WORD32 fac_len;

  FLOAT64 *left_fac_time_data = pstr_scratch->p_left_fac_time_data;

  FLOAT32 *left_fac_timedata_flt = pstr_scratch->p_left_fac_timedata_flt;

  FLOAT32 *left_fac_spec = pstr_scratch->p_left_fac_spec;

  FLOAT64 *fac_win = pstr_scratch->p_fac_win;

  WORD32 *fac_prm = pstr_scratch->p_fac_prm;

  WORD16 *fac_bits_word = pstr_scratch->p_fac_bits_word;

  FLOAT32 *acelp_folded = pstr_scratch->p_acelp_folded_scratch;

  *num_fac_bits = 0;

  if (last_subfr_was_acelp || next_frm_lpd)

  {

    if (window_sequence == EIGHT_SHORT_SEQUENCE)

      fac_len = (pstr_acelp->len_frame / 16);

    else

      fac_len = (pstr_acelp->len_frame / 8);

    low_pass_line = (WORD32)(sfb_offsets[sfb_active] * fac_len /

      (FLOAT32)pstr_acelp->len_frame);

  }

  if (last_subfr_was_acelp) {

    FLOAT32 *tmp_lp_res = pstr_scratch->ptr_tmp_lp_res;

    FLOAT32 lpc_coeffs[ORDER + 1];

    FLOAT32 ener, fac_gain;

    WORD32 left_start;

    switch (fac_len) {

      case 48:

        sin_window = iusace_sin_window_96;

        break;

      case 64:

        sin_window = iusace_sin_window_128;

        break;

      case 96:

        sin_window = iusace_sin_window_192;

        break;

      case 128:

        sin_window = iusace_sin_window_256;

        break;

      default:

        return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_FAC_LEN;

    }

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

      fac_win[i] = sin_window[i] * sin_window[(2 * fac_len) - 1 - i];

      fac_win[fac_len + i] = 1.0f - (sin_window[fac_len + i] * sin_window[fac_len + i]);

    }

    left_start = (pstr_acelp->len_frame / 2) - fac_len - ORDER;

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

      left_fac_time_data[i] = orig_sig_dbl[left_start + i];

    }

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

      left_fac_time_data[fac_len + ORDER + i] =

          left_fac_time_data[fac_len + ORDER + i] - synth_time[left_start + fac_len + ORDER + i];

    }

    zir_sig = pstr_acelp->lpd_state.tcx_quant;

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

      left_fac_time_data[fac_len + i] =

          left_fac_time_data[fac_len + i] - zir_sig[1 + 128 - ORDER + i];

    }

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

      acelp_folded[i] = zir_sig[1 + 128 + i] * (FLOAT32)fac_win[fac_len + i] +

                        zir_sig[1 + 128 - 1 - i] * (FLOAT32)fac_win[fac_len - 1 - i];

    }

    {

      FLOAT32 ener_tmp;

      ener = 0.0f;

      ener_tmp = 0.0f;

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

        ener += (FLOAT32)(left_fac_time_data[i + ORDER + fac_len] *

                          left_fac_time_data[i + ORDER + fac_len]);

      }

      ener *= 2.0f;

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

        ener_tmp += acelp_folded[i] * acelp_folded[i];

      }

      if (ener_tmp > ener)

        fac_gain = (FLOAT32)sqrt(ener / ener_tmp);

      else

        fac_gain = 1.0f;

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

        left_fac_time_data[i + ORDER + fac_len] -= fac_gain * acelp_folded[i];

      }

    }

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

      left_fac_timedata_flt[i] = (FLOAT32)left_fac_time_data[i];

    }

    lpc_coeffs_q = pstr_acelp->lpd_state.lpc_coeffs_quant;

    lpc_coeffs_q += ORDER + 1;

    iusace_get_weighted_lpc(lpc_coeffs_q, lpc_coeffs);

    iusace_compute_lp_residual(lpc_coeffs, left_fac_timedata_flt + ORDER + fac_len, tmp_lp_res,

                               fac_len);

    FLOAT32 coeff = (2.0f / (FLOAT32)fac_len);

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

      tmp_lp_res[i] = tmp_lp_res[i] * coeff;

    }

    iusace_tcx_mdct(tmp_lp_res, left_fac_spec, fac_len, pstr_scratch);

    memset(&left_fac_spec[low_pass_line], 0, (fac_len - low_pass_line) * sizeof(FLOAT32));

    fac_gain = iusace_calc_sq_gain(left_fac_spec, 240, fac_len, pstr_scratch->p_sq_gain_en);

    index = (WORD32)floor(0.5f + (28.0f * (FLOAT32)log10(fac_gain)));

    if (index < 0) index = 0;

    if (index > 127) index = 127;

    iusace_write_bits2buf(index, 7, fac_bits_word);

    *num_fac_bits += 7;

    fac_gain = (FLOAT32)pow(10.0f, ((FLOAT32)index) / 28.0f);

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

      left_fac_spec[i] /= fac_gain;

    }

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

      iusace_find_nearest_neighbor(&left_fac_spec[i], &fac_prm[i]);

    }

    *num_fac_bits += iusace_fd_encode_fac(fac_prm, &fac_bits_word[7], fac_len);

    for (i = 0; i < (*num_fac_bits + 7) / 8; i++) {

      fac_prm_out[i] =

          (WORD16)((fac_bits_word[8 * i + 0] & 0x1) << 7 | (fac_bits_word[8 * i + 1] & 0x1) << 6 |

                   (fac_bits_word[8 * i + 2] & 0x1) << 5 | (fac_bits_word[8 * i + 3] & 0x1) << 4 |

                   (fac_bits_word[8 * i + 4] & 0x1) << 3 | (fac_bits_word[8 * i + 5] & 0x1) << 2 |

                   (fac_bits_word[8 * i + 6] & 0x1) << 1 | (fac_bits_word[8 * i + 7] & 0x1) << 0);

    }

  } else {

    *num_fac_bits = 0;

  }

  if (next_frm_lpd) {

    for (i = 0; i < 1024 / 2 + 1 + ORDER; i++) {

      pstr_acelp->fd_synth[i] = (FLOAT32)synth_time[pstr_acelp->len_frame - 1 + i - ORDER];

      pstr_acelp->fd_orig[i] = (FLOAT32)orig_sig_dbl[pstr_acelp->len_frame + i - ORDER];

    }

    pstr_acelp->low_pass_line = low_pass_line;

  }

  return IA_NO_ERROR;

}