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

 *                                                                            *

 * 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 "iusace_cnst.h"

#include "iusace_type_def.h"

#include "iusace_block_switch_const.h"

#include "iusace_block_switch_struct_def.h"

#include "iusace_bitbuffer.h"

#include "iusace_tns_usac.h"

#include "impd_drc_common_enc.h"

#include "impd_drc_uni_drc.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_psy_utils.h"

#include "ixheaac_error_standards.h"

#include "iusace_type_def.h"

#include "iusace_cnst.h"

#include "iusace_ms.h"

#include "iusace_psy_utils.h"

#include "ixheaace_adjust_threshold_data.h"

#include "iusace_fd_qc_util.h"

#include "ixheaace_memory_standards.h"

#include "iusace_config.h"

#include "iusace_arith_enc.h"

#include "iusace_fd_quant.h"

#include "iusace_signal_classifier.h"

#include "iusace_block_switch_const.h"

#include "ixheaace_sbr_header.h"

#include "ixheaace_config.h"

#include "ixheaace_asc_write.h"

#include "iusace_main.h"

VOID iusace_psy_mod_init(ia_psy_mod_struct *pstr_psy_mod, WORD32 sample_rate, WORD32 bit_rate,

                         WORD32 band_width, WORD32 num_channels, WORD32 ch, WORD32 ele_id,

                         WORD32 ccfl) {

  WORD32 i;

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

    iusace_psy_long_config_init(bit_rate / num_channels, sample_rate, band_width,

                                &(pstr_psy_mod->str_psy_long_config[ele_id]), ccfl);

    iusace_psy_short_config_init(bit_rate / num_channels, sample_rate, band_width,

                                 &(pstr_psy_mod->str_psy_short_config[ele_id]), ccfl);

    pstr_psy_mod->str_psy_data[ch].ptr_sfb_thr_long =

        (FLOAT32 *)pstr_psy_mod->str_psy_data[ch].sfb_thr_short;

    pstr_psy_mod->str_psy_data[ch].ptr_sfb_energy_long =

        (FLOAT32 *)pstr_psy_mod->str_psy_data[ch].sfb_energy_short;

    pstr_psy_mod->str_psy_data[ch].ptr_sfb_spreaded_energy_long =

        (FLOAT32 *)pstr_psy_mod->str_psy_data[ch].sfb_spreaded_energy_short;

    memcpy(pstr_psy_mod->str_psy_data[ch].sfb_thr_nm1,

           pstr_psy_mod->str_psy_long_config[ele_id].sfb_thr_quiet,

           pstr_psy_mod->str_psy_long_config[ele_id].sfb_count * sizeof(FLOAT32));

    ch++;

  }

  return;

}

