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