VOID iusace_psy_mod_lb(ia_psy_mod_struct *pstr_psy_mod, ia_sfb_params_struct *pstr_sfb_prms,

                       FLOAT64 *ptr_spec_in, ia_tns_info *pstr_tns_info[MAX_TIME_CHANNELS],

                       WORD32 tns_select, WORD32 i_ch, WORD32 chn, WORD32 channel_type,

                       FLOAT64 *scratch_tns_filter, WORD32 elem_idx, FLOAT64 *ptr_tns_scratch,

                       WORD32 ccfl) {

  ia_psy_mod_data_struct *pstr_psy_data = &(pstr_psy_mod->str_psy_data[i_ch]);

  ia_psy_mod_long_config_struct *pstr_psy_config = &(pstr_psy_mod->str_psy_long_config[elem_idx]);

  WORD32 window_sequence = pstr_sfb_prms->window_sequence[i_ch];

  WORD32 num_sfb = pstr_sfb_prms->num_sfb[i_ch];

  ia_tns_info *ptr_tns_info = pstr_tns_info[i_ch];

  WORD32 sfb, line;

  WORD32 i;

  WORD32 frame_len_long = ccfl;

  FLOAT32 energy_shift = 0.25f;

  FLOAT32 clip_energy = pstr_psy_config->clip_energy * energy_shift;

  (VOID) channel_type;

  pstr_psy_data->window_sequence = window_sequence;

  memset(&ptr_spec_in[pstr_psy_config->low_pass_line], 0,

         (frame_len_long - pstr_psy_config->low_pass_line) * sizeof(FLOAT64));

  iusace_calc_band_energy(ptr_spec_in, pstr_psy_config->sfb_offset, pstr_psy_config->sfb_active,

                          pstr_psy_data->ptr_sfb_energy_long, pstr_psy_config->sfb_count);

  if (tns_select != 0) {

    ia_tns_info *ptr_tns_info_ch2 = pstr_tns_info[i_ch - chn];

    ptr_tns_info->number_of_bands = num_sfb;

    ptr_tns_info->block_type = window_sequence;

    ptr_tns_info->spec = ptr_spec_in;

    iusace_tns_encode(ptr_tns_info_ch2, ptr_tns_info, pstr_psy_data->ptr_sfb_energy_long, 0, chn,

                      pstr_psy_config->low_pass_line, scratch_tns_filter, 0, ptr_tns_scratch);

  }

  for (i = 0; i < pstr_psy_config->sfb_count; i++) {

    pstr_psy_data->ptr_sfb_thr_long[i] =

        pstr_psy_data->ptr_sfb_energy_long[i] * pstr_psy_config->ratio;

    pstr_psy_data->ptr_sfb_thr_long[i] = MIN(pstr_psy_data->ptr_sfb_thr_long[i], clip_energy);

  }

  if (tns_select != 0) {

    if (ptr_tns_info->tns_data_present == 1) {

      iusace_calc_band_energy(ptr_spec_in, pstr_psy_config->sfb_offset,

                              pstr_psy_config->sfb_active, pstr_psy_data->ptr_sfb_energy_long,

                              pstr_psy_config->sfb_count);

    }

  }

  iusace_find_max_spreading(pstr_psy_config->sfb_count, pstr_psy_config->sfb_mask_low_fac,

                            pstr_psy_config->sfb_mask_high_fac, pstr_psy_data->ptr_sfb_thr_long);

  for (i = 0; i < pstr_psy_config->sfb_count; i++) {

    pstr_psy_data->ptr_sfb_thr_long[i] = MAX(pstr_psy_data->ptr_sfb_thr_long[i],

                                             (pstr_psy_config->sfb_thr_quiet[i] * energy_shift));

  }

  if (pstr_psy_data->window_sequence == LONG_STOP_SEQUENCE) {

    for (i = 0; i < pstr_psy_config->sfb_count; i++) {

      pstr_psy_data->sfb_thr_nm1[i] = 1.0e20f;

    }

  }

  iusace_pre_echo_control(pstr_psy_data->sfb_thr_nm1, pstr_psy_config->sfb_count,

                          pstr_psy_config->max_allowed_inc_fac,

                          pstr_psy_config->min_remaining_thr_fac,

                          pstr_psy_data->ptr_sfb_thr_long);

  if (pstr_psy_data->window_sequence == LONG_START_SEQUENCE) {

    for (i = 0; i < pstr_psy_config->sfb_count; i++) {

      pstr_psy_data->sfb_thr_nm1[i] = 1.0e20f;

    }

  }

  for (i = 0; i < pstr_psy_config->sfb_count; i++) {

    pstr_psy_data->ptr_sfb_spreaded_energy_long[i] = pstr_psy_data->ptr_sfb_energy_long[i];

  }

  iusace_find_max_spreading(

      pstr_psy_config->sfb_count, pstr_psy_config->sfb_mask_low_fac_spr_ener,

      pstr_psy_config->sfb_mask_high_fac_spr_ener, pstr_psy_data->ptr_sfb_spreaded_energy_long);

  for (sfb = pstr_psy_config->sfb_count - 1; sfb >= 0; sfb--) {

    for (line = pstr_psy_config->sfb_offset[sfb + 1] - 1;

         line >= pstr_psy_config->sfb_offset[sfb]; line--) {

      if (ptr_spec_in[line] != 0) break;

    }

    if (line >= pstr_psy_config->sfb_offset[sfb]) break;

  }

  pstr_psy_mod->str_psy_out_data[i_ch].max_sfb_per_grp = sfb + 1;

  return;

}

VOID iusace_psy_mod_sb(ia_psy_mod_struct *pstr_psy_mod, ia_sfb_params_struct *pstr_sfb_prms,

                       FLOAT64 *ptr_spec_in, ia_tns_info *pstr_tns_info[MAX_TIME_CHANNELS],

                       WORD32 tns_select, WORD32 i_ch, WORD32 chn, WORD32 channel_type,

                       FLOAT64 *scratch_tns_filter, WORD32 elem_idx, FLOAT64 *ptr_tns_scratch,

                       WORD32 ccfl) {

  ia_psy_mod_data_struct *pstr_psy_data = &(pstr_psy_mod->str_psy_data[i_ch]);

  ia_psy_mod_short_config_struct *pstr_psy_config =

      &(pstr_psy_mod->str_psy_short_config[elem_idx]);

  WORD32 max_sfb = 0, sfb, line;

  WORD32 window_sequence = pstr_sfb_prms->window_sequence[i_ch];

  WORD32 num_sfb = pstr_sfb_prms->num_sfb[i_ch];

  ia_tns_info *ptr_tns_info = pstr_tns_info[i_ch];

  WORD32 i, w;

  WORD32 frame_len_short = (ccfl * FRAME_LEN_SHORT_128) / FRAME_LEN_LONG;

  FLOAT32 energy_shift = 0.25f;

  FLOAT32 clip_energy = pstr_psy_config->clip_energy * energy_shift;

  (VOID) channel_type;

  pstr_psy_data->window_sequence = window_sequence;

  for (w = 0; w < MAX_SHORT_WINDOWS; w++) {

    WORD32 w_offset = w * frame_len_short;

    WORD32 offset;

    FLOAT64 *pmdct_double = &ptr_spec_in[pstr_psy_config->low_pass_line + w_offset];

    offset = frame_len_short - pstr_psy_config->low_pass_line;

    memset(pmdct_double, 0, sizeof(FLOAT64) * offset);

    iusace_calc_band_energy(ptr_spec_in + w_offset, pstr_psy_config->sfb_offset,

                            pstr_psy_config->sfb_active, pstr_psy_data->sfb_energy_short[w],

                            pstr_psy_config->sfb_count);

    if (tns_select != 0) {

      ia_tns_info *ptr_tns_info_ch2 = pstr_tns_info[i_ch - chn];

      ptr_tns_info->number_of_bands = num_sfb;

      ptr_tns_info->block_type = window_sequence;

      ptr_tns_info->spec = ptr_spec_in + w_offset;

      iusace_tns_encode(ptr_tns_info_ch2, ptr_tns_info, pstr_psy_data->sfb_energy_short[w], w,

                        chn, pstr_psy_config->low_pass_line, scratch_tns_filter, 0,

                        ptr_tns_scratch);

    }

    for (i = 0; i < pstr_psy_config->sfb_count; i++) {

      pstr_psy_data->sfb_thr_short[w][i] =

          pstr_psy_data->sfb_energy_short[w][i] * pstr_psy_config->ratio;

      pstr_psy_data->sfb_thr_short[w][i] = MIN(pstr_psy_data->sfb_thr_short[w][i], clip_energy);

    }

    if (tns_select != 0) {

      if (ptr_tns_info->tns_data_present == 1) {

        iusace_calc_band_energy(ptr_spec_in + w_offset, pstr_psy_config->sfb_offset,

                                pstr_psy_config->sfb_active, pstr_psy_data->sfb_energy_short[w],

                                pstr_psy_config->sfb_count);

      }

    }

    iusace_find_max_spreading(pstr_psy_config->sfb_count, pstr_psy_config->sfb_mask_low_fac,

                              pstr_psy_config->sfb_mask_high_fac,

                              pstr_psy_data->sfb_thr_short[w]);

    for (i = 0; i < pstr_psy_config->sfb_count; i++) {

      pstr_psy_data->sfb_thr_short[w][i] =

          MAX(pstr_psy_data->sfb_thr_short[w][i], (pstr_psy_config->sfb_thr_quiet[i] * 0.25f));

    }

    iusace_pre_echo_control(pstr_psy_data->sfb_thr_nm1, pstr_psy_config->sfb_count,

                            pstr_psy_config->max_allowed_inc_fac,

                            pstr_psy_config->min_remaining_thr_fac,

                            pstr_psy_data->sfb_thr_short[w]);

    for (i = 0; i < pstr_psy_config->sfb_count; i++) {

      pstr_psy_data->sfb_spreaded_energy_short[w][i] = pstr_psy_data->sfb_energy_short[w][i];

    }

    iusace_find_max_spreading(

        pstr_psy_config->sfb_count, pstr_psy_config->sfb_mask_low_fac_spr_ener,

        pstr_psy_config->sfb_mask_high_fac_spr_ener, pstr_psy_data->sfb_spreaded_energy_short[w]);

  }

  for (WORD32 wnd = 0; wnd < MAX_SHORT_WINDOWS; wnd++) {

    for (sfb = pstr_psy_config->sfb_count - 1; sfb >= max_sfb; sfb--) {

      for (line = pstr_psy_config->sfb_offset[sfb + 1] - 1;

           line >= pstr_psy_config->sfb_offset[sfb]; line--) {

        if (ptr_spec_in[wnd * frame_len_short + line] != 0.0) break;

      }

      if (line >= pstr_psy_config->sfb_offset[sfb]) break;

    }

    max_sfb = MAX(max_sfb, sfb);

  }

  max_sfb = max_sfb > 0 ? max_sfb : 0;

  pstr_psy_mod->str_psy_out_data[i_ch].max_sfb_per_grp = max_sfb + 1;

  return;

